Canonical log / EXP-001—EXP-075

Experiments are evidence trails, not victory laps.

Seventy-five Advantage Decomposition families are consolidated from canonical reports. Every new entry includes its scientific basis, mathematical model, validation controls and explicit limitations. Some investigations require weeks or months of collection, replication and analysis.

Experiment lifecycle
PROPOSEDPREREGISTEREDRUNNINGANALYZINGREPLICATINGCLOSED

6 published entries remain experimental or in progress.

Claim boundary

3 isolated local gains, zero demonstrated end-to-end mining advantages.

“Local gain” is deliberately narrow: a measured reduction in diagnostic work or an exact avoided-enumeration capability inside a registered subproblem. It does not mean faster full SHA-256, higher hashrate, lower energy per valid Bitcoin block or an economic mining advantage.

75 / 75
EXP-005EXPERIMENTAL
Advantage Decomposition / Capability portfolio

Hybrid semantic portfolio

A portfolio of exact specialized representations can cover more contexts than one global grammar.

Variants
7
Hardware
Classical deterministic verifier
Open experiment log
EXP-006VALIDATED
Advantage Decomposition / Modular addition

Carry-state semantic factors

Explicit carry state can factor contextual behavior that appears opaque in a coarse word-level representation.

Variants
6
Hardware
Classical deterministic verifier
Open experiment log
EXP-007VALIDATED
Advantage Decomposition / Decision semantics

SAFE-PRUNE / DEFER decision policy

A partial engine can expose only two safe online outcomes: exact rejection or defer-to-baseline.

Variants
6
Hardware
Classical verifier; policy designed for later ASIC-compatible orchestration
Open experiment log
EXP-008VALIDATED
Advantage Decomposition / Formal interface

Abstract SAFE-PRUNE certificates

Pruning evidence can be separated from the discovery engine and checked through a small abstract certificate interface.

Variants
6
Hardware
Classical verifier using Bitcoin-format job data
Open experiment log
EXP-016VALIDATED
Advantage Decomposition / Header scheduling

Legal nTime capability classes

Legal nTime values can dispatch exact R4 low-bit capability classes while version and merkle context remain fixed.

Variants
7
Hardware
Classical exact verifier
Open experiment log
EXP-017VALIDATED
Advantage Decomposition / Forward propagation

M4→M5 inherited semantic context

An exact M4 representation remains useful when inherited into the M5 transition even if the coarse next-stage label becomes GENERAL.

Variants
7
Hardware
Classical deterministic verifier
Open experiment log
EXP-021VALIDATED
Advantage Decomposition / SHA-256

Exact carry and Majority program families

The R5 Σ0/carry and Majority low-bit wall can be replaced by finite exact program families, and any candidate simplification that survives into R6 can be detected without approximation.

Variants
8
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-022VALIDATED
Advantage Decomposition / SHA-256

K/P/G carry transfer and long-jump irrelevance

Carry propagation across selected A5 intervals can be represented by exact Kill/Propagate/Generate transfer states, and an interval with identically zero propagation makes its incoming carry irrelevant.

Variants
8
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-025VALIDATED
Advantage Decomposition / SHA-256

Corrected inner-T2 carry certificate

The dominant bit-18 freeze can be reconstructed from the inner carry of Σ0(a4)+Maj4, and the original source-predicate shortcut must be rejected if independent review does not support it.

Variants
8
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-026VALIDATED
Advantage Decomposition / SHA-256

High-reset Σ0 freeze frontier

For bits 15–18, Σ0(a4) freezes exactly when one low rotated source bit freezes, because the other rotated source bits and Majority inputs are already constant in the registered context.

Variants
5
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-027VALIDATED
Advantage Decomposition / SHA-256

Baseline-only exact freeze detector

The V26 freeze and carry certificate can be derived from one baseline source trace and exact modular boundaries, without enumerating all 16 W3.low4 children online.

Variants
4
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-028VALIDATED
Advantage Decomposition / SHA-256

Bitsliced outer bit-18 reset detector

The complete outer T1/T2 bit-18 hard reset can be predicted exactly with 16-lane truth masks and ripple carry from one inherited M4 baseline state.

Variants
5
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-029VALIDATED
Advantage Decomposition / SHA-256

Connected reset suffix to carry 22

The exact bit-18 reset certificate can skip the preceding dependency and propagate through bits 19–21 to produce the true carry-22 mask on the same survivor population.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-030VALIDATED
Advantage Decomposition / SHA-256

Consumption of the reset path by Σ0(a5)

If the connected reset path retains a useful simplification, it should appear in the exact a5[22] mask or in the four low lanes of Σ0(a5) for the actual survivors.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-031VALIDATED
Advantage Decomposition / SHA-256

ANF cancellation attribution in Σ0 lane 0

The attenuation observed at Σ0(a5) lane 0 can be attributed exactly to cancellation among rotated input monomials rather than described only by an aggregate complexity score.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-032VALIDATED
Advantage Decomposition / SHA-256

Full nonlinear overlap map

If attenuation is diffuse, a complete monomial-by-monomial overlap map should show broadly distributed small differences rather than one dominant reproducible cancellation term.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-033VALIDATED
Advantage Decomposition / SHA-256

Attribution of the x3 source branch

The replicated suppression pattern can be localized to terms containing source variable x3 and traced to the exact rotated input components that create or cancel them.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-034VALIDATED
Advantage Decomposition / SHA-256

Carry regeneration after cancellation

Any suppression attributed to x3 may be erased when modular addition regenerates nonlinear terms through carry, so the next connected carry frontier must be profiled exactly.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-035VALIDATED
Advantage Decomposition / SHA-256

K/P/G attribution at carry 20

The exact source of carry-21 regeneration can be separated into Generate at bit 20 and the product of Propagate with incoming carry, revealing which primitive restores x3 complexity.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-036VALIDATED
Advantage Decomposition / SHA-256

Full T2₅ low-bit consumer

A local simplification is meaningful only if it survives composition into the complete T2₅ low-four-bit consumer, including Σ0(a5), Majority and inner carry.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-037VALIDATED
Advantage Decomposition / SHA-256

Majority branch attribution

The increased Majority complexity seen in V36 may be explained by mixing the c5=0 and c5=1 Boolean branches rather than by one stable within-branch mechanism.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-038NEGATIVE
Advantage Decomposition / SHA-256

Within-family affine audit

If the Majority contrast is structural, it should remain directionally coherent after conditioning on exact affine truth-table families and c5 branches.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-039VALIDATED
Advantage Decomposition / SHA-256

Exact R5→R6 state-transition audit

Any reset-derived reduction that matters beyond T2₅ must remain visible after the complete state update into a6 and e6, rather than only inside an operand.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-040NEGATIVE
Advantage Decomposition / SHA-256

E6 nonlinear-union audit and branch closure

The small e6 attenuation can support the bit18-to-R6 line only if the complete nonlinear monomial union, not a selected subset, replicates across original and fresh cohorts.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-041VALIDATED
Advantage Decomposition / SHA-256

Effective bit-17 restart to carry 22

A hard reset at bit 17 remains operationally effective only when no later bit-18 reset overwrites it; under that condition it should reconstruct carry 22 exactly.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-042VALIDATED
Advantage Decomposition / SHA-256

Bit-17 attenuation ladder

If the effective bit-17 restart creates a connected simplification, its direction should replicate across carry 22, a5[22], Σ0(a5)[0], T2₅.low4 and a6.low4 against matched no-later-reset controls.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-043VALIDATED
Advantage Decomposition / SHA-256

Generic latest-reset capability

Reset positions 16–18 can be unified by one exact rule: choose the latest active reset and evaluate only the suffix after that position.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-044NEGATIVE
Advantage Decomposition / SHA-256

R60 nested-reset cost audit

A nested decision tree of exact reset certificates can evaluate the R60 target predicate with less diagnostic work than the exact ripple baseline.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-045VALIDATED
Advantage Decomposition / SHA-256

Exact B8→B16 target nesting

A candidate that passes the first target byte can be tested for the second byte incrementally, with total work equal to B8 work plus conditional B16 work and no decision errors.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-047VALIDATED
Advantage Decomposition / SHA-256

B32→B40 cross-word target bridge

The exact target ladder can cross from digest word 7 to the first byte of word 6 when the required e62/feedforward identity is included.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-048VALIDATED
Advantage Decomposition / SHA-256

Generic B40–B64 word-6 family

Once the cross-word bridge is established, the same byte-wise target family should extend through B48, B56 and B64 within digest word 6.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-049VALIDATED
Advantage Decomposition / SHA-256

B64→B72 cross-word backward capability

The target ladder can cross from B64 into digest word 5 by reconstructing the exact e63/feedforward relation and evaluating the next target byte backward from the final digest.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-050VALIDATED
Advantage Decomposition / SHA-256

B72 target-boundary tri-state

After the B72 prefix, exact lexicographic comparison can classify many states as final ACCEPT or REJECT while safely deferring only prefix ties to the remaining suffix.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-051VALIDATED
Advantage Decomposition / SHA-256

Target-byte 0x35 tri-state refinement

For cases deferred by V50, comparison with the next registered target byte 0x35 should again produce exact ACCEPT, REJECT or a much smaller DEFER set.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-052VALIDATED
Advantage Decomposition / SHA-256

Target-byte 0x3D tri-state closure

Applying the next target byte 0x3D to V51 defers should resolve nearly all remaining cases and reveal whether a zero-suffix deferral can still satisfy PoW.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-053VALIDATED
Advantage Decomposition / SHA-256

R59 predecessor transport

The digest-word-5 target relation can be transported exactly to an R59 predecessor interface using a fixed affine identity and only four reduced T1 primitives.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-054VALIDATED
Advantage Decomposition / SHA-256

Generic exact inverse round

A complete SHA-256 round is a point-state bijection when the schedule word and round constant are fixed, allowing exact inversion and restart from the recovered predecessor.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-055VALIDATED
Advantage Decomposition / SHA-256

Compact one-dimensional inverse fiber

Holding a next-round state fixed except for next-a defines a compact one-dimensional predecessor fiber with invariant support, affine d/h laws and exact forward restart.

Variants
3
Hardware
Classical exact algebraic verifier
Open experiment log
EXP-059VALIDATED
Canonical GPU engineering / SHA-256d

Static Blackwell SASS audit

The sm_120 compiler already maps the external SHA-256d arithmetic to Blackwell-native shift, Boolean and add instructions.

Variants
3
Hardware
NVIDIA GeForce RTX 5080 · exact SHA-256d verifier
Open experiment log
EXP-063NEGATIVE
Canonical GPU engineering / SHA-256d

Forced 2×/4× inter-nonce unrolling

Forcing two or four nonces into one unrolled body can expose enough instruction-level parallelism to exceed the baseline.

Variants
3
Hardware
NVIDIA GeForce RTX 5080 · exact SHA-256d verifier
Open experiment log
EXP-064NEGATIVE
Canonical GPU engineering / SHA-256d

Pilot screening of header templates

A small pilot can select headers whose disjoint holdout has a higher below-target density than equal-work random allocation.

Variants
3
Hardware
NVIDIA GeForce RTX 5080 · exact SHA-256d verifier
Open experiment log
EXP-065NEGATIVE
Canonical GPU engineering / SHA-256d

Nonce-prefix regional persistence

Pilot B8 density within a high-byte nonce region predicts density in a disjoint low-24-bit holdout from the same region.

Variants
3
Hardware
NVIDIA GeForce RTX 5080 · exact SHA-256d verifier
Open experiment log
EXP-073EXPERIMENTAL
Canonical GPU engineering / SHA-256d

Host polling depth over T512-N4

Batching multiple launches before result copy/synchronization improves end-to-end throughput by amortizing host overhead.

Variants
3
Hardware
NVIDIA GeForce RTX 5080 · exact SHA-256d verifier
Open experiment log