Skip to content
Draft
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
207 changes: 207 additions & 0 deletions research/six-source-c6-prefix-pair-03/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,207 @@
# The pair (0, 3) on the sharp T2 window

Scoped written proof with an exhaustive finite certificate in `verify.py`.
The model is six sources, characteristic 6, and floor words of length 36.
No claim is made about the unrestricted six-source depth-two exclusion, which
remains the solver verdict of PR6141. The selected frontier is unchanged.

## 0. Setting

The interface is the one in the merged package
`research/six-source-c6-centre-classification`, pinned in `SOURCES.json`.
A floor word calls each source `0,...,5` exactly six times. `q_t` counts the
first `t` letters. For `4 <= s <= 18`,

```text
S(s) = q_s + q_{39-s}.
```

`S(s)` is weight-3 when every coordinate lies in `{0,1,6,7,12}` and exactly
three lie in `{1,7}`. The same predicate applied to `q_t` is the weight-3
condition at the pair `(0,t)`. A chain on `[8,18]` is a floor word whose
`S(s)` is weight-3 for every `s` in that interval. Its family is the sorted
tuple `S(18)`. The T2 family is `(0,6,7,7,7,12)`.

Open PR #7176 proves that this family has sharp window `[8,18]`, that exactly
720 of the `180 * 120` endpoint pairs are joined there, and that weight-3 at
`(0,9)` coexists with a chain on `[s0,18]` exactly for `s0 >= 8`. Its first
open question asks which further pair with `s + t ≡ 3 (mod 6)` can hold
together with `(0,9)` and that window, starting from the 180 extendible states
at `s = 8` and retaining prefix order. This note answers that question for the
named pair `(0,3)`.

## 1. Lemma. One-low states at s = 8

*There are exactly 180 weight-3 diagonal states at `s = 8` with one coordinate
at most 1. Each has `q_8` a permutation of `(6,1,1,0,0,0)` and `S(8)` a
permutation of `(1,6,6,7,7,12)`. None has sorted sum `(0,6,7,7,7,12)`.*

A weight-3 vector sums to 39 and has exactly three coordinates congruent to 1
modulo 6, so its bases `6 * floor(S_j / 6)` sum to 36. Writing `n0, n6, n12`
for the number of coordinates of each base gives `n0 + n6 + n12 = 6` and
`n6 + 2 n12 = 6`, hence `n12 = n0`. Call this common value `L`.

At `s = 8` the complementary count is `q_31`, the state records a pair
`(q, t)` with `0 <= q_j <= t_j <= 6` and `S = q + t`, and
`sum_j (6 - t_j) = 5`. Those five letters occupy positions `31,...,35`. A
coordinate of base 0 has `t_j <= 1`, so it contributes at least five of those
suffix letters. Two such coordinates need at least ten suffix letters. Thus
`L <= 1`. If the unique low coordinate has `S_j = 0`, then `t_j = 0` and that
coordinate alone needs six suffix letters. So `S_j = 1`, which forces
`(q_j, t_j) = (0, 1)`, and the suffix is five copies of this low source.

The unique high coordinate has sum 12. The only solution of `q + t = 12` with
`0 <= q <= t <= 6` is `(6, 6)`. The four middle coordinates then have
`t`-sum `31 - 6 - 1 = 24` and each `t_j <= 6`, so each equals 6. Their allowed
sums are 6 or 7, so their `q` entries lie in `{0,1}` and sum to
`8 - 6 - 0 = 2`. Exactly two of them equal 1.

Choose the high source in 6 ways, the low source in 5 ways, and which two of
the remaining four sources have prefix count 1 in `C(4,2) = 6` ways:
`6 * 5 * 6 = 180`. Each choice is a weight-3 state, and the two paragraphs
above exclude every other one-low state. The sorted sum is
`(1,6,6,7,7,12)`. In particular the T2 tuple `(0,6,7,7,7,12)` does not occur
at `s = 8`.

`verify.py` enumerates the diagonal states independently from the ten legal
column pairs and checks that the one-low subset is exactly this set of 180.
The same enumeration finds 3,420 zero-low states at `s = 8` and no state with
two or more low coordinates.

## 2. Lemma. Prefixes that make (0, 3) weight-3

*For each of these 180 states, exactly 6 of the 56 words of length 8 with
letter counts `q_8` make `q_3` weight-3.*

The count vector is six copies of a heavy source `H` and one copy each of two
sources `A` and `B`. The number of distinct words is `8 * 7 = 56`. A length-3
prefix has sum 3, so the only weight-3 shape available to it is a permutation
of `(1,1,1,0,0,0)`: three distinct letters. The only three letters present are
`H, A, B`, and the two singletons must occupy two of the first three positions.
There are `3 * 2 = 6` such words; the other five positions are `H`. The other
50 words repeat `H` often enough that `q_3` has a coordinate outside
`{0,1,6,7,12}` or has fewer than three residues 1.

The diagonal sums `S(s)` for `s >= 8`, and the count `q_9`, depend on `q_8`
and on letters at positions `>= 8`. They do not depend on the order inside
the first eight letters. Reordering that prefix preserves every chain of
diagonal states and preserves the truth value of weight-3 at `(0,9)`.

## 3. Theorem. An explicit word for every state

*For every one-low state at `s = 8` and every one of its six favorable
prefixes, there is a floor word that is weight-3 at `(0,3)`, at `(0,9)`, and
at every `s` in `[8,18]`, with `S(18) = S(9)` equal to a permutation of
`(0,6,7,7,7,12)`.*

Let `H` be heavy, `L` low, `{A,B}` the two middle sources of prefix count 1,
and `{C,D}` the two middle sources of prefix count 0. Put a permutation of
`(A,B,H)` in positions `0,1,2` and `H` in positions `3,...,7`. Put `C` in
position 8. On each pair of positions `(s, 38-s)` for `s = 9,...,17`, put the
same letter, using `A,A,B,B,C,C,D,D,D` in that order of `s`. Put `A,B,C` in
positions `18,19,20`, put `L` in position 30, and put `L` in positions
`31,...,35`.

Each source occurs six times: `H` six times in the prefix; `A` once in the
prefix, four times in two pairs, and once in the middle, and likewise `B`;
`C` once at position 8, four times in two pairs, and once in the middle; `D`
six times in three pairs; `L` once at position 30 and five times in the
suffix. The word is a floor word. Its prefix count is the state of Section 1,
and its first three letters are `A,B,H` in some order, so `(0,3)` is weight-3.
Position 8 contributes `C`, so

```text
q_9 = e_A + e_B + e_C + 6 e_H,
```

which is a permutation of `(1,1,1,6,0,0)` and is weight-3.

The first 31 letters contain every copy of every source except five copies of
`L`, so `q_31 = 6(1,...,1) - 5 e_L`. Therefore

```text
S(8)_H = 12, S(8)_A = S(8)_B = 7, S(8)_C = S(8)_D = 6, S(8)_L = 1.
```

The step from `s = 8` to `s = 9` adds `e_C` and subtracts `e_L`, because
position 8 is `C` and position 30 is `L`. Hence `S(9)` is the same tuple with
the `C` coordinate raised from 6 to 7 and the `L` coordinate lowered from 1 to
0: a permutation of `(0,6,7,7,7,12)`. For `s = 9,...,17` the letters at `s`
and at `38-s` were chosen equal, so `S(s+1) = S(s)`. Thus `S(s) = S(9)` for
every `s` in `[9,18]`, and the endpoint family is T2.

There are 180 states and 6 prefixes, so the construction produces 1,080 words.
`verify.py` checks each word from the letters alone. The lexicographically
first parameter tuple `(H,L,A,B,C,D) = (0,1,2,3,4,5)`, with prefix order
`(A,B,H)`, produces

```text
230000004223344555234555443322111111
```

## 4. The 180 states are the T2 start states, and (0, 9) keeps every joined pair

Section 3 already shows that every one-low state reaches at least one T2
endpoint through a word that is weight-3 at `(0,9)`. The certificate also
enumerates the whole weight-3 graph for `8 <= s <= 18`:

- column pairs `(q,t)` with `0 <= q <= t <= 6` and `q+t` in `{0,1,6,7,12}`:
exactly the ten pairs `(0,0), (0,1), (3,3), (2,4), (3,4), (1,5), (2,5),
(0,6), (1,6), (6,6)`;
- a state is any 6-tuple of those pairs whose `q`-sum is `s`, whose `t`-sum
is `39-s`, and whose coordinate sums have exactly three residues 1;
- an edge increments one `q` coordinate and decrements one positive `t`
coordinate, landing on a state at `s+1`.

The layer sizes are `3600, 5520, 7740, 9900, 11220, 11280, 9780, 7240, 4500,
2040, 700`. Every one of the 592,020 edges preserves the base vector. The 700
endpoint states split into the six families with sizes `20, 20, 120, 180, 180,
180`, and the T2 family has 120 states.

Backward reachability and a second, forward reachability agree on the
following. Exactly the 180 one-low states reach T2. Between them and the 120
T2 endpoints there are 720 joined pairs. For each of the 180 states, the set
of reachable T2 endpoints is the same when every `s = 9` state with
non-weight-3 `q_9` is deleted. The same equality holds for the other one-low
endpoint family `(1,6,6,7,7,12)`, whose 1,080 joined pairs are a by-product of
the same masks. Thus weight-3 at `(0,9)` coexists with every T2 pair joined
on `[8,18]`.

The graph does not say that every path is weight-3 at `(0,9)`. The word

```text
345555554433222111234111220334400000
```

printed by PR #7176 is a chain on `[8,18]` with T2 endpoint and with weight-3
`(0,3)`, while its `q_9` is a permutation of `(0,0,0,1,2,6)`. Deleting the
non-weight-3 layer leaves a path to the same endpoints; it does not delete
the endpoints. The companion word

```text
345555552443322111234111223344000000
```

from the same PR is one more explicit point in the coexistence set: weight-3
at `(0,3)`, at `(0,9)`, and on the whole window, with T2 endpoint.

For each of the 720 joined pairs the certificate lifts one filtered path to a
word, using one favorable prefix, and checks that word from the letters. A
favorable prefix does not change `q_8`, so the same lift works for all six
prefixes of Section 2. Every T2 pair joined on `[8,18]` therefore has a floor
word that is also weight-3 at `(0,9)` and at `(0,3)`.

## 5. What this does and does not settle

Settled, in this model: the classification of the 180 states; the 6-out-of-56
prefix count for `(0,3)`; coexistence of `(0,3)` with `(0,9)` and with every
T2 pair joined on `[8,18]`; the explicit 1,080-word family; and the equality
of the filtered and unfiltered T2 endpoint sets.

Not settled: any pair other than `(0,3)` and the already assumed `(0,9)`;
constant-multiset chains, which Section 1 already forbids at `s = 8` for the
T2 tuple; other characteristics and source counts; and the unrestricted
depth-two exclusion. A single exhibited word would have shown bare
coexistence. The census is the stronger statement that the obstruction fails
for every extendible state and for every previously joined T2 pair, on an
explicit 6/56 fraction of the prefix orders.
137 changes: 137 additions & 0 deletions research/six-source-c6-prefix-pair-03/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,137 @@
# The pair (0, 3) coexists with (0, 9) on the sharp T2 window

**Exhaustive finite census with explicit words. No new κ and no selected-frontier
change.** In the six-source characteristic-6 floor-word model, the named pair
`(0, 3)` coexists with weight-3 at `(0, 9)` and with every T2 pair joined on
the sharp window `[8, 18]`.

A floor word calls each source exactly six times. `S(s) = q_s + q_{39-s}` is
weight-3 when every coordinate lies in `{0,1,6,7,12}` and exactly three lie in
`{1,7}`. The same predicate on `q_3` and on `q_9` is weight-3 at `(0,3)` and
at `(0,9)`. The T2 family is the endpoint multiset `(0,6,7,7,7,12)`. The
interface is the merged centre-classification package pinned in
[SOURCES.json](SOURCES.json). The question is open-next item 1 of
[PR #7176](https://github.com/CrocSwap/integer-mult-bounds/pull/7176), restricted
to the single pair `(0,3)`.

The selected conditional κ remains `363005817/100000000000` in
`certificates/selected-result.json`.

## Census

There are exactly **180** weight-3 diagonal states at `s = 8` with one
coordinate at most 1. They are given by a heavy source `H`, a low source `L`,
and which two of the other four sources have prefix count 1:

- `q_8` is the matching permutation of `(6,1,1,0,0,0)`;
- `S(8)` is the matching permutation of `(1,6,6,7,7,12)`.

The T2 tuple itself does not occur at `s = 8`: a coordinate equal to 0 would
need six copies in the five-letter suffix. These 180 states are exactly the
states that reach the T2 family on `[8,18]`. They meet the 120 T2 endpoints in
**720** joined pairs, the count proved for this window by #7176. Deleting every
`s = 9` state whose `q_9` is not weight-3 leaves each of those 720 endpoint
sets unchanged. The same holds for the other one-low endpoint family
`(1,6,6,7,7,12)` and its 1,080 pairs; that count is a by-product of the same
masks.

For each of the 180 states the prefix of length 8 has **56** orders and exactly
**6** of them make `(0,3)` weight-3: the two singleton letters both sit in the
first three positions. Prefix order does not change `q_8`, so it preserves the
diagonal chain and the truth value of `(0,9)`. Every previously joined T2 pair
therefore has a floor word that is weight-3 at `(0,3)`, at `(0,9)`, and at
every `s` in `[8,18]`.

The proof, including the uniform word that realises all `180 * 6 = 1080`
favorable prefixes, is in [PROOF.md](PROOF.md).

## Witnesses

`verify.py` rebuilds all 1,080 words and lifts one filtered path for each of
the 720 joined pairs. Three words are also written here and checked from the
string alone.

| role | word |
| --- | --- |
| canonical construction `(H,L,A,B,C,D) = (0,1,2,3,4,5)` | `230000004223344555234555443322111111` |
| #7176 word, weight-3 at `(0,9)` and at `(0,3)` | `345555552443322111234111223344000000` |
| #7176 T2 word whose `q_9` has shape `(0,0,0,1,2,6)` | `345555554433222111234111220334400000` |

The third word is a chain on `[8,18]` with T2 endpoint and with weight-3
`(0,3)`. Its `q_9` is not weight-3, so a T2 chain need not pass through
`(0,9)`. The filtered graph still reaches the same endpoints by another path.
Replacing the canonical prefix by six heavies followed by the two singletons
keeps the window and `(0,9)` and makes `(0,3)` fail, so the prefix order is
the exact extra datum.

## Reproduce

Python 3.12, standard library only, from the repository root:

```sh
python3.12 -I -W error -B research/six-source-c6-prefix-pair-03/verify.py
python3.12 -I -O -W error -B research/six-source-c6-prefix-pair-03/verify.py
python3.12 -B scripts/research_package.py --package research/six-source-c6-prefix-pair-03
```

Expected marker:

```text
PASS_SIX_SOURCE_C6_PREFIX_PAIR_03 l1=180 prefixes=56 favorable=6 constructed=1080 lifts=720 joined_t2=720 joined_other=1080 forward=720 layer8=3600 l0=3420 controls=7 inputs=1
```

The verifier enumerates every weight-3 diagonal state for `8 <= s <= 18`,
checks base preservation on every legal edge, compares backward and forward
T2 endpoint sets with and without the `(0,9)` filter, checks all 56 prefixes
of each of the 180 states, and checks every constructed and lifted word from
its letters. Seven controls accept the two cited words, reject a bad prefix
order, a 35-letter string, and a seventh copy of one letter, and reject a
nearby count vector that is outside the census. Failures raise `SystemExit`.

Layer sizes are fixed at `3600` through `700` as listed in the proof. Each
state has six coordinates and at most 36 successor candidates. Partial column
enumeration uses the ten legal pairs and at most `10^6` partial tuples. No
solver or child process is started.

Python dicts and arbitrary-precision endpoint masks are a managed-runtime
deviation while the domains above stay fixed. Normal and optimized runs both
exercise the full domains.

## Scope and limits

The result fixes six sources, characteristic 6, length 36, the diagonal pairs
`(s, 39-s)` for `8 <= s <= 18`, and the two early pairs `(0,9)` and `(0,3)`.
It is an exhaustive census of that finite set, not a sample and not a proof
of the unrestricted depth-two exclusion. Intermediate multisets may differ
from the endpoint: every word above has `S(8)` of type `(1,6,6,7,7,12)` and
`S(s)` of T2 type for `s >= 9`. Pairs such as `(4,5)`, `(2,7)`, `(3,6)` and
`(1,8)` are untouched. Independent human and formal proof-kernel review are
unclaimed. No supplier, consumer, or selected frontier changes.

## Open next questions

1. On these same 180 states, which of the six `(0,3)`-favorable prefixes make
`(4,5)` weight-3? *Why:* `(0,3)` sees only the first three letters and
never obstructs a joined T2 pair, while `(4,5)` still lies inside the free
prefix and reads five letters, so it can reject some of those six orders.
*First step:* evaluate `q_4 + q_5 = 2 q_4 + e_{w_4}` on the six prefixes of
the canonical word, then repeat for every state only if that word is empty.
*Blocked by:* nothing in the present certificate; the checker is hard-coded
for `(0,3)`.

The structured copy is in [TASK.json](TASK.json).

## Credit

The classification, the prefix count, the 1,080-word construction and the
endpoint-set comparison were prepared by unpaidmoon with substantial Cursor
Grok assistance. Nick Petalas's open
[PR #7176](https://github.com/CrocSwap/integer-mult-bounds/pull/7176) supplies
the sharp-window theorem, the figures 180 and 720, the question, and the two
cited words; those words are rechecked here and that package is not replayed.
unpaidmoon's [PR #7099](https://github.com/CrocSwap/integer-mult-bounds/pull/7099),
[PR #7029](https://github.com/CrocSwap/integer-mult-bounds/pull/7029) and
[PR #7042](https://github.com/CrocSwap/integer-mult-bounds/pull/7042) supply
the T2 question, the six families and the `(0,9)` pricing. The mask definition
is the merged `six-source-c6-centre-classification` package. No predecessor
credit is changed. Apache-2.0.
24 changes: 24 additions & 0 deletions research/six-source-c6-prefix-pair-03/SOURCES.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,24 @@
{
"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/six-source-c6-centre-classification/README.md",
"usage": "input",
"git_blob": "3e6b3c225c15b081f2b66dd16c97118e3b8c494b",
"sha256": "0d86c0d2524036b1fe36bc4217a935b97160f8155b810bb0010a3130d97f3dcf"
}
]
}
Loading