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
19 changes: 18 additions & 1 deletion docs/ci-verification.md
Original file line number Diff line number Diff line change
@@ -1,8 +1,25 @@
# CI verification

## Current selected-family replay: #6030
## Current selected-family replay: #7000 with #7001

The [selected record](../certificates/selected-result.json) binds conditional
κ = 0.00363005817 to the [application review](research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md),
[validation receipts](research/pr-intake-evidence/pr7000-application/VALIDATION.json),
and [explicit source closure](../certificates/frontier7000-source.json).
`make frontier7000-verify` follows that exact-source selected replay. The review
reuses eleven authenticated preceding executions and records seven fresh serial
application, scalar and complete native-catalogue executions. The earlier
monolithic timeout is retained separately and is not completed coverage.
Consult the receipts for exact commands, source heads and limits.

The five inherited framework assumptions remain. No complete uniform word,
literal multiplier execution, independent human proof or formal-kernel proof
is asserted. Routine research submissions do not need to rerun this
selected-family replay. The sections below preserve historical checkpoints.

## Historical selected-family replay: #6030

The [historical checkpoint](../certificates/checkpoints/frontier6030.json) binds conditional
κ = 0.003125804 to the [proof review](research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md),
[validation receipts](research/pr-intake-evidence/pr6030-audit/VALIDATION.json),
and [explicit source closure](../certificates/frontier6030-source.json).
Expand Down
97 changes: 97 additions & 0 deletions research/half-sum-clear-circuit/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,97 @@
# A smaller reversible circuit for one signed half-sum CLEAR

At signed width 1,076, this circuit implements the complete output map for the
eight-limb row at event 88937 with **93,811 gates and 15,103 internal zero bits**.
SYLforge reports 277,929 gates and 86,525 internal zero bits for the same row
in the general rational circuit. Specializing to four positive unit coefficients,
four negative unit coefficients and denominator two saves 184,118 gates and
71,422 work bits. Both counts include output copying and cleanup.
[Published comparator and source row](https://github.com/SYLforge/integer-mult-bounds/blob/e5ba67dfd6237a1a3acf4d67098d3242adee8229/research/clean-rational-clear-witness/README.md)

## Interface and scope

This is a scoped proof with an executable finite gate certificate. In SYLforge's
#7669 word, target 1502 uses donors 1072 and 500. The eight signed limbs are
the real and imaginary parts at addresses 0 and 102 of the first donor, then
the same four of the second donor. We use the real output at address zero
identified by #7687. The caller-to-row identification and the comparator counts
are taken from that work. The circuit accepts arbitrary donor bitstrings.
[Source word](https://github.com/CrocSwap/integer-mult-bounds/pull/7669)

For any positive width w, let N be the sum of the first four signed donors
minus the sum of the last four. Put q = floor(N/2). The circuit leaves donors
untouched, XORs the low w bits of q into the target, and toggles the diagnostic
if N is odd or q is outside the signed w-bit range. Every work bit starts and
ends zero. With initial diagnostic zero, both outputs are zero exactly when
N equals twice the signed target. In particular, a fractional quotient or
signed overflow stays detectable even if the target XOR produces zero.

## Construction and proof

Let n = w + 3. The largest possible N is 4(2^w − 1), attained by placing
the four maxima before the four minima. Swapping the groups attains its
negative. Both fit in signed n bits. Sign extension aliases the donor sign
wire as a control. Start with the first extended donor and accumulate the
other seven modulo 2^n. The final residue therefore encodes N exactly.

Each ripple stage uses fresh result bits and fresh internal carries. In a
column with accumulator bit a, operand bit b and incoming carry or borrow c,
first write p = a XOR b. Addition's outgoing carry is ab XOR cp. Subtraction's
outgoing borrow is (1−a)b XOR (1−p)c, or ab XOR b XOR cp XOR c. These formulas
follow by treating the equal-bit and unequal-bit cases separately. Both stages
then XOR c into p to produce the result bit. The low column takes c = 0 and
the top column discards its outgoing carry. This proves the modular stage
identity by induction over the columns. Donor wires appear only as controls.

The low bit of N flags oddness, including for negative N. Bits 1 through w
give the low w quotient bits because arithmetic right shift gives floor
division by two. The quotient fits exactly if bits w+1 and w+2 of N both
equal bit w. Two XOR comparisons and Boolean ORs therefore implement the
specified diagnostic. Copy the result bits and flag to the output ports and
run the internal gate list backwards. Each gate is an involution, and the
internal list never accesses the output ports. This restores every work bit
regardless of validity or initial target.

## Complete resource count

Each of seven stages allocates n result bits and n−1 carry bits. Two comparison
bits and two OR bits give 7(2n−1)+4 = **14w+39 work bits**. The external wires
are the 8w immutable inputs, w target bits and one diagnostic bit.

An addition uses 2n gates to form p, n−1 to copy incoming carries into the
result, n−1 for ab and n−2 for cp. Each of the four subtractions adds
(n−1)+(n−2) borrow toggles. The flag needs four CNOTs for comparisons and
three gates for each of two ORs. Thus the forward computation uses
7(5n−4)+4(2n−3)+10 = 43n−30 gates. Output copying costs w+1 and the reverse
costs another 43n−30, giving **87w+199 gates**. At width 1,076 the emitted
list contains 63,637 CNOTs and 30,174 Toffolis.

## Reproduce

From the repository root with CPython 3.12 and its standard library, run

~~~sh
python3.12 -B research/half-sum-clear-circuit/verify.py
python3.12 -B scripts/research_package.py --package research/half-sum-clear-circuit
~~~

The verifier simulates every gate, checks wire indices and donor immutability,
and compares every output and workspace wire with an integer oracle. It
exhausts donor tuples at widths one and two, then executes 32 cases at width
1,076, including negative odd numerators, both signed endpoints, wrapped
overflow and reproducible mixed inputs. It prints PASS_HALF_SUM_CLEAR.
The gate certificate establishes an upper bound for this row. Optimality,
rounded producer reachability, full erasure, tape costs and a change to κ
remain outside its scope.

## Open next questions

What does this circuit cost on the physical tapes? Fix a tape layout and
account for its clean banks, carry access, output copy and reverse scans.

## Credit

The specialized circuit, proof and verifier were produced by Nick Petalas.
SYLforge supplied the source word, the coordinate identification, the complete
validity interface, the published comparator and the smaller-circuit question.
Ripple arithmetic and reversible compute/copy/uncompute are standard.
18 changes: 18 additions & 0 deletions research/half-sum-clear-circuit/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"
}
]
}
95 changes: 95 additions & 0 deletions research/half-sum-clear-circuit/TASK.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,95 @@
{
"schema_version": 1,
"task_id": "formal-interface-lemma",
"priority_revision": 8,
"base_commit": "e54523517d0f03e58352e647c403a5af3e525a57",
"original_card": {
"id": "formal-interface-lemma",
"question": "Can one uncovered interface implication be formalized with exact caller and certificate bindings?",
"starting_points": [
"docs/research/research-family-status.md",
"certificates/selected-result.json",
"research/gate-operand-parity-lean/README.md",
"research/staged544-certified-endpoint/README.md",
"research/unconditional-batched-crt/README.md"
],
"methods": [
"Formalize a missing boundary lemma identified by the selected review.",
"Audit a formal theorem-to-certificate binding independently."
],
"acceptance_gate": "State the exact formalized proposition and remaining assumptions; avoid duplicate arithmetic formalizations already present.",
"first_step": {
"command": [
"python3",
"-B",
"scripts/research_selected_baseline.py"
],
"expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
"inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.",
"scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse."
},
"first_experiment": "Write one missing statement with quantified hypotheses, actual caller and existing coverage. A compact-switch lemma is a candidate only after its mathematical contract is reviewed. Establish a bounded proof plan before a separately budgeted proof-assistant build; do not rerun large Lean jobs as orientation.",
"bottleneck_link": "A missing interface proof can reduce the conditional gap even if it does not change kappa.",
"allowed_variations": [
"Narrow to one formal lemma or one theorem-to-certificate binding."
],
"scope_change_triggers": [
"Formalizing already-covered arithmetic and claiming the full multiplication theorem."
],
"overlap_terms": [
"hyperplane end",
"formal interface",
"Lean binding",
"3807",
"3857",
"4100",
"gate-operand-parity-lean",
"staged544-certified-endpoint",
"unconditional-batched-crt"
],
"existing_checks": [
{
"scope": "PR #3807: scoped gate-operand parity formalization.",
"evidence": "research/gate-operand-parity-lean/README.md",
"remaining": "Exact theorem-to-caller binding and genuinely uncovered interface lemmas.",
"status": "author-checked",
"source_commit": "4c3530f42a6abcc48e7a6bcffd6c901911dc8269",
"selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
},
{
"scope": "PR #3857: certified real-power moment/endpoint arithmetic.",
"evidence": "research/staged544-certified-endpoint/README.md",
"remaining": "Uniform algorithmic implications, not another endpoint digit.",
"status": "author-checked",
"source_commit": "ef4315b8caa605e47a2515004845eb2d2ed71a86",
"selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
},
{
"scope": "PR #4100: compact-switch formalization proposed as future validation.",
"evidence": "research/unconditional-batched-crt/README.md",
"remaining": "Audit the statement and assumptions before a formal proof campaign.",
"status": "author-checked",
"source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
"selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
}
]
},
"scope_status": "changed",
"actual_scope": "Construct a smaller exact reversible gate circuit for the single signed half-sum CLEAR row at event 88937.",
"scope_change_reason": "Question 3 of PR #7687 asks for a constructive gate and workspace improvement under its existing output contract. This contributes a mathematical interface proof and executable circuit rather than a proof-assistant formalization.",
"bottleneck_link": "The owned_erasure interface needs an exact validity test and restoration of temporary storage at the chosen row. Gate-level cost is only one part of that service.",
"budget_minutes": 60,
"stop_rule": "Stop at the first construction improving the cited complete gate and clean-workspace counts at width 1076 with all four output obligations proved.",
"outcome": "completed",
"evidence": "README.md gives the all-input proof and resource count. verify.py executes the emitted gates and compares every wire to integer arithmetic.",
"author": "Nick Petalas",
"ai_assistance": "Independent human and formal proof-kernel review are unclaimed.",
"open_questions": [
{
"question": "What tape movement and initialization cost does this row require?",
"why_it_matters": "The gate count omits physical access and clean-bank provisioning.",
"first_step": "Assign each bit block to a tape and count the full forward, output and reverse scans.",
"blocked_by": "A fixed tape layout and initialization service for this word remain unspecified."
}
]
}
18 changes: 18 additions & 0 deletions research/half-sum-clear-circuit/VERIFY.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,18 @@
{
"schema_version": 1,
"status": "ready",
"python": "3.12",
"requirements": [],
"inputs": [],
"commands": [
{
"argv": [
"{python}",
"-B",
"{package}/verify.py"
],
"timeout_seconds": 120,
"checks": "Check every gate and complete emitted resource counts. Compare all wires to exact arithmetic for all donor tuples at widths 1 and 2 and full-width fixtures at 1076."
}
]
}
59 changes: 59 additions & 0 deletions research/half-sum-clear-circuit/circuit.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,59 @@
"""Reversible CLEAR for (x0+x1+x2+x3-x4-x5-x6-x7)/2.

Wires store little-endian bits. A gate tuple contains its controls followed
by its XOR target. The first 8*w wires are immutable inputs, followed by the
w target wires and the diagnostic. All remaining wires start and end zero.
"""


def compile_row(width):
if width < 1:
raise ValueError("positive signed width required")
size = width + 3
next_wire = 9 * width + 1
gates = []

def allocate(length):
nonlocal next_wire
block = range(next_wire, next_wire + length)
next_wire += length
return block

def signed_operand(index):
start = index * width
return [start + min(bit, width - 1) for bit in range(size)]

total = signed_operand(0)
for index in range(1, 8):
operand = signed_operand(index)
result = allocate(size)
carries = allocate(size - 1)
for bit, (a, b, out) in enumerate(zip(total, operand, result, strict=True)):
gates.extend(((a, out), (b, out))) # propagate bit p = a XOR b
if bit + 1 < size:
carry = carries[bit]
gates.append((a, b, carry))
if index >= 4:
gates.append((b, carry))
if bit:
gates.append((carries[bit - 1], out, carry))
if index >= 4:
gates.append((carries[bit - 1], carry))
if bit:
gates.append((carries[bit - 1], out))
total = result

mismatch = allocate(2)
for offset, flag in enumerate(mismatch):
gates.extend(((total[width], flag), (total[width + offset + 1], flag)))

def boolean_or(left, right):
out, = allocate(1)
gates.extend(((left, out), (right, out), (left, right, out)))
return out

overflow = boolean_or(*mismatch)
invalid = boolean_or(total[0], overflow)
copy_outputs = [(total[bit + 1], 8 * width + bit) for bit in range(width)]
copy_outputs.append((invalid, 9 * width))
return next_wire, gates + copy_outputs + gates[::-1]
80 changes: 80 additions & 0 deletions research/half-sum-clear-circuit/verify.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,80 @@
"""Execute the generated gates and compare all wires to signed integer arithmetic."""

from collections import Counter
from itertools import batched, product
from random import Random

from circuit import compile_row


def check_batch(width, size, gates, cases):
"""Each bit of a Python integer simulates one independent circuit input."""
states = [0] * size
expected_outputs = [0] * (width + 1)
limit = 1 << (width - 1)
for lane, (donors, target, diagnostic) in enumerate(cases):
for port, value in enumerate((*donors, target)):
for bit in range(width):
states[port * width + bit] |= ((value >> bit) & 1) << lane
states[9 * width] |= diagnostic << lane
numerator = sum(donors[:4]) - sum(donors[4:])
quotient, remainder = divmod(numerator, 2)
invalid = bool(remainder or not -limit <= quotient < limit)
for bit in range(width):
expected_outputs[bit] |= (((target ^ quotient) >> bit) & 1) << lane
expected_outputs[-1] |= (diagnostic ^ invalid) << lane
expected = states.copy()
expected[8 * width:9 * width + 1] = expected_outputs
for gate in gates:
flip = states[gate[0]]
if len(gate) == 3:
flip &= states[gate[1]]
states[gate[-1]] ^= flip
if states != expected:
raise ValueError("gate output differs from the full expected wire state")


def cases_for(width):
limit = 1 << (width - 1)
if width <= 2:
for values in product(range(-limit, limit), repeat=8):
# Targets are XOR outputs. Cover every donor configuration.
yield values, sum(values) % (2 * limit) - limit, values[0] & 1
return
low, high = -limit, limit - 1
for numerator in (-1, 0, 1, 2):
yield (numerator,) + (0,) * 7, numerator // 2, 0
for value in (low, high):
yield (value, value, 0, 0, 0, 0, 0, 0), value, 0
opposite = -1 - value
quotient = 2 * (value - opposite)
wrapped = (quotient + limit) % (2 * limit) - limit
yield (value,) * 4 + (opposite,) * 4, wrapped, 0
rng = Random(88937)
for _ in range(24):
words = [rng.randrange(low, high + 1) for _ in range(9)]
yield tuple(words[:8]), words[8], rng.randrange(2)


def main():
for width in (1, 2, 1076):
size, gates = compile_row(width)
counts = Counter(map(len, gates))
for gate in gates:
if (len(gate) not in (2, 3) or len(set(gate)) != len(gate)
or min(gate) < 0 or max(gate) >= size or gate[-1] < 8 * width):
raise ValueError(f"illegal gate {gate}")
work = size - 9 * width - 1
if (len(gates), work) != (87 * width + 199, 14 * width + 39):
raise ValueError("emitted gate or workspace count differs from the proof")
checked = 0
for batch in batched(cases_for(width), 256):
check_batch(width, size, gates, batch)
checked += len(batch)
print(f"w={width} cases={checked} CNOT={counts[2]} Toffoli={counts[3]} "
f"total={len(gates)} work={size - 9 * width - 1}")
print("PASS_HALF_SUM_CLEAR")


if __name__ == "__main__":
main()
Loading