Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

MovesV/ValidOn for preF ++ copyoND ++ leafMix from initR (QHNetRecR leaf prefix)

Open
IntMul.Kappa.R8.Bit.Oppbank.MovesV_preF_copyoND_leafMix

by Ethan Cheung Wang · Nov 15, 2026 · Mathlib 0df444a (Lean v4.33.1)

bitnbcomplexity-theoryinteger-multiplicationleafmixmovesvoppbankprefixqhnetrecrr8round-eight

Leaf prefix of the variant-R word is a valid nested move

On the published variant-R carrier, let initR\mathrm{initR}initR be the stage-one initial labelling (wX(t)=cND(t)\mathrm{wX}(t)=\mathrm{cND}(t)wX(t)=cND(t), densified RETN−1\mathrm{RETN}-1RETN−1 on the wTwTwT wires, and 000 elsewhere). Let leafMix\mathrm{leafMix}leafMix be the list of v=1771v=1771v=1771 leaf mix-forward records whose extra slots occupy the open interval between consecutive srcS\mathrm{srcS}srcS values (and, for the last leaf, up to the leaf slot bound 110991109911099). Write copyoND_leafMix\mathrm{copyoND\_leafMix}copyoND_leafMix for the concatenation of the copy stage copyoND\mathrm{copyoND}copyoND with leafMix\mathrm{leafMix}leafMix. Running the prefix preF\mathrm{preF}preF followed by copyoND_leafMix\mathrm{copyoND\_leafMix}copyoND_leafMix from initR\mathrm{initR}initR yields a valid labelling whose recorded moves are nested at bound 642516425164251:

ValidOn(initR) ∧ MovesV(genF(initR,preF+ ⁣+copyoND_leafMix)) ∧ ValidOn(genF(initR,preF+ ⁣+copyoND_leafMix)1).\mathrm{ValidOn}(\mathrm{initR})\ \wedge\ \mathrm{MovesV}(\mathrm{genF}(\mathrm{initR},\mathrm{preF}{+}\!{+}\mathrm{copyoND\_leafMix}))\ \wedge\ \mathrm{ValidOn}(\mathrm{genF}(\mathrm{initR},\mathrm{preF}{+}\!{+}\mathrm{copyoND\_leafMix})_1).ValidOn(initR) ∧ MovesV(genF(initR,preF++copyoND_leafMix)) ∧ ValidOn(genF(initR,preF++copyoND_leafMix)1​).

This extends the already-established preF+ ⁣+copyoND\mathrm{preF}{+}\!{+}\mathrm{copyoND}preF++copyoND prefix by the first 177117711771 leaf records of the mix-forward schedule. After the copy stage, each pivot slot wS(srcS(t))\mathrm{wS}(\mathrm{srcS}(t))wS(srcS(t)) already carries cND(t)\mathrm{cND}(t)cND(t), and each extra slot in a leaf interval is still 000, so every recorded leaf move is a boundary write.

Formalization Note. The statement is Lab.ValidOn / Lab.MovesV for Gen.genF initR (QHNetRecR.preF ++ copyoND_leafMix) at codeBound = 64251, with copyoND_leafMix := QHNetRecR.copyoND ++ leafMix. It does not unfold segsR or W1F, does not cover the later mix-forward gates or preloads, and is not a full-word MovesV certificate.

Preamble
import Definitions.Def_IntMul_Kappa_R8_Data_BitOppbankGenF
import Definitions.Def_IntMul_Kappa_R8_Data_BitOppbankLab1
import Definitions.Def_IntMul_Kappa_R8_Data_BitOppbankQHNetRecR
import Mathlib

set_option autoImplicit false
set_option relaxedAutoImplicit false
set_option maxHeartbeats 8000000
set_option maxRecDepth 1000000
Formal statement
namespace IntMul.Kappa.R8.Bit.Oppbank

/-- Variant-R stage-one initial map (`initH`): `wX t = cND t`,
`wT c = cND (retN c)` with densified `RETN-1`, all other wires `0`. -/
def initR (w : ℕ) : ℕ :=
  if w < v then QHNetRecR.cND w
  else if wAuxEnd ≤ w ∧ w < NL then QHNetRecR.cND (QHNetRecR.retN (w - wAuxEnd))
  else 0

/-- Exclusive upper bound on source-slot indices appearing in leaf extras. -/
def leafSlotBound : ℕ := 11099

/-- Exclusive end of the open slot interval belonging to leaf `t`. -/
def leafHi (t : ℕ) : ℕ := if t + 1 = v then leafSlotBound else QHNetRecR.srcS (t + 1)

/-- Extra source slots written by leaf `t`: strictly between consecutive `srcS`
values, or up to `leafSlotBound` for the last leaf. -/
def leafExtras (t : ℕ) : List ℕ :=
  List.range' (QHNetRecR.srcS t + 1) (leafHi t - (QHNetRecR.srcS t + 1))

/-- The mix-forward instruction for leaf `t`. -/
def leafAt (t : ℕ) : QHNetRecR.LInstr :=
  QHNetRecR.mk (QHNetRecR.cND t)
    (leafExtras t |>.map fun o => (wS o, wS (QHNetRecR.srcS t)))

/-- The 1771 leaf mix-forward records. Marked irreducible so the concrete
`List.range v` map is never unfolded. -/
@[irreducible] def leafMix : List QHNetRecR.LInstr := (List.range v).map leafAt

/-- Concatenation of the copy stage with the leaf mix-forward pack. -/
@[irreducible] def copyoND_leafMix : List QHNetRecR.LInstr :=
  QHNetRecR.copyoND ++ leafMix

/-- The prefix `preF ++ copyoND_leafMix` of `QHNetRecR.W1F`, run from `initR`,
is `ValidOn` / `MovesV` at densified `codeBound = 64251`. This does not unfold
`segsR` or `W1F`, does not cover later mix-forward gates or preloads, and is
not a full-word `MovesV` certificate. -/
theorem MovesV_preF_copyoND_leafMix :
    Lab.ValidOn initR ∧
      Lab.MovesV (Gen.genF initR (QHNetRecR.preF ++ copyoND_leafMix)).2 ∧
        Lab.ValidOn (Gen.genF initR (QHNetRecR.preF ++ copyoND_leafMix)).1 := by
  sorry

end IntMul.Kappa.R8.Bit.Oppbank
Source
IntMul Kappa R8 Bit Oppbank FormalOK: prefix MovesV/ValidOn for QHNetRecR.preF ++ copyoND ++ leafMix from initR (initH, RETN-1, wX t = cND t) at Lab.codeBound 64251. leafMix is the 1771 leaf mix-forward records. Not a full-word MovesV certificate; does not unfold segsR or W1F.

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me