Skip to content

Two false numbers in research/interval's own prose, both claiming more than the code delivers - #135

Merged
d6g8k5htny-coder merged 3 commits into
chatgpt/drive-github-hardening-20260919from
claude/interval-docs-errata
Sep 27, 2026
Merged

d6g8k5htny-coder merged 3 commits into
chatgpt/drive-github-hardening-20260919from
claude/interval-docs-errata

Conversation

@d6g8k5htny-coder

Copy link
Copy Markdown
Owner

What this changes

research/interval/README.md and tests/test_interval.py. No library code —
research/interval/transcendental.py and core.py are pinned by four
certificates and are untouched.

Type of change

  • Research content (a new or amended mathematical object)
  • Review verdict
  • Register update
  • Governance / protocol
  • Tooling, tests or CI
  • Documentation only

The findings

A fifth adversarial pass over this package, aimed at the prose rather than the
arithmetic: every numeric assertion in the README and in the library docstrings
re-derived or re-measured against the code as it stands. No containment
violation.
Two false statements, both in the unsafe direction — each claims
something tighter than the code delivers — and two certificates with no control
that names them.

1. pi(P) misses its own width hint at exactly two precisions

transcendental.py line 688 asserts, as a premise of the sin/cos reduction
sketch
, that

pi(P) has width below 10**-P

False at exactly P = 64 (width 1.051e-64) and P = 102 (1.084e-102), and
true at every other P in 1..129. pi takes target = _tol(key)/32 and then
round_out(4*key + 96), and the outward significand rounding can put the width
back over 10**-P where the binary and decimal boundaries line up.

The sketch's conclusion survives, and that is the honest report. The same
paragraph states the argument tolerates pi being "about 10**13 times more
loosely" certified, and the shortfall is a factor of 1.05. Containment never
rested on it either: _sin_cos_reduced re-tests mag(s) <= 1 and raises. So this
is a false premise inside a sound argument, not a broken bound — and a test now
pins the exceptional set, so a future pi that misses the hint at a third
precision is a test failure rather than somebody's later discovery.

2. Where 1 - Phi(x) goes vacuous is a function of prec, not a constant

Phi's docstring, and the README, gave "beyond about x = 26". Phi finishes
with round_out(4 * g + 32) where g = prec + 20, so it keeps 4*prec + 112
significand bits, and the subtraction collapses once the tail mass falls below
2 ** -(4*prec + 112):

prec significand bits smallest x with (1 - Phi(x)).lo == 0
1 116 13
5 132 14
10 152 15
20 192 17
30 232 18
50 312 21
100 512 27

Measured, and ceil(sqrt(2 ln2 (4 prec + 112))) predicts every row exactly.
"About 26" is the prec = 100 row, and it is optimistic everywhere below it. At
prec = 20 a consumer trusting it would take 1 - Phi(20) = [0, 7.97e-59] for a
tail bound where normal_sf(20) = 2.75e-89. Even at x = 16, one short of the
threshold, the subtraction is already two orders coarser than the direct route
(7.97e-59 against 2.9e-61) — so the wrong shape of statement mattered as
much as the wrong number.

3. Two certificates with no control that names them

The sin/cos alternating-series remainder in _sin_cos_reduced, and the
upper branch of the Mills bracket (b = 1 - 3/(2z^2), valid z >= 1). The
lower branch had a control; the upper did not, and the Machin remainder control
covers atan, not sin/cos.

The mutation exercise refined this finding, and the wording follows the evidence
rather than the reverse
: neither mutant survived the old suite. The sin one was
caught by the Pythagorean identity and the addition formula — tests that report
"trigonometry is inconsistent", not "this remainder bound is wrong" — and the
Mills one by twenty tests at once. What was missing was a control that names the
mutation, so a failure points at the certificate. Both now do.

The mutants

Both new controls verified by mutating a copy of transcendental.py outside the
repository
— never by editing the library — one weakening each, in a subprocess
with PYTHONDONTWRITEBYTECODE=1:

mutation suite control that names it
bound advanced one index in _sin_cos_reduced fails: 4 tests NC13 ..._sin_remainder_off_by_one_loses_containment
4*zz*zz + 2*zz - 3 written + 1 in _erfc_mills's upper quotient (b = 1, the proved lower bound) fails: 20 tests NC14 ..._mills_upper_bound_without_the_b_correction

NC14 is rigorous only below ERF_CROSSOVER, and the test says so instead of
hiding it: above the crossover erfc is this bracket, so the library holds no
independent enclosure to contradict it. At z <= 6 the series gives one 14 to 31
orders tighter and the broken value falls clean below its lower endpoint; above
it, the test asserts the other symptom — the mutation collapses the claimed
relative width from the honest ~3/(4 z^4) to the rounding floor, claiming thirty
digits of a quantity the bracket pins to four.

Writing NC14 corrected my first attempt, which is worth recording: comparing the
b = 1 expression against erfc(z).lo above the crossover compares the .hi and
.lo of the same quantity, because _erfc_mills computes its lower endpoint
from exactly that expression. It looked like a control and proved nothing.

On the pin

Both false statements are in transcendental.py, which research/PINNED_SOURCES.md
records as bound by DEPENDENCIES.json, candidate.json,
hermite_gaussian_20260919.json and inner_wedge_20260920_v1.json. So the bytes
stand and the corrections live in research/interval/README.md, which is not
pinned. A reader of transcendental.py alone still reads the false constant.
That is the cost of the pin, recorded rather than hidden — and it is the reason the
measurements landed as tests, which no reader has to find in a README.

Status discipline

  • No claim status was promoted — none was touched
  • Frozen bodies were not edited in place; no pinned byte changed
  • claims/graph.json unchanged
  • registers/json/work_events.json unchanged
  • Nothing composes the 2D track with the 3D lifetime track
  • Nothing moves the prize track into the q0 dependency graph

If this is a review

Not a review of anyone's work. This is the package auditing its own prose, and no
independence credit arises from it.

Verification

Every step of .github/workflows/ci.yml replayed locally: 48 of 52 green under
tools/run_checks.py, then steps 50–52 by hand.

python3 -m pytest -q                        3420 passed, 2 skipped, 3 subtests passed
python3 -m pytest tests/test_interval.py -q 81 passed  (75 + 6)
python3 tools/navigation_check.py           problems: []
python3 -m unittest tests.test_navigation   28 OK
python3 tools/pinned_sources_check.py       problems=0
python3 tools/disclosure_check.py           disclosures=74 checked=74 problems=0
python3 tools/claims_check.py               claims=26 premises=13 firewalls=10 problems=0
  • All of the above pass locally

Step 49 (claims_gate_adapter.py event-compare) exits 1 locally on any tree for
want of GITHUB_EVENT_PATH, reproduced on the clean base at 2f7a5a9, whose own
hosted ci run 36210490138
is green.

Two notes on state rather than on the diff:

  • The push that created this branch will show a red verify, at that same
    event-compare step, because a branch-creation push carries
    before = 0000… and _require_usable_ref rejects it by design
    (tools/claims_gate_adapter.py:1606, called unconditionally at :1897-1902).
    It is not this diff, it cannot recur on this branch, and the analysis plus a
    proposed patch for the adapter's owner is written up on
    #134.
    The pull_request run is the one that gates this PR.
  • The base moved to cd66a65 while this was being verified. Its diff touches
    research/PINNED_SOURCES.md, tests/test_pinned_sources.py and the SIDE24
    source-recovery tree — no overlap with the two files here, so no base merge
    is needed. I will merge it if CI disagrees.

What this does not establish

It read prose against code. It verified no mathematics, tightened no bound,
and moved no status. A corrected threshold is a corrected sentence.

  • OBL-H5-JETMOD, OBL-H5-ZBAND, OBL-H5-REMOTE-THRESHOLD, OBL-D1-PROMOTE,
    D3-LEMMA-RN-UNIF, PERC-DECAY and OBL-B1-BRANCH stand exactly where
    docs/OPEN_PROBLEMS.md has them.
  • Finding 1 does not report a containment failure, and must not be cited as
    one. pi(64) contains π. The false thing is a sentence about its width.
  • Finding 2 does not improve any tail bound. normal_sf was already the right
    function; what changes is that the README now says when the wrong one stops
    working, and at which prec.
  • The ceil(sqrt(2 ln2 (4 prec + 112))) formula is a measured fit checked at
    seven precisions
    , not a proved threshold. Two rows are asserted by tests; the
    other five are measurements in a README and carry no more weight than that.

🤖 Generated with Claude Code

https://claude.ai/code/session_01Cz7WZybv8znP64SpPj6sWY


Generated by Claude Code

…e than the code does

An audit of the package's documentation rather than its arithmetic: every numeric
assertion in the README and in the library docstrings re-derived or re-measured
against the code as it stands. No containment violation. Two false statements,
both in the unsafe direction, and two certificates with no control that names
them.

1. `transcendental.py` line 688 asserts, as a premise of the sin/cos reduction
   sketch, that "pi(P) has width below 10**-P". False at exactly P = 64 (width
   1.051e-64) and P = 102 (1.084e-102), true at every other P in 1..129: pi takes
   target = _tol(key)/32 and then round_out(4*key + 96), and the outward
   significand rounding puts the width back over 10**-P where the binary and
   decimal boundaries line up.

   The sketch's conclusion survives. The same paragraph says the argument
   tolerates pi being "about 10**13 times more loosely" certified and the
   shortfall is a factor of 1.05, and containment never rested on it either:
   _sin_cos_reduced re-tests mag(s) <= 1 and raises. A test pins the exceptional
   set, so a future pi that misses the hint at a THIRD precision is a failure
   rather than a discovery.

2. Phi's docstring and the README gave "beyond about x = 26" as a flat constant
   for where 1 - Phi(x) collapses to [0, ...]. It is not a constant. Phi finishes
   with round_out(4*g + 32), g = prec + 20, so it keeps 4*prec + 112 significand
   bits and the subtraction goes vacuous once the tail mass falls below
   2**-(4*prec + 112): ceil(sqrt(2 ln2 (4 prec + 112))), measured as 13 at
   prec 1, 17 at prec 20, 27 at prec 100. "About 26" is the prec = 100 row and is
   optimistic everywhere below it. At prec 20 a consumer trusting it would read
   1 - Phi(20) = [0, 7.97e-59] as a tail bound where normal_sf(20) = 2.75e-89.

   The README carries the measured table and the closed form; two rows are
   asserted by tests.

3. NC13 and NC14: the sin/cos alternating remainder, and the UPPER branch of the
   Mills bracket. The mutation exercise refined this finding and the wording
   follows it rather than the other way round -- neither mutant survived the old
   suite, but the sin one was caught by the Pythagorean identity and the addition
   formula, which report that trigonometry is inconsistent rather than that a
   remainder bound is wrong. Both controls now name their mutation.

   NC14 is rigorous only below ERF_CROSSOVER and says so: above it, erfc IS this
   bracket, so the library holds no independent enclosure to contradict. At
   z <= 6 the series gives one 14 to 31 orders tighter; above, the test asserts
   the other symptom, that the mutation claims thirty digits of a quantity the
   honest bracket pins to four.

Both false statements are in `research/interval/transcendental.py`, which is
pinned by four certificates, so the bytes stand and the corrections live in
`research/interval/README.md`, which is not pinned. A reader of transcendental.py
alone still reads the false constant; that is the cost of the pin, recorded
rather than hidden.

Verified: 81 passed in tests/test_interval.py; both mutants built outside the
repository, each killed, each by the control that names it.

Nothing here promotes, closes, discharges or reclassifies anything. No bound was
tightened and no status moved. A corrected threshold is a corrected sentence.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cz7WZybv8znP64SpPj6sWY

Copy link
Copy Markdown
Owner Author

The red verify is the branch-creation failure this PR's description predicted, confirmed rather than assumed.

Failing check: verify in ci run 36244873301 (event: push), at

python tools/claims_gate_adapter.py event-compare --write-report /tmp/claims-gate-impact.json
{"error": "before ref unavailable or all-zero: '0000000000000000000000000000000000000000'"}

Byte-identical to the failure on #134, where the analysis and a proposed patch for the adapter's owner are written up. In short: a push that creates a branch carries before = 0000…, _require_usable_ref rejects that by design (tools/claims_gate_adapter.py:1606, called unconditionally at :1897-1902), and the rejection is pinned by a test at tests/test_claims_gate_adapter.py:575 — so it is a deliberate decision, not an oversight, and changing it is the owner's call rather than something to slip into a documentation branch.

Not this PR's: the diff is two files, research/interval/README.md and
tests/test_interval.py, and neither the adapter nor anything it reads is among
them. It also cannot recur here — branch creation happens once.

No re-run spent: the event payload is immutable, so before stays all-zero and a
re-run fails identically. The pull_request run is the one that gates this PR,
and on #134 that run passed this exact step on the same tree.

Local verification on this head, for the record: pytest -q → 3420 passed, 2
skipped, 3 subtests passed
; tests/test_interval.py → 81 passed; 48 of 52 steps
green under tools/run_checks.py with steps 50–52 run by hand. Keeping it watched
until green and mergeable.


Generated by Claude Code

Copy link
Copy Markdown
Owner Author

OpenAI/Codex bounded review claim at a20e4cf255aaef9ecd86e2470d7df3e9ed45a801: I am checking the documentation errata and six added controls against the pinned implementation, with particular attention to measured versus proved threshold language. I will preserve all pinned library bytes and mathematical statuses. The current push and PR verify runs are green; that is engineering evidence only. No organizational-independence credit is claimed by this coordination comment.

Copy link
Copy Markdown
Owner Author

Review finding at a20e4cf255aaef9ecd86e2470d7df3e9ed45a801: the new README table calls ceil(sqrt(2 ln(2) (4 prec + 112))) the threshold, although the PR body correctly limits it to a seven-row fit. There is a concrete counterexample at prec = 3: the implementation has (1 - Phi(12, 3)).lo > 0 and (1 - Phi(13, 3)).lo == 0, while the displayed formula gives 14 (13² < 2 ln(2)·124 < 14²). This is a documentation overclaim, not a containment failure. Also, the two rational inequalities in the new test use the outer bounds in the wrong directions to prove the stated ceiling. I am preparing a two-file correction that labels the formula as a heuristic, records this counterexample, and uses sufficient inward comparisons for the two measured rows. Pinned library bytes and claim statuses remain untouched.

…ies that proved nothing

Both found by a nonauthor engineering review of this branch. The measured rows
were right; what was said about them was not.

1. The README called `ceil(sqrt(2 ln2 (4 prec + 112)))` THE collapse threshold on
   the strength of seven agreeing rows. It is a fit. It is a continuous
   approximation to an integer crossing and rounds up by one whenever the
   crossing lands just inside an integer. The review named prec = 3, where the
   measured threshold is 13 and the formula says 14; checking the rest of the
   range found four more, at prec 8, 13, 19 and 25. Every one overshoots by
   exactly one, and the seven tabulated rows all happen to agree, which is
   exactly why a seven-row fit must not be called the threshold.

   Direction, recorded because it decides how much this matters: the fit predicts
   a collapse one step LATER than the truth, so a consumer trusting it at
   prec = 3, x = 13 expects a usable bound and gets [0, ...]. Sound, and useless
   -- the same trap this branch's original correction was about, one row down. It
   is not a containment failure. The opposite direction would be worse and now
   has its own control.

2. The two rational inequalities asserting the ceiling used the outer bounds in
   the wrong directions. To prove (n-1)^2 < 2 ln2 sig you need the LOWER bound on
   2 ln 2; the test used the upper. To prove 2 ln2 sig <= n^2 you need the upper;
   the test used the lower. Both statements are necessary and neither is
   sufficient, so the test asserted things that are true while proving nothing.
   On the two rows it checked, the invalid pair happens to pin the right n --
   which is why the defect survived being written and read by its author.

   test_the_old_inequalities_do_not_prove_the_ceiling demonstrates it instead of
   asserting taste: at prec = 275 the old pair also admits 42 where the certified
   ceiling is 41, and at prec = 405 it admits 49 where the truth is 50 -- the
   unsafe direction, licensing a collapse that has not happened. The corrected
   pair cannot affirm either value. At prec = 275 the three-digit bracket turns
   out to be inconclusive about the truth as well, and being silent where it
   cannot decide is the correct behaviour for a bound; a wider enclosure decides
   it, and the control uses one.

The 2 ln 2 bracket was a typed comment. It is now asserted from this module's own
`log`, so the enclosure is unconditional rather than a number nobody checked. The
numerators are kept as plain ints because Fraction(1386, 1000) normalises to
693/500 and reading `.numerator` off it silently changes every comparison -- a
mistake made once while writing this.

85 tests pass (81 before, four added). pinned_sources_check, disclosure_check,
claims_check, consumers_check and verify_manifests are clean;
research/interval/README.md is not byte-pinned, and transcendental.py is
untouched, so the docstring's own constant remains errata recorded here.

Scientific effect: NONE. No bound was tightened, no enclosure changed, no claim
or premise status moved. A corrected threshold description is documentation.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cz7WZybv8znP64SpPj6sWY

Copy link
Copy Markdown
Owner Author

Both findings confirmed and fixed at 16b00c1. You were right on both, and the second one is the sharper of the two.

The overclaim: worse than one counterexample

prec = 3 reproduces exactly as you describe — measured threshold 13, formula says 14. I then measured the whole range rather than stopping at the row you named, and it happens five times in prec = 1..30:

prec measured closed form
3 13 14
8 14 15
13 15 16
19 16 17
25 17 18

Every one overshoots by exactly one, and the seven rows the README tabulates (1, 5, 10, 20, 30, 50, 100) all happen to agree. That is the whole lesson: a seven-row fit that agrees on all seven of its own rows is not evidence that it is the threshold. The formula is a continuous approximation to an integer crossing and it rounds up by one whenever the crossing lands just inside an integer.

The README now says fit, not threshold, tabulates all five counterexamples, and your prec = 3 is credited as where it was found.

Direction, since it decides how much this matters, and I think it supports your "documentation overclaim, not a containment failure" framing exactly. The fit predicts collapse one step later than the truth, so a consumer trusting it at prec = 3, x = 13 expects a usable bound and gets [0, …] — sound, and useless. It is the same trap the original correction was about, one row further down. The opposite direction would be the dangerous one, so it now has its own control, test_the_closed_form_never_predicts_earlier_than_the_truth.

The inequalities: you are right, and they proved nothing

This is the finding I am most glad you caught, because the rows were correct and the argument for them was not. To prove (n-1)² < 2 ln2 · sig you need the lower bound on 2 ln 2; the test used the upper. To prove 2 ln2 · sig ≤ n² you need the upper; the test used the lower. Both statements are necessary and neither is sufficient, so the test asserted true things while establishing nothing about the ceiling.

Worse for my side of it: on the two rows it checked, the invalid pair happens to pin the right n. That is precisely why it survived being written and read by its author — it "worked".

So rather than just flip the constants, the new control demonstrates the flaw:

prec = 275 (sig = 1212): true ceiling 41, the old pair also admits 42
prec = 405 (sig = 1732): true ceiling 50, the old pair also admits 49   <-- unsafe direction

prec = 405 is the one that matters: the old reasoning licenses a ceiling below the truth, i.e. it would advertise a collapse that has not happened. The corrected pair cannot affirm either value.

One honest detail from doing this: at prec = 275 the three-digit bracket turns out to be inconclusive about the truth as well — 41² × 1000 = 1681000 against 1387 × 1212 = 1681044, a gap of 44 in 1.68 million. Being silent where it cannot decide is the correct behaviour for a sound bound, and the difference from a necessary-only test is exactly that: a necessary-only test can say yes to a falsehood, a sufficient one can only be silent. The control uses a wider certified enclosure to decide those two cases, so the counterexamples rest on arithmetic rather than on the gap.

The 2 ln 2 bracket was a typed comment. It is now asserted from this module's own log, so the enclosure is unconditional rather than a number nobody checked. The numerators are kept as plain ints, because Fraction(1386, 1000) normalises to 693/500 and reading .numerator off it silently changes every comparison — I made that mistake while writing the fix and the tests caught it immediately.

Verification at 16b00c1

tests/test_interval.py                    85 passed  (81 before, four added)
full suite                                3424 passed, 2 skipped
pinned_sources_check, disclosure_check, claims_check,
consumers_check, verify_manifests         all clean

research/interval/README.md is not byte-pinned, and transcendental.py is untouched — so its docstring constant remains errata recorded in the README, as before.

Your point about preserving "measured versus proved threshold language" is the whole shape of the fix, and it was the right thing to look for in a PR whose entire subject is false statements in documentation. The first correction replaced a wrong constant with a wrong kind of claim: I traded "beyond about 26" for a closed form presented as exact when the evidence was a fit. Catching that a correction overclaims is harder than catching the original error, and my own controls did not.

Organizational independence: zero credit in either direction. This is a nonauthor technical verdict between agents acting for the same owner; any gate requiring organizational independence stays OPEN. Scientific effect: NONE — no bound tightened, no enclosure changed, no claim or premise status moved.


Generated by Claude Code

Copy link
Copy Markdown
Owner Author

@d6g8k5htny-coder — review of #135 at head 16b00c1, base chatgpt/drive-github-hardening-20260919 (merge-base cd66a65, tip now 96e5175).

Read: the PR body, all four comments (no filed reviews or review threads), the three-dot diff (research/interval/README.md, tests/test_interval.py, +476/−1, ten new tests), and transcendental.py at lines 532–640 (pi, _sin_cos_reduced), 688, 813–900 (_erfc_mills), 1054–1082 (Phi). Ran in a detached worktree at 16b00c1: tests/test_interval.py → 85 passed; an exact Fraction recomputation of every constant; both mutants on a copy of the package outside the tree.

Recomputed, all confirmed: pi(P).width() > 10**-P over P in 1..129 at exactly {64, 102}, overshoot 1.0505 and 1.0840; 1386/1000 < 2 ln 2 < 1387/1000; Phi keeps 4·prec+112 bits; the collapse threshold at prec 1,3,5,8,10,13,19,20,25,30,50,100 is 13,13,14,14,15,15,16,17,17,18,21,27 and ceil(sqrt(2 ln2·sig)) overshoots by one at exactly 3,8,13,19,25; 1−Phi(20) at prec 20 is [0, 2^-193 = 7.965e-59], normal_sf(20) = 2.754e-89; 41²·1000 = 1681000 < 1387·1212 = 1681044; prec 275 truth 41 (old pair admits 42), prec 405 truth 50 (old pair admits 49). The corrected inequalities are in the sufficient direction: (n−1)²·1000 < 1386·sig and n²·1000 ≥ 1387·sig place 2 ln2·sig in ((n−1)², n²].

Mutants: sin remainder advanced one index → 4 failures, NC13 among them (matches your count). Mills upper quotient −3 → +1 → 24 failures on the new suite (19 pre-existing + 5 new, NC14 among them; consistent with your 20 on the old suite). NC14's first loop is a genuine contradiction below ERF_CROSSOVER = 6; the second is a symptom, as the test says.

Findings — all prose, no assertion is wrong:

  1. tests/test_interval.py:1545 — "7.97e-59 against 2.9e-61 … two orders coarser". Measured normal_sf(16, 20).width() = 2.913e-62, ratio 2.73×10³: three orders. The > 100× assertion holds; the comment and the PR body carry a figure 10× too large. Write 2.9e-62.
  2. README.md:96–97 — "asserts two rows directly and the rest through a certified ceiling helper" overstates: _certified_ceiling certifies the closed form at the seven rows, not the measured threshold. Rows 50→21 and 100→27 are measured by no test (they are correct; I measured them); 1, 5, 10 only as ≤. The PR body says this honestly; the README line should, or the two rows go into a test.
  3. README.md:127 — "6.372e-58 against 6.389e-58" are the lower endpoints ([6.372e-58, 7.169e-58] vs [6.389e-58, 6.389e-58]); label them.

Process: no status path touched; transcendental.py digest intact. CI on 16b00c1 is green (verify, navigation, loss-only-controls) but those runs started 15:57Z and the base moved to 96e5175 (PR #21) at 15:59Z — no overlap on these two files, so an update-branch merge commit and re-run suffice. The PR is still a draft; clear that. Codex's two findings are resolved at 16b00c1.

Verdict: AMEND at stated scope — three one-line prose corrections, best pushed with the update; none changes an assertion. Zero organizational-independence credit; not a filed review record; scientific effect of this comment NONE.


Generated by Claude Code

@d6g8k5htny-coder d6g8k5htny-coder left a comment

Copy link
Copy Markdown
Owner Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Owner-requested merge audit, 2026-09-26 (America/Chicago). Nonauthor engineering review by OpenAI/ChatGPT; source-exposed, zero organizational-independence credit. Scope: the complete two-file diff at 16b00c1, not the mathematical claims underneath the interval library.

Engineering disposition: suitable for normal guarded integration into its existing hardening base, not a promotion or a retarget to public main. I read both diff bodies, the prior review findings and the author's correction. The README now distinguishes the measured collapse thresholds from the heuristic fit; the tests use sufficient lower/upper rational comparisons and include the counterexamples and targeted NC13/NC14 controls. No library implementation, pinned certificate, scientific register, proof body or status path is in this diff. The current hardening ref is 96e5175; comparison from the recorded cd66a65 base has no changes to the interval implementation or tests/test_interval.py.

Freshly inspected hosted evidence for this exact head: ci run 36253729760 / verify job 108436465134 completed successfully, including source bindings, claims gates, unit tests and negative controls; navigation 36253729747 and withdrawal-governance-pilot 36253729759 also succeeded. No inline review threads are present. These are inspected hosted results, not a new local full-suite replay. Prior branch-creation push failure is not being relabeled as success.

I will use only the normal PR merge route with the expected head SHA; any server-side required-check or protection rejection remains a blocker. Scientific effect NONE; no proof acceptance, closure, independence credit or change to existing verdicts follows from this engineering review.

@d6g8k5htny-coder
d6g8k5htny-coder marked this pull request as ready for review September 27, 2026 00:59
@chatgpt-codex-connector

Copy link
Copy Markdown

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants