Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
19 changes: 18 additions & 1 deletion docs/ci-verification.md
Original file line number Diff line number Diff line change
@@ -1,8 +1,25 @@
# CI verification

## Current selected-family replay: #6030
## Current selected-family replay: #7000 with #7001

The [selected record](../certificates/selected-result.json) binds conditional
κ = 0.00363005817 to the [application review](research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md),
[validation receipts](research/pr-intake-evidence/pr7000-application/VALIDATION.json),
and [explicit source closure](../certificates/frontier7000-source.json).
`make frontier7000-verify` follows that exact-source selected replay. The review
reuses eleven authenticated preceding executions and records seven fresh serial
application, scalar and complete native-catalogue executions. The earlier
monolithic timeout is retained separately and is not completed coverage.
Consult the receipts for exact commands, source heads and limits.

The five inherited framework assumptions remain. No complete uniform word,
literal multiplier execution, independent human proof or formal-kernel proof
is asserted. Routine research submissions do not need to rerun this
selected-family replay. The sections below preserve historical checkpoints.

## Historical selected-family replay: #6030

The [historical checkpoint](../certificates/checkpoints/frontier6030.json) binds conditional
κ = 0.003125804 to the [proof review](research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md),
[validation receipts](research/pr-intake-evidence/pr6030-audit/VALIDATION.json),
and [explicit source closure](../certificates/frontier6030-source.json).
Expand Down
205 changes: 205 additions & 0 deletions research/cubic-r15-height-obstruction/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,205 @@
# A coefficient-height obstruction at arity 15

Produced by Nick Petalas. Apache-2.0.

## Statement and exact contract

Use the exact dyadic cubic-reader contract of Armin Pourshafeie / apoursh,
PR #6212. The distinct registers y,a,b have arbitrary incoming values Y,A,B.
Retain all fifteen children, in their original order:

```text
y += a^3
a += b
```

The eager endpoint is (Y+15A^3,A,B). The deferred endpoint is
(Y+sum_{i=0}^{14}(A+iB)^3,A+15B,B). An appended repair may use any fixed
invertible dyadic linear source changes on a,b alone and signed dyadic
weighted cube queries, with both sources restored. There is no output feedback, child
fusion, nonlinear source change or output recoding. This is the inherited
contract, not a new physical implementation.

For a nonzero dyadic source row (alpha,beta), write it as t(a,b), where
(a,b) is a primitive integer pair, a>0 or a=0<b, and t is nonzero and dyadic.
Define its primitive height as max(|a|,|b|). This height is invariant under
nonzero dyadic rescaling of the source row whenever that rescaling is legal.

**Theorem, finite certificate with a scoped algebraic proof.** Any exact
three-query repair at arity 15 has at least two source directions of
primitive height greater than 64. The third direction is unrestricted.
This does not prove that a three-query repair exists, or that four queries
are necessary. The bound 64 is not asserted to be sharp.

The new computational content is a complete pair exclusion over 5,040
primitive directions and 12,698,280 unordered pairs. For each pair an exact
algebraic reduction determines its only possible third direction, without
a height cutoff on that direction. Two full implementations find no
dyadic triple containing a pair from this domain. The theorem depends on that finite
execution. It is not a proof-kernel formalization.

## Normalize all possible source rows

The output defect, credited to Nick Petalas's PR #6200, is

```text
D15 = 315 A^2 B + 3045 A B^2 + 11025 B^3.
```

Every source row reached by a product of dyadic source changes has dyadic
entries. Clear powers of two from a nonzero row and divide the resulting
integer pair by its gcd, choosing the sign above. The resulting scale t is
dyadic, so gamma(alpha A+beta B)^3 becomes
(gamma t^3)(aA+bB)^3 with a dyadic weight. Conversely, a primitive integer
row has a determinant-one integer completion by Bezout's identity. Thus
excluding primitive weighted-cube decompositions excludes the corresponding
source programs even without imposing chronological restrictions.

Two rational cubes cannot represent D15. In a two-cube representation,
A^3 cancellation and the nonzero A^2 B coefficient force both A coefficients
and both weights to be nonzero. Normalize their forms to A+sB and A+tB.
The coefficient comparison from PR #6200 / apoursh's PR #6212 gives

```text
s+t = 3045/315 = 29/3,
s^2+s*t+t^2 = 11025/105 = 105,
(t-s)^2 = 4*105 - 3*(29/3)^2 = 419/3.
```

A rational square has a square reduced denominator; 419/3 has denominator
3. Hence zero, one or two cubes are impossible, even over Q. In a
three-query representation the weights are therefore nonzero and the
three primitive directions are distinct. Repeated directions would combine
to at most two cubes.

## Determine the unrestricted third row

Write the normalized moments of D15 as

```text
(s0,s1,s2,s3) = (0,105,1015,11025).
```

For three distinct rows (a_j,b_j), the homogeneous version of the node
condition in Nick Petalas's PR #6653 is

```text
s1*(b1*b2*a3 + b1*a2*b3 + a1*b2*b3)
- s2*(b1*a2*a3 + a1*b2*a3 + a1*a2*b3)
+ s3*a1*a2*a3 = 0. (1)
```

One direct derivation applies the commuting differential operators
(a_j partial_B - b_j partial_A) to D15. Their product annihilates every
one of the three proposed cubes, since one factor annihilates its own
source form. Applied to D15, the product is six times the left side of
(1). This also proves (1) when a row is the pure-B direction (0,1), with
no division by its A coefficient. For finite slopes it is precisely the
credited node condition after homogenization.

Fix the first two rows u=(a,b) and v=(c,d). Put

```text
E = s1*b*d - s2*(b*c+a*d) + s3*a*c,
F = s1*(b*c+a*d) - s2*a*c.
```

Equation (1) says E*a3+F*b3=0. Unless E=F=0, its unique projective solution
is the primitive normalization of (F,-E). The verifier explicitly rejects
an E=F=0 pair as an incomplete certificate; none occurs in the finite domain.
It discards a repeated third direction using the two-cube argument above.

For any remaining candidate triple, a row j with a_j != 0 has the unique
weight

```text
gamma_j = [s2*a_k*a_l - s1*(b_k*a_l+a_k*b_l)]
/ [a_j*(b_j*a_k-b_k*a_j)*(b_j*a_l-b_l*a_j)]. (2)
```

Here {j,k,l}={1,2,3}. To derive (2), apply the moment functional
L(1)=0, L(x)=s1, L(x^2)=s2 to the degree-two Lagrange polynomial for the
three finite slopes, then undo the a_j^3 normalization. If one direction
is (0,1), the same formula for the other two follows directly from A^3
and A^2 B comparison. Its remaining weight is
s3 minus the two finite rows' B^3 contributions.

A nonzero rational numerator/denominator is dyadic exactly when the
absolute denominator after gcd reduction is a power of two. The primary
checker uses this integer test before constructing fractions. Every
accepted control also undergoes all four exact moment checks.

## Complete finite domain and result

The height-64 projective integer box is exactly

```text
{(0,1)} union {(a,b): 1<=a<=64, -64<=b<=64, gcd(a,b)=1}.
```

It has 5,040 rows. Distinct canonical primitive rows are distinct projective
directions, so every unordered pair is independent. The primary checker
visits all 5,040*5,039/2 = 12,698,280 pairs and obtains:

| Classification | Pairs |
| --- | ---: |
| Unique third direction repeats one of the pair | 17 |
| Unique distinct triple has a non-dyadic forced weight | 12,698,263 |
| Undetermined third direction | 0 |
| Admissible dyadic triple | 0 |

These are per-pair classifications, not a classification of every failed
search method or every global representation. The third primitive row can
have arbitrarily larger height than the pair cutoff; it is never clipped.
A separate positive control with two height-one rows forces a third row of
height 129 and is accepted, testing that distinction.

If an exact three-query repair had two directions of height at most 64,
their unordered pair would occur in the census. Its unique third direction
and forced weights would pass. None does, proving the theorem.

## Separate coordinate proof and checker

The second checker does not import the primary one or use (1) or (2).
For each pair u=(a,b), v=(c,d), put X=aA+bB, Y=cA+dB and delta=ad-bc.
Expand

```text
delta^3 D15(A,B) = P(X,Y) = p0 X^3+p1 X^2 Y+p2 X Y^2+p3 Y^3
```

by substituting A=(dX-bY)/delta and B=(-cX+aY)/delta.
A third cube, together with arbitrary X^3 and Y^3 terms, must account for
both mixed coefficients. If exactly one of p1,p2 vanishes, this is
impossible. If both vanish, D15 would be two rational cubes, already
excluded above. Otherwise the third form is proportional to p1 X+p2 Y,
and the forced weights on the first two primitive rows are

```text
(3*p0*p2-p1^2)/(3*delta^3*p2),
(3*p3*p1-p2^2)/(3*delta^3*p1).
```

If g=gcd(p1*a+p2*c,p1*b+p2*d), the third primitive-row weight, before
canonical sign correction, is g^3/(3*delta^3*p1*p2). The second checker
checks these dyadic denominators over the same complete pair domain.
Its different intermediate classification is recorded by its own output;
both implementations must reject all 12,698,280 pairs.

## Scope, credit and next step

The question comes from apoursh's PR #7475 and its remaining-arity opening;
its r=24 construction is not rerun here. apoursh's #7479 proves modular
solubility for every odd modulus, and #7478 classifies a fixed equal-weight
family. Neither result is contradicted by a coefficient-height restriction
on one global dyadic representation. The new pair reduction and complete
height-64 exclusion are this contribution. The fixed reader, general-frame
contract, node lemma and earlier constructions retain their named credit.
No predecessor executable is imported or executed.

There is no repaired word, physical query price, favorable invoice or new
kappa. Native caller compatibility, chronology, restoration costs, routing,
precision, storage and the five selected framework assumptions remain
outside this finite coefficient result. A larger unrestricted search must
allow at least two primitive rows beyond height 64; it may instead seek a
stronger global valuation argument. Neither path is reserved here.
156 changes: 156 additions & 0 deletions research/cubic-r15-height-obstruction/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,156 @@
# Two small query directions cannot repair the arity-15 cubic reader

This result was produced by Nick Petalas. Apache-2.0.

**Finite certificate with a scoped algebraic proof.** Every exact three-query
dyadic repair of the fixed cubic reader at arity 15 needs at least two source
directions whose primitive integer coefficient height exceeds 64. The third
direction has no height bound in the check. This does not settle whether three
queries exist, prove a four-query lower bound, or improve kappa.

A dyadic source row is normalized to a signed primitive integer pair (a,b),
with a>0 or a=0<b. Its height is max(|a|,|b|). The statement applies to
arbitrary invertible dyadic source changes, not only monic forms or shears
that keep the original b fixed. The incoming y,a,b are arbitrary. The
fifteen original children remain in order. Source changes act on a,b alone;
both sources must be restored, and queries are fixed dyadic weighted cubes
without output feedback.

The new step is an exact reduction from any two query directions to their
only possible third direction, followed by two complete finite checks.
There are 5,040 canonical primitive rows in the height-64 box and 12,698,280
unordered pairs. Both checkers find zero admissible dyadic triples. The
primary census rejects 17 pairs because their third direction repeats one
of the pair and 12,698,263 because a forced weight is not dyadic. It finds
no pair with an undetermined third direction. These counts enumerate the
stated pair domain only.

[PROOF.md](PROOF.md) proves the unrestricted-third-row reduction and the
connection to source-restoring programs. `verify.py` uses a homogeneous
annihilating-cubic condition and exact forced weights. `independent.py`
changes to the two selected source coordinates and compares the mixed
coefficients there. It imports neither the primary checker nor predecessor
code. Both checks cover the full pair domain; both include positive
certificates with an unbounded third row and pure-B directions, along with
non-dyadic and defect controls. Finite execution supports the stated finite
exclusion; independent human and formal proof-kernel review are unclaimed.

## Reproduce

From the repository root, using CPython 3.12 and the standard library:

```sh
~/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/cubic-r15-height-obstruction
~/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/cubic-r15-height-obstruction/verify.py
~/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/cubic-r15-height-obstruction/independent.py
~/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/cubic-r15-height-obstruction --check-source-history
```

The registered manifest runs both complete checkers normally and under `-O`.
Each command has a 300-second bound. Expected markers are
`PASS_CUBIC_R15_HEIGHT_OBSTRUCTION`, `PASS_CUBIC_R15_INDEPENDENT`, and
`PASS_REGISTERED_RESEARCH_PACKAGE`. Every run must report 12,698,280 pairs
and zero admissible triples. The primary has eight control fixtures; the
coordinate checker has fourteen, including nine substitution fixtures.

Source documents are bound to canonical main
`e54523517d0f03e58352e647c403a5af3e525a57` in [SOURCES.json](SOURCES.json).
They are read-only inputs to metadata authentication; their scientific
executables are not run. The selected record and original card are historical
provenance. Revision 8's assessment predates the selected #7000 record;
the cheap selected source-binding orientation passed, without a supplier replay.

## Local verification and CI limitation

Both full checks passed in normal and optimized mode under CPython 3.12.
The four timed direct runs took 16.79, 17.04, 16.28 and 16.00 seconds,
respectively. These are command-duration records for the replay budget,
not performance-comparison claims. Each run visited all 12,698,280 pairs.

The unchanged base has a separate CI navigation failure. The six-test
`test_research_current_status.py` module has one failure because
`test_current_ci_section_matches_selected_record` expects
`make frontier7000-verify`, while `docs/ci-verification.md` still names
#6030. The same final test failure appears in the hosted planning jobs for
[#7475](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/43291062509/job/131437108801)
and [#7478](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/43291772301/job/131439552156).
Those logs were read; their research results were not replayed. This package
leaves that shared documentation and its test unchanged. Hosted success for
this contribution is unclaimed.

## Overlap coverage

Live PR title/body searches included the exact arity, cubic repair, general
frames, coefficient height and general-arity variants, alongside main-branch
README searches. The task overlap helper fetched all 800 open PR records and
7,396 Discussion records at the reported snapshot, but its sparse local scan
covered only 222 of 10,178 tracked note paths. Relevant cubic packages were
materialized and main was searched directly. No duplicate pair-height
exclusion was found within that coverage. This is not a novelty certificate
or a claim about private work or every historical code diff.

## Limitations and expansion decision

This is a local coefficient obstruction. No attaining r=15 word, priced
query or shear, complete caller invoice, restoration implementation, native
backend, routing, precision/storage or new selected assumption is supplied.
A finite exclusion with two bounded directions is stronger than a search
that bounds all three, but it is not an unrestricted nonexistence theorem.
Height 64 is not claimed to be sharp. The three-versus-four dyadic query
minimum remains open. No selected scientific cold replay, Lean or Docker
run is needed for this isolated result, and none was run.

Stop this construction attempt at the proved finite exclusion. Further
searches must allow at least two larger primitive directions and still need
an exact identity and legal restoring schedule before physical pricing.
This package does not authorize a larger dependent implementation campaign.

The checkers have no recursion or external solver. Their fixed loops visit
5,040 rows, 12,698,280 pairs and at most three weights per pair. Per-pair
state is local. Python and Fraction allocate dynamically, a managed-runtime
deviation from fixed-allocation guidance; the fixed input box bounds the
integer sizes and live storage. The primary third-row coordinates have
absolute value below 2^26, and the separate coordinate check uses fixed-degree
integer formulas. Warning-strict normal and optimized executions provide the
available interpreted-language diagnostics. No repository-wide changes are made.

## Open next questions

1. Does arity 15 have an exact three-query dyadic repair with at least two
primitive directions above height 64? Start with larger primitive pairs
or a global valuation restriction on one common rational triple. An exact
identity and source-restoring schedule are the missing obligations.
2. Can an unbounded family of pairs be excluded algebraically? Start with
odd prime factors of the three forced denominators. The present finite
domain alone does not control arbitrary coefficient height.

These questions are open, not reserved follow-on work. Structured first steps
and blockers are also recorded in [TASK.json](TASK.json).

## Credit and related open work

The immediate source question is Armin Pourshafeie / apoursh's
[PR #7475](https://github.com/CrocSwap/integer-mult-bounds/pull/7475),
head `ee81d7e993025b62983ac3def76991af1a58eb01`. Its three-query construction
at r=24 is cited, not replayed. The arity-15 opening predates that work in
Nick Petalas's #6653. The fixed cubic reader and defect are from Nick Petalas's
#6200; the dyadic general-frame contract and query lower bound are apoursh's
#6212. The finite-slope node lemma is Nick Petalas's #6653. Its integer-direction
search did not cover the general primitive rows excluded here.
apoursh's #6215 already excludes every r=15 three-query repair containing a
pure-original-B query. The new exclusion also covers pairs of two non-pure-B,
nonmonic directions. The classical annihilating-form and coordinate-change
methods are not claimed as new general mathematics.

- [#7475](https://github.com/CrocSwap/integer-mult-bounds/pull/7475) constructs
an exact three-query dyadic repair at arity 24; this package excludes small
pairs at arity 15, without recomputing the arity-24 result.
- [#7478](https://github.com/CrocSwap/integer-mult-bounds/pull/7478) classifies
fixed equal-weight repairs by a Pell recurrence; this package allows every
dyadic weight within its stated pair domain.
- [#7479](https://github.com/CrocSwap/integer-mult-bounds/pull/7479) establishes
three-query solvability modulo every odd integer; this package constrains
one exact global representation and does not contradict modular solvability.

All predecessor attributions and frozen files remain unchanged. The new pair
exclusion and its two complete checkers are the contribution here.
Loading