Skip to content

Close the arbitrary-clean-workspace gap for two bit targets #2913

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
Mister-Meeseeks merged 1 commit into from
Oct 16, 2026
Merged

Close the arbitrary-clean-workspace gap for two bit targets #2913

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
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
233 changes: 233 additions & 0 deletions research/bit-clean-workspace-compression/README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,233 @@
# Arbitrarily many clean auxiliaries still need six calls

In the formal abelian bit model below, two invertible rational 3-by-3 targets
need exactly six rank-one calls, even with any finite number of clean auxiliary
registers. Clean auxiliaries start at zero and must return to zero. The theorem
uses a new workspace reduction and an independently implemented exact census
of 69,728 reduced words. It is a computer-assisted scoped theorem, not a native
supplier, a new kappa or proof-assistant verification.

waynenilsen's [PR2167](https://github.com/CrocSwap/integer-mult-bounds/pull/2167),
head `cea5d7be431b09877848354f04d5f2ba512339fd`, establishes the same minimum
with one or two clean auxiliaries and explicitly leaves arbitrary counts open.
Its [canonical discussion](https://github.com/CrocSwap/integer-mult-bounds/discussions/2073)
is the predecessor investigation. No code or recorded search output from that
PR is used here. This package closes the unbounded-workspace question through a
separate proof and census, rather than repeating its 24.9-billion-word run.

## Model

Let `H` be generated by nonzero rational rank-one address matrices `A_j` in
`M_3(Q)`. Work over `F2[H]`, with `[A][B]=[A+B]`. On any finite number `n` of
binary scalar roles, call `j` acts chronologically by

`F_j = I + ([A_j]-1) x_j y_j^T`, with `y_j^T x_j = 1`.

Thus its scalar coupling is rank one and idempotent. The endpoint need only
satisfy `P e_i = [C_i] e_i` for the two data basis vectors `i=0,1`, where
`P=F_k ... F_1` and both `C_i` are invertible. Every auxiliary output on these
data columns is zero. Auxiliary input columns are unrestricted, since the
auxiliaries start at zero. Equality is coefficientwise in the formal group
algebra, not equality at sampled address sizes.

Free binary scalar changes of basis are allowed. Commute them to one final
scalar map `M`, conjugating the rank-one idempotents along the way. Augmentation
of the clean endpoint gives `M e_i=e_i`. Removing `M` therefore preserves the
same data-column endpoint, even though `M` need not be identity on auxiliary
columns. Free address maps, nilpotent couplings and discarded nonzero auxiliary
outputs are not included.

## 1. Delete a coloop image in a shortest word

This argument works for any address dimension and any number of data targets
of rational rank at least two. Call `j` a coloop when `x_j` is outside the binary
span of all other `x_t`. Choose a binary linear functional `lambda` killing
those other images and satisfying `lambda(x_j)=1`.

Only call `j` can change the `lambda` coordinate. For each data input,
chronological telescoping gives

`([A_j]-1) h_ji = ([C_i]-1) lambda(e_i)`,

where `h_ji = y_j^T F_(j-1) ... F_1 e_i`.

Since `rank A_j=1` but `rank C_i>=2`, there is a rational linear functional
`ell` on address matrices killing `A_j` but not `C_i`. The induced map
`[A] -> [ell(A)]` makes the left side zero. The right side is nonzero if
`lambda(e_i)=1`. Hence `lambda(e_i)=0` for every data input. Back in the
original ring, the displayed equation gives `h_ji=0`, since `A_j!=0` and the
group algebra of a finitely generated torsion-free abelian group is a domain.
Call `j` therefore acts as identity on every actual data column at its cut.
Deleting it preserves all subsequent data columns and the clean endpoint.

Consequently a shortest successful word has no coloop image. If it has `k`
calls, its image span `U=sum im(x_j y_j^T)` has dimension at most `k-1`.
The rank-at-least-two hypothesis matters. A one-call rank-one target on one
data role is a nonremovable active coloop, checked by the replay.

## 2. Compress the clean workspace

Every coefficient image of `P-I` lies in `U`. The coefficient at each nonzero
data target contains its data axis, so `U` contains both data axes. It is also
invariant under every paid coupling. Restrict to `U`, using a binary basis
starting with the data axes. Each restricted coupling remains rank-one
idempotent: its image vector lies in `U` and it fixes that vector. The clean
data-column endpoint survives; the remaining basis coordinates still start
and end at zero. No condition on auxiliary input columns is needed.

Thus a shortest successful `k`-call word uses at most `k-1` total roles.
If a word of at most five calls exists, first take a shortest one and split
nonzero frames as needed using

`D_N(A) = D_N(A/2) D_N(A/2)`.

Splitting preserves the rational frame span and the absence of image coloops.
It yields five calls on an image span of dimension `r` with `2 <= r <= 4`.

This is a clean-input reduction. It is different from the mixed-target dirty
reduction in [PR2900](https://github.com/CrocSwap/integer-mult-bounds/pull/2900),
head `af4e996ac29cfced53ce8a6d1feed95918fd7f76`, which requires the entire
endpoint matrix and uses an augmentation bound involving target-frame span.
We do not assume its stronger dirty endpoint for clean auxiliaries.

## 3. Reduce the rational addresses to 117 collision patterns

The inherited low-span argument of
[Ali Romman's PR468, section 3](../bit-three-register-lower-bound/README.md)
works on clean data columns, as PR2167 observes. For completeness, choose a
basis of paid rank-one frames when their span has dimension at most three.
An invertible target forces dimension exactly three. Common invertible row
and column transformations make that span diagonal, so each paid rank-one
frame occupies exactly one diagonal line. Project onto one line. Both data
targets have nonzero projected labels, and the projected data block of `P-I`
has rank two over the projected Laurent fraction field. Each remaining call
contributes rank at most one by telescoping. Every line therefore needs at
least two calls, requiring six in total.

At five calls the frame span is consequently four or five. Its integral
relation lattice is saturated and has rank at most one. With no relation,
subset sums do not collide. With a primitive generator `a` having an entry
of absolute value at least two, they do not collide either: no nonzero
integer multiple of `a` is a difference of binary subset indicators.
Otherwise `a` is a cube vector in `{-1,0,1}^5`, up to sign, with at least two
nonzero entries. There are 116 such vectors and one no-collision case.
These are exactly the same address reductions used by the predecessor,
not a search bound on rational frame numerators.

Expand the full product as `sum_b M_b [sum_j b_j A_j]`, with `b` binary.
For each relation pattern, add coefficients whose subset indicators differ
by a multiple of `a`. A possible data input is any nonzero binary vector `v`
for which the grouped polynomial sends `v` to a single monomial times `v`.
Two distinct such vectors are automatically independent over `F2`.

A monomial with subset representative `b` cannot have address rank three if
`b+t a` has support at most two for some rational `t`. Checking `t=-1,0,1`
suffices. A nonzero entry can vanish only at those values; all other `t`
have support at least that of `b`. The no-collision case uses only `support(b)`.
For a noncube relation this deliberately ignores additional sparse rational
representatives, making the screen more favorable, never less, to a proposed
construction. This is a necessary rank test, not an assertion that every
surviving address has rank three. Excluding even these favorable candidates
proves exclusion.

## 4. Complete reduced scalar census

Represent the ordered image vectors by the columns of an `r`-by-5 binary
matrix `X`. Row operations change the scalar basis only. Each row space has
one reduced row-echelon representative, so enumerate those representatives,
requiring every column nonzero and no coloop. For each column `x_j`, enumerate
all `2^(r-1)` covectors satisfying `y_j^T x_j=1`. No gate order, relation or
scalar coupling is omitted. After the basis change the two original data axes
can be any two independent binary vectors, which is why all nonzero vectors
are tested rather than only two coordinate columns.

| Image dimension | Image row spaces | Ordered scalar words | High-rank candidate pairs |
|---:|---:|---:|---:|
| 2 | 35 | 1,120 | 0 |
| 3 | 35 | 35,840 | 0 |
| 4 | 1 | 32,768 | 0 |

All 69,728 words are tested against all 117 address patterns, a total of
8,158,176 word/pattern cases. In dimension two, 12,208 cases have one possible
rank-three monomial eigenvector, so the one-target branch is nonvacuous. None
has two. Dimensions three and four have none. No five-call word exists.
Splitting excludes every shorter word as above. Six calls suffice by giving
each data role the three rank-one column summands of its invertible target.
This proves the stated exact minimum for any finite number of clean auxiliaries.

## Reproduce and evidence

Python 3.12 or newer and a C++20 compiler are required. No third-party Python
packages are needed. From the repository root:

```sh
python3.12 -I -B scripts/research_package.py --package research/bit-clean-workspace-compression
python3.12 -I -O -B research/bit-clean-workspace-compression/verify.py
python3.12 -I -B research/bit-clean-workspace-compression/test_package.py
```

The registered replay compiles with conversion, sign-conversion, shadow and
pedantic warnings treated as errors. It runs the complete native census and
compares `RESULT.json`. The Python oracle independently enumerates actual
binary subspaces and checks all 1,120 dimension-two words plus deterministic
probes in dimensions three and four. Across 1,223 words and 143,091 relation
cases it compares every monomial eigenvector and exponent. It propagates
vectors with exact integer exponent tuples and eliminates the rational
relation, rather than using the C++ matrix expansion and subset-pair tables.
This is a full second implementation for the dimension-two census, not a
second full census in dimensions three and four.

Positive controls include the exact six-call formal construction with distinct
integer and fractional targets, a removable clean-only coloop and the active
rank-one boundary where deletion is invalid.
Omitting a direct call fails. A synthetic two-eigenvector polynomial tests the
native candidate-acceptance branch but is not presented as a legal five-call
word. The CLI tests run normally and optimized after relocation without Git;
they reject a corrupted receipt/source and actual implementation mutations
that omit quotient grouping, skip the census or strengthen the rank threshold.
Normal replay writes nothing. `--write` regenerates only `RESULT.json`.

The written reductions and full C++ census establish the scoped theorem.
Finite oracle probes alone do not prove it. Neither PR2167's engine nor its
historical receipt is trusted or imported. Source bindings, predecessor heads,
freshness, commands and limitations are recorded in `SOURCES.json` and
`TASK.json`. No selected cold replay, supplier-native compilation, hosting,
precision, all-size supplier or multiplication theorem is checked.

## Open next questions

Does the image-coloop reduction help the three-data-target, eight-call problem
with clean auxiliaries? It bounds a shortest word to at most seven total roles,
but that alone does not justify another large census. First specify one exact
frame multiset with favorable complete native and consumer costs, then test
its rational rank cuts and determinant before scalar enumeration. The missing
candidate and its full physical bill remain blockers. No family expansion is
claimed here. Structured next steps are in `TASK.json`.

## Credit and implementation limits

Nick Petalas. Apache-2.0. No independent human or proof-kernel review is claimed.
waynenilsen supplies PR2167's clean-auxiliary question, low-span observation
and one/two-auxiliary results, following the dirty-workspace work in PR1882.
Ali Romman/PR468 supplies the formal model, low-span and rational relation
methods, with eumemic/PR288 and huxint/PR203 retained. The new coloop deletion,
uniform clean compression and reduced census are the contribution here.
Build the Lever led to the replayable reduced census. Prove It Works and Test
Behavior, Not Implementation led to the independent vector oracle and real
CLI implementation mutants.

Power of Ten review covers these three code files. All functions are below
60 lines, control flow is nonrecursive, and all loops have fixed finite
bounds. C++ uses fixed arrays, at most 32 polynomial coefficients, 117 relation
patterns and 4-by-4 binary matrices. Python and standard-library I/O allocation
are rule 3 deviations. Fixed subspace/probe domains and at most 32 terms per
vector polynomial bound the live collections. The engine's fixed record domain
bounds output below 15 MB; replay additionally rejects output above 2 MB.
Compiler and engine calls each have a 60-second timeout and temporary files
have scoped cleanup. This is a finite research command, not a steady service.
Replace the managed allocations
with fixed storage before service use. The fixed local sorting key and
Unittest dispatch are rule 9 deviations with one key function, six fixed test
methods and bounded subprocesses. No external code is imported or generated.
The generic registered runner supplies process
group cleanup; direct native compiler cancellation is not separately audited.
91 changes: 91 additions & 0 deletions research/bit-clean-workspace-compression/RESULT.json
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,91 @@
{
"schema_version": 1,
"census": {
"summaries": [
{
"image_dimension": 2,
"image_spaces": 35,
"words": 1120,
"monomial_vectors": 47484,
"candidate_cases": 0,
"high_rank_vector_histogram": [
118832,
12208,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
},
{
"image_dimension": 3,
"image_spaces": 35,
"words": 35840,
"monomial_vectors": 1659156,
"candidate_cases": 0,
"high_rank_vector_histogram": [
4193280,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
},
{
"image_dimension": 4,
"image_spaces": 1,
"words": 32768,
"monomial_vectors": 2402432,
"candidate_cases": 0,
"high_rank_vector_histogram": [
3833856,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
}
],
"oracle_probes": 1223,
"oracle_relations": 143091,
"relation_patterns": 117
},
"controls": {
"six_call_positive": true,
"omission_rejected": true,
"removable_clean_coloop": true,
"rank_one_boundary": true
}
}
30 changes: 30 additions & 0 deletions research/bit-clean-workspace-compression/SOURCES.json
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,30 @@
{
"schema_version": 1,
"base_commit": "0706e744cbda1e4d0da5a6c569ad9b47876c6960",
"files": [
{
"path": "certificates/selected-result.json",
"usage": "provenance",
"git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81",
"sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
},
{
"path": "docs/research/agent-task-catalog.json",
"usage": "provenance",
"git_blob": "889b95d936746df124872133ae1e7cc339adcb92",
"sha256": "7d185cd8c2af35988d638d969748ad7b670f902606444dbfc748e4402c340df6"
},
{
"path": "research/bit-dirty-auxiliary-registers/README.md",
"usage": "input",
"git_blob": "273bb963ee40869145cf8309db4f8dddebcfe43d",
"sha256": "da984fddaa09bfa7b1a3e11505e737283cee36e7972b2081f9de28ec420607cd"
},
{
"path": "research/bit-three-register-lower-bound/README.md",
"usage": "input",
"git_blob": "25e41c370c101a33a6deb978de08b03ed7539b79",
"sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd"
}
]
}
Loading
Loading