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
195 changes: 195 additions & 0 deletions research/principal-demand-dirty-spare/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,195 @@
# A restored spare removes the principal-demand orbit obstruction

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

## Contract

Let R be any associative ring with identity, 1 != 0. It need not be finite,
commutative, a domain or a field. Three rows A0,A1,H and a disjoint source p
start with independent arbitrary values a0,a1,h,p in R^w, w >= 1. Every
coefficient acts by left multiplication. The required endpoint is

```text
(A0,A1,H,p) = (a0+x p, a1+y p, h, p).
```

A fixed, input-independent finite word may use only source insertions
P_i(beta): row i += beta p and row additions E_ij(c): row i += c row j,
i != j, with rows numbered 0,1,2 and H numbered 2. Every original dirt
column must return exactly. There is no clearing, observation, free basis
map, extra row, or input-dependent control. We count nonzero source
insertions. Row additions, coefficient preparation and physical use are
separate costs. The optional tariff below charges every gate in the word.

## Theorem

Put L=Rx+Ry, a left ideal. The minimum number of nonzero source insertions is

```text
0 if x=y=0;
1 if L is nonzero and principal;
2 if L is not principal.
```

The new assertion is sufficiency of principality over arbitrary rings after
adding one restored dirty spare. A one-insertion word uses at most eight
row additions, with its insertion at the spare. This bound need not be a
shortest word. Necessity and the two-insertion echo are credited to Ali
Romman #5310 and the retained ring-valued fanout lineage. Their finite-ring
sufficiency theorem does not assert this arbitrary-ring stabilization.

### Necessity

No insertion leaves the source column zero. If a word has exactly one
nonzero insertion beta at row i, let C be the invertible matrix product of
all later row additions. The final source column is

```text
lambda=(x,y,0)^T = C e_i beta.
```

Every coordinate is a left multiple of beta, so L is contained in R beta.
Applying C^-1 expresses beta as a left linear combination of x,y,0 and
gives the opposite containment. Thus L=R beta is principal. This proof
works with any finite number of restored dirty spectators, and it does
not use commutativity, finiteness, or a division operation. Invertibility
also shows that nonzero beta cannot produce zero demand.

### The eight-ADD construction

Suppose L=R beta is nonzero. Since x,y belong to R beta and beta belongs
to Rx+Ry, choose a,b,s,t in R satisfying

```text
x=a beta, y=b beta, beta=s x+t y.
```

These are witnesses, not free divisions. The theorem is existential when
only the ideal's principality is known. An implementation must supply the
witnesses and pay for their preparation. Define the four-ADD word R in
chronological order by

```text
E_20(s), E_21(t), E_02(-a), E_12(-b).
```

On the desired source column it performs

```text
(x,y,0) -> (x,y,sx) -> (x,y,beta)
-> (0,y,beta) -> (0,0,beta).
```

Execute R, then P_2(beta), then the literal inverse of R:

| Step | Gate |
|---:|---|
| 1 | H += s A0 |
| 2 | H += t A1 |
| 3 | A0 -= a H |
| 4 | A1 -= b H |
| 5 | H += beta p |
| 6 | A1 += b H |
| 7 | A0 += a H |
| 8 | H -= t A1 |
| 9 | H -= s A0 |

On every original dirt column, steps 1-4 and 6-9 cancel exactly. The source
column after step 5 evolves under steps 6-9 as

```text
(0,0,beta) -> (0,b beta,beta)
-> (a beta,b beta,beta)
-> (a beta,b beta,beta-t b beta)
-> (a beta,b beta,beta-t b beta-s a beta)
= (x,y,0).
```

The additive group of a ring is commutative; no multiplicative coefficients
were commuted. In particular the order is s a and t b, not a s or b t.
This proves the endpoint for arbitrary dirt and every data width. Zero
coefficient gates may be deleted. The inverse reverses all nine gates and
negates their coefficients, and must be charged if used.

A useful stronger identity holds without any witness relation: the same
word has identity dirt block and source column

```text
(a beta, b beta, (1-s a-t b) beta)^T.
```

The verifier checks this full identity over the free associative integer
polynomial ring. It is a finite coefficient certificate, independently of
all finite-ring substitutions.

### At most two insertions

For any x,y, even without a spare, the chronological word

```text
A1 -= y A0; A0 += p; A1 += y A0; A0 += (x-1) p
```

restores all dirt and produces increments (x p,y p). Delete zero calls.
If L is nonprincipal, x cannot equal 1, so both source coefficients are
nonzero. The necessity argument makes two insertions minimal. Zero demand
has the empty word. These observations complete the classification.

## Polynomial first example and complete declared gate price

For R=K[u,v] over any field K, take

```text
x=1+uv, y=u^2, beta=1,
a=1+uv, b=u^2, s=1-uv, t=v^2.
```

The witness identity is (1-uv)(1+uv)+v^2 u^2=1. Every coefficient of the
eight row additions is a nonzero polynomial over every field, including
characteristic two. The word therefore uses exactly eight nonzero row
additions and one nonzero source insertion, restores the arbitrary third
row, and realizes precisely the demand in Nick Petalas #5211.

That predecessor proves that the same demand with exactly two mutable
rows has no one-insertion word, using Cohn's cited classical theorem.
We use that obstruction as a cited premise and do not replay or reprove it.
The new constructive upper bound is independent of Cohn's theorem.

Let each row addition into row i cost c_i>0, independently of coefficient
and source row, and let insertion at the spare cost mu_2>0. The exact price
of the displayed polynomial word is

```text
mu_2 + 2 c_0 + 2 c_1 + 4 c_2.
```

This charges all preparation, dirty restoration and the insertion in this
abstract alphabet. At mu_0=100, mu_1=1000, mu_2=100 and c_0=c_1=c_2=1,
the displayed word costs 108. The predecessor's exact two-row tariff at
the matching two-row prices is 202. This is a comparison of two explicitly
different workspace contracts, not a new three-row optimum or a physical
cost claim. Inverse execution would cost another 108 under these stationary
prices. Coefficient preparation, storage, movement and actual native gates
are outside the declared abstract tariff and are not assigned zero cost.

## Relation to stabilized dual exchange

Nick Petalas #6280 gives a dyadic exchange for a genuine dual pair ab=1,
with three block shears and one sign SCALE. Its classical stabilized
completion mechanism is related precedent. The present word uses only
elementary row additions and requires merely (1-sa-tb) beta=0. The element
beta may be a zero divisor and sa+tb need not equal 1. Thus no dual pair or
unit beta is assumed. For example, in Z/4, beta=2, a=b=s=1, t=2 satisfies
the witness while sa+tb=3. The claim here is the exact ring-valued fanout
criterion, explicit eight-ADD word and Cohn application, not historical
priority for stabilization or elementary matrix algebra.

## Limits

The finite certificate establishes the stated polynomial identity. The
all-ring classification rests on the written algebraic proof. No shortest
ADD count, all-positive-price three-row tariff, native coefficient
implementation, physical spare lifetime, precision/tape cost, recursive
supplier admission, new kappa, or complete multiplication theorem follows.
All five selected framework assumptions remain. Independent human and
formal proof-kernel review are unclaimed.
164 changes: 164 additions & 0 deletions research/principal-demand-dirty-spare/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,164 @@
# A restored dirty spare reaches every principal two-row demand

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

Claim type: scoped algebraic proof with an exact free-associative polynomial
certificate and finite corroboration. Over every associative unital ring R,
for two demanded rows and one arbitrary dirty spare restored to its original
value, the minimum source-insertion count is

```text
0 for zero demand;
1 for a nonzero principal left demand ideal;
2 for a nonprincipal left demand ideal.
```

The new step is arbitrary-ring sufficiency with the restored spare, using
one source insertion and at most eight elementary row additions. Finiteness,
commutativity, invertible demand coefficients and a clean spare are unnecessary.
[PROOF.md](PROOF.md) gives the ordered-ring construction and all-input proof.
The bound of eight ADDs is constructive, not an ADD optimum or exact tariff.

This answers the feasibility part of Open next question in Nick Petalas's
[PR #5211](https://github.com/CrocSwap/integer-mult-bounds/pull/5211). For its
polynomial demand `(1+uv,u²)` over every field K, one restored dirty spare
removes the two-row one-insertion obstruction. The literal new word has
exactly eight nonzero ADDs and one insertion. Its complete declared abstract
gate price is `mu_2+2c_0+2c_1+4c_2`, with c_i charging each ADD into row i
and mu_2 charging the insertion at the spare. At prices mu_0=100, mu_1=1000,
mu_2=100 and all c_i=1, the word costs 108. The cited two-row optimum is
202 at the matching original prices. The workspace contracts differ; no
three-row optimum or physical saving is inferred.

## Construction and evidence

Given witnesses `x=a beta`, `y=b beta`, `beta=s x+t y`, execute the following
nine gates on arbitrary incoming A0,A1,H,p:

```text
H += s A0; H += t A1; A0 -= a H; A1 -= b H;
H += beta p;
A1 += b H; A0 += a H; H -= t A1; H -= s A0.
```

The endpoint is `(A0+x p,A1+y p,H,p)`. The first and last four gates cancel
on every original dirt column. Without any witness relation, the residual
increment at H is exactly `(1-sa-tb) beta p`. Thus witnesses need only satisfy
an annihilator relation, not `sa+tb=1`. Coefficient preparation and physical
access remain separately paid obligations.

The standard-library verifier imports no predecessor scientific code. It
checks the full four-by-four affine map over the free associative integer
polynomial ring, including the precise product orders, and the literal
inverse. A separate commutative integer polynomial specialization checks
the Cohn word, its inverse, all nine individual gate deletions, every
nonzero coefficient and destination counts `(2,2,4)`.

Exact finite substitutions cover every five-tuple `(beta,a,b,s,t)` over Z/4
and UT2(F2): 1,024 and 32,768 tuples, respectively. Every full affine map and
inverse agrees with the unconstrained residual identity. Among these are
192 and 6,720 nonzero valid witnesses; 48 and 4,704 of those have the chosen
`sa+tb != 1`. A further 3,420 selected witnesses in M2(F2), including 2,160
with the chosen `sa+tb != 1`, check genuinely noncommutative substitutions.
These finite tests check the new word, not predecessor source-count theorems.
Eight invalid-domain controls and explicit wrong-order/nonzero-residual
discriminators also pass. Three disposable optimized-script mutations are
rejected at the free-associative endpoint check: lost restoration, wrong
preparation sign and reversed multiplication. The universal criterion is
the written proof.

## Reproduce

From the repository root, with standard-library CPython 3.12:

```sh
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/principal-demand-dirty-spare/verify.py
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/principal-demand-dirty-spare/verify.py
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/principal-demand-dirty-spare
/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/principal-demand-dirty-spare --check-source-history
```

Substitute another CPython 3.12 path on other hosts. Both registered commands
emit `PASS_PRINCIPAL_DEMAND_DIRTY_SPARE` in a generated JSON receipt binding
all six package files by SHA256. Replay writes nothing. The receipt is
generated by execution, not handwritten. SOURCES.json pins predecessor text
as historical provenance; no external live scientific inputs are required.

## Scope, credit and overlap

Base is canonical main `e54523517d0f03e58352e647c403a5af3e525a57`, priority
revision 8, selected #7000 with conditional kappa 0.00363005817 unchanged.
The selected source-binding positive control passed. The priority catalogue
still describes #5599; its numerical headline is historical. TASK.json
explicitly changes the bit-helper-contract card to this algebraic interface
question. No G20 supplier or selected framework assumption is discharged.
The [advance CLAIM](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19601509)
records the question and proposed ten-ADD bound before the new checks. The
first verified word uses eight ADDs and is packaged without seeking an optimum.

Credit Nick Petalas #5211 for the explicit restored-spare question and the
cited two-row polynomial obstruction; lee-phys #5139/#5089 for the principal
ideal interface; Ali Romman #5310 for the finite associative-ring criterion,
all-ring necessity and two-insertion echo; Krzysztof Wójt #5045 for the
source-count/return classification; and Nick Petalas #4916 for the ring-valued
contract. Ross Richardson, Cinna Davis, Anthony, Oscar Fennell, Tekalign and
the retained fanout lineage keep their credit. Nick Petalas #6280 is related
dyadic dual-exchange precedent. The new annihilator-witness word uses no
SCALE and need not have a genuine dual pair. Elementary stabilization and
row algebra are classical; no literature-wide priority is claimed.

Live open/account PR lists, recent handoffs, active Discussions, local
reservations, all-main README searches for the object and its general-ring
form, and merged/all-state PR searches were checked before the claim.
The batch reservation records the source and main predecessor author.
The cached card search covers 846 open PRs and 7,480 Discussion records,
with complete reported remote pagination at 22:38 and 22:39 UTC on November
13, 2026. Its later local scan covers 222 of 10,178 tracked notes. Sparse local
notes, unpublished work and arbitrary historical diffs are not exhaustively
covered. These searches are overlap checks, not a novelty certificate.

## Limits and verifier constraints

Only the abstract ring gate contract and source-insertion count are settled.
A shortest ADD word and exact three-row directional tariff remain open.
Native coefficient realization, a physical restored spare, source access,
precision/tapes, movement, stock, compiler closure and a complete supplier
invoice are not supplied. Unknown physical costs are not zero. No new kappa,
selected-frontier update or complete multiplication theorem is claimed.
Independent human and formal proof-kernel review are unclaimed. No predecessor
scientific replay, selected cold replay, Lean or Docker build was run.

Build the Lever led to the retained deterministic full-state checker. Prove
It Works led to every independent dirty column, exact noncommutative product
orders, literal inverses and gate-deletion controls. Power of Ten inspection
covers this verifier. Its functions remain below 60 physical lines, matrices
are four by four, words have at most eighteen gates, ring tables have at most
sixteen elements, and the exhaustive tuple domain has at most 32,768 members.
Polynomial capacity is 128 terms and degree twelve, with at most 16,384 term
pairs per product. Six source reads are capped at 256 KiB plus one guard byte.
There is no recursion, subprocess, network, dynamic code generation or write
path. Explicit exception checks remain active under -O. Warning-strict normal
and optimized replay supply interpreter diagnostics; no shared build settings
change.

Power of Ten rule 3 deviation: Python and its standard library allocate managed
objects during this fixed offline run. The capacities above bound live data;
allocator internals are not instrumented. A larger domain or embedded service
must add a separately verified allocation policy. Rule 9 deviation: word
inversion receives only the locally defined polynomial negation function or
a fixed finite-table lookup. These two targets are immediate and retain no
mutable state; both are exercised by the normal and optimized replay. No
open-ended dispatch is accepted.

## Open next questions

- Find the exact directional tariff for the polynomial demand with one
restored dirty spare. Start from the displayed `(2,2,4)` ADD vector and
retain all three dirt columns while classifying arbitrary words. The
missing step is a three-row lower bound, not another check of this word.
- Bind one actual helper boundary to the ring action and a physically
available restored spare. First price coefficient preparation, source
access, lifetimes, routing and the complete consumer. No such physical
binding or favorable recursive invoice is supplied.

Structured relevance, first steps and blockers are in TASK.json.
36 changes: 36 additions & 0 deletions research/principal-demand-dirty-spare/SOURCES.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,36 @@
{
"schema_version": 1,
"base_commit": "e54523517d0f03e58352e647c403a5af3e525a57",
"files": [
{
"path": "certificates/selected-result.json",
"usage": "provenance",
"git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8",
"sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1"
},
{
"path": "docs/research/agent-task-catalog.json",
"usage": "provenance",
"git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
"sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
},
{
"path": "research/cohn-fanout-obstruction/README.md",
"usage": "provenance",
"git_blob": "831e465aa74eb0b8265fdc9f7ee6b692a895e9b3",
"sha256": "a3ffdc41437ba17031276b215fd4a55173817af41b1ddfd426c3ce0127076f07"
},
{
"path": "research/division-free-dual-exchange/README.md",
"usage": "provenance",
"git_blob": "5cf1073edeca87d6a28f0e1b29101d3a3aeafbbd",
"sha256": "c7f6c03990f858c85fd199babdc927f79af25de4421681d9a488c9f8d231ce09"
},
{
"path": "research/finite-ring-source-insertions/README.md",
"usage": "provenance",
"git_blob": "74b9c1a2c17c1330ade8b6f24af225d8aa74f17e",
"sha256": "4e44aabcfb788f16732ecadfe3b85dfa516fdc12909712fd5edb60ea8c6c89b6"
}
]
}
Loading
Loading