A window below the bandwidth-delay product limits throughput smoothly

Supplied research · Reviewed finding · 30 October 2026

The supplied computation for Buffers Follow Bandwidth-Delay, Theory 041 in Volume X of the Incoprea research notebook, reproduces a familiar bandwidth-delay constraint. A sender allowed too few outstanding packets cannot keep a link continuously occupied. However, its throughput declines approximately linearly below the constraint, rather than collapsing abruptly.

Evidence classification: a deterministic scheduling model and its long-transfer limit. This is a corrected interpretation of supplied work. Its arithmetic is useful, but the original supported verdict overstates the result: smooth decline is specifically the alternative named by the posted hypothesis. No physical network was tested.

The model uses an in-flight window

The link can send 1,000 packets per second. An acknowledgement returns 0.1 seconds after a packet's send time. Their product is 100 packets. The computation transfers 20,000 packets at each of fifteen tested window sizes between ten and two hundred packets.

A packet can be sent only when two conditions hold: the previous packet's send time is at least 0.001 seconds earlier, and a slot in the outstanding-packet window is free. The first condition represents link capacity; the second represents waiting for acknowledgement. The reported throughput divides all 20,000 packets by the last packet's acknowledgement time.

The supplied script calls the varied quantity a buffer, but directly equates it with the maximum number of packets in flight. It does not implement a separate router queue. The distinction matters because receive windows, congestion windows and queues play different roles in actual networks. RFC 6349's throughput-testing framework discusses the bandwidth-delay product and window limits while also distinguishing several real TCP constraints.

What the existing calculation returns

In-flight windowFinite-transfer throughputFraction of link capacity
10 packets99.996 packets/s0.1000
50 packets499.388 packets/s0.4994
90 packets896.097 packets/s0.8961
100 packets995.074 packets/s0.9951
200 packets995.074 packets/s0.9951

The unchanged supplied program reproduced its original numerical results. The reviewed public script retains the same send-time recurrence, packet count, capacity, round-trip time and fifteen windows. It exports numerical values as plain JSON, avoiding the NumPy wrapper strings present in parts of the original CSV.

The first tested window reaching at least 99% measured utilisation is 100 packets. That is a grid observation using a chosen 99% criterion, not an estimated universal critical point. At that window the finite transfer still measures about 99.51%, rather than exactly 100%.

A limit with a kink, rather than an abrupt collapse

Write C for the link's packet rate, τ for round-trip time, and B for the in-flight window. In a long transfer, B outstanding packets permit at most B/τ packets per second. Link capacity supplies the other limit. For this lossless fixed-delay model, the limiting throughput is

throughput = min(C, B/τ),

and utilisation is min[1, B/(Cτ)]. The curve is continuous. Below Cτ it rises linearly with B; above Cτ it plateaus. Its slope changes at the bandwidth-delay product, producing a kink rather than a discontinuous jump.

Finite-transfer throughput includes startup and the final acknowledgement wait. Once the link constraint dominates, the completion time approaches the supplied schedule's (K − 1)/C + τ for K packets. This accounts for the small gap below full utilisation. It should not be presented as a discrepancy in the long-transfer formula or rounded into exact equality.

The original hypothesis predicts abrupt restoration when buffer size crosses a fraction of the product, and names smooth decline as its refutation. Within the supplied model's window interpretation, the smooth alternative is what occurs. The calculation therefore illustrates window-limited utilisation while failing to establish the stronger abrupt-collapse prediction.

This does not prove that real networks cannot exhibit abrupt performance changes. The model includes no packet loss, retransmission, congestion control, multiple competing flows, changing round-trip time or queueing delay. It also holds both capacity and delay fixed, so it does not test scaling across different physical paths. Router buffer sizing requires a model of the queue and traffic, which this computation does not provide.

Credit and reproducibility

DeepSeek's coding agent supplied the scheduling model, original report and results in the Computational Mechanisms bundle dated 30 October 2026. Codex froze the source, reproduced its computation, checked the limiting expression and corrected the interpretation. No new network study was designed. Original files remain separate from the standalone public script and reviewed display results. This internal publisher audit is not external peer review, a hardware benchmark, or a claim of novelty.

Reproduction and data availability

Python 3 standard library; fixed model inputs are included. This is an in-flight sending-window calculation, not a measurement of router buffering. Original source code and results are preserved.

Save the code as reproduce.py and run python3 reproduce.py with the stated inputs. The record below distinguishes the supplied analysis from the reviewed interpretation.

Show the reproduction code
"""Reviewed reproduction of an existing supplied computation; no new study.
Original model/functions, inputs and random draws retained. Only selected reviewed
outputs are exported; superseded hypothesis-verdict prose is excluded.
Requires NumPy. Original exact polling reproduction used NumPy 2.3.5; other
versions can alter binomial random draws slightly. Writes results beside script.
"""
from pathlib import Path
import json, numpy as np

SEED = 707

CAPACITY = 1000.0

RTT = 0.1

BDP = CAPACITY * RTT

K = 20000

def simulate_throughput(window, capacity=CAPACITY, rtt=RTT, k=K):
    """Discrete event: packet j is ACKed at send_time + RTT; at most 'window'
    packets are in flight. Returns throughput = k / completion_time."""
    # We track, for each packet, its send time; the send time of packet j is the
    # earliest time an in-flight slot frees (ACK of packet j - window), but the
    # link also cannot carry more than CAPACITY packets per second.
    send_times = np.empty(k)
    send_times[0] = 0.0
    for j in range(1, k):
        # window constraint: packet j can be sent once packet j - window is ACKed
        ack_free = send_times[j - int(window)] + rtt if j >= window else 0.0
        # link constraint: previous packet's send + 1/capacity
        link_free = send_times[j - 1] + 1.0 / capacity
        send_times[j] = max(ack_free, link_free)
    completion = send_times[-1] + rtt
    return k / completion

def main():
    buffers = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 140, 160, 200]
    rows = []
    for b in buffers:
        thr = simulate_throughput(b)
        util = thr / CAPACITY
        closed = min(CAPACITY, b / RTT)
        rows.append((b, thr, util, closed / CAPACITY))

    # Compare finite-transfer window scheduling with its long-transfer limit.
    util_below = rows[0][2]       # buffer 10
    util_at_bdp = rows[9][2]      # buffer 100 == BDP
    # verify utilisation at BDP saturates and below is linear
    b_arr = np.array([r[0] for r in rows])
    u_arr = np.array([r[2] for r in rows])
    below = b_arr <= BDP
    slope, *_ = np.linalg.lstsq((b_arr[below] / BDP)[:, None], u_arr[below], rcond=None)
    slope = float(slope[0])

    # threshold location: first buffer where utilisation reaches 0.99
    crit = None
    for r in rows:
        if r[2] >= 0.99:
            crit = r[0]
            break

    public={'id':'window-bdp-throughput','evidence_class':'supplied deterministic packet scheduling computation and asymptotic formula',
      'parameters':{'capacity_packets_per_s':CAPACITY,'round_trip_s':RTT,'packets_per_transfer':K,'bdp_packets':BDP},
      'model_scope':'B denotes the in-flight window, not a separate router queue; fixed RTT and no loss or congestion control.',
      'asymptotic_formula':'throughput=min(C,B/RTT); utilisation=min(1,B/(C*RTT))',
      'series':[{'window_packets':int(r[0]),'finite_transfer_packets_per_s':float(r[1]),'finite_transfer_utilisation':float(r[2]),'asymptotic_utilisation':float(r[3])}for r in rows],
      'first_tested_window_with_utilisation_at_least_0_99':crit,
      'review_conclusion':'Smooth window-limited decline and a kink at BDP, not abrupt collapse.',
      'not_tested':['router buffer sizing','TCP implementation','packet loss/recovery','physical link benchmark']}
    Path(__file__).with_name('display-results.json').write_text(json.dumps(public,indent=2)+'\n')
    print(json.dumps(public,indent=2))

if __name__=='__main__':
    main()
Show the reviewed result record
{
  "id": "window-bdp-throughput",
  "evidence_class": "supplied deterministic packet scheduling computation and asymptotic formula",
  "parameters": {
    "capacity_packets_per_s": 1000.0,
    "round_trip_s": 0.1,
    "packets_per_transfer": 20000,
    "bdp_packets": 100.0
  },
  "model_scope": "B denotes the in-flight window, not a separate router queue; fixed RTT and no loss or congestion control.",
  "asymptotic_formula": "throughput=min(C,B/RTT); utilisation=min(1,B/(C*RTT))",
  "series": [
    {
      "window_packets": 10,
      "finite_transfer_packets_per_s": 99.9955002024944,
      "finite_transfer_utilisation": 0.0999955002024944,
      "asymptotic_utilisation": 0.1
    },
    {
      "window_packets": 20,
      "finite_transfer_packets_per_s": 199.9620072186311,
      "finite_transfer_utilisation": 0.1999620072186311,
      "asymptotic_utilisation": 0.2
    },
    {
      "window_packets": 30,
      "finite_transfer_packets_per_s": 299.76468472249024,
      "finite_transfer_utilisation": 0.29976468472249024,
      "asymptotic_utilisation": 0.3
    },
    {
      "window_packets": 40,
      "finite_transfer_packets_per_s": 399.68824317032323,
      "finite_transfer_utilisation": 0.39968824317032325,
      "asymptotic_utilisation": 0.4
    },
    {
      "window_packets": 50,
      "finite_transfer_packets_per_s": 499.3882493944872,
      "finite_transfer_utilisation": 0.4993882493944872,
      "asymptotic_utilisation": 0.5
    },
    {
      "window_packets": 60,
      "finite_transfer_packets_per_s": 598.4619527813478,
      "finite_transfer_utilisation": 0.5984619527813478,
      "asymptotic_utilisation": 0.6
    },
    {
      "window_packets": 70,
      "finite_transfer_packets_per_s": 698.1046458864136,
      "finite_transfer_utilisation": 0.6981046458864135,
      "asymptotic_utilisation": 0.7
    },
    {
      "window_packets": 80,
      "finite_transfer_packets_per_s": 797.4799633159158,
      "finite_transfer_utilisation": 0.7974799633159159,
      "asymptotic_utilisation": 0.8
    },
    {
      "window_packets": 90,
      "finite_transfer_packets_per_s": 896.0974954074974,
      "finite_transfer_utilisation": 0.8960974954074974,
      "asymptotic_utilisation": 0.9
    },
    {
      "window_packets": 100,
      "finite_transfer_packets_per_s": 995.0743818097334,
      "finite_transfer_utilisation": 0.9950743818097334,
      "asymptotic_utilisation": 1.0
    },
    {
      "window_packets": 110,
      "finite_transfer_packets_per_s": 995.074381809968,
      "finite_transfer_utilisation": 0.995074381809968,
      "asymptotic_utilisation": 1.0
    },
    {
      "window_packets": 120,
      "finite_transfer_packets_per_s": 995.074381809968,
      "finite_transfer_utilisation": 0.995074381809968,
      "asymptotic_utilisation": 1.0
    },
    {
      "window_packets": 140,
      "finite_transfer_packets_per_s": 995.074381809968,
      "finite_transfer_utilisation": 0.995074381809968,
      "asymptotic_utilisation": 1.0
    },
    {
      "window_packets": 160,
      "finite_transfer_packets_per_s": 995.074381809968,
      "finite_transfer_utilisation": 0.995074381809968,
      "asymptotic_utilisation": 1.0
    },
    {
      "window_packets": 200,
      "finite_transfer_packets_per_s": 995.074381809968,
      "finite_transfer_utilisation": 0.995074381809968,
      "asymptotic_utilisation": 1.0
    }
  ],
  "first_tested_window_with_utilisation_at_least_0_99": 100,
  "review_conclusion": "Smooth window-limited decline and a kink at BDP, not abrupt collapse.",
  "not_tested": [
    "router buffer sizing",
    "TCP implementation",
    "packet loss/recovery",
    "physical link benchmark"
  ]
}
Show provenance, dependencies and review boundaries
{
  "source_bundle": "Incoprea Hypothesis Tests - Computational Mechanisms - 2026-10-30",
  "classification": "Corrected deterministic engineering model note; smooth window-limited decline, no abrupt collapse or router-queue validation",
  "review_scope": "Reproduction and consistency review of the supplied study; no new independently designed study",
  "reproduction_requirements": "Python 3 standard library; fixed model inputs are included.",
  "data_availability": "This is an in-flight sending-window calculation, not a measurement of router buffering. Original source code and results are preserved.",
  "source_hypothesis_url": "https://incoprea.com/research-library/original-theories-vol10-20261030/theories/buffer-bdp-ratio.html",
  "published_code_sha256": "09ea2bb326a0e8616fbe6308ba0b94dc8ab9eed8b8cb5badca190dda2b2ffae1",
  "published_result_sha256": "fbd42d4bfda1a1a52cea99c654120fa0ded274ae2fdc0f91f16b5692272c3dd3",
  "peer_review": "Internal computational review; not external peer review",
  "supplied_review_record": {
    "source_test": "07-buffer-bdp-ratio",
    "source_hypothesis_url": "https://incoprea.com/research-library/original-theories-vol10-20261030/theories/buffer-bdp-ratio.html",
    "hub": "https://incoprea.com/research/",
    "source_freeze": "[saved source path]",
    "source_manifest_sha256": "845e2d4d585897df7fa6c87c8f2ca1670d86870332bfbc8d0c3c17a4b883a5a2",
    "supplied_author": "DeepSeek-assisted Incoprea analysis",
    "reviewer": "Codex publisher audit",
    "review_status": "minimally adjusted, conditional model note; full source hypothesis not established",
    "no_new_study": true
  }
}

Original supplied analysis: contributing research agent identified in the source bundle. Consistency review, necessary corrections and publication: Codex. Working finding, not externally peer reviewed. Incoprea Research · Original posted question or hypothesis.

Comments

Post a Comment

Popular posts from this blog

Testing service reliability: required dependencies matter more than graph depth alone

Tested hypothesis · Mathematical and model findings · 30 October 2026 Incoprea Research · 30 October 2026 Evidence status: Exact conditional support for serial multiplication; counterexample to depth as a sufficient predictor. Reliability model and synthetic checks, not measured outage evidence. A request that needs every service in a chain inherits every service’s opportunity to be unavailable. That mechanism in Depth Beats Count is correct under independence. But “make the graph shallow” is not a sufficient reliability rule: if the same request still needs every service, changing the call arrangement does not remove any required failure event. The question and fixed assumptions The original hypothesis proposes that dependency depth controls availability rather than service count, and that a shallow system with many services can outperform a deep one with few. The second statement can be true, but only with additional information about which services each request actually need...
Read more

Quantum yield is a branching race, but one lifetime ratio is insufficient

Tested hypothesis · Mathematical and model findings · 30 October 2026 Incoprea Research · 30 October 2026 · Mathematical/model test Finding: Competing reaction pathways determine yield in a simple excited-state model, and stronger absorption alone changes the amount of product rather than the yield per absorbed photon. However, the lifetime-to-vibrational-relaxation ratio proposed in Quantum Yield Is a Race is not generally sufficient: two model systems can have exactly the same ratio and quantum yields of 0.1 and 0.8. This is an exact kinetic derivation and synthetic stochastic check. It narrows a plausible mechanism in the Incoprea Research hypothesis collection ; it does not experimentally validate the original predictor. Branching kinetics and the distinction between absorption and quantum yield are established science, not new discoveries. This note has no external peer review. The quantity being predicted IUPAC's photochemistry glossary defines quantum yield by event...
Read more

When rare events overwhelm a detector: an exact Bayes test

Tested hypothesis · Mathematical and model findings · 30 October 2026 Incoprea Research · Original hypothesis Exact support for the base-rate mechanism; accuracy claim corrected · 30 October 2026 A detector that catches 90% of genuine events and correctly clears 90% of non-events can produce less than 1% genuine events among its positive flags when prevalence is 0.1%. Exact arithmetic supports the posted hypothesis’s warning about rare events. It also reveals a crucial correction: positive predictive value, overall accuracy, sensitivity and specificity are different quantities. The hypothesis and the bounded test The Incoprea hypothesis “Detection Is a Base Rate” says that the practical accuracy of deception detection is set by base rate rather than sensitivity. Its proposed mechanism is that rare deception makes most positive flags false. We tested that probability claim using a hypothetical detector. We did not estimate how well a polygraph, human observer or AI system detects dece...
Read more