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
128 changes: 128 additions & 0 deletions research/last-call-common-postmap/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,128 @@
# A common free post-map can be moved before the last call

## Result and model

Consider one prepared last call followed by one common free map on its output. When the shared part has one level-two leading term and only lower-level companion terms, this post-map adds no power to finishing a level-three target. A target-frame projection forces the post-map to be invertible in a specific subgroup algebra. It can then be moved before the call.

As a consequence, the nonplain kind B obstruction in [PR #7683](https://github.com/CrocSwap/integer-mult-bounds/pull/7683) also holds with arbitrary common free postprocessing. This includes arbitrary spare address bits and all nonzero rational coefficients. A second result within this same boundary check is an explicit false positive for a larger linear-span test: two independently prepared and independently postprocessed columns can span the target, while one prepared call cannot produce it. The distinction is the common post-map, not the availability of a free matrix.

Work in `Q[G]`, where `G=Sp(2m,2)`, `m>=3`, and `P=Stab_G(L)` for the raw Lagrangian L. Terms are formal group basis elements. Their level is `ell(g)=m-dim(L intersection g^-1 L)`. Level is invariant under free left or right factors and is subadditive. Free combinations form the algebra `Q[P]`. A paid call T is an involution of level one.

Let M have level two with `ell(TM)=3`. Let B be any finite collection of terms of level at most one. Let z be any rational combination of terms of level at most one, and set

```text
y = M+z,
U = sum_(b in B) Q[P] b + Q[P] y,
H = P intersection T P T.
```

Every term in U has level at most two. U is closed under left multiplication by `Q[P]`. The most general output under the present one-call contract is

```text
u+F T v, u,v in U, F in Q[P].
```

The same F acts on the whole output of the one call. It is not assumed invertible. Free preparation of v and free additions of earlier arrays are unrestricted within U. Several consecutive free post-maps compose to one F.

**Folding theorem.** The target TM has a representation `u+F T v` if and only if it lies in `U+TU`. In every such representation, F is a unit of `Q[H]`, and `F T = T (T F T)` with `T F T` free.

The statement concerns this fixed target TM and one last call. It does not cover a second last output, multiple call outputs with separate post-maps, a second level-two companion term, Pauli phases, or a physical realization of the free algebra. No new kappa or general two-in-five impossibility follows.

## Project onto the target's frame

Let C be the left coset `P TM` and let pi keep only coefficients with indices in C. Every term in C has level three. Since free left multiplication preserves each left coset of P, pi commutes with left multiplication by every F in `Q[P]`.

For any p in P and b in B, `Tpb` has level at most two. The same bound holds for every term of `Tpz`. Hence only the leading term `TpM` can contribute to `pi(Tv)`. It belongs to C exactly when

```text
(TpM)(TM)^-1 = TpT is in P.
```

In that case `h=TpT` lies in H, since `ThT=p` is also free. Conversely every h in H has this form with p free. Therefore

```text
pi(Tv) = A TM for some A in Q[H].
```

Also `pi(u)=0`. If `TM=u+F T v`, projection gives `TM=F A TM`. The group term TM is invertible, so

```text
F A = 1.
```

This is an identity in the full free group algebra. It is not a coefficient equation in a quotient where extra support can be ignored.

## A one-sided inverse stays in the subgroup algebra

P and H are finite groups. From `FA=1`, left multiplication by A is injective on the finite-dimensional space `Q[H]`: `Ax=0` implies `x=FAx=0`. It is therefore surjective on that space. There is a B0 in `Q[H]` with `A B0=1`.

Now `F=F A B0=B0`. Thus F belongs to `Q[H]` and is the two-sided inverse of A. This proves invertibility rather than assuming it. It also excludes a singular post-map that tries to erase other level-three frames.

By the definition of H, `T F T` belongs to `Q[P]`. Consequently

```text
F T v = T (T F T) v is in TU.
```

The last inclusion uses the left `Q[P]` stability of U. Thus every postprocessed finishing witness is already a call-alone witness. The reverse direction uses F=1. This proves the folding theorem at every address width. It does not require an enumeration of the group or a choice of coefficients in z.

## Corollary for nonplain kind B

Take `B={1,D}`, `M=WD` and `z=cW gamma`, where D,W,T are paid calls, gamma is free, `c!=0`, `ell(TWD)=3`, and `W gamma` is outside PD. The sole companion term has level one. All hypotheses of the folding theorem hold.

The [call-alone proof at its exact head](https://github.com/aliromman/integer-mult-bounds/blob/9b99d7b30972a78e1ad0e90dd6ff3187bd3cc86c/research/kind-b-last-call-obstruction/PROOF.md) gives `TM` outside `U+TU`. It supplies a two- or three-coordinate separating functional for that space. Folding therefore rules out `TM=u+F T v` for every common F and every u,v in U. No nonplain kind B part finishes under this one-call postprocessing contract, including with spare bits.

This strengthens the stated call-alone boundary. It still leaves joint decoding, different shared-call arrangements and extra high-level terms open. It is a formal-frame result, not a physical engine lower bound.

## A relaxed span gives a false positive

Use three address bits and binary row-matrix encoding in order `(x0,x1,x2,z0,z1,z2)`. Let `D=t_1`, `W=t_2`, `T=t_5`, with pure horizontal normals given by those bit masks. Use the following free matrices, with each row written as its bit mask:

```text
gamma = (1,2,5,40,16,32),
R = (5,4,2,8,40,16),
S = (3,5,2,40,32,56).
```

Here gamma swaps D and T by conjugation and commutes with W. Also `R T R^-1=W` and `S=R^-1 gamma`. Set `M=WD`, `E=W gamma` and `y=M+cE`. The target TM has level three and E is nonplain. Exact multiplication gives

```text
TE = E D = R T S D,
TM = T y - c R T (S D).
```

The right side belongs to the linear span of independently prepared and independently postprocessed columns: one input is y with identity post-map, and the other input is SD with post-map R. Both inputs are in U. But the theorem proves that no single common F on one prepared call produces TM, for any nonzero rational c. This identity can be executed with two separate calls; treating its column span as one call loses the common-factor constraint.

The checker also verifies the exact call-alone separator for this example over all 10752 free preparations, with polynomial coefficients in c. Its support is `TM,TE,gamma E`, with weights `c^2,-c,1`. Every old or paid binomial and earlier singleton is killed. The relaxed identity is checked at five nonzero rational coefficients; its displayed symbolic equality proves it for all c. This is a counterexample to sufficiency of the relaxed test, not a construction of a two-in-five unit.

## Why the low-level companion condition matters

Kind A can have a second level-two term. The folding theorem then does not apply. A positive control uses `D=t_1`, `W=t_2`, `T=t_4`,

```text
gamma_A = (1,2,6,8,52,34),
E_A = W gamma_A D,
h = (1,6,4,8,20,50).
```

E_A has level two and a different frame from M. The free element h has order two, lies outside H, and satisfies `T E_A=h TM`. For coefficient two,

```text
T (M+2E_A) = (1+2h) TM,
F = (2h-1)/3,
F T (M+2E_A) = TM.
```

This is one actual prepared call followed by one common free map. The target-coset coefficient is now `1+2h`, which lies outside `Q[H]` because the second high-level term also contributes. This verifies the boundary of the new lemma. The existence of kind A post-call gains is prior work in [PR #7629](https://github.com/CrocSwap/integer-mult-bounds/pull/7629) and [PR #7649](https://github.com/CrocSwap/integer-mult-bounds/pull/7649); this example is a control, not a new claimed construction.

## Exact checks and limits

The finite checker enumerates all 10752 three-bit free elements and all 32 calls that raise the fixed `WD` to level three. It checks all 344064 preparation/call pairs. Exactly 768 columns survive the target-frame projection for each call, for 24576 surviving columns in total. Every survivor is in the intersection subgroup. All paid earlier inputs and every kind B companion family stay below level three. The latter check is independent of gamma because a free factor on the right does not change level.

For all 32 calls, explicit group-algebra units and their inverses verify the fold. Nonunit examples have a checked nonzero kernel, and an outside-subgroup unit has an inverse outside the required projection space. Ninety-six wider conjugated contracts at widths four through six verify these unit and nonunit statements with a spare coordinate in the conjugation. The relaxed false positive and the kind A positive control are checked as exact group-algebra identities. [Receipt and matrices](RESULT.json) · [Verifier](verify.py)

These finite checks support the proof; they do not enumerate arbitrary rational post-maps or all wider groups. The prior call-alone proof is a mathematical dependency, not a runtime import. Its full census was not rerun. Native operators, selected cold replay, Lean and Docker were not run. Independent human and formal-kernel review are unclaimed. All five selected assumptions and the selected frontier remain unchanged.

## Attribution

Prepared by Ali Romman with substantial OpenAI Codex assistance. Jacob Sussman supplied the kind B definitions and the untested post-call question in [PR #7629](https://github.com/CrocSwap/integer-mult-bounds/pull/7629), [pinned source](https://github.com/jacobalansussman/integer-mult-bounds/blob/c2a2131e7dba35f9396b16588e125a7e8b5fab8e/research/complex-m3-shared-call-finish-or-remove/README.md). Nick Petalas supplied the related coset method and post-call boundary in [PR #7649](https://github.com/CrocSwap/integer-mult-bounds/pull/7649), [pinned proof](https://github.com/petalas/integer-mult-bounds/blob/f642d2740265a61f8ac64b3a087f0118382c56e3/research/kind-a-last-call-coset/README.md). Ali Romman's [PR #7683](https://github.com/CrocSwap/integer-mult-bounds/pull/7683) supplies the call-alone obstruction used in the corollary. Binary matrix routines are reused from that package and its [PR #7679](https://github.com/CrocSwap/integer-mult-bounds/pull/7679) predecessor. The common-factor proof and exact separation from the relaxed column span are the new work. New work is Apache-2.0.
37 changes: 37 additions & 0 deletions research/last-call-common-postmap/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,37 @@
# Enforce one common free map after one last call

If a shared part has one level-two leading term and only lower-level companions, a free map on one last-call output adds no finishing power. Projection onto the level-three target frame forces that map to be an invertible element of `Q[P intersection TPT]`. It can be moved before the call.

For nonplain kind B parts, the [call-alone obstruction #7683](https://github.com/CrocSwap/integer-mult-bounds/pull/7683) therefore extends to arbitrary common free postprocessing, at every address width and every nonzero rational coefficient. An explicit two-column identity shows why the larger span of independently postprocessed calls is insufficient as a one-call test. A known kind A post-call mechanism gives a positive control when there is a second level-two term.

[Proof and scope](PROOF.md) · [Exact receipt and matrices](RESULT.json) · [Verifier](verify.py) · [Task and questions](TASK.json)

No general two-in-five impossibility, joint decoder, phase lift, native word or kappa improvement is claimed. The theorem concerns one common map applied to one prepared call output. The call-alone proof is a mathematical dependency and is linked at its exact commit.

## Reproduce

Use CPython 3.12 and its standard library. No external file is read at run time.

```sh
python3.12 -I -W error -B research/last-call-common-postmap/verify.py
python3.12 -I -W error -B -O research/last-call-common-postmap/verify.py
python3.12 -B scripts/research_package.py --package research/last-call-common-postmap
```

Expected status: `PASS_LAST_CALL_COMMON_POSTMAP`. The verifier checks all 344064 three-bit preparation/call pairs, all 24576 surviving target-frame columns, 32 unit/nonunit cases, 96 wider conjugated contracts, the relaxed-span false positive and an actual kind A one-call post-map. The latter is a boundary control, not a new construction. Each registered command has a 120-second bound.

The written proof covers all widths and all common free maps. Finite checks do not enumerate arbitrary rational maps or the full wider groups. The predecessor's full call-alone census, native operators, selected cold replay, Lean and Docker were not rerun. Independent human and formal-kernel review are unclaimed.

## Task and scope

Base: canonical main `e54523517d0f03e58352e647c403a5af3e525a57`, priority revision 8, card `complex-rank-shape-decoder` refined to the post-call boundary. The [advance claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19704278) explicitly separates a relaxed span from one common-map realization. The family gate keeps this a bounded proof task; no physical cost or supplier gain is inferred. Refreshed open/closed PR and Discussion overlap contains the earlier finite, kind A and call-alone results. Sparse local and unpublished work remain coverage limits.

## Open next questions

Can two last outputs jointly decode both input parts? Keep separate common-map factors for each physical output. The relaxed identity here uses two calls and shows why freely summing prepared/postprocessed columns can undercount them.

Can the target-frame unit argument handle two or more high-level companions? First compute their full projected coefficient algebra. The kind A control shows that it can exceed the intersection subgroup and that the present fold then fails. A phase lift and full physical invoice remain separate obligations. [Structured questions](TASK.json)

## Credit

Prepared by Ali Romman with substantial OpenAI Codex assistance. Credit Jacob Sussman for the definitions and kind B post-call question in [PR #7629](https://github.com/CrocSwap/integer-mult-bounds/pull/7629), [exact source](https://github.com/jacobalansussman/integer-mult-bounds/blob/c2a2131e7dba35f9396b16588e125a7e8b5fab8e/research/complex-m3-shared-call-finish-or-remove/README.md); Nick Petalas for the related coset method and boundary in [PR #7649](https://github.com/CrocSwap/integer-mult-bounds/pull/7649), [exact proof](https://github.com/petalas/integer-mult-bounds/blob/f642d2740265a61f8ac64b3a087f0118382c56e3/research/kind-a-last-call-coset/README.md); and Ali Romman's [PR #7683](https://github.com/CrocSwap/integer-mult-bounds/pull/7683), [exact call-alone proof](https://github.com/aliromman/integer-mult-bounds/blob/9b99d7b30972a78e1ad0e90dd6ff3187bd3cc86c/research/kind-b-last-call-obstruction/PROOF.md), for the corollary's required predecessor. Its binary matrix code, originally from [PR #7679](https://github.com/CrocSwap/integer-mult-bounds/pull/7679), is reused. New work is Apache-2.0.
63 changes: 63 additions & 0 deletions research/last-call-common-postmap/RESULT.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,63 @@
{
"status": "PASS_LAST_CALL_COMMON_POSTMAP",
"projection_census": {
"preparation_call_pairs": 344064,
"finishing_calls": 32,
"surviving_projection_columns": 24576,
"unit_and_nonunit_checks": 32
},
"wider_unit_contracts": 96,
"relaxed_span_counterexample": {
"gamma_rows": [
1,
2,
5,
40,
16,
32
],
"last_normal": 5,
"post_rows": [
5,
4,
2,
8,
40,
16
],
"prep_rows": [
3,
5,
2,
40,
32,
56
],
"nonzero_coefficients_checked": 5,
"separator_columns_checked": 21504,
"meaning": "The relaxed span accepts two independently prepared/postprocessed columns; the common-map theorem excludes one call."
},
"higher_term_positive_control": {
"gamma_rows": [
1,
2,
6,
8,
52,
34
],
"post_binomial_rows": [
1,
6,
4,
8,
20,
50
],
"post_binomial_order": 2,
"coefficient": "2",
"extra_level": 2,
"actual_one_call_finish": true
},
"scope": "One common free post-map on one call output, with a unique level-two leading term and only lower-level companions; no joint decoder or kappa."
}
18 changes: 18 additions & 0 deletions research/last-call-common-postmap/SOURCES.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,18 @@
{
"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"
}
]
}
Loading
Loading