Skip to content

Prove a last-call obstruction for simple BIT support graphs #5456

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 25, 2026
Merged

Prove a last-call obstruction for simple BIT support graphs #5456

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
147 changes: 147 additions & 0 deletions research/bit-simple-graph-obstruction/CONTROL.json
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,147 @@
{
"model": "Coordinate rank-four D supports; two early q helper columns; all Q outputs",
"results": [
{
"name": "two-full-complement-control",
"order": [
0,
1
],
"edges": [
[
0,
1
],
[
0,
1
],
[
0,
1
],
[
0,
1
]
],
"fields": [
{
"name": "e01",
"vertices": [
0,
1
]
},
{
"name": "e01",
"vertices": [
0,
1
]
},
{
"name": "e01",
"vertices": [
0,
1
]
},
{
"name": "e01",
"vertices": [
0,
1
]
}
],
"supports": [
[
0,
1,
2,
3
],
[
0,
1,
2,
3
]
],
"calls": 2,
"active_fields": 4,
"private_fields": 0,
"edge_fields": 4,
"status": "sat",
"solver_seconds": 0.002181,
"boolean_code_variables": 16,
"all_active_outputs_have_Q": true,
"formal_group_bits": 2,
"native_full_calls_per_port": 2,
"unused_helpers_per_full": 217,
"paid_profile": {
"1": 2646,
"2": 2684,
"3": 158,
"4": 88,
"5": 204,
"6": 22,
"7": 38
},
"target_profile": {
"8": 434,
"15": 444
},
"rank_surplus": -126,
"R_rows": [
[
6,
15,
13,
6
],
[
7,
13,
9,
14
]
],
"native_chains": [
{
"u": 9,
"w": 12,
"basis": [
9,
12,
1,
2
],
"early_q_column_updates": [
7,
9
]
},
{
"u": 11,
"w": 15,
"basis": [
11,
15,
1,
2
],
"early_q_column_updates": [
6,
11
]
}
],
"literal_stage_product_check": "PASS",
"exact_endpoint_check": "PASS",
"all_native_chain_checks": "PASS",
"witness_scope": "Abstract native-call word; fixed cover-route tariff is not certified"
}
]
}
120 changes: 120 additions & 0 deletions research/bit-simple-graph-obstruction/PROOF.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,120 @@
# A last-call obstruction for a simple support graph

This is a scoped negative result over F2. It does not give a kappa value or an
obstruction to every BIT controller.

## Model

There are finitely many field coordinates and f>0 calls, in order 0 through
f-1. Call i has a coordinate support C_i of size four. Every coordinate lies
in one or two supports. Two distinct supports intersect in at most one
coordinate. Thus shared coordinates form a simple graph; private coordinates
fill the supports to size four.

Let q squared be zero. For every call i, let D_i be a separate commuting
involution. Its formal group symbol is independent of the other symbols.
Write T_i for the diagonal matrix which applies D_i on C_i and the identity
outside C_i. The call is

F_i = T_i (I + q R_i).

Every column of R_i outside C_i is zero. Rows outside C_i are permitted.
There must be u_i,w_i in the span of C_i with

u_i != 0, R_i u_i = 0, R_i w_i = u_i.

This is the native main Jordan chain. Complete (u_i,w_i) to a basis of C_i
with two helper directions. Their R_i columns are arbitrary, including
writes outside C_i. This is a relaxation of the two-early-helper caller
interface; the theorem does not require a physical implementation for every
matrix it permits.

The desired endpoint is diagonal. On coordinate a it is

(product of D_i for which a is in C_i) (I + t_a q),

where each t_a is zero or one. Thus D-only targets are permitted. The word
has no additional thin call. A scalar basis change is permitted only when
it can be absorbed into this stated form and the supports remain coordinate
supports. Non-coordinate D projectors are outside this model.

## Coefficient equation

Let s_i(a) be the bit vector of earlier calls k<i whose supports contain a.
Factoring all diagonal T_i to the left in

F_(f-1) ... F_1 F_0

shows that the q coefficient from R_i(a,b) has group label

s_i(a) XOR s_i(b).

There are no products of two R terms because q squared is zero. Independent
D symbols give an exact equation for every group label at every matrix entry.
At an off-diagonal entry, every such coefficient must cancel.

## The last call

Let l=f-1. Take distinct a,b in C_l. If b is private, only R_l can have a
nonzero column b. Its off-diagonal coefficient therefore has no term with
which to cancel, and R_l(a,b)=0.

If b also belongs to an earlier support C_i, only calls i and l can supply
this column. A nonzero R_l(a,b) requires their group labels to agree. The bit
i is absent from s_i(a) XOR s_i(b). In s_l(a) XOR s_l(b), that bit is zero
only if a also belongs to C_i, since b belongs to C_i. But a is already in
C_l, and the simple-graph hypothesis gives C_i intersect C_l={b}. This would
force a=b, a contradiction. Hence R_l(a,b)=0 in this case as well.

The restriction A of R_l to the four rows and columns C_l is diagonal over
F2, so A squared is A. Restrict the native chain equations to these rows:

A u_l = 0, A w_l = u_l.

They imply

0 = A u_l = A squared w_l = A w_l = u_l,

contrary to u_l!=0. No word in the stated model has the required endpoint.
The proof does not use the diagonal target flags t_a, so it also covers the
D-only choices.

## Boundary and positive control

The theorem needs the simple-graph and at-most-two-owner hypotheses. Two
calls with four shared fields are outside the simple-graph class. The saved
matrices in CONTROL.json obey the native main chains and satisfy R_0+R_1=I.
On these four fields both T_i are scalar diagonal blocks, so

T_1 (I+qR_1) T_0 (I+qR_0) = T_1 T_0 (I+qI).

The verifier multiplies these stage matrices in the exact group ring and
checks the complete endpoint. It also checks the independent four-role basis
and both early-helper column updates for each call.

For the arithmetic control, use two retained PR589 FULL invoices. Each has
paid profile {1:1323,2:1342,3:79,4:44,5:102,6:11,7:19}. Using two helper roles
per port leaves 217 original H8 targets per FULL. The active four fields,
at each of 111 ports, each receive two seven-axis D factors and one Q factor.
The complete declared target profile is therefore {8:434,15:444}. Its target
rank minus paid rank is -126. All paid ranks are below all target ranks, so
this negative rank surplus also rules out a gain for every tariff r^t with
0<t<=1. This is a check of the declared invoice, not a new physical supplier.

## Evidence scope

The general argument above proves the simple-graph result. The standard-
library verifier checks 48 K4/K4-minus-edge order fixtures and all 3,840
four-dimensional diagonal-matrix/nonzero-u/w cases. These fixtures exercise
the proof implications; they do not replace the general argument.

The 80 saved UNSAT outcomes in solver-evidence/ are separate finite solver
evidence. They include 48 simple-graph cases and 32 explicit parallel-edge
cases. No proof certificate accompanies them. The standard-library verifier
checks their hashes, counts and support descriptions. It does not prove those
UNSAT statuses. Optional replay uses the pinned Z3 version and is not part of
the registered verification.

This result does not cover fields in three or more calls, non-coordinate D
supports, dependent D symbols, paid thin calls, or a different native main
block. It does not prove a complete multiplication theorem or a new kappa.
113 changes: 113 additions & 0 deletions research/bit-simple-graph-obstruction/README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,113 @@
# A simple-graph obstruction for early-helper BIT controllers

No controller in the stated simple support-graph model can close its diagonal
Q/D targets. The model permits two arbitrary helper columns per call,
including writes outside that call's D support. The obstruction is the last
call: its restricted q matrix must be diagonal, which cannot contain the
required nonzero main Jordan chain. The complete kappa calculation does not
improve.

Read [the proof](PROOF.md), [exact verification result](RESULT.json), and
[positive control](CONTROL.json). The publication base is
`32890bc5de034ab8fc93ac88ead7279a6a416d04`. The package has no executable
source dependency outside its own directory. [SOURCES.json](SOURCES.json)
pins the task catalogue and selected record as historical provenance only.

## Exact scope

Each call has a coordinate rank-four D support and a q coefficient R, with
q squared zero. The two main directions obey Ru=0 and Rw=u with u nonzero.
The two helper columns are arbitrary. Columns outside the support are zero;
rows outside it can be nonzero. Every field belongs to one or two calls, and
two call supports intersect in at most one field. The commuting D symbols
are formally independent. The target is diagonal, with either QD or D-only
on each field. There are no paid thin calls.

The proof covers any finite number of calls in this class. It does not cover
parallel edges, more than two owners per field, non-coordinate supports,
dependent D symbols, or another native main block. A failed solver search is
not used as the proof.

The positive control uses two calls and four parallel edges. It satisfies the
main chains and the complete formal endpoint. Its declared complete recursive
invoice has a rank deficit of 126, so it supplies no kappa gain. It also shows
why the simple-graph hypothesis must not be removed.

## Preserved solver evidence

The [solver manifest](solver-evidence/MANIFEST.json) pins 80 recorded outcomes.
K4 and K4 minus one edge are UNSAT in each of their 24 orders. Three further
parallel-edge tests are UNSAT: a two-call double edge in both orders, a
three-call doubled path in all six orders, and a four-call (2,1,2) path in all
24 orders. These last 32 cases are finite solver-dependent evidence. There
is no all-parallel-graph theorem or retained solver proof certificate.

The exact solver code is [solver_search.py](solver_search.py). The publication
work did not repeat these failed discovery searches. Their solver version is
`z3-solver==5.3.1.0`. Solver times are historical measurements and can change.

## Reproduce the mandatory checks

Use Python 3.12. No third-party package is needed.

```sh
python3 -B research/bit-simple-graph-obstruction/verify.py
python3 -O -B research/bit-simple-graph-obstruction/verify.py
python3 -B scripts/research_package.py --package research/bit-simple-graph-obstruction --check-only
python3 -B scripts/research_package.py --package research/bit-simple-graph-obstruction
```

Expected direct output:

```text
PASS_BIT_SIMPLE_GRAPH_OBSTRUCTION fixtures=48 diagonal_cases=3840 control=PASS solver_run=false new_kappa=false
```

The verifier checks the last-call coefficient fixtures, all diagonal chain
cases, and a literal exact group-ring product for the positive control. It
also checks the native role bases, helper-column updates, and complete target
debit. It rejects a changed q coefficient, a missing target Q, a zero main
chain, and application of the simple-graph lemma to parallel edges. Its check
of the frozen solver receipts is an integrity check only.

The direct verifier works in the committed export without Git. The registered
metadata command uses Git for provenance. Optional solver replay is separate:

```sh
python3 -m pip install -r research/bit-simple-graph-obstruction/requirements-solver.txt
python3 research/bit-simple-graph-obstruction/solver_search.py --suite simple --all-orders --out /tmp/bit-graph-simple.json
python3 research/bit-simple-graph-obstruction/solver_search.py --suite parallel --all-orders --out /tmp/bit-graph-parallel.json
python3 research/bit-simple-graph-obstruction/solver_search.py --suite control --out /tmp/bit-graph-control.json
```

A different satisfying control can be returned by the solver. The mandatory
verifier checks the retained control directly, without invoking Z3.

## Open next questions

The [task record](TASK.json) asks whether a caller can change an essential
support hypothesis and still close at a favorable complete bill. Start with
one literal word and all helper target debits. No funded candidate outside
the theorem's scope is supplied. A larger graph scan without such a changed
contract is not a next step justified by this package.

## Credit

The controller model is motivated by the forward BIT early-query interface
and the entrance method of
[PR #5388](https://github.com/CrocSwap/integer-mult-bounds/pull/5388), whose
[pinned proof](https://github.com/CrocSwap/integer-mult-bounds/blob/568717635d8d11175a80024c9c596e16f54b1ea4/research/native-helper-query-bank/PROOF.md)
is conceptual credit, not an executable dependency. The declared arithmetic
control uses the retained
[PR #589](https://github.com/CrocSwap/integer-mult-bounds/pull/589) and
[PR #555](https://github.com/CrocSwap/integer-mult-bounds/pull/555) profile in
[the pinned BIT reconstruction](https://github.com/CrocSwap/integer-mult-bounds/blob/32890bc5de034ab8fc93ac88ead7279a6a416d04/research/kappa-rebuild/bit/README.md).
Its [source notice](https://github.com/CrocSwap/integer-mult-bounds/blob/32890bc5de034ab8fc93ac88ead7279a6a416d04/research/e8-bit-p111-tuned/NOTICE.md)
credits eumemic with substantial Anthropic Claude assistance and retains the
earlier contributors.

The parallel controller researcher identified the complementary two-FULL
comparison and a degree-two precursor. This last-call proof, the solver
model, exact checker, and package have substantial OpenAI Codex assistance.
New files are Apache-2.0. This is author-side evidence, not an independent
human review or supplier admission.
Loading