def CosetAdderDeviationBound (pad : Nat) (dev : ℝ) : Prop

def TraceDistanceFromDeviation (m n anc : Nat)
    (f g : Nat → BaseUCom (n + anc)) (totalDev : ℝ) : Prop

structure ApproxCosetShor (a r N m n anc : Nat)

theorem ApproxCosetShor.shorCorrect {a r N m n anc : Nat}
    (W : ApproxCosetShor a r N m n anc) :
    W.idealBound - (2 ^ m : ℝ) * (2 * (2 * Real.sqrt W.totalDev))
      ≤ probability_of_success a r N m n anc W.fApprox

theorem ApproxCosetShor.shorCorrect_exact {a r N m n anc : Nat}
    (W : ApproxCosetShor a r N m n anc) (h0 : W.totalDev = 0) :
    W.idealBound ≤ probability_of_success a r N m n anc W.fApprox

structure Op (G E C : Type)

def encodings (f : G → C → E) (g : G) : Finset E

def deviated (f : G → C → E) (P : Op G E C) (g : G) : Finset C

def DevBound (f : G → C → E) (P : Op G E C) (ε : ℝ) : Prop

def Op.comp (P₀ P₁ : Op G E C) : Op G E C

theorem DevBound_comp (f : G → C → E) (hf : ∀ g, Function.Injective (f g))
    (P₀ P₁ : Op G E C) (ε₀ ε₁ : ℝ)
    (h₀ : DevBound f P₀ ε₀) (h₁ : DevBound f P₁ ε₁) :
    DevBound f (P₀.comp P₁) (ε₀ + ε₁)

def Op.id : Op G E C

theorem DevBound_id (f : G → C → E) : DevBound f Op.id 0

def compList : List (Op G E C) → Op G E C
  | [] => Op.id
  | P :: Ps => P.comp (compList Ps)

theorem DevBound_compList (f : G → C → E) (hf : ∀ g, Function.Injective (f g)) (ε : ℝ) :
    ∀ (Ps : List (Op G E C)), (∀ P ∈ Ps, DevBound f P ε) →
      DevBound f (compList Ps) ((Ps.length : ℝ) * ε)
  | [], _ =>

noncomputable def pmNorm {d : Nat} (φ : QState d) : ℝ

noncomputable def pmDist {d : Nat} (φ ψ : QState d) : ℝ

lemma pmNorm_nonneg {d : Nat} (φ : QState d) : 0 ≤ pmNorm φ

lemma pmDist_nonneg {d : Nat} (φ ψ : QState d) : 0 ≤ pmDist φ ψ

lemma pmNorm_sq {d : Nat} (φ : QState d) :
    (pmNorm φ) ^ 2 = ∑ i, Complex.normSq (φ i 0)

lemma pmDist_sq {d : Nat} (φ ψ : QState d) :
    (pmDist φ ψ) ^ 2 = ∑ i, Complex.normSq (φ i 0 - ψ i 0)

lemma partial_meas_index_inj {m_dim full_dim : Nat} (h_dvd : m_dim ∣ full_dim)
    (s : Fin m_dim) : Function.Injective (partial_meas_index h_dvd s)

lemma block_sum_le {m_dim full_dim : Nat} (s : Nat) (h_s_lt : s < m_dim)
    (h_dvd : m_dim ∣ full_dim) (g : Fin full_dim → ℝ) (hg : ∀ i, 0 ≤ g i) :
    ∑ y : Fin (full_dim / m_dim), g (partial_meas_index h_dvd ⟨s, h_s_lt⟩ y)
      ≤ ∑ i, g i

lemma normSq_sub_le (a b : ℂ) :
    |Complex.normSq a - Complex.normSq b| ≤ ‖a - b‖ * (‖a‖ + ‖b‖)

theorem prob_partial_meas_diff_le_two_dist {m_dim full_dim : Nat} (s : Nat)
    (h_s_lt : s < m_dim) (h_dvd : m_dim ∣ full_dim) (φ ψ : QState full_dim)
    (hφ : pmNorm φ ≤ 1) (hψ : pmNorm ψ ≤ 1) :
    |prob_partial_meas (basis_vector m_dim s) φ
        - prob_partial_meas (basis_vector m_dim s) ψ|
      ≤ 2 * pmDist φ ψ

lemma shor_dvd (m n anc : Nat) : (2 ^ m) ∣ (2 ^ m * 2 ^ n * 2 ^ anc)

theorem probability_of_success_stable (a r N m n anc : Nat)
    (f g : Nat → BaseUCom (n + anc)) (δ : ℝ)
    (hf : pmNorm (Shor_final_state m n anc f) ≤ 1)
    (hg : pmNorm (Shor_final_state m n anc g) ≤ 1)
    (hclose : pmDist (Shor_final_state m n anc f) (Shor_final_state m n anc g) ≤ δ) :
    |probability_of_success a r N m n anc f - probability_of_success a r N m n anc g|
      ≤ (2 ^ m : ℝ) * (2 * δ)

theorem shor_success_approx (a r N m n anc : Nat) (f g : Nat → BaseUCom (n + anc))
    (B δ : ℝ)
    (hf : pmNorm (Shor_final_state m n anc f) ≤ 1)
    (hg : pmNorm (Shor_final_state m n anc g) ≤ 1)
    (h_ideal : B ≤ probability_of_success a r N m n anc g)
    (hclose : pmDist (Shor_final_state m n anc f) (Shor_final_state m n anc g) ≤ δ) :
    B - (2 ^ m : ℝ) * (2 * δ) ≤ probability_of_success a r N m n anc f

noncomputable def totalDeviationR : ℝ

theorem totalDeviationR_eq : totalDeviationR = (41 : ℝ) / 536870912

theorem totalDeviationR_nonneg : 0 ≤ totalDeviationR

theorem totalDeviation_eq_wrapCount :
    (totalDeviation 2048 3072 : ℚ)
      = countingBoundQ (FormalRV.Shor.WindowedCostModel.lookupAdditionCount 2048 3072)
          (2048 / 1024) (2048 ^ 2 * 3072 * 1024)

theorem prob_success_stable
    (a r N m n anc : Nat) (f₁ f₂ : Nat → BaseUCom (n + anc)) :
    |probability_of_success a r N m n anc f₁
        - probability_of_success a r N m n anc f₂|
      ≤ normSqDist (Shor_final_state m n anc f₁) (Shor_final_state m n anc f₂)

structure CosetIdealL1Bound
    (a r N m n anc : Nat)
    (f_coset f_ideal : Nat → BaseUCom (n + anc))

theorem coset_shor_succeeds_param
    (a r N m n anc : Nat)
    (f_coset f_ideal : Nat → BaseUCom (n + anc))
    (P_ideal : ℝ)
    (h_ideal : probability_of_success a r N m n anc f_ideal ≥ P_ideal)
    (B : CosetIdealL1Bound a r N m n anc f_coset f_ideal) :
    probability_of_success a r N m n anc f_coset
      ≥ P_ideal - 2 * totalDeviationR

theorem ge2021_coset_shor_succeeds
    (w bits numWin N a ainv0 r m : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hb1 : 1 ≤ bits)
    (hN1 : 1 < N) (hN2 : 2 * N ≤ 2 ^ bits)
    (h_inv0 : a * ainv0 % N = 1)
    (h_setting : ShorSetting a r N m bits)
    (f_coset : Nat → BaseUCom (bits + (2 * w + 2 * bits + 3)))
    (B : CosetIdealL1Bound a r N m bits (2 * w + 2 * bits + 3) f_coset
          (windowedModNMultiplier_verifiedModMulFamily w bits numWin N a ainv0
            hw hbits hb1 hN1 hN2 h_inv0).family) :
    probability_of_success a r N m bits (2 * w + 2 * bits + 3) f_coset
      ≥ κ / (Nat.log2 N : ℝ) ^ 4 - 2 * totalDeviationR

def jointIdx {m_dim full_dim : Nat} (h : m_dim ∣ full_dim)
    (x : Fin m_dim) (y : Fin (full_dim / m_dim)) : Fin full_dim

theorem prob_partial_meas_basis_eq
    {m_dim full_dim : Nat} (φ : QState full_dim)
    (x : Fin m_dim) (h : m_dim ∣ full_dim) :
    prob_partial_meas (basis_vector m_dim x.val) φ
      = ∑ y : Fin (full_dim / m_dim), Complex.normSq (φ (jointIdx h x y) 0)

noncomputable def normSqDist {dim : Nat} (s₁ s₂ : QState dim) : ℝ

theorem normSqDist_nonneg {dim : Nat} (s₁ s₂ : QState dim) :
    0 ≤ normSqDist s₁ s₂

theorem prob_partial_meas_basis_sub_abs_le
    {m_dim full_dim : Nat} (s₁ s₂ : QState full_dim)
    (x : Fin m_dim) (h : m_dim ∣ full_dim) :
    |prob_partial_meas (basis_vector m_dim x.val) s₁
        - prob_partial_meas (basis_vector m_dim x.val) s₂|
      ≤ ∑ y : Fin (full_dim / m_dim),
          |Complex.normSq (s₁ (jointIdx h x y) 0)
            - Complex.normSq (s₂ (jointIdx h x y) 0)|

theorem jointIdx_eq_finProdFinEquiv {m_dim full_dim : Nat} (h : m_dim ∣ full_dim)
    (x : Fin m_dim) (y : Fin (full_dim / m_dim)) :
    jointIdx h x y
      = Fin.cast (Nat.mul_div_cancel' h) (finProdFinEquiv (x, y))

theorem sum_jointIdx_eq {m_dim full_dim : Nat} (h : m_dim ∣ full_dim)
    (g : Fin full_dim → ℝ) :
    ∑ x : Fin m_dim, ∑ y : Fin (full_dim / m_dim), g (jointIdx h x y)
      = ∑ i : Fin full_dim, g i

theorem r_found_nonneg (o m r a N : Nat) : 0 ≤ r_found o m r a N

theorem r_found_le_one (o m r a N : Nat) : r_found o m r a N ≤ 1

theorem prob_of_success_transfer_normSqDist
    (a r N m n anc : Nat)
    (f₁ f₂ : Nat → BaseUCom (n + anc)) :
    |probability_of_success a r N m n anc f₁
        - probability_of_success a r N m n anc f₂|
      ≤ normSqDist (Shor_final_state m n anc f₁) (Shor_final_state m n anc f₂)

theorem normSq_sub_abs_le (a b : ℂ) :
    |Complex.normSq a - Complex.normSq b| ≤ (‖a‖ + ‖b‖) * ‖a - b‖

noncomputable def ampDist {dim : Nat} (s₁ s₂ : QState dim) : ℝ

theorem ampDist_nonneg {dim : Nat} (s₁ s₂ : QState dim) : 0 ≤ ampDist s₁ s₂

theorem normSqDist_le_ampDist {dim : Nat} (s₁ s₂ : QState dim) :
    normSqDist s₁ s₂ ≤ ampDist s₁ s₂

theorem prob_of_success_transfer_ampDist
    (a r N m n anc : Nat) (f₁ f₂ : Nat → BaseUCom (n + anc)) :
    |probability_of_success a r N m n anc f₁
        - probability_of_success a r N m n anc f₂|
      ≤ ampDist (Shor_final_state m n anc f₁) (Shor_final_state m n anc f₂)

theorem sum_mul_le_sqrt_mul_sqrt {dim : Nat} (f g : Fin dim → ℝ)
    (hf : ∀ i, 0 ≤ f i) (hg : ∀ i, 0 ≤ g i) :
    ∑ i, f i * g i ≤ Real.sqrt (∑ i, f i ^ 2) * Real.sqrt (∑ i, g i ^ 2)

theorem sqrt_sum_add_sq_le {dim : Nat} (f g : Fin dim → ℝ)
    (hf : ∀ i, 0 ≤ f i) (hg : ∀ i, 0 ≤ g i) :
    Real.sqrt (∑ i, (f i + g i) ^ 2)
      ≤ Real.sqrt (∑ i, f i ^ 2) + Real.sqrt (∑ i, g i ^ 2)

noncomputable def l2norm {dim : Nat} (s : QState dim) : ℝ

noncomputable def l2dist {dim : Nat} (s₁ s₂ : QState dim) : ℝ

theorem l2norm_nonneg {dim : Nat} (s : QState dim) : 0 ≤ l2norm s

theorem l2dist_nonneg {dim : Nat} (s₁ s₂ : QState dim) : 0 ≤ l2dist s₁ s₂

theorem ampDist_le_l2 {dim : Nat} (s₁ s₂ : QState dim) :
    ampDist s₁ s₂ ≤ (l2norm s₁ + l2norm s₂) * l2dist s₁ s₂

theorem prob_of_success_transfer_l2
    (a r N m n anc : Nat) (f₁ f₂ : Nat → BaseUCom (n + anc))
    (h₁ : l2norm (Shor_final_state m n anc f₁) ≤ 1)
    (h₂ : l2norm (Shor_final_state m n anc f₂) ≤ 1) :
    |probability_of_success a r N m n anc f₁
        - probability_of_success a r N m n anc f₂|
      ≤ 2 * l2dist (Shor_final_state m n anc f₁) (Shor_final_state m n anc f₂)

theorem aqft_transfer_compose
    (a r N m n anc : Nat)
    (f_ideal f_compiled : Nat → BaseUCom (n + anc))
    (P_ideal ε : ℝ)
    (h_ideal : probability_of_success a r N m n anc f_ideal ≥ P_ideal)
    (h_norm_ideal : l2norm (Shor_final_state m n anc f_ideal) ≤ 1)
    (h_norm_comp : l2norm (Shor_final_state m n anc f_compiled) ≤ 1)
    (h_close : l2dist (Shor_final_state m n anc f_compiled)
                      (Shor_final_state m n anc f_ideal) ≤ ε) :
    probability_of_success a r N m n anc f_compiled ≥ P_ideal - 2 * ε

def Periodic (N P : ℕ) (f : ℕ → ℕ) : Prop

theorem modexp_periodic (N g r : ℕ) (hr : g ^ r ≡ 1 [MOD N]) :
    Periodic N r (fun x => g ^ x % N)

theorem periodic_mul (N P : ℕ) (f : ℕ → ℕ) (hf : Periodic N P f) :
    ∀ y x, f (x + y * P) ≡ f x [MOD N]
  | 0, x => by simp [Nat.ModEq]
  | y + 1, x =>

theorem approx_periodic (N P : ℕ) (hN : 0 < N) (f ftil : ℕ → ℕ) (ε : ℕ)
    (hper : Periodic N P f) (hdev : ∀ x, modDev N (f x) (ftil x) ≤ ε) (x y : ℕ) :
    modDev N (ftil (x + y * P)) (ftil x) ≤ 2 * ε

theorem window_overlap_card (a W d : ℕ) (hd : d ≤ W) :
    (Finset.Ico a (a + W) ∩ Finset.Ico (a + d) (a + d + W)).card = W - d

theorem infidelity_ratio_bound (N S eps d W : ℕ) (hN : 0 < N) (hS : 0 < S)
    (hd : d ≤ N * eps) (hW : S * N ≤ W) :
    (d : ℚ) / W ≤ (eps : ℚ) / S

noncomputable def unifSuper {d : ℕ} (W : ℕ) (A : Finset (Fin d)) : Fin d → ℂ

theorem unifSuper_inner {d : ℕ} (W : ℕ) (hW : 0 < W) (A B : Finset (Fin d)) :
    (∑ x, conj (unifSuper W A x) * unifSuper W B x) = ((A ∩ B).card : ℂ) / W

theorem masked_fidelity {D : ℕ} (W d : ℕ) (hW : 0 < W) (A B : Finset (Fin D))
    (hov : (A ∩ B).card = W - d) :
    (∑ x, conj (unifSuper W A x) * unifSuper W B x) = ((W - d : ℕ) : ℂ) / W

theorem global_fidelity_ge {M d : ℕ} (U V : Fin M → Fin d → ℂ) (c : ℝ)
    (hcond : ∀ e, c ≤ (∑ x, conj (U e x) * V e x).re) :
    (M : ℝ) * c ≤ (∑ p : Fin M × Fin d, conj (U p.1 p.2) * V p.1 p.2).re

def SmallPrimeRNSModulusExists (N m f ℓ : ℕ) : Prop

theorem rnsModulus_deviation_meaning (N L f : ℕ) (hN : 0 < N) :
    (modDev N L 0 * 2 ^ f < N) ↔ (modDev N L 0 : ℚ) / N < 1 / 2 ^ f

noncomputable def Lhat {t : ℕ} (p : Fin t → ℕ) (j : Fin t) : ℕ

noncomputable def crtBasis {t : ℕ} (p : Fin t → ℕ) (j : Fin t) : ℕ

theorem Lhat_coprime {t : ℕ} (p : Fin t → ℕ)
    (hco : ∀ i j, i ≠ j → Nat.Coprime (p i) (p j)) (j : Fin t) :
    Nat.Coprime (Lhat p j) (p j)

theorem crtBasis_delta {t : ℕ} (p : Fin t → ℕ) (hp : ∀ i, 1 < p i)
    (hco : ∀ i j, i ≠ j → Nat.Coprime (p i) (p j)) (i j : Fin t) :
    crtBasis p j % p i = if i = j then 1 else 0

theorem reconstruction_explicit {t : ℕ} (p : Fin t → ℕ) (hp : ∀ i, 1 < p i)
    (hco : ∀ i j, i ≠ j → Nat.Coprime (p i) (p j)) (V : ℕ) :
    (∑ j, (V % p j) * crtBasis p j) % (∏ i, p i) = V % (∏ i, p i)

theorem residue_modexp_via_crt_explicit (g e N : ℕ) (hN : 2 ≤ N) {m : ℕ} (hm : 1 ≤ m)
    (he : e < 2 ^ m) {tP : ℕ} (p : Fin tP → ℕ) (hp : ∀ i, 1 < p i)
    (hco : ∀ i j, i ≠ j → Nat.Coprime (p i) (p j)) (hL : N ^ m ≤ ∏ i, p i) :
    (∑ j, (modexpProd g N m e % p j) * crtBasis p j) % (∏ i, p i) % N = g ^ e % N

theorem cfs_correctness_capstone
    -- circuit / residue-arithmetic data (T7 contract = the conjecture's content + primality)
    (P : Nat → Nat) (ainvss : Nat → Nat → Nat) (numP w bits numWin g N e m : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hPok : ∀ j, j < numP → 1 < P j ∧ 2 * P j ≤ 2 ^ bits ∧
      ∀ k, k < m → ainvss j k < P j ∧ residueConst g N (P j) e k * ainvss j k % (P j) = 1)
    (hN : 2 ≤ N) (hm : 1 ≤ m) (he : e < 2 ^ m)
    (hco : ∀ i j : Fin numP, i ≠ j → Nat.Coprime (P i.val) (P j.val))
    (hL : N ^ m ≤ ∏ i : Fin numP, P i.val)
    -- the dlog-recovery success witness (T1; carries the Lemma-1 / Lemma-2 obligations)
    (S : EkeraDLPSuccess)
    -- factorisation data (Ekerå–Håstad)

theorem cfs_capstone_under_rns_modulus
    (ainvss : Nat → Nat → Nat) (w bits numWin g N e m f ℓ : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hN : 2 ≤ N) (hm : 1 ≤ m) (he : e < 2 ^ m)
    (hassume : SmallPrimeRNSModulusExists N m f ℓ)
    -- the per-prime residue-circuit instantiation contract (size + invertible multiplier table)
    (hfit : ∀ (t : ℕ) (P : Fin t → ℕ), (∀ i, (P i).Prime) → ∀ j : Fin t,
      2 * P j ≤ 2 ^ bits ∧
      ∀ k, k < m → ainvss j.val k < P j ∧ residueConst g N (P j) e k * ainvss j.val k % (P j) = 1)
    (S : EkeraDLPSuccess)
    (p q d : Nat) (hd : d = p + q - 2) (hNpq : N = p * q) (hp : 2 ≤ p) (hq : 2 ≤ q)
    (hphi : g ^ ((p - 1) * (q - 1)) ≡ 1 [MOD p * q]) :

theorem pow_mod_sub_one (p gp S : ℕ) (hp : p.Prime) (hgp : ¬ (p ∣ gp)) :
    gp ^ S % p = gp ^ (S % (p - 1)) % p

theorem prod_dlog (g N p m : ℕ) (gp : ℕ) (D : ℕ → ℕ) (e : ℕ)
    (hD : ∀ k, k < m → (Mconst g N k : ZMod p) = (gp : ZMod p) ^ (D k)) :
    (∏ k ∈ Finset.range m, ((Mconst g N k : ZMod p)) ^ bit e k)
      = (gp : ZMod p) ^ (∑ k ∈ Finset.range m, D k * bit e k)

theorem modexpProd_eq_prod (g N e : ℕ) :
    ∀ m, modexpProd g N m e = ∏ k ∈ Finset.range m, Mconst g N k ^ bit e k
  | 0 => by simp [modexpProd]
  | m + 1 =>

theorem dlog_reduction (g N p m : ℕ) (hp : p.Prime) (gp : ℕ) (D : ℕ → ℕ) (e : ℕ)
    (hgp : ¬ (p ∣ gp))
    (hD : ∀ k, k < m → Mconst g N k % p = gp ^ (D k) % p) :
    gp ^ ((∑ k ∈ Finset.range m, D k * bit e k) % (p - 1)) % p = modexpProd g N m e % p

theorem dlog_reduction_eq_residueAccumulate (g N p m : ℕ) (hp : p.Prime) (gp : ℕ) (D : ℕ → ℕ)
    (e : ℕ) (hgp : ¬ (p ∣ gp))
    (hD : ∀ k, k < m → Mconst g N k % p = gp ^ (D k) % p) :
    gp ^ ((∑ k ∈ Finset.range m, D k * bit e k) % (p - 1)) % p
      = residueAccumulate g N p e m

theorem ekeraGoodFactor_le_clamped_trigamma (τ : ℕ) :
    ekeraGoodFactor τ ≤ max 0 (1 - FormalRV.CFS.Trigamma.trigamma ((2 : ℝ) ^ τ))

theorem ekera_hastad_exponent (p q g : ℕ) (hp : 1 ≤ p) (hq : 1 ≤ q)
    (hphi : g ^ ((p - 1) * (q - 1)) ≡ 1 [MOD p * q]) :
    g ^ (p * q - 1) ≡ g ^ (p + q - 2) [MOD p * q]

theorem ekera_hastad_recovery (p q d N : ℕ) (hd : d = p + q - 2) (hN : N = p * q)
    (hp : 2 ≤ p) (hq : 2 ≤ q) :
    p * (d - p + 2) = N ∧ p * p + N = (d + 2) * p

theorem sum_unit_vectors_sq_ge {ι : Type*} (s : Finset ι) (θ : ι → ℝ)
    (hθ : ∀ i ∈ s, |θ i| ≤ Real.pi / 4) :
    (s.card : ℝ) ^ 2 / 2
      ≤ Complex.normSq (∑ i ∈ s, Complex.exp ((θ i : ℂ) * Complex.I))

theorem good_pair_angle_le (ℓ m : ℕ) (hℓ : 1 ≤ ℓ) (hm : 2 ≤ m)
    (b : ℕ) (hb : b < 2 ^ ℓ) (c : ℤ) (hc : |c| ≤ 2 ^ (m - 2)) :
    |(2 * Real.pi / (2 : ℝ) ^ (ℓ + m)) * ((b : ℝ) - (2 : ℝ) ^ (ℓ - 1)) * (c : ℝ)| ≤ Real.pi / 4

theorem sum_Te_sq_ge {ιe : Type*} (ℓ m : ℕ) (hℓ : 1 ≤ ℓ) (E : Finset ιe) (T : ιe → ℝ)
    (hEcard : (E.card : ℝ) ≤ 2 * (2 : ℝ) ^ (ℓ + m))
    (hTtot : ∑ e ∈ E, T e = (2 : ℝ) ^ (2 * ℓ + m)) :
    (2 : ℝ) ^ (3 * ℓ + m - 1) ≤ ∑ e ∈ E, (T e) ^ 2

theorem ekera_lemma7 {ιe : Type*} (ℓ m : ℕ) (hℓ : 1 ≤ ℓ)
    (E : Finset ιe) (Be : ιe → Finset ℕ) (θ : ιe → ℕ → ℝ)
    (hangle : ∀ e ∈ E, ∀ b ∈ Be e, |θ e b| ≤ Real.pi / 4)
    (hEcard : (E.card : ℝ) ≤ 2 * (2 : ℝ) ^ (ℓ + m))
    (hTtot : ∑ e ∈ E, ((Be e).card : ℝ) = (2 : ℝ) ^ (2 * ℓ + m)) :
    (2 : ℝ) ^ (-(ℓ + m + 2 : ℤ))
      ≤ (1 / (2 : ℝ) ^ (2 * (2 * ℓ + m)))
          * ∑ e ∈ E, Complex.normSq (∑ b ∈ Be e, Complex.exp ((θ e b : ℂ) * Complex.I))

noncomputable def ehE (ℓ m : ℕ) : Finset ℤ

noncomputable def ehBe (ℓ m d : ℕ) (e : ℤ) : Finset ℕ

theorem ehE_card_le (ℓ m : ℕ) : ((ehE ℓ m).card : ℝ) ≤ 2 * (2 : ℝ) ^ (ℓ + m)

theorem eh_per_b_count (ℓ m d : ℕ) (hdlt : d < 2 ^ m) (b : ℕ) (hb : b < 2 ^ ℓ) :
    ((ehE ℓ m).filter
        (fun e => 0 ≤ e + (b : ℤ) * (d : ℤ) ∧ e + (b : ℤ) * (d : ℤ) < (2 : ℤ) ^ (ℓ + m))).card
      = 2 ^ (ℓ + m)

theorem ehTtot (ℓ m d : ℕ) (hdlt : d < 2 ^ m) :
    ∑ e ∈ ehE ℓ m, ((ehBe ℓ m d e).card : ℝ) = (2 : ℝ) ^ (2 * ℓ + m)

theorem ekera_lemma7_unconditional (ℓ m d : ℕ) (hℓ : 1 ≤ ℓ) (hm : 2 ≤ m) (hdlt : d < 2 ^ m)
    (c : ℤ) (hc : |c| ≤ 2 ^ (m - 2)) :
    (2 : ℝ) ^ (-(ℓ + m + 2 : ℤ))
      ≤ (1 / (2 : ℝ) ^ (2 * (2 * ℓ + m)))
          * ∑ e ∈ ehE ℓ m, Complex.normSq (∑ b ∈ ehBe ℓ m d e,
              Complex.exp (((2 * Real.pi / (2 : ℝ) ^ (ℓ + m))
                * ((b : ℝ) - (2 : ℝ) ^ (ℓ - 1)) * (c : ℝ) : ℝ) * Complex.I))

noncomputable def ekeraGoodFactor (τ : ℕ) : ℝ

noncomputable def ekeraBalancedFactor (Δ t τ : ℕ) : ℝ

theorem ekeraGoodFactor_nonneg (τ : ℕ) : 0 ≤ ekeraGoodFactor τ

theorem ekeraBalancedFactor_nonneg (Δ t τ : ℕ) : 0 ≤ ekeraBalancedFactor Δ t τ

theorem ekeraGoodFactor_le_one (τ : ℕ) : ekeraGoodFactor τ ≤ 1

theorem ekeraBalancedFactor_le_one (Δ t τ : ℕ) : ekeraBalancedFactor Δ t τ ≤ 1

theorem ekeraGoodFactor_ge (τ : ℕ) :
    1 - 3 / (2 : ℝ) ^ τ ≤ ekeraGoodFactor τ

theorem ekera_twoFactor_lower_bound (J : Finset ℕ) (measProb condGood : ℕ → ℝ) (A B : ℝ)
    (hA : 0 ≤ A)
    (hmeas : ∀ j ∈ J, 0 ≤ measProb j)
    (hgood : ∀ j ∈ J, A ≤ condGood j)
    (hbal : B ≤ ∑ j ∈ J, measProb j) :
    A * B ≤ ∑ j ∈ J, measProb j * condGood j

structure EkeraDLPSuccess

noncomputable def EkeraDLPSuccess.successProb (S : EkeraDLPSuccess) : ℝ

theorem EkeraDLPSuccess.success_ge (S : EkeraDLPSuccess) :
    ekeraGoodFactor S.τ * ekeraBalancedFactor S.Δ S.t S.τ ≤ S.successProb

noncomputable def ekeraTrivialSuccess (τ Δ t : ℕ) : EkeraDLPSuccess

theorem ekera_contract_inhabited (τ Δ t : ℕ) :
    ekeraGoodFactor τ * ekeraBalancedFactor Δ t τ ≤ (ekeraTrivialSuccess τ Δ t).successProb

theorem ekera_success_to_factors (S : EkeraDLPSuccess) (p q d N : ℕ)
    (hd : d = p + q - 2) (hN : N = p * q) (hp : 2 ≤ p) (hq : 2 ≤ q) :
    ekeraGoodFactor S.τ * ekeraBalancedFactor S.Δ S.t S.τ ≤ S.successProb
      ∧ (p * (d - p + 2) = N ∧ p * p + N = (d + 2) * p)

def winFin (D a W : ℕ) : Finset (Fin D)

theorem winFin_card {D a W : ℕ} (h : a + W ≤ D) : (winFin D a W).card = W

theorem winFin_inter {D a d W : ℕ} (hd : d ≤ W) :
    winFin D a W ∩ winFin D (a + d) W = winFin D (a + d) (W - d)

theorem winFin_inter_card {D a d W : ℕ} (hd : d ≤ W) (hfit : a + W ≤ D) :
    (winFin D a W ∩ winFin D (a + d) W).card = W - d

noncomputable def maskedIdeal (D a W : ℕ) : Fin D → ℂ

noncomputable def maskedApprox (D a d W : ℕ) : Fin D → ℂ

theorem maskedState_normalized {D : ℕ} (a W : ℕ) (hW : 0 < W) (hfit : a + W ≤ D) :
    (∑ x, conj (maskedIdeal D a W x) * maskedIdeal D a W x) = 1

theorem masked_amplitude_identity {D : ℕ} (a d W : ℕ) (hW : 0 < W) (hd : d ≤ W) (hfit : a + W ≤ D) :
    (∑ x, conj (maskedIdeal D a W x) * maskedApprox D a d W x) = ((W - d : ℕ) : ℂ) / W

theorem masked_amplitude_abs {D : ℕ} (a d W : ℕ) (hW : 0 < W) (hd : d ≤ W) (hfit : a + W ≤ D) :
    ‖∑ x, conj (maskedIdeal D a W x) * maskedApprox D a d W x‖ = ((W - d : ℕ) : ℝ) / W

theorem masked_fidelity_ge {D : ℕ} (a d W N S eps : ℕ) (hd : d ≤ W) (_hfit : a + W ≤ D)
    (hN : 0 < N) (hS : 0 < S) (hdev : d ≤ N * eps) (hmask : S * N ≤ W) :
    (1 : ℚ) - (eps : ℚ) / S ≤ ((W - d : ℕ) : ℚ) / W

theorem masked_infidelity_sq_le {D : ℕ} (a d W N S eps : ℕ) (hd : d ≤ W) (hfit : a + W ≤ D)
    (hN : 0 < N) (hS : 0 < S) (hdev : d ≤ N * eps) (hmask : S * N ≤ W) :
    (1 : ℚ) - (((W - d : ℕ) : ℚ) / W) ^ 2 ≤ 2 * ((eps : ℚ) / S)

def fwdDist (N a b : ℕ) : ℕ

def modDev (N a b : ℕ) : ℕ

theorem fwdDist_lt (N a b : ℕ) (hN : 0 < N) : fwdDist N a b < N

theorem fwdDist_self (N a : ℕ) (hN : 0 < N) : fwdDist N a a = 0

theorem fwdDist_add (N a b c : ℕ) (hN : 0 < N) :
    (fwdDist N a b + fwdDist N b c) % N = fwdDist N a c

theorem mod_lt_two_mul (x N : ℕ) (hx : x < 2 * N) : x % N = x ∨ x % N + N = x

theorem fwdDist_antipodal (N a b : ℕ) (hN : 0 < N) :
    fwdDist N a b + fwdDist N b a = 0 ∨ fwdDist N a b + fwdDist N b a = N

theorem fwdDist_eq_zero_iff (N a b : ℕ) (hN : 0 < N) : fwdDist N a b = 0 ↔ a % N = b % N

theorem modDev_self (N a : ℕ) (hN : 0 < N) : modDev N a a = 0

theorem modDev_comm (N a b : ℕ) : modDev N a b = modDev N b a

theorem modDev_eq_zero_iff (N a b : ℕ) (hN : 0 < N) : modDev N a b = 0 ↔ a ≡ b [MOD N]

theorem modDev_triangle (N a b c : ℕ) (hN : 0 < N) :
    modDev N a c ≤ modDev N a b + modDev N b c

theorem modDev_chain (N : ℕ) (hN : 0 < N) (s : ℕ → ℕ) :
    ∀ n, modDev N (s 0) (s n) ≤ ∑ i ∈ Finset.range n, modDev N (s i) (s (i + 1))
  | 0 => by simp [modDev_self N (s 0) hN]
  | n + 1 =>

theorem basisVec_orthonormal {q r : Nat} (hrq : r ≤ 2 ^ q) (j j' : Fin r) :
    (∑ y : Fin (2 ^ q),
        starRingEnd ℂ (FormalRV.Framework.basis_vector (2 ^ q) j'.val y 0)
          * FormalRV.Framework.basis_vector (2 ^ q) j.val y 0)
      = if j = j' then (1 : ℂ) else 0

theorem cfs_qft_peak_law_concrete (m q r k : Nat)
    (hk : k < r) (hr : 0 < r) (hrq : r ≤ 2 ^ q)
    (hsm : FormalRV.SQIRPort.s_closest m k r < 2 ^ m) :
    FormalRV.SQIRPort.prob_partial_meas
        (FormalRV.SQIRPort.basis_vector (2 ^ m) (FormalRV.SQIRPort.s_closest m k r))
        (fun i j => (1 / (Real.sqrt r : ℂ)) *
          ((∑ j_idx : Fin r,
             FormalRV.Framework.kron_vec
               (FormalRV.Framework.qpe_phase_state m ((j_idx.val : ℝ) / r))
               (FormalRV.Framework.basis_vector (2 ^ q) j_idx.val) :
             Matrix (Fin (2 ^ (m + q))) (Fin 1) ℂ) i j))
      ≥ 4 / (Real.pi ^ 2 * (r : ℝ))

noncomputable def residueOracleFamily (w bits numWin pj steps dim : Nat)
    (cs cinvs : Nat → Nat → Nat) : Nat → FormalRV.Framework.BaseUCom dim

theorem residueOracleFamily_wellTyped (w bits numWin pj steps dim : Nat)
    (cs cinvs : Nat → Nat → Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hdim : 1 + 2 * w + (2 * bits + 1) + numWin * w + 1 ≤ dim) (i : Nat) :
    FormalRV.SQIRPort.uc_well_typed (residueOracleFamily w bits numWin pj steps dim cs cinvs i)

theorem residueShorFinalState_peak_law
    (a r N m steps w bits numWin pj : Nat) (n anc : Nat)
    (cs cinvs : Nat → Nat → Nat) (k : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hdim : 1 + 2 * w + (2 * bits + 1) + numWin * w + 1 ≤ n + anc)
    (h_basic : FormalRV.SQIRPort.BasicSetting a r N m n)
    (h_mmi : FormalRV.SQIRPort.ModMulImpl a N n anc
              (residueOracleFamily w bits numWin pj steps (n + anc) cs cinvs))
    (hk : k < r)
    (h_orbit_exists :
        ∃ (β : Fin r → Matrix (Fin (2 ^ (n + anc))) (Fin 1) ℂ)
          (actual_state : Matrix (Fin (2 ^ (m + (n + anc)))) (Fin 1) ℂ),

def UnboundedPrimeRNSModulusExists (N m f : ℕ) : Prop

theorem smallPrimeRNSModulus_imp_unbounded {N m f ℓ : ℕ}
    (h : SmallPrimeRNSModulusExists N m f ℓ) : UnboundedPrimeRNSModulusExists N m f

noncomputable def nextPrime1 (N k : ℕ) (hN : N ≠ 0) : ℕ

theorem nextPrime1_spec (N k : ℕ) (hN : N ≠ 0) :
    k < nextPrime1 N k hN ∧ (nextPrime1 N k hN).Prime ∧ nextPrime1 N k hN ≡ 1 [MOD N]

noncomputable def seqPrime1 (N : ℕ) (hN : N ≠ 0) : ℕ → ℕ
  | 0 => nextPrime1 N N hN
  | (i + 1) => nextPrime1 N (seqPrime1 N hN i) hN

theorem seqPrime1_prime (N : ℕ) (hN : N ≠ 0) (i : ℕ) : (seqPrime1 N hN i).Prime

theorem seqPrime1_modEq (N : ℕ) (hN : N ≠ 0) (i : ℕ) : seqPrime1 N hN i ≡ 1 [MOD N]

theorem seqPrime1_lt_succ (N : ℕ) (hN : N ≠ 0) (i : ℕ) :
    seqPrime1 N hN i < seqPrime1 N hN (i + 1)

theorem seqPrime1_strictMono (N : ℕ) (hN : N ≠ 0) : StrictMono (seqPrime1 N hN)

theorem seqPrime1_gt (N : ℕ) (hN : N ≠ 0) (i : ℕ) : N < seqPrime1 N hN i

theorem unboundedRNSModulus_of_lt_two_pow (N m f : ℕ) (h1N : 1 < N) (hf : 2 ^ f < N) :
    UnboundedPrimeRNSModulusExists N m f

theorem reconstruction {t : ℕ} (p : Fin t → ℕ)
    (hco : ∀ i j, i ≠ j → Nat.Coprime (p i) (p j))
    (V : ℕ) (u : Fin t → ℕ) (hu : ∀ i j, u j % p i = if i = j then 1 else 0) :
    (∑ j, (V % p j) * u j) % (∏ i, p i) = V % (∏ i, p i)

theorem residue_modexp_via_crt (g e N L : ℕ) (hN : 2 ≤ N) {m : ℕ} (hm : 1 ≤ m)
    (hL : N ^ m ≤ L) (he : e < 2 ^ m)
    {tP : ℕ} (p : Fin tP → ℕ) (hco : ∀ i j, i ≠ j → Nat.Coprime (p i) (p j))
    (hLp : (∏ i, p i) = L) (u : Fin tP → ℕ) (hu : ∀ i j, u j % p i = if i = j then 1 else 0) :
    (∑ j, (modexpProd g N m e % p j) * u j) % L % N = g ^ e % N

theorem residue_no_wraparound (V N L : Nat) (h : V < L) : V % L % N = V % N

def bit (e m : Nat) : Nat

def Mconst (g N m : Nat) : Nat

def modexpProd (g N : Nat) : Nat → Nat → Nat
  | 0,     _ => 1
  | m + 1, e => modexpProd g N m e * Mconst g N m ^ bit e m

theorem mod_two_pow_succ (e m : Nat) :
    e % 2 ^ (m + 1) = e % 2 ^ m + 2 ^ m * bit e m

theorem modexpProd_modEq (g N e : Nat) : ∀ m,
    modexpProd g N m e ≡ g ^ (e % 2 ^ m) [MOD N]
  | 0 => by simp only [modexpProd, pow_zero, Nat.mod_one]; exact Nat.ModEq.refl 1
  | m + 1 =>

theorem modexpProd_le (g e : Nat) {N : Nat} (hN : 2 ≤ N) : ∀ m, modexpProd g N m e ≤ (N - 1) ^ m
  | 0 => by simp [modexpProd]
  | m + 1 =>

theorem modexpProd_lt_pow (g e : Nat) {N : Nat} (hN : 2 ≤ N) {m : Nat} (hm : 1 ≤ m) :
    modexpProd g N m e < N ^ m

theorem residue_modexp_exact (g e N L m : Nat) (hlt : modexpProd g N m e < L) :
    modexpProd g N m e % L % N = g ^ (e % 2 ^ m) % N

theorem residue_modexp_exact_shor (g e N L : Nat) (hN : 2 ≤ N) {m : Nat} (hm : 1 ≤ m)
    (hL : N ^ m ≤ L) :
    modexpProd g N m e % L % N = g ^ (e % 2 ^ m) % N

theorem residue_modexp_exact_of_lt (g e N L : Nat) (hN : 2 ≤ N) {m : Nat} (hm : 1 ≤ m)
    (hL : N ^ m ≤ L) (he : e < 2 ^ m) :
    modexpProd g N m e % L % N = g ^ e % N

theorem residueFold_crt_correct (P : Nat → Nat) (ainvss : Nat → Nat → Nat)
    (numP w bits numWin g N e m : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hPok : ∀ j, j < numP → 1 < P j ∧ 2 * P j ≤ 2 ^ bits ∧
      ∀ k, k < m → ainvss j k < P j ∧ residueConst g N (P j) e k * ainvss j k % (P j) = 1)
    (hN : 2 ≤ N) (hm : 1 ≤ m) (he : e < 2 ^ m)
    (hco : ∀ i j : Fin numP, i ≠ j → Nat.Coprime (P i.val) (P j.val))
    (hL : N ^ m ≤ ∏ i : Fin numP, P i.val) :
    (∑ j : Fin numP,
        (decodeReg (fun i => j.val * residueWidth w bits numWin + (1 + 2 * w + (2 * bits + 1) + i)) bits
          (Gate.applyNat (residueFold P ainvss numP w bits numWin g N e m) (globalInput w bits numWin)))
          * crtBasis (fun i : Fin numP => P i.val) j) % (∏ i : Fin numP, P i.val) % N

def residueAccumulate (g N pj e : ℕ) : ℕ → ℕ
  | 0 => 1 % pj
  | k + 1 => (residueAccumulate g N pj e k * Mconst g N k ^ bit e k) % pj

theorem residueAccumulate_step (g N pj e k : ℕ) :
    residueAccumulate g N pj e (k + 1) =
      if bit e k = 1 then (Mconst g N k * residueAccumulate g N pj e k) % pj
      else residueAccumulate g N pj e k % pj

theorem residueAccumulate_eq (g N pj e : ℕ) :
    ∀ m, residueAccumulate g N pj e m = modexpProd g N m e % pj
  | 0 => rfl
  | m + 1 =>

def residueWidth (w bits numWin : Nat) : Nat

theorem residueGateAt_frame_above (b w bits numWin pj : Nat) (cs cinvs : Nat → Nat) (m : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (f : Nat → Bool) (q : Nat)
    (hq : b + residueWidth w bits numWin ≤ q) :
    Gate.applyNat (residueGateAt b w bits numWin pj cs cinvs m) f q = f q

def residueFold (P : Nat → Nat) (ainvss : Nat → Nat → Nat)
    (numP w bits numWin g N e m : Nat) : Gate

theorem residueFold_fixes_above (P : Nat → Nat) (ainvss : Nat → Nat → Nat)
    (w bits numWin g N e m : Nat) (hw : 0 < w) (hbits : numWin * w = bits) :
    ∀ (numP : Nat) (f : Nat → Bool) (q : Nat),
      numP * residueWidth w bits numWin ≤ q →
      Gate.applyNat (residueFold P ainvss numP w bits numWin g N e m) f q = f q

theorem residueFold_toffoli (P : Nat → Nat) (ainvss : Nat → Nat → Nat)
    (numP w bits numWin g N e m : Nat) :
    toffoliCount (residueFold P ainvss numP w bits numWin g N e m)
      = numP * (m * numWin * (16 * w * 2 ^ w + 16 * bits))

theorem residueGateAt_value_local (b w bits numWin pj g N e m : Nat) (ainvs : Nat → Nat)
    (F : Nat → Bool) (hw : 0 < w) (hbits : numWin * w = bits) (hpj1 : 1 < pj) (hpj2 : 2 * pj ≤ 2 ^ bits)
    (hinv : ∀ k, k < m → ainvs k < pj ∧ residueConst g N pj e k * ainvs k % pj = 1)
    (hFloc : ∀ p, p < residueWidth w bits numWin →
      F (p + b) = mulInputOf cuccaroAdder w bits numWin 1 p) :
    decodeReg (fun i => b + (1 + 2 * w + (2 * bits + 1) + i)) bits
        (Gate.applyNat (residueGateAt b w bits numWin pj (residueConst g N pj e) ainvs m) F)
      = modexpProd g N m e % pj

def globalInput (w bits numWin : Nat) : Nat → Bool

theorem residueFold_correct (P : Nat → Nat) (ainvss : Nat → Nat → Nat)
    (w bits numWin g N e m : Nat) (hw : 0 < w) (hbits : numWin * w = bits) :
    ∀ (numP : Nat),
      (∀ j, j < numP → 1 < P j ∧ 2 * P j ≤ 2 ^ bits ∧
        ∀ k, k < m → ainvss j k < P j ∧ residueConst g N (P j) e k * ainvss j k % (P j) = 1) →
      ∀ j, j < numP →
        decodeReg (fun i => j * residueWidth w bits numWin + (1 + 2 * w + (2 * bits + 1) + i)) bits
            (Gate.applyNat (residueFold P ainvss numP w bits numWin g N e m)
              (globalInput w bits numWin))
          = modexpProd g N m e % (P j)

def residueConst (g N pj e k : Nat) : Nat

theorem residueConst_prod_collapse (g N pj e m : Nat) :
    (∏ k ∈ Finset.range m, residueConst g N pj e k) % pj = modexpProd g N m e % pj

theorem residueGate_verified (w bits numWin pj g N e m : Nat) (ainvs : Nat → Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hpj1 : 1 < pj) (hpj2 : 2 * pj ≤ 2 ^ bits)
    (hinv : ∀ k, k < m → ainvs k < pj ∧ residueConst g N pj e k * ainvs k % pj = 1) :
    decodeReg (fun i => 1 + 2 * w + (2 * bits + 1) + i) bits
        (Gate.applyNat (windowedModNMulInPlaceSeq w bits pj numWin (residueConst g N pj e) ainvs m)
          (mulInputOf cuccaroAdder w bits numWin 1))
        = modexpProd g N m e % pj
    ∧ toffoliCount (windowedModNMulInPlaceSeq w bits pj numWin (residueConst g N pj e) ainvs m)
        = m * numWin * (16 * w * 2 ^ w + 16 * bits)

def residueGateAt (b w bits numWin pj : Nat) (cs cinvs : Nat → Nat) (m : Nat) : Gate

theorem residueGateAt_verified (b w bits numWin pj g N e m : Nat) (ainvs : Nat → Nat) (F : Nat → Bool)
    (hw : 0 < w) (hbits : numWin * w = bits) (hpj1 : 1 < pj) (hpj2 : 2 * pj ≤ 2 ^ bits)
    (hinv : ∀ k, k < m → ainvs k < pj ∧ residueConst g N pj e k * ainvs k % pj = 1)
    (hF : ∀ j, F (j + b) = mulInputOf cuccaroAdder w bits numWin 1 j) :
    decodeReg (fun i => b + (1 + 2 * w + (2 * bits + 1) + i)) bits
        (Gate.applyNat (residueGateAt b w bits numWin pj (residueConst g N pj e) ainvs m) F)
        = modexpProd g N m e % pj
    ∧ toffoliCount (residueGateAt b w bits numWin pj (residueConst g N pj e) ainvs m)
        = m * numWin * (16 * w * 2 ^ w + 16 * bits)

theorem coprime_list_prod (m : ℕ) :
    ∀ l : List ℕ, (∀ x ∈ l, m.Coprime x) → m.Coprime l.prod
  | [], _ => by simpa using (Nat.coprime_one_right m)
  | a :: l, h =>

theorem modEq_list_prod_of_forall (a b : ℕ) :
    ∀ l : List ℕ, l.Pairwise Nat.Coprime → (∀ m ∈ l, a ≡ b [MOD m]) → a ≡ b [MOD l.prod]
  | [], _, _ => by simp only [List.prod_nil]; exact Nat.modEq_one
  | m :: l, hpw, h =>

theorem modEq_prod_of_forall {t : ℕ} (p : Fin t → ℕ)
    (hco : ∀ i j, i ≠ j → Nat.Coprime (p i) (p j))
    (a b : ℕ) (h : ∀ i, a ≡ b [MOD p i]) : a ≡ b [MOD ∏ i, p i]

theorem rns_faithful (l : List ℕ) (hpw : l.Pairwise Nat.Coprime) (V W : ℕ)
    (h : ∀ m ∈ l, V % m = W % m) : V % l.prod = W % l.prod

theorem rns_recover (l : List ℕ) (hpw : l.Pairwise Nat.Coprime) (V W : ℕ)
    (hV : V < l.prod) (h : ∀ m ∈ l, V % m = W % m) : W % l.prod = V

theorem windowedModNMulInPlaceSeq_wellTyped (w bits N numWin : Nat) (as ainvs : Nat → Nat)
    (n dim : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hdim : 1 + 2 * w + (2 * bits + 1) + numWin * w + 1 ≤ dim) :
    Gate.WellTyped dim (windowedModNMulInPlaceSeq w bits N numWin as ainvs n)

theorem residueGate_uc_eval (w bits N numWin : Nat) (as ainvs : Nat → Nat) (n dim : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hdim : 1 + 2 * w + (2 * bits + 1) + numWin * w + 1 ≤ dim) (f : Nat → Bool) :
    uc_eval (Gate.toUCom dim (windowedModNMulInPlaceSeq w bits N numWin as ainvs n)) * f_to_vec dim f
      = f_to_vec dim (Gate.applyNat (windowedModNMulInPlaceSeq w bits N numWin as ainvs n) f)

theorem residueGate_unitary_computes_residue (w bits numWin pj g N e m dim : Nat) (ainvs : Nat → Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hpj1 : 1 < pj) (hpj2 : 2 * pj ≤ 2 ^ bits)
    (hdim : 1 + 2 * w + (2 * bits + 1) + numWin * w + 1 ≤ dim)
    (hinv : ∀ k, k < m → ainvs k < pj ∧ residueConst g N pj e k * ainvs k % pj = 1) :
    uc_eval (Gate.toUCom dim
            (windowedModNMulInPlaceSeq w bits pj numWin (residueConst g N pj e) ainvs m))
          * f_to_vec dim (mulInputOf cuccaroAdder w bits numWin 1)
        = f_to_vec dim (Gate.applyNat
            (windowedModNMulInPlaceSeq w bits pj numWin (residueConst g N pj e) ainvs m)
            (mulInputOf cuccaroAdder w bits numWin 1))
    ∧ decodeReg (fun i => 1 + 2 * w + (2 * bits + 1) + i) bits
        (Gate.applyNat (windowedModNMulInPlaceSeq w bits pj numWin (residueConst g N pj e) ainvs m)

theorem residueShorFinalState_peak_law_closed
    (a r N m steps w bits numWin pj : Nat) (n anc : Nat)
    (cs cinvs : Nat → Nat → Nat) (k : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hdim : 1 + 2 * w + (2 * bits + 1) + numWin * w + 1 ≤ n + anc)
    (h_basic : FormalRV.SQIRPort.BasicSetting a r N m n)
    (h_mmi : FormalRV.SQIRPort.ModMulImpl a N n anc
              (residueOracleFamily w bits numWin pj steps (n + anc) cs cinvs))
    (hk : k < r) :
    FormalRV.SQIRPort.prob_partial_meas
        (FormalRV.SQIRPort.basis_vector (2 ^ m) (FormalRV.SQIRPort.s_closest m k r))
        (FormalRV.SQIRPort.Shor_final_state m n anc

theorem cfs_shor_semantic_correctness
    -- the quantum period-finding oracle (a verified modular multiplier; ModMulImpl)
    (a r N m n anc : Nat) (u : Nat → FormalRV.SQIRPort.BaseUCom (n + anc))
    (h_basic : FormalRV.SQIRPort.BasicSetting a r N m n)
    (h_mmi : FormalRV.SQIRPort.ModMulImpl a N n anc u)
    (h_wt : ∀ i, i < m → FormalRV.SQIRPort.uc_well_typed (u i))
    -- the CFS residue circuit data (the efficient modexp implementation, T7)
    (P : Nat → Nat) (ainvss : Nat → Nat → Nat) (numP w bits numWin g e : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hPok : ∀ j, j < numP → 1 < P j ∧ 2 * P j ≤ 2 ^ bits ∧
      ∀ k, k < m → ainvss j k < P j ∧ residueConst g N (P j) e k * ainvss j k % (P j) = 1)
    (hN : 2 ≤ N) (hm : 1 ≤ m) (he : e < 2 ^ m)

theorem cfs_shor_semantic_correctness_concrete
    (g r N e m ainv : Nat)
    (h_basic_r : FormalRV.BQAlgo.BasicSettingRelaxed g r N m (Nat.log2 (2 * N) + 1))
    (h_inv : g * ainv % N = 1)
    -- the CFS residue circuit data (T7, the efficient modexp implementation)
    (P : Nat → Nat) (ainvss : Nat → Nat → Nat) (numP w bits numWin : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hPok : ∀ j, j < numP → 1 < P j ∧ 2 * P j ≤ 2 ^ bits ∧
      ∀ k, k < m → ainvss j k < P j ∧ residueConst g N (P j) e k * ainvss j k % (P j) = 1)
    (hN : 2 ≤ N) (hm : 1 ≤ m) (he : e < 2 ^ m)
    (hco : ∀ i j : Fin numP, i ≠ j → Nat.Coprime (P i.val) (P j.val))
    (hL : N ^ m ≤ ∏ i : Fin numP, P i.val)

noncomputable def short_dlp_orbit_state
    {a b rM rL : Nat}
    (φM : Fin rM → Matrix (Fin (2 ^ a)) (Fin 1) ℂ)
    (φL : Fin rL → Matrix (Fin (2 ^ b)) (Fin 1) ℂ)
    (kM : Fin rM) (kL : Fin rL) :
    Matrix (Fin (2 ^ (a + b))) (Fin 1) ℂ

theorem fourierEigenstate_eigen_M
    {a rM : Nat} (h_rM : 0 < rM)
    (φM : Fin rM → Matrix (Fin (2 ^ a)) (Fin 1) ℂ)
    (MM : Matrix (Fin (2 ^ a)) (Fin (2 ^ a)) ℂ) (sM : Nat) (kM : Fin rM)
    (h_shiftM : ∀ j : Fin rM,
        MM * φM j = φM ⟨(sM + j.val) % rM, Nat.mod_lt _ h_rM⟩) :
    MM * FormalRV.SQIRPort.fourierEigenstate rM φM kM
      = Complex.exp
          (((2 * Real.pi * (sM : ℝ) * (kM.val : ℝ) / (rM : ℝ) : ℝ) : ℂ) * Complex.I)
        • FormalRV.SQIRPort.fourierEigenstate rM φM kM

theorem short_dlp_orbit_joint_eigen
    {a b rM rL : Nat} (h_rM : 0 < rM) (h_rL : 0 < rL)
    (φM : Fin rM → Matrix (Fin (2 ^ a)) (Fin 1) ℂ)
    (φL : Fin rL → Matrix (Fin (2 ^ b)) (Fin 1) ℂ)
    (MM : Matrix (Fin (2 ^ a)) (Fin (2 ^ a)) ℂ) (sM : Nat)
    (ML : Matrix (Fin (2 ^ b)) (Fin (2 ^ b)) ℂ) (sL : Nat)
    (kM : Fin rM) (kL : Fin rL)
    (h_shiftM : ∀ j : Fin rM,
        MM * φM j = φM ⟨(sM + j.val) % rM, Nat.mod_lt _ h_rM⟩)
    (h_shiftL : ∀ j : Fin rL,
        ML * φL j = φL ⟨(sL + j.val) % rL, Nat.mod_lt _ h_rL⟩) :
    FormalRV.Framework.kron_vec

noncomputable def qpe_amp_2d (m ℓ j k : Nat) (θ : ℝ × ℝ) : ℂ

noncomputable def qpe_prob_2d (m ℓ j k : Nat) (θ : ℝ × ℝ) : ℝ

theorem qpe_prob_2d_nonneg (m ℓ j k : Nat) (θ : ℝ × ℝ) : 0 ≤ qpe_prob_2d m ℓ j k θ

theorem qpe_prob_2d_factorizes (m ℓ j k : Nat) (θ : ℝ × ℝ) :
    qpe_prob_2d m ℓ j k θ = qpe_prob m j θ.1 * qpe_prob ℓ k θ.2

theorem qpe_prob_2d_peak_bound (m ℓ j k : Nat) (θ : ℝ × ℝ)
    (hj : |qpe_phase_discrepancy m j θ.1| ≤ 1 / 2)
    (hk : |qpe_phase_discrepancy ℓ k θ.2| ≤ 1 / 2) :
    qpe_prob_2d m ℓ j k θ ≥ (4 / Real.pi ^ 2) ^ 2

theorem peak_sq_ge_eighth : (1 : ℝ) / 8 ≤ (4 / Real.pi ^ 2) ^ 2

theorem two_pow_neg_le_eighth (m ℓ : Nat) (h : 1 ≤ m + ℓ) :
    (2 : ℝ) ^ (-(m + ℓ + 2 : ℤ)) ≤ 1 / 8

theorem two_pow_neg_le_peak_sq (m ℓ : Nat) (h : 1 ≤ m + ℓ) :
    (2 : ℝ) ^ (-(m + ℓ + 2 : ℤ)) ≤ (4 / Real.pi ^ 2) ^ 2

noncomputable def short_dlp_measurement_dist (m ℓ : Nat) (x_reg y_reg : Nat → Nat → ℝ) :
    Nat → Nat → ℝ

theorem short_dlp_measurement_dist_eq_qpe_prob_2d (m ℓ : Nat) (x_reg y_reg : Nat → Nat → ℝ)
    (j k : Nat) :
    short_dlp_measurement_dist m ℓ x_reg y_reg j k
      = qpe_prob_2d m ℓ j k (x_reg j k / 2 ^ m, y_reg j k / 2 ^ ℓ)

theorem short_dlp_measurement_dist_nonneg (m ℓ : Nat) (x_reg y_reg : Nat → Nat → ℝ) (j k : Nat) :
    0 ≤ short_dlp_measurement_dist m ℓ x_reg y_reg j k

theorem short_dlp_prob_bound_of_phase_bounds (m ℓ : Nat) (x_reg y_reg : Nat → Nat → ℝ)
    (j k : Nat) (hℓm : 1 ≤ m + ℓ)
    (phase_bounds :
        |qpe_phase_discrepancy m j (x_reg j k / 2 ^ m)| ≤ 1 / 2 ∧
        |qpe_phase_discrepancy ℓ k (y_reg j k / 2 ^ ℓ)| ≤ 1 / 2) :
    short_dlp_measurement_dist m ℓ x_reg y_reg j k ≥ (2 : ℝ) ^ (-(m + ℓ + 2 : ℤ))

theorem cfs_deviant_bound (ε S : ℝ) (hε : 0 ≤ ε) (hS : 0 < S) :
    2 * Real.sqrt ε ≤ S + ε / S

theorem cfs_deviant_min (ε : ℝ) (hε : 0 < ε) :
    Real.sqrt ε + ε / Real.sqrt ε = 2 * Real.sqrt ε

theorem cfs_success_minimization (ε : ℝ) (hε : 0 < ε) :
    (∀ S : ℝ, 0 < S → 2 * Real.sqrt ε ≤ S + ε / S)
    ∧ Real.sqrt ε + ε / Real.sqrt ε = 2 * Real.sqrt ε

noncomputable def trigamma (x : ℝ) : ℝ

noncomputable def nemesH (y : ℝ) : ℝ

theorem nemesH_telescope_identity (y : ℝ) (hy : 0 < y) :
    nemesH y - nemesH (y + 1) - 1 / y ^ 2 = 1 / (6 * y ^ 3 * (y + 1) ^ 3)

theorem nemesH_telescope_ge (y : ℝ) (hy : 0 < y) :
    1 / y ^ 2 ≤ nemesH y - nemesH (y + 1)

theorem nemesH_telescope_nonneg (y : ℝ) (hy : 0 < y) :
    0 ≤ nemesH y - nemesH (y + 1)

theorem nemesH_tendsto_zero (x : ℝ) (_hx : 0 < x) :
    Tendsto (fun n : ℕ => nemesH (x + n)) atTop (𝓝 0)

theorem hasSum_nemesH_telescope (x : ℝ) (hx : 0 < x) :
    HasSum (fun n : ℕ => nemesH (x + (n:ℝ)) - nemesH (x + ((n:ℝ) + 1))) (nemesH x)

theorem summable_nemesH_telescope (x : ℝ) (hx : 0 < x) :
    Summable (fun n : ℕ => nemesH (x + (n:ℝ)) - nemesH (x + ((n:ℝ) + 1)))

theorem trigamma_term_le (x : ℝ) (hx : 0 < x) (n : ℕ) :
    1 / (x + (n : ℝ)) ^ 2 ≤ nemesH (x + (n : ℝ)) - nemesH (x + ((n : ℝ) + 1))

theorem trigamma_summable (x : ℝ) (hx : 0 < x) :
    Summable (fun n : ℕ => 1 / (x + (n : ℝ)) ^ 2)

theorem nemes_trigamma_bound (x : ℝ) (hx : 0 < x) :
    trigamma x ≤ 1 / x + 1 / (2 * x ^ 2) + 1 / (6 * x ^ 3)

theorem nemes_trigamma_bound_ge_one (x : ℝ) (hx : x ≥ 1) :
    trigamma x ≤ 1 / x + 1 / (2 * x ^ 2) + 1 / (6 * x ^ 3)

theorem ekeraGoodFactor_trigamma (τ : ℕ) (_hτ : τ > 0) :
    trigamma ((2 : ℝ) ^ τ) ≤
      1 / (2 : ℝ) ^ τ + 1 / (2 * (2 : ℝ) ^ (2 * τ)) + 1 / (6 * (2 : ℝ) ^ (3 * τ))

theorem fwdDist_cast (N a b : ℕ) [NeZero N] : (fwdDist N a b : ZMod N) = (a : ZMod N) - b

theorem fwdDist_add_right (N a b c : ℕ) (hN : 0 < N) :
    fwdDist N (a + c) (b + c) = fwdDist N a b

theorem modDev_add_right (N a b c : ℕ) (hN : 0 < N) :
    modDev N (a + c) (b + c) = modDev N a b

theorem modDev_zero_le (N x : ℕ) : modDev N x 0 ≤ x

theorem modDev_le_sub (N a b : ℕ) (hN : 0 < N) (hba : b ≤ a) : modDev N a b ≤ a - b

def truncShift (x t : ℕ) : ℕ

theorem truncShift_le (x t : ℕ) : truncShift x t ≤ x

theorem sub_truncShift_lt (x t : ℕ) : x - truncShift x t < 2 ^ t

def exactAcc (s : ℕ → ℕ) : ℕ → ℕ
  | 0 => 0
  | k + 1 => exactAcc s k + s k

def apprAcc (s : ℕ → ℕ) (t : ℕ) : ℕ → ℕ
  | 0 => 0
  | k + 1 => truncShift (apprAcc s t k + s k) t

theorem modDev_truncAcc (N : ℕ) (hN : 0 < N) (s : ℕ → ℕ) (t : ℕ) :
    ∀ A, modDev N (exactAcc s A) (apprAcc s t A) ≤ A * 2 ^ t
  | 0 => by simp [exactAcc, apprAcc, modDev_self N 0 hN]
  | A + 1 =>

theorem modDev_truncAcc_normalized (N : ℕ) (hN : 0 < N) (s : ℕ → ℕ) (t f P ell : ℕ)
    (htf : 2 ^ (t + f) ≤ N) :
    (modDev N (exactAcc s (P * ell)) (apprAcc s t (P * ell)) : ℚ) / N
      ≤ (P * ell : ℕ) / 2 ^ f

noncomputable def truncBits (x : ℝ) (f : ℕ) : ℝ

theorem truncBits_le (x : ℝ) (f : ℕ) : truncBits x f ≤ x

theorem truncBits_err_lt (x : ℝ) (f : ℕ) : x - truncBits x f < 1 / 2 ^ f

theorem sum_truncBits_error' {ι : Type*} (s : Finset ι) (hs : s.Nonempty) (g : ι → ℝ) (f : ℕ) :
    |(∑ j ∈ s, g j) - ∑ j ∈ s, truncBits (g j) f| < s.card / 2 ^ f

theorem sum_truncBits_error {t : ℕ} (ht : 0 < t) (g : Fin t → ℝ) (f : ℕ) :
    |(∑ j, g j) - ∑ j, truncBits (g j) f| < t / 2 ^ f

theorem sum_truncBits_error_double {P ell : ℕ} (hP : 0 < P) (hl : 0 < ell)
    (g : Fin P → Fin ell → ℝ) (f : ℕ) :
    |(∑ j, ∑ k, g j k) - ∑ j, ∑ k, truncBits (g j k) f| < (P * ell : ℕ) / 2 ^ f

theorem uc_eval_control_toUCom_on_basis {dim : Nat} (q : Nat) (G : Gate)
    (hq : q < dim) (h_fresh : is_fresh q (Gate.toUCom dim G)) (h_wt : Gate.WellTyped dim G)
    (hpres : ∀ f, Gate.applyNat G f q = f q) (f : Nat → Bool) :
    uc_eval (FormalRV.Framework.BaseUCom.control q (Gate.toUCom dim G)) * f_to_vec dim f
      = if f q then f_to_vec dim (Gate.applyNat G f) else f_to_vec dim f

theorem embedU_control_gate_on_superposition
    {dim : Nat} {ι : Type*} (q : Nat) (G : Gate)
    (hq : q < dim) (h_fresh : is_fresh q (Gate.toUCom dim G)) (h_wt : Gate.WellTyped dim G)
    (hpres : ∀ f, Gate.applyNat G f q = f q)
    (s : Finset ι) (α : ι → ℂ) (g : ι → Nat → Bool) :
    c_eval (Com.embedU (FormalRV.Framework.BaseUCom.control q (Gate.toUCom dim G)))
        ((∑ i ∈ s, α i • f_to_vec dim (g i)) * (∑ i ∈ s, α i • f_to_vec dim (g i))ᴴ)
      = (∑ i ∈ s, α i • f_to_vec dim (if (g i) q then Gate.applyNat G (g i) else g i))
          * (∑ i ∈ s, α i • f_to_vec dim (if (g i) q then Gate.applyNat G (g i) else g i))ᴴ

theorem is_fresh_toUCom_of_maxIdx_lt {dim : Nat} (cq : Nat) :
    ∀ (G : Gate), maxIdx G < cq → is_fresh cq (Gate.toUCom dim G)

theorem is_fresh_cuccaro_of_above {dim : Nat} (cq bits q_start : Nat)
    (h : q_start + 2 * bits + 1 ≤ cq) :
    is_fresh cq (Gate.toUCom dim (cuccaro_n_bit_adder_full bits q_start))

private theorem measWord_eq_embedRead_on_loaded
    {dim : Nat} {ι : Type*} (w bits : Nat) (pos : Nat → Nat) (T : Nat → Nat)
    (hw : 0 < w) (hdim : 2 * w + 1 ≤ dim)
    (hpos : ∀ j, j < bits → pos j < dim)
    (hpos_high : ∀ j, j < bits → 2 * w < pos j)
    (hinj : ∀ j, j < bits → ∀ k, k < bits → j ≠ k → pos j ≠ pos k)
    (s : Finset ι) (α : ι → ℂ) (g : ι → Nat → Bool) (addr : ι → Nat)
    (hav : ∀ i ∈ s, addr i < 2 ^ w)
    (hgood : ∀ i ∈ s, GoodState w (g i))
    (haddr : ∀ i ∈ s, ∀ k, k < w → g i (ulookup_address_idx k) = (addr i).testBit k)
    (hword : ∀ i ∈ s, ∀ j, j < bits → g i (pos j) = (T (addr i)).testBit j) :
    c_eval (measWordUncompute dim pos (fun j => phaseLookup dim w (fun v => (T v).testBit j)) bits)

def cPhysMeasModNLookupAddStep (cq w bits N : Nat) (T : Nat → Nat)
    (q_start flagPos dim : Nat) : BaseCom dim

def cModNLookupAddStepUCom (cq w bits N : Nat) (T : Nat → Nat)
    (q_start flagPos dim : Nat) : BaseUCom dim

theorem cPhysMeasStep_channel
    {dim : Nat} {ι : Type*} (cq w bits N : Nat) (T : Nat → Nat) (q_start flagPos : Nat)
    (s : Finset ι) (α : ι → ℂ) (e : ι → Nat → Bool) (v : ι → Nat) (sacc : ι → Nat)
    (hw : 0 < w) (hN_pos : 0 < N) (hN2 : 2 * N ≤ 2 ^ bits)
    (hq : 2 * w < q_start)
    (hflag_hi : q_start + 2 * bits + 1 ≤ flagPos)
    (hdim : q_start + 2 * bits + 1 ≤ dim) (hflag_lt : flagPos < dim)
    (hcq_lt : cq < dim) (hcq_above : q_start + 2 * bits + 1 ≤ cq)
    (hv : ∀ i ∈ s, v i < 2 ^ w) (hs : ∀ i ∈ s, sacc i < N) (hTv : ∀ i ∈ s, T (v i) < N)
    (hctrl : ∀ i ∈ s, e i ulookup_ctrl_idx = true)
    (haddr : ∀ i ∈ s, ∀ k, k < w → e i (ulookup_address_idx k) = (v i).testBit k)
    (hand : ∀ i ∈ s, ∀ k, k < w → e i (ulookup_and_idx k) = false)

noncomputable def bornWeightOn {dim : Nat} (s : QState dim) (B : Finset (Fin dim)) : ℝ

theorem bornWeightOn_nonneg {dim : Nat} (s : QState dim) (B : Finset (Fin dim)) :
    0 ≤ bornWeightOn s B

theorem bornWeightOn_union_le {dim : Nat} (s : QState dim) (A B : Finset (Fin dim)) :
    bornWeightOn s (A ∪ B) ≤ bornWeightOn s A + bornWeightOn s B

theorem normSqDist_eq_sum_on_bad {dim : Nat} (s₁ s₂ : QState dim)
    (B : Finset (Fin dim))
    (hagree : ∀ i, i ∉ B → s₁ i 0 = s₂ i 0) :
    normSqDist s₁ s₂
      = ∑ i ∈ B, |Complex.normSq (s₁ i 0) - Complex.normSq (s₂ i 0)|

theorem abs_sub_le_add_of_nonneg {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) :
    |a - b| ≤ a + b

theorem normSqDist_le_of_agree_off {dim : Nat} (s₁ s₂ : QState dim)
    (B : Finset (Fin dim)) (W : ℝ)
    (hagree : ∀ i, i ∉ B → s₁ i 0 = s₂ i 0)
    (hw₁ : bornWeightOn s₁ B ≤ W)
    (hw₂ : bornWeightOn s₂ B ≤ W) :
    normSqDist s₁ s₂ ≤ 2 * W

noncomputable def uniformAmp (gpad : Nat) : ℂ

theorem uniformAmp_normSq (gpad : Nat) :
    Complex.normSq (uniformAmp gpad) = 1 / (2 ^ gpad : ℝ)

theorem uniformBornWeight_eq_count {dim : Nat} (s : QState dim)
    (B : Finset (Fin dim)) (gpad : Nat)
    (hamp : ∀ i ∈ B, s i 0 = uniformAmp gpad) :
    bornWeightOn s B = (B.card : ℝ) / (2 ^ gpad : ℝ)

theorem uniformBornWeight_le_countingBound {dim : Nat} (s : QState dim)
    (B : Finset (Fin dim)) (gpad numAdds adv : Nat)
    (hamp : ∀ i ∈ B, s i 0 = uniformAmp gpad)
    (hcard : B.card ≤ numAdds * adv) :
    bornWeightOn s B ≤ ((countingBoundQ (numAdds : ℚ) (adv : ℚ) ((2 : ℚ) ^ gpad) : ℚ) : ℝ)

theorem wrapProbCountR_le_totalDeviationR (gpad numAdds adv : Nat)
    (hq : countingBoundQ (numAdds : ℚ) (adv : ℚ) ((2 : ℚ) ^ gpad)
            ≤ (FormalRV.Shor.WindowedCostModel.totalDeviation 2048 3072 : ℚ)) :
    ((wrapProbCount gpad numAdds adv : ℚ) : ℝ) ≤ totalDeviationR

theorem uniformBornWeight_le_totalDeviationR {dim : Nat} (s : QState dim)
    (B : Finset (Fin dim)) (gpad numAdds adv : Nat)
    (hamp : ∀ i ∈ B, s i 0 = uniformAmp gpad)
    (hcard : B.card ≤ numAdds * adv)
    (hq : countingBoundQ (numAdds : ℚ) (adv : ℚ) ((2 : ℚ) ^ gpad)
            ≤ (FormalRV.Shor.WindowedCostModel.totalDeviation 2048 3072 : ℚ)) :
    bornWeightOn s B ≤ totalDeviationR

structure CosetAgreesOffWrap
    (m n anc : Nat) (f_coset f_ideal : Nat → BaseUCom (n + anc))

theorem coset_ideal_normSqDist_le
    {m n anc : Nat} {f_coset f_ideal : Nat → BaseUCom (n + anc)}
    (A : CosetAgreesOffWrap m n anc f_coset f_ideal) :
    normSqDist (Shor_final_state m n anc f_coset) (Shor_final_state m n anc f_ideal)
      ≤ 2 * totalDeviationR

def cosetIdealL1Bound_of_agreesOffWrap
    {a r N m n anc : Nat} {f_coset f_ideal : Nat → BaseUCom (n + anc)}
    (A : CosetAgreesOffWrap m n anc f_coset f_ideal) :
    ApproxCosetShorBound.CosetIdealL1Bound a r N m n anc f_coset f_ideal

theorem ge2021_coset_shor_succeeds_of_agreesOffWrap
    (w bits numWin N a ainv0 r m : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hb1 : 1 ≤ bits)
    (hN1 : 1 < N) (hN2 : 2 * N ≤ 2 ^ bits)
    (h_inv0 : a * ainv0 % N = 1)
    (h_setting : ShorSetting a r N m bits)
    (f_coset : Nat → BaseUCom (bits + (2 * w + 2 * bits + 3)))
    (A : CosetAgreesOffWrap m bits (2 * w + 2 * bits + 3) f_coset
          (windowedModNMultiplier_verifiedModMulFamily w bits numWin N a ainv0
            hw hbits hb1 hN1 hN2 h_inv0).family) :
    probability_of_success a r N m bits (2 * w + 2 * bits + 3) f_coset
      ≥ κ / (Nat.log2 N : ℝ) ^ 4 - 2 * totalDeviationR

theorem prob_partial_meas_basis_dataPerm
    {m_dim full_dim : Nat} (h : m_dim ∣ full_dim)
    (φ₁ φ₂ : QState full_dim) (x : Fin m_dim)
    (σ : Equiv.Perm (Fin (full_dim / m_dim)))
    (hrel : ∀ y, φ₁ (jointIdx h x y) 0 = φ₂ (jointIdx h x (σ y)) 0) :
    prob_partial_meas (basis_vector m_dim x.val) φ₁
      = prob_partial_meas (basis_vector m_dim x.val) φ₂

theorem prob_partial_meas_basis_dataPerm_offBad
    {m_dim full_dim : Nat} (h : m_dim ∣ full_dim)
    (φ₁ φ₂ : QState full_dim) (x : Fin m_dim)
    (σ : Equiv.Perm (Fin (full_dim / m_dim)))
    (badY : Finset (Fin (full_dim / m_dim)))
    (hrel : ∀ y, y ∉ badY → φ₁ (jointIdx h x y) 0 = φ₂ (jointIdx h x (σ y)) 0) :
    |prob_partial_meas (basis_vector m_dim x.val) φ₁
        - prob_partial_meas (basis_vector m_dim x.val) φ₂|
      ≤ (∑ y ∈ badY, Complex.normSq (φ₁ (jointIdx h x y) 0))
          + (∑ y ∈ badY, Complex.normSq (φ₂ (jointIdx h x (σ y)) 0))

theorem shorDvd (m n anc : Nat) : (2 ^ m) ∣ (2 ^ m * 2 ^ n * 2 ^ anc)

theorem prob_of_success_dataPerm_offBad
    (a r N m n anc : Nat) (f_coset f_ideal : Nat → BaseUCom (n + anc))
    (σ : Equiv.Perm (Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m)))
    (badY : Fin (2 ^ m) → Finset (Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m)))
    (hagree : ∀ (x : Fin (2 ^ m)) (y), y ∉ badY x →
        Shor_final_state m n anc f_coset (jointIdx (shorDvd m n anc) x y) 0
          = Shor_final_state m n anc f_ideal (jointIdx (shorDvd m n anc) x (σ y)) 0) :
    |probability_of_success a r N m n anc f_coset
        - probability_of_success a r N m n anc f_ideal|
      ≤ (∑ x : Fin (2 ^ m), ∑ y ∈ badY x,
            Complex.normSq (Shor_final_state m n anc f_coset
              (jointIdx (shorDvd m n anc) x y) 0))

structure CosetMarginalRelabel
    (a r N m n anc : Nat) (f_coset f_ideal : Nat → BaseUCom (n + anc)) (ε : ℝ)

theorem coset_shor_succeeds_marginal
    (a r N m n anc : Nat) (f_coset f_ideal : Nat → BaseUCom (n + anc))
    (ε P_ideal : ℝ)
    (h_ideal : probability_of_success a r N m n anc f_ideal ≥ P_ideal)
    (R : CosetMarginalRelabel a r N m n anc f_coset f_ideal ε) :
    probability_of_success a r N m n anc f_coset ≥ P_ideal - 2 * ε

def cosetMarginalRelabel_exact
    (a r N m n anc : Nat) (f_coset f_ideal : Nat → BaseUCom (n + anc))
    (σ : Equiv.Perm (Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m)))
    (hagree : ∀ (x : Fin (2 ^ m)) (y),
        Shor_final_state m n anc f_coset (jointIdx (shorDvd m n anc) x y) 0
          = Shor_final_state m n anc f_ideal (jointIdx (shorDvd m n anc) x (σ y)) 0) :
    CosetMarginalRelabel a r N m n anc f_coset f_ideal 0

theorem coset_shor_succeeds_exact
    (a r N m n anc : Nat) (f_coset f_ideal : Nat → BaseUCom (n + anc))
    (P_ideal : ℝ)
    (h_ideal : probability_of_success a r N m n anc f_ideal ≥ P_ideal)
    (σ : Equiv.Perm (Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m)))
    (hagree : ∀ (x : Fin (2 ^ m)) (y),
        Shor_final_state m n anc f_coset (jointIdx (shorDvd m n anc) x y) 0
          = Shor_final_state m n anc f_ideal (jointIdx (shorDvd m n anc) x (σ y)) 0) :
    probability_of_success a r N m n anc f_coset ≥ P_ideal

theorem qpe_var_lsb_on_eigenfamily_initial
    {m n anc r : Nat} (hmanc : 0 < m + (n + anc)) (hm : 0 < m)
    (f : Nat → FormalRV.Framework.BaseUCom (n + anc))
    (ψ : Fin r → Matrix (Fin (2 ^ (n + anc))) (Fin 1) ℂ)
    (h_wt_all : ∀ i, i < m → UCom.WellTyped (n + anc) (f i))
    (h_eig : ∀ k : Fin r, ∀ i, i < m →
        FormalRV.Framework.uc_eval (f i) * ψ k
          = Complex.exp (((2 * Real.pi * ((2 ^ i : Nat) : ℝ)
              * ((k.val : ℝ) / (r : ℝ)) : ℝ) : ℂ) * Complex.I) • ψ k)
    (h_decomp : kron_vec (FormalRV.Framework.basis_vector (2 ^ n) 1)
          (FormalRV.Framework.kron_zeros anc)
        = (1 / (Real.sqrt r : ℂ)) • ∑ k : Fin r, ψ k) :

theorem coset_shor_succeeds_embed
    (a r N m n anc : Nat) (f_coset f_ideal : Nat → BaseUCom (n + anc))
    (embedIdeal : QState (2 ^ m * 2 ^ n * 2 ^ anc))
    (ε P_ideal : ℝ)
    (h_ideal : probability_of_success a r N m n anc f_ideal ≥ P_ideal)
    (badY : Fin (2 ^ m) → Finset (Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m)))
    -- (2) E_phys preserves the ideal's per-outcome readout marginal (the canonical isometry).
    (hmarg : ∀ (x : Fin (2 ^ m)),
        prob_partial_meas (basis_vector (2 ^ m) x.val) embedIdeal
          = prob_partial_meas (basis_vector (2 ^ m) x.val)
              (Shor_final_state m n anc f_ideal))
    -- (1) off the wrap set, the coset final state IS the embedded ideal (orbit-lifted EmbedAgree).

theorem ge2021_coset_shor_succeeds_marginal
    (w bits numWin N a ainv0 r m : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hb1 : 1 ≤ bits)
    (hN1 : 1 < N) (hN2 : 2 * N ≤ 2 ^ bits)
    (h_inv0 : a * ainv0 % N = 1)
    (h_setting : ShorSetting a r N m bits)
    (f_coset : Nat → BaseUCom (bits + (2 * w + 2 * bits + 3)))
    (R : CosetMarginalRelabel a r N m bits (2 * w + 2 * bits + 3) f_coset
          (windowedModNMultiplier_verifiedModMulFamily w bits numWin N a ainv0
            hw hbits hb1 hN1 hN2 h_inv0).family
          totalDeviationR) :
    probability_of_success a r N m bits (2 * w + 2 * bits + 3) f_coset

def eAnc : EGate → Nat
  | .base g  => ((gateRots g).map rotAnc).sum
  | .mz _    => 0
  | .seq a b => eAnc a + eAnc b

def eSlots : EGate → Nat
  | .base g  => ((gateRots g).map rotSlots).sum
  | .mz _    => 1
  | .seq a b => eSlots a + eSlots b

def lowerMz (c q : Nat) : PPMProg

def lowerEGate (a c : Nat) : EGate → PPMProg
  | .base g  => lowerFlat a c (gateRots g)
  | .mz q    => lowerMz c q
  | .seq x y => lowerEGate a c x ++ lowerEGate (a + eAnc x) (c + eSlots x) y

theorem lowerMz_magicT (c q : Nat) : countMagicT (lowerMz c q) = 0

theorem lowerMz_cwidth (c q : Nat) : PPMProg.cwidth (lowerMz c q) = 1

theorem lowerEGate_magicT (g : EGate) :
    ∀ (a c : Nat), countMagicT (lowerEGate a c g) = EGate.tcount g

theorem lowerEGate_magicCCZ (g : EGate) :
    ∀ (a c : Nat), countMagicCCZ (lowerEGate a c g) = 0

theorem lowerEGate_cwidth (g : EGate) :
    ∀ (a c : Nat), PPMProg.cwidth (lowerEGate a c g) = eSlots g

def clearBitFin (m q : Nat) (hq : q < m) (x : Fin (2 ^ m)) : Fin (2 ^ m)

theorem clearBitFin_testBit (m q : Nat) (hq : q < m) (x : Fin (2 ^ m)) (b : Nat) :
    ((clearBitFin m q hq x : Fin (2 ^ m)) : Nat).testBit b
      = EGate.applyNat (.mz q) (fun k => (x : Nat).testBit k) b

theorem mulVec_single_one {N : Nat} (M : Matrix (Fin N) (Fin N) ℂ) (x : Fin N) :
    M.mulVec (Pi.single x (1 : ℂ)) = fun i => M i x

theorem axisMat_nil (n : Nat) : axisMat n ([] : PauliProduct) = 1

theorem axisZ_mulVec_single (m q : Nat) (hq : q < m) (x : Fin (2 ^ m)) :
    (axisMat m [⟨q, PKind.z⟩]).mulVec (Pi.single x (1 : ℂ))
      = (if (x : Nat).testBit q then (-1 : ℂ) else 1)
          • (Pi.single x (1 : ℂ) : Fin (2 ^ m) → ℂ)

theorem axisX_mulVec_single (m q : Nat) (hq : q < m) (x : Fin (2 ^ m)) :
    (axisMat m [⟨q, PKind.x⟩]).mulVec (Pi.single x (1 : ℂ))
      = Pi.single (⟨(x : Nat) ^^^ 2 ^ q,
          Nat.xor_lt_two_pow x.isLt (Nat.pow_lt_pow_right (by norm_num) hq)⟩ :
          Fin (2 ^ m)) (1 : ℂ)

theorem getD_extend_self (ω : Nat → Bool) (outs : List Bool) :
    (outs ++ [ω outs.length]).getD outs.length false = ω outs.length

theorem lowerMz_progDenote (m q : Nat) (ω : Nat → Bool) (outs : List Bool) :
    progDenote m ω outs (lowerMz outs.length q)
      = (if ω outs.length then axisMat m [⟨q, PKind.x⟩] else axisMat m ([] : PauliProduct))
          * projHalf (axisMat m [⟨q, PKind.z⟩]) (ω outs.length)

private theorem fold_proj {N : Nat} (c1 c2 : ℂ) (v : Fin N → ℂ) :
    (2⁻¹ : ℂ) • (v + c1 • (c2 • v)) = (2⁻¹ * (1 + c1 * c2)) • v

theorem lowerMz_denote_basis (m q : Nat) (hq : q < m) (ω : Nat → Bool)
    (outs : List Bool) (x : Fin (2 ^ m)) :
    (progDenote m ω outs (lowerMz outs.length q)).mulVec (Pi.single x (1 : ℂ))
      = (if ω outs.length = (x : Nat).testBit q then (1 : ℂ) else 0)
          • (Pi.single (clearBitFin m q hq x) (1 : ℂ) : Fin (2 ^ m) → ℂ)

theorem eAnc_mzList (L : List Nat) : eAnc (mzList L) = 0

theorem eSlots_mzList (L : List Nat) : eSlots (mzList L) = L.length

theorem lowerMzList_denote_basis (m : Nat) :
    ∀ (L : List Nat), (∀ q ∈ L, q < m) →
      ∀ (ω : Nat → Bool) (outs : List Bool) (x : Fin (2 ^ m)),
        ∃ (sc : ℂ) (y : Fin (2 ^ m)),
          (progDenote m ω outs (lowerEGate m outs.length (mzList L))).mulVec
              (Pi.single x (1 : ℂ))
            = sc • (Pi.single y (1 : ℂ) : Fin (2 ^ m) → ℂ)
          ∧ ∀ b, (y : Nat).testBit b
              = EGate.applyNat (mzList L) (fun k => (x : Nat).testBit k) b

def measReset (dim q : Nat) : BaseCom dim

theorem measReset_basis (dim q : Nat) (hq : q < dim) (f : Nat → Bool) :
    c_eval (measReset dim q) (f_to_vec dim f * (f_to_vec dim f)ᴴ)
      = f_to_vec dim (Function.update f q false)
          * (f_to_vec dim (Function.update f q false))ᴴ

def EGate.toCom (dim : Nat) : EGate → BaseCom dim
  | .base g  => Com.embedU (Gate.toUCom dim g)
  | .mz q    => measReset dim q
  | .seq a b => Com.useq (EGate.toCom dim a) (EGate.toCom dim b)

def EGate.WellTypedAt (dim : Nat) : EGate → Prop
  | .base g  => Gate.WellTyped dim g
  | .mz q    => q < dim
  | .seq a b => EGate.WellTypedAt dim a ∧ EGate.WellTypedAt dim b

theorem eGate_toCom_basis (dim : Nat) (g : EGate)
    (h_wt : EGate.WellTypedAt dim g) (f : Nat → Bool) :
    c_eval (EGate.toCom dim g) (f_to_vec dim f * (f_to_vec dim f)ᴴ)
      = f_to_vec dim (EGate.applyNat g f) * (f_to_vec dim (EGate.applyNat g f))ᴴ

theorem measuredModExpAt_acts_as_reversible_on_clean
    (dim w W bits : Nat) (Tfam : Nat → Nat → Nat → Nat)
    (q_start numMults numWin : Nat)
    (h_wt : EGate.WellTypedAt dim (modExpAt w W bits Tfam q_start numMults numWin))
    (f : Nat → Bool) :
    c_eval (EGate.toCom dim (modExpAt w W bits Tfam q_start numMults numWin))
        (f_to_vec dim f * (f_to_vec dim f)ᴴ)
      = f_to_vec dim
          (EGate.applyNat (modExpAt w W bits Tfam q_start numMults numWin) f)
        * (f_to_vec dim
            (EGate.applyNat (modExpAt w W bits Tfam q_start numMults numWin) f))ᴴ

structure MeasuredEqualsReversibleOnEncoded
    (a N bits anc : Nat) (eg : Nat → EGate) (encode : Nat → Nat → (Nat → Bool))

theorem MeasuredEqualsReversibleOnEncoded.channel_eq_unitary_on_encoded
    {a N bits anc : Nat} {eg : Nat → EGate} {encode : Nat → Nat → (Nat → Bool)}
    (B : MeasuredEqualsReversibleOnEncoded a N bits anc eg encode)
    (i x : Nat) (hx : x < N) :
    c_eval (EGate.toCom (bits + anc) (eg i))
        (f_to_vec (bits + anc) (encode i x) * (f_to_vec (bits + anc) (encode i x))ᴴ)
      = Framework.uc_eval (B.rev.family i) * (f_to_vec (bits + anc) (encode i x)
            * (f_to_vec (bits + anc) (encode i x))ᴴ)
          * (Framework.uc_eval (B.rev.family i))ᴴ

def MeasuredEqualsReversibleOnEncoded.family
    {a N bits anc : Nat} {eg : Nat → EGate} {encode : Nat → Nat → (Nat → Bool)}
    (B : MeasuredEqualsReversibleOnEncoded a N bits anc eg encode) :
    VerifiedModMulFamily a N bits anc

def gcFlag (bits : Nat) : Nat

def gcYBase (bits : Nat) : Nat

def gcCAnc (w bits numWin : Nat) : Nat → Nat

def gcCtrl (w bits numWin : Nat) : Nat

def gcAIdxAt (w bits j : Nat) : Nat → Nat

def biasedTableValue (a N bits w j : Nat) : Nat → Nat

def gcStep (w bits a N numWin j : Nat) : EGate

def gcMulN (w bits a N numWin m : Nat) : EGate

def gcMul (w bits a N numWin : Nat) : EGate

def GCInv (w bits numWin y acc : Nat) (g : Nat → Bool) : Prop

theorem gcInv_step (w n a N numWin y acc j : Nat)
    (hw : 0 < w) (hN : 0 < N) (hN2 : N ≤ 2 ^ (n + 1))
    (hbw : numWin * w = n + 1) (hj : j < numWin) (hacc : acc < N)
    (g : Nat → Bool) (hg : GCInv w (n + 1) numWin y acc g) :
    GCInv w (n + 1) numWin y
        ((acc + WindowedArith.tableValue a N w j (WindowedArith.window w y j)) % N)
        (EGate.applyNat (gcStep w (n + 1) a N numWin j) g)

theorem gcInv_fold (w n a N numWin y : Nat)
    (hw : 0 < w) (hN : 0 < N) (hN2 : N ≤ 2 ^ (n + 1)) (hbw : numWin * w = n + 1)
    (g : Nat → Bool) (hg : GCInv w (n + 1) numWin y 0 g) :
    ∀ m, m ≤ numWin →
      GCInv w (n + 1) numWin y
          (WindowedArith.windowedLookupFold a N w (WindowedArith.window w y) m 0)
          (EGate.applyNat (gcMulN w (n + 1) a N numWin m) g)

theorem gcMul_value (w n a N numWin y : Nat)
    (hw : 0 < w) (hN : 0 < N) (hN2 : N ≤ 2 ^ (n + 1)) (hbw : numWin * w = n + 1)
    (hy : y < (2 ^ w) ^ numWin)
    (g : Nat → Bool) (hg : GCInv w (n + 1) numWin y 0 g) :
    gidney_target_val (n + 1) (EGate.applyNat (gcMul w (n + 1) a N numWin) g) = (a * y) % N

def gcInit (w bits numWin y : Nat) : Nat → Bool

theorem gcInv_init (w bits numWin y : Nat) : GCInv w bits numWin y 0 (gcInit w bits numWin y)

theorem gcMul_value_init (w n a N numWin y : Nat)
    (hw : 0 < w) (hN : 0 < N) (hN2 : N ≤ 2 ^ (n + 1)) (hbw : numWin * w = n + 1)
    (hy : y < (2 ^ w) ^ numWin) :
    gidney_target_val (n + 1)
        (EGate.applyNat (gcMul w (n + 1) a N numWin) (gcInit w (n + 1) numWin y)) = (a * y) % N

theorem tcount_gidneyModAddRegMeasured (n N : Nat) :
    EGate.tcount (gidneyModAddRegMeasured (n + 1) N) = 14 * (n + 2)

theorem tcount_gcStep (w n a N numWin j : Nat) :
    EGate.tcount (gcStep w (n + 1) a N numWin j) = 7 * ((2 ^ w - 1) + 2 * (n + 2))

theorem tcount_gcMulN (w n a N numWin m : Nat) :
    EGate.tcount (gcMulN w (n + 1) a N numWin m) = m * (7 * ((2 ^ w - 1) + 2 * (n + 2)))

theorem toffoli_gcMul (w n a N numWin : Nat) :
    EGate.toffoli (gcMul w (n + 1) a N numWin) = numWin * ((2 ^ w - 1) + 2 * (n + 2))

theorem gidneyTCount_gcMul (w n a N numWin : Nat) :
    gidneyTCount (gcMul w (n + 1) a N numWin) = 4 * (numWin * ((2 ^ w - 1) + 2 * (n + 2)))

theorem gcMul_value_and_count (w n a N numWin y : Nat)
    (hw : 0 < w) (hN : 0 < N) (hN2 : N ≤ 2 ^ (n + 1)) (hbw : numWin * w = n + 1)
    (hy : y < (2 ^ w) ^ numWin) :
    gidney_target_val (n + 1)
        (EGate.applyNat (gcMul w (n + 1) a N numWin) (gcInit w (n + 1) numWin y)) = (a * y) % N
    ∧ EGate.toffoli (gcMul w (n + 1) a N numWin) = numWin * ((2 ^ w - 1) + 2 * (n + 2))

theorem gcInv_fold_acc (w n a N numWin y acc0 : Nat)
    (hw : 0 < w) (hN : 0 < N) (hN2 : N ≤ 2 ^ (n + 1)) (hbw : numWin * w = n + 1) (hacc0 : acc0 < N)
    (g : Nat → Bool) (hg : GCInv w (n + 1) numWin y acc0 g) :
    ∀ m, m ≤ numWin →
      GCInv w (n + 1) numWin y
          (WindowedArith.windowedLookupFold a N w (WindowedArith.window w y) m acc0)
          (EGate.applyNat (gcMulN w (n + 1) a N numWin m) g)

theorem gcMul_GCInv_from_acc (w n a N numWin y acc0 : Nat)
    (hw : 0 < w) (hN : 0 < N) (hN2 : N ≤ 2 ^ (n + 1)) (hbw : numWin * w = n + 1)
    (hacc0 : acc0 < N) (hy : y < (2 ^ w) ^ numWin)
    (g : Nat → Bool) (hg : GCInv w (n + 1) numWin y acc0 g) :
    GCInv w (n + 1) numWin y ((acc0 + a * y) % N)
      (EGate.applyNat (gcMul w (n + 1) a N numWin) g)

def gcSwap (bits : Nat) : Gate

theorem adder_input_F_eq_off_target (bits A Y q : Nat)
    (hq : q < adder_n_qubits (bits + 1)) (hnot : ∀ i, i < bits → q ≠ target_idx i)
    (hA : A < 2 ^ bits) (hY : Y < 2 ^ bits) :
    adder_input_F (bits + 1) 0 A q = adder_input_F (bits + 1) 0 Y q

theorem gcSwap_transport (w n numWin Y A : Nat)
    (hbw : numWin * w = n + 1) (hY : Y < 2 ^ (n + 1)) (hA : A < 2 ^ (n + 1))
    (g : Nat → Bool) (hg : GCInv w (n + 1) numWin Y A g) :
    GCInv w (n + 1) numWin A Y (EGate.applyNat (EGate.base (gcSwap (n + 1))) g)

def gcMulInPlace (w bits a ainv N numWin : Nat) : EGate

theorem gcMulInPlace_value (w n a ainv N numWin x : Nat)
    (hw : 0 < w) (hN : 0 < N) (hN2 : N ≤ 2 ^ (n + 1)) (hbw : numWin * w = n + 1)
    (hx : x < N) (hainv : ainv < N) (h_inv : a * ainv % N = 1)
    (g : Nat → Bool) (hg : GCInv w (n + 1) numWin x 0 g) :
    GCInv w (n + 1) numWin ((a * x) % N) 0
      (EGate.applyNat (gcMulInPlace w (n + 1) a ainv N numWin) g)

def gcAnc (w bits : Nat) : Nat

def gcEncodeIn (w bits numWin : Nat) : Gate

def gcEncodeOut (w bits numWin : Nat) : Gate

def gcMulEncodeGate (w bits a ainv N numWin : Nat) : EGate

theorem gcStep_wellTypedAt (w n a N numWin j dim : Nat)
    (hbw : numWin * w = n + 1) (hj : j < numWin)
    (hdim : 4 * (n + 1) + w + 7 ≤ dim) :
    EGate.WellTypedAt dim (gcStep w (n + 1) a N numWin j)

theorem gcMulN_wellTypedAt (w n a N numWin m dim : Nat)
    (hbw : numWin * w = n + 1) (hm : m ≤ numWin)
    (hdim : 4 * (n + 1) + w + 7 ≤ dim) :
    EGate.WellTypedAt dim (gcMulN w (n + 1) a N numWin m)

theorem gcMul_wellTypedAt (w n a N numWin dim : Nat)
    (hbw : numWin * w = n + 1)
    (hdim : 4 * (n + 1) + w + 7 ≤ dim) :
    EGate.WellTypedAt dim (gcMul w (n + 1) a N numWin)

theorem gcSwap_wellTyped (w n numWin dim : Nat)
    (hbw : numWin * w = n + 1)
    (hdim : 4 * (n + 1) + w + 7 ≤ dim) :
    Gate.WellTyped dim (gcSwap (n + 1))

theorem gcMulInPlace_wellTypedAt (w n a ainv N numWin dim : Nat)
    (hbw : numWin * w = n + 1)
    (hdim : 4 * (n + 1) + w + 7 ≤ dim) :
    EGate.WellTypedAt dim (gcMulInPlace w (n + 1) a ainv N numWin)

theorem gcEncodeIn_wellTyped (w n numWin dim : Nat)
    (hbw : numWin * w = n + 1)
    (hdim : 4 * (n + 1) + w + 7 ≤ dim) :
    Gate.WellTyped dim (gcEncodeIn w (n + 1) numWin)

theorem gcEncodeOut_wellTyped (w n numWin dim : Nat)
    (hbw : numWin * w = n + 1)
    (hdim : 4 * (n + 1) + w + 7 ≤ dim) :
    Gate.WellTyped dim (gcEncodeOut w (n + 1) numWin)

theorem gcMulEncodeGate_wellTypedAt (w n a ainv N numWin dim : Nat)
    (hbw : numWin * w = n + 1)
    (hdim : 4 * (n + 1) + w + 7 ≤ dim) :
    EGate.WellTypedAt dim (gcMulEncodeGate w (n + 1) a ainv N numWin)

theorem gcMulEncodeGate_wellTypedAt_canonical (w n a ainv N numWin : Nat)
    (hbw : numWin * w = n + 1) :
    EGate.WellTypedAt ((n + 1) + gcAnc w (n + 1)) (gcMulEncodeGate w (n + 1) a ainv N numWin)

theorem toffoli_gcMulInPlace (w n a ainv N numWin : Nat) :
    EGate.toffoli (gcMulInPlace w (n + 1) a ainv N numWin)
      = 2 * (numWin * ((2 ^ w - 1) + 2 * (n + 2)))

theorem toffoli_gcMulEncodeGate (w n a ainv N numWin : Nat) :
    EGate.toffoli (gcMulEncodeGate w (n + 1) a ainv N numWin)
      = 2 * (numWin * ((2 ^ w - 1) + 2 * (n + 2)))

theorem gcEncodeIn_GCInv (w n a numWin x : Nat)
    (hbw : numWin * w = n + 1) (hx2 : x < 2 ^ (n + 1)) :
    GCInv w (n + 1) numWin x 0
      (EGate.applyNat (EGate.base (gcEncodeIn w (n + 1) numWin))
        (encodeDataZeroAnc (n + 1) (gcAnc w (n + 1)) x))

theorem gcStep_frame (w n a N numWin j : Nat) (hbw : numWin * w = n + 1) (f : Nat → Bool) (p : Nat)
    (hp : (n + 1) + gcAnc w (n + 1) ≤ p) :
    EGate.applyNat (gcStep w (n + 1) a N numWin j) f p = f p

theorem gcMulN_frame (w n a N numWin : Nat) (hbw : numWin * w = n + 1) (p : Nat)
    (hp : (n + 1) + gcAnc w (n + 1) ≤ p) :
    ∀ m (f : Nat → Bool), EGate.applyNat (gcMulN w (n + 1) a N numWin m) f p = f p

theorem gcMul_frame (w n a N numWin : Nat) (hbw : numWin * w = n + 1) (f : Nat → Bool) (p : Nat)
    (hp : (n + 1) + gcAnc w (n + 1) ≤ p) :
    EGate.applyNat (gcMul w (n + 1) a N numWin) f p = f p

theorem gcSwap_frame (w n numWin : Nat) (hbw : numWin * w = n + 1) (f : Nat → Bool) (p : Nat)
    (hp : (n + 1) + gcAnc w (n + 1) ≤ p) :
    EGate.applyNat (EGate.base (gcSwap (n + 1))) f p = f p

theorem gcEncodeIn_frame (w n numWin : Nat) (hbw : numWin * w = n + 1) (f : Nat → Bool) (p : Nat)
    (hp : (n + 1) + gcAnc w (n + 1) ≤ p) :
    EGate.applyNat (EGate.base (gcEncodeIn w (n + 1) numWin)) f p = f p

theorem gcEncodeOut_frame (w n numWin : Nat) (hbw : numWin * w = n + 1) (f : Nat → Bool) (p : Nat)
    (hp : (n + 1) + gcAnc w (n + 1) ≤ p) :
    EGate.applyNat (EGate.base (gcEncodeOut w (n + 1) numWin)) f p = f p

theorem gcMulInPlace_frame (w n a ainv N numWin : Nat) (hbw : numWin * w = n + 1)
    (f : Nat → Bool) (p : Nat) (hp : (n + 1) + gcAnc w (n + 1) ≤ p) :
    EGate.applyNat (gcMulInPlace w (n + 1) a ainv N numWin) f p = f p

theorem gcMulEncodeGate_frame (w n a ainv N numWin : Nat) (hbw : numWin * w = n + 1)
    (f : Nat → Bool) (p : Nat) (hp : (n + 1) + gcAnc w (n + 1) ≤ p) :
    EGate.applyNat (gcMulEncodeGate w (n + 1) a ainv N numWin) f p = f p

theorem gcMulEncodeGate_apply (w n a ainv N numWin x : Nat)
    (hw : 0 < w) (hN : 0 < N) (hN2 : N ≤ 2 ^ (n + 1)) (hbw : numWin * w = n + 1)
    (hx : x < N) (hainv : ainv < N) (h_inv : a * ainv % N = 1) :
    EGate.applyNat (gcMulEncodeGate w (n + 1) a ainv N numWin)
        (encodeDataZeroAnc (n + 1) (gcAnc w (n + 1)) x)
      = encodeDataZeroAnc (n + 1) (gcAnc w (n + 1)) ((a * x) % N)

theorem windowedModNEncodeGate_apply_anc
    (w bits numWin N c cinv x ancbig : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hb1 : 1 ≤ bits)
    (hN_pos : 0 < N) (hN2 : 2 * N ≤ 2 ^ bits)
    (hx : x < N) (hcinv : cinv < N) (hinv : c * cinv % N = 1)
    (hbig : 2 * w + 2 * bits + 3 ≤ ancbig) :
    Gate.applyNat (windowedModNEncodeGate w bits N numWin c cinv)
        (encodeDataZeroAnc bits ancbig x)
      = encodeDataZeroAnc bits ancbig (c * x % N)

noncomputable def gcRevEncode (w bits numWin N : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hb1 : 1 ≤ bits)
    (hN1 : 1 < N) (hN2 : 2 * N ≤ 2 ^ bits) :
    EncodeRoundTripModMul N bits (3 * bits + w + 7)

noncomputable def gcRevFamily (w bits numWin N a ainv0 : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hb1 : 1 ≤ bits)
    (hN1 : 1 < N) (hN2 : 2 * N ≤ 2 ^ bits) (h_inv0 : a * ainv0 % N = 1) :
    VerifiedShor.VerifiedModMulFamily a N bits (3 * bits + w + 7)

noncomputable def gcMulShorWitness (w n numWin N a ainv0 : Nat)
    (hw : 0 < w) (hbits : numWin * w = n + 1)
    (hN1 : 1 < N) (hN2 : 2 * N ≤ 2 ^ (n + 1)) (h_inv0 : a * ainv0 % N = 1) :
    MeasuredEqualsReversibleOnEncoded a N (n + 1) (3 * (n + 1) + w + 7)
      (fun i => gcMulEncodeGate w (n + 1) ((a ^ (2 ^ i)) % N) (modInv N (a ^ (2 ^ i))) N numWin)
      (fun _ x => encodeDataZeroAnc (n + 1) (3 * (n + 1) + w + 7) x)

theorem gcMul_shor_resource_capstone (w n numWin N a ainv0 r m : Nat)
    (hw : 0 < w) (hbits : numWin * w = n + 1)
    (hN1 : 1 < N) (hN2 : 2 * N ≤ 2 ^ (n + 1)) (h_inv0 : a * ainv0 % N = 1)
    (h_setting : ShorSetting a r N m (n + 1)) :
    probability_of_success a r N m (n + 1) (3 * (n + 1) + w + 7)
        (gcRevFamily w (n + 1) numWin N a ainv0 hw hbits (by omega) hN1 hN2 h_inv0).family
      ≥ κ / (Nat.log2 N : ℝ) ^ 4
    ∧ ∀ i, EGate.toffoli
        (gcMulEncodeGate w (n + 1) ((a ^ (2 ^ i)) % N) (modInv N (a ^ (2 ^ i))) N numWin)
        = 2 * (numWin * ((2 ^ w - 1) + 2 * (n + 2)))

theorem toffoli_gidneyModAddRegMeasured (n N : Nat) :
    EGate.toffoli (gidneyModAddRegMeasured (n + 1) N) = 2 * (n + 2)

theorem toffoli_gcStep (w n a N numWin j : Nat) :
    EGate.toffoli (gcStep w (n + 1) a N numWin j) = (2 ^ w - 1) + 2 * (n + 2)

theorem gcMul_adder_eq_gidney2025_addCost (n N : Nat) :
    EGate.toffoli (gidneyModAddRegMeasured (n + 1) N)
      = FormalRV.Audit.Gidney2025.ToffoliReproduction.addCost (n + 1)

theorem gcStep_eq_gidney2025_loopBody (w n a N numWin j : Nat) :
    EGate.toffoli (gcStep w (n + 1) a N numWin j)
      = FormalRV.Audit.Gidney2025.ToffoliReproduction.lookupCost w
        + FormalRV.Audit.Gidney2025.ToffoliReproduction.addCost (n + 1)

theorem gcMul_count_eq_gidney2025 (w n a N numWin : Nat) :
    EGate.toffoli (gcMul w (n + 1) a N numWin)
      = numWin * (FormalRV.Audit.Gidney2025.ToffoliReproduction.lookupCost w
        + FormalRV.Audit.Gidney2025.ToffoliReproduction.addCost (n + 1))

def lookupZone (w : Nat) : Nat

def aReg (w : Nat) : Nat

def bReg (w bits : Nat) : Nat

def temp (w bits : Nat) : Nat

def carry (w bits : Nat) : Nat

def productAddDim (w bits : Nat) : Nat

theorem productAddDim_eq_cosetDim (w bits : Nat) :
    productAddDim w bits = 2 + 2 * w + 3 * bits

theorem blocks_disjoint (w bits : Nat) :
    -- lookup zone strictly below a
    lookupZone w ≤ aReg w
    -- a-block [aReg, aReg+bits) below b
    ∧ aReg w + bits ≤ bReg w bits
    -- b-block [bReg, bReg+bits) below temp
    ∧ bReg w bits + bits ≤ temp w bits
    -- temp-block [temp, temp+bits) below carry
    ∧ temp w bits + bits ≤ carry w bits
    -- carry is the last position
    ∧ carry w bits < productAddDim w bits

theorem pass1_packed_valid (w bits : Nat) :
    contiguousPackedAdder.valid bits (bReg w bits) (temp w bits)

theorem pass2_packed_temp_hits_b (w bits : Nat) :
    aReg w + bits = bReg w bits

theorem pass2_packed_invalid (w bits : Nat) (hbits : 0 < bits) :
    ¬ contiguousPackedAdder.valid bits (aReg w) (temp w bits)

def aRegionDed (w : Nat) : Nat

def bRegionDed (w bits : Nat) : Nat

def productAddDimDed (w bits : Nat) : Nat

theorem productAddDimDed_eq (w bits : Nat) :
    productAddDimDed w bits = lookupZone w + 2 * (2 * bits + 1)

theorem dedicated_pass1_valid (w bits : Nat) :
    contiguousPackedAdder.valid bits (bRegionDed w bits) (bRegionDed w bits + bits)

theorem dedicated_pass2_valid (w bits : Nat) :
    contiguousPackedAdder.valid bits (aRegionDed w) (aRegionDed w + bits)

theorem dedicated_regions_disjoint (w bits : Nat) :
    aRegionDed w + (2 * bits + 1) ≤ bRegionDed w bits

def relocatedLookupAdd (w bits : Nat) (T : Nat → Nat) (accBase tempBase : Nat) : Gate

def relocatedProductAddStep (w bits : Nat) (T : Nat → Nat)
    (accBase tempBase yBase j : Nat) : Gate

def gidneyProductAddTOf (w bits : Nat) (Tfam : Nat → Nat → Nat)
    (accBase tempBase yBase numWin : Nat) : Gate

theorem relocatedProductAddStep_wellTyped (w bits : Nat) (T : Nat → Nat)
    (accBase tempBase yBase j numWin dim : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hj : j < numWin)
    (hv : accBase + bits ≤ tempBase)
    (hyBase : 2 * w < yBase) (hyfit : yBase + bits ≤ dim)
    (htemp : 2 * w < tempBase) (htfit : tempBase + bits + 1 ≤ dim) :
    Gate.WellTyped dim (relocatedProductAddStep w bits T accBase tempBase yBase j)

theorem gidneyProductAddTOf_wellTyped (w bits : Nat) (Tfam : Nat → Nat → Nat)
    (accBase tempBase yBase numWin dim : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hv : accBase + bits ≤ tempBase)
    (hyBase : 2 * w < yBase) (hyfit : yBase + bits ≤ dim)
    (htemp : 2 * w < tempBase) (htfit : tempBase + bits + 1 ≤ dim) :
    Gate.WellTyped dim (gidneyProductAddTOf w bits Tfam accBase tempBase yBase numWin)

theorem gidneyProductAdd_pass1_wellTyped (w bits : Nat) (Tfam : Nat → Nat → Nat) (numWin : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) :
    Gate.WellTyped (2 + 2 * w + 3 * bits)
      (gidneyProductAddTOf w bits Tfam (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) numWin)

theorem gidneyProductAdd_pass2_wellTyped (w bits : Nat) (Tfam : Nat → Nat → Nat) (numWin : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) :
    Gate.WellTyped (2 + 2 * w + 3 * bits)
      (gidneyProductAddTOf w bits Tfam (1 + 2 * w) (1 + 2 * w + 2 * bits) (1 + 2 * w + bits) numWin)

def RelocStepInv (w bits numWin y accBase tempBase yBase s : Nat) (g : Nat → Bool) : Prop

theorem relocatedProductAddStep_inv (w bits numWin : Nat) (T : Nat → Nat)
    (y accBase tempBase yBase j s : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hj : j < numWin)
    (hv : accBase + bits ≤ tempBase) (hacc : 2 * w < accBase) (hyy : 2 * w < yBase)
    (hytemp : yBase + bits ≤ tempBase)
    (hpresY : ∀ (f' : Nat → Bool) i, i < numWin * w →
      Gate.applyNat (relocatedAdderCircuit accBase tempBase bits) f' (yBase + i) = f' (yBase + i))
    (g : Nat → Bool) (hg : RelocStepInv w bits numWin y accBase tempBase yBase s g) :
    RelocStepInv w bits numWin y accBase tempBase yBase (s + T (WindowedArith.window w y j))
      (Gate.applyNat (relocatedProductAddStep w bits T accBase tempBase yBase j) g)

theorem relocatedProductAdd_fold (w bits numWin : Nat) (Tfam : Nat → Nat → Nat)
    (y accBase tempBase yBase : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hv : accBase + bits ≤ tempBase) (hacc : 2 * w < accBase) (hyy : 2 * w < yBase)
    (hytemp : yBase + bits ≤ tempBase)
    (hpresY : ∀ (f' : Nat → Bool) i, i < numWin * w →
      Gate.applyNat (relocatedAdderCircuit accBase tempBase bits) f' (yBase + i) = f' (yBase + i))
    (g : Nat → Bool) (hg : RelocStepInv w bits numWin y accBase tempBase yBase 0 g) :
    ∀ n, n ≤ numWin →
      RelocStepInv w bits numWin y accBase tempBase yBase
        (∑ k ∈ Finset.range n, Tfam k (WindowedArith.window w y k))
        (Gate.applyNat (gidneyProductAddTOf w bits Tfam accBase tempBase yBase n) g)

theorem gidneyProductAddTOf_decode (w bits numWin : Nat) (Tfam : Nat → Nat → Nat)
    (y accBase tempBase yBase : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hv : accBase + bits ≤ tempBase) (hacc : 2 * w < accBase) (hyy : 2 * w < yBase)
    (hytemp : yBase + bits ≤ tempBase)
    (hpresY : ∀ (f' : Nat → Bool) i, i < numWin * w →
      Gate.applyNat (relocatedAdderCircuit accBase tempBase bits) f' (yBase + i) = f' (yBase + i))
    (g : Nat → Bool) (hg : RelocStepInv w bits numWin y accBase tempBase yBase 0 g) :
    decodeReg (fun i => accBase + i) bits
        (Gate.applyNat (gidneyProductAddTOf w bits Tfam accBase tempBase yBase numWin) g)
      = (∑ k ∈ Finset.range numWin, Tfam k (WindowedArith.window w y k)) % 2 ^ bits

theorem gidneyProductAdd_pass1_decode (w bits numWin : Nat) (Tfam : Nat → Nat → Nat)
    (y : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (g : Nat → Bool)
    (hg : RelocStepInv w bits numWin y (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) 0 g) :
    decodeReg (fun i => 1 + 2 * w + bits + i) bits
        (Gate.applyNat (gidneyProductAddTOf w bits Tfam (1 + 2 * w + bits) (1 + 2 * w + 2 * bits)
          (1 + 2 * w) numWin) g)
      = (∑ k ∈ Finset.range numWin, Tfam k (WindowedArith.window w y k)) % 2 ^ bits

theorem gidneyProductAdd_pass2_decode (w bits numWin : Nat) (Tfam : Nat → Nat → Nat)
    (y : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (g : Nat → Bool)
    (hg : RelocStepInv w bits numWin y (1 + 2 * w) (1 + 2 * w + 2 * bits) (1 + 2 * w + bits) 0 g) :
    decodeReg (fun i => 1 + 2 * w + i) bits
        (Gate.applyNat (gidneyProductAddTOf w bits Tfam (1 + 2 * w) (1 + 2 * w + 2 * bits)
          (1 + 2 * w + bits) numWin) g)
      = (∑ k ∈ Finset.range numWin, Tfam k (WindowedArith.window w y k)) % 2 ^ bits

theorem relocatedProductAddStep_frame (w bits : Nat) (T : Nat → Nat)
    (accBase tempBase yBase j : Nat) (hv : accBase + bits ≤ tempBase) (htemp : 2 * w < tempBase)
    (p : Nat) (haddr : ∀ i, i < w → p ≠ ulookup_address_idx i)
    (hbound : ¬ inBlock accBase (tempBase + bits + 1 - accBase) p) (g : Nat → Bool) :
    Gate.applyNat (relocatedProductAddStep w bits T accBase tempBase yBase j) g p = g p

theorem gidneyProductAddTOf_frame (w bits : Nat) (Tfam : Nat → Nat → Nat)
    (accBase tempBase yBase numWin : Nat) (hv : accBase + bits ≤ tempBase) (htemp : 2 * w < tempBase)
    (p : Nat) (haddr : ∀ i, i < w → p ≠ ulookup_address_idx i)
    (hbound : ¬ inBlock accBase (tempBase + bits + 1 - accBase) p) (g : Nat → Bool) :
    Gate.applyNat (gidneyProductAddTOf w bits Tfam accBase tempBase yBase numWin) g p = g p

theorem gidneyProductAddTOf_offAcc (w bits numWin : Nat) (Tfam : Nat → Nat → Nat)
    (y accBase tempBase yBase : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hv : accBase + bits ≤ tempBase) (hacc : 2 * w < accBase) (hyy : 2 * w < yBase)
    (hytemp : yBase + bits ≤ tempBase)
    (hpresY : ∀ (f' : Nat → Bool) i, i < numWin * w →
      Gate.applyNat (relocatedAdderCircuit accBase tempBase bits) f' (yBase + i) = f' (yBase + i))
    (hcover : ∀ q, accBase ≤ q → q < tempBase + bits + 1 →
      (∃ i, i < bits ∧ q = accBase + i) ∨ (∃ i, i < bits ∧ q = tempBase + i)
        ∨ q = tempBase + bits ∨ (∃ i, i < numWin * w ∧ q = yBase + i))
    (g : Nat → Bool) (hg : RelocStepInv w bits numWin y accBase tempBase yBase 0 g)
    (p : Nat) (hp_acc : ∀ i, i < bits → p ≠ accBase + i) :

theorem gidneyProductAddTOf_state (w bits numWin : Nat) (Tfam : Nat → Nat → Nat)
    (y accBase tempBase yBase : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hv : accBase + bits ≤ tempBase) (hacc : 2 * w < accBase) (hyy : 2 * w < yBase)
    (hytemp : yBase + bits ≤ tempBase)
    (hpresY : ∀ (f' : Nat → Bool) i, i < numWin * w →
      Gate.applyNat (relocatedAdderCircuit accBase tempBase bits) f' (yBase + i) = f' (yBase + i))
    (hcover : ∀ q, accBase ≤ q → q < tempBase + bits + 1 →
      (∃ i, i < bits ∧ q = accBase + i) ∨ (∃ i, i < bits ∧ q = tempBase + i)
        ∨ q = tempBase + bits ∨ (∃ i, i < numWin * w ∧ q = yBase + i))
    (g : Nat → Bool) (hg : RelocStepInv w bits numWin y accBase tempBase yBase 0 g) (p : Nat) :
    Gate.applyNat (gidneyProductAddTOf w bits Tfam accBase tempBase yBase numWin) g p

theorem E2residue_hwork_int_canonical
    (m w bits N cm kstep : Nat) (mult : Nat → Nat)
    (hN : 0 < N) (hNbits : N ≤ 2 ^ bits)
    (f_runwayIdeal f_residueIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hf_runway : ∀ (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
          (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
              workMat m bits (cosetAnc w bits) kstep f_runwayIdeal y yp
                * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)
            = cosetInputVec w bits N cm ((mult kstep * z) % N) 0
                (Fin.cast (E2shor_dim_eq m w bits) y) 0)
    (hf_res_can : ∀ a b : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),

theorem E2residueEmbedZ_intertwine_canonical
    (m w bits N cm kstep : Nat) (hk : kstep < m) (mult : Nat → Nat)
    (hN : 0 < N) (hNbits : N ≤ 2 ^ bits)
    (f_runwayIdeal f_residueIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwt_c : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hwt_i : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_residueIdeal j))
    (hf_runway : ∀ (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
          (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
              workMat m bits (cosetAnc w bits) kstep f_runwayIdeal y yp
                * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)
            = cosetInputVec w bits N cm ((mult kstep * z) % N) 0

theorem orbit_oracle_bridge_canonical (m w bits N cm : Nat) (hm : 0 < m) (hbits : 0 < bits)
    (mult : Nat → Nat) (hN : 0 < N) (hN1 : 1 < N) (hNbits : N ≤ 2 ^ bits)
    (f_runwayIdeal f_residueIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwt_c : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hwt_i : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_residueIdeal j))
    (hf_runway : ∀ (kstep : Nat), kstep < m → ∀ (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
          (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
              workMat m bits (cosetAnc w bits) kstep f_runwayIdeal y yp
                * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)
            = cosetInputVec w bits N cm ((mult kstep * z) % N) 0
                (Fin.cast (E2shor_dim_eq m w bits) y) 0)

theorem Shor_final_state_E2coset_eq_embed_canonical (m w bits N cm : Nat)
    (hm : 0 < m) (hbits : 0 < bits)
    (mult : Nat → Nat) (hN : 0 < N) (hN1 : 1 < N) (hNbits : N ≤ 2 ^ bits)
    (f_runwayIdeal f_residueIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwt_c : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hwt_i : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_residueIdeal j))
    (hf_runway : ∀ (kstep : Nat), kstep < m → ∀ (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
          (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
              workMat m bits (cosetAnc w bits) kstep f_runwayIdeal y yp
                * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)
            = cosetInputVec w bits N cm ((mult kstep * z) % N) 0

theorem probability_of_success_E2coset_eq_canonical (a r N m w bits cm : Nat)
    (hm : 0 < m) (hbits : 0 < bits)
    (mult : Nat → Nat) (hN : 0 < N) (hN1 : 1 < N)
    (numWin : Nat) (hw : 0 < w) (hbitsWin : numWin * w = bits) (hMN : 2 ^ cm * N ≤ 2 ^ bits)
    (f_runwayIdeal f_residueIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwt_c : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hwt_i : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_residueIdeal j))
    (hf_runway : ∀ (kstep : Nat), kstep < m → ∀ (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
          (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
              workMat m bits (cosetAnc w bits) kstep f_runwayIdeal y yp
                * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)

theorem divModN_arith (N z j : Nat) (hN : 0 < N) (hz : z < N) :
    (z + j * N) / N = j ∧ (z + j * N) % N = z

def encDiv (bits v : Nat) : Nat → Bool

theorem encDiv_data (bits v i : Nat) (hi : i < bits) :
    encDiv bits v (0 + 2 * i + 1) = v.testBit i

theorem encDiv_read (bits v i : Nat) (_hi : i < bits) :
    encDiv bits v (0 + 2 * i + 2) = false

theorem encDiv_cin (bits v : Nat) : encDiv bits v 0 = false

theorem encDiv_flag (bits v : Nat) : encDiv bits v (flagW bits) = false

theorem encDiv_qbit (bits v k : Nat) : encDiv bits v (qBase bits + k) = false

theorem cuccaro_target_val_encDiv (bits v : Nat) (hv : v < 2 ^ bits) :
    cuccaro_target_val bits 0 (encDiv bits v) = v

theorem divModN_decode_base (bits N v : Nat) (hv : v < 2 ^ bits) :
    Gate.applyNat (divModN bits 0 N) (encDiv bits v) = encDiv bits v
    ∧ cuccaro_target_val bits 0
        (Gate.applyNat (divModN bits 0 N) (encDiv bits v)) = v

theorem divModN_succ_eq (bits cm N : Nat) :
    divModN bits (cm + 1) N
      = Gate.seq (divStepAt bits N cm) (divModN bits cm N)

theorem cuccaro_target_val_succ (n q : Nat) (f : Nat → Bool) :
    cuccaro_target_val (n + 1) q f
      = cuccaro_target_val n q f + (if f (q + 2 * n + 1) then 2 ^ n else 0)

theorem cuccaro_target_val_split (bits k : Nat) (f : Nat → Bool) (hk : k ≤ bits) :
    cuccaro_target_val bits 0 f
      = cuccaro_target_val k 0 f
        + 2 ^ k * cuccaro_target_val (bits - k) (2 * k) f

theorem cuccaro_target_val_lt' (k q : Nat) (f : Nat → Bool) :
    cuccaro_target_val k q f < 2 ^ k

theorem window_val_encDiv (bits v k : Nat) (hv : v < 2 ^ bits) (hk : k ≤ bits) :
    cuccaro_target_val (bits - k) (2 * k) (encDiv bits v) = v / 2 ^ k

theorem encDiv_DivState (bits cm N v : Nat)
    (hr : v < N * 2 ^ cm) (hbud : N * 2 ^ cm ≤ 2 ^ bits) (hcm : cm ≤ bits) (hN : 0 < N) :
    DivState bits cm N v (encDiv bits v)

theorem divModN_decode
    (bits cm N z j : Nat)
    (hbits : 1 ≤ bits) (hN : 0 < N) (hcm : cm ≤ bits)
    (hbudget : 2 ^ cm * N ≤ 2 ^ bits)
    (hz : z < N) (hj : j < 2 ^ cm) :
    -- DATA band → remainder z = v % N
    cuccaro_target_val bits 0
        (Gate.applyNat (divModN bits cm N) (encDiv bits (z + j * N))) = z
    -- QUOTIENT band → bit k of j = v / N
    ∧ (∀ k, k < cm →
        Gate.applyNat (divModN bits cm N) (encDiv bits (z + j * N)) (qBase bits + k)
          = j.testBit k)

structure DivState (bits cm N r : Nat) (f : Nat → Bool) : Prop

theorem topStep_local_hyps (bits cm N r : Nat) (f : Nat → Bool)
    (S : DivState bits (cm + 1) N r f) :
    -- the window value is r / 2^cm and it is < 2N
    cuccaro_target_val (bits - cm) (2 * cm) f = r / 2 ^ cm
    ∧ r / 2 ^ cm < 2 * N
    ∧ f (2 * cm) = false
    ∧ (∀ i, i < bits - cm → f (2 * cm + 2 * i + 1) = (r / 2 ^ cm).testBit i)
    ∧ (∀ i, i < bits - cm → f (2 * cm + 2 * i + 2) = false)

def topStepRunning (cm N r : Nat) : Nat

theorem topStepRunning_lt (cm N r : Nat) (hN : 0 < N) :
    topStepRunning cm N r < N * 2 ^ cm

theorem topStepRunning_div (cm N r : Nat) :
    topStepRunning cm N r / 2 ^ cm = (r / 2 ^ cm) % N

theorem topStepRunning_mod (cm N r : Nat) :
    topStepRunning cm N r % 2 ^ cm = r % 2 ^ cm

theorem topStepRunning_low_testBit (cm N r i : Nat) (hi : i < cm) :
    r.testBit i = (topStepRunning cm N r).testBit i

theorem topStepRunning_high_testBit (cm N r i : Nat) (hi : cm ≤ i) :
    ((r / 2 ^ cm) % N).testBit (i - cm) = (topStepRunning cm N r).testBit i

theorem topStep_global_out (bits cm N r : Nat) (f : Nat → Bool)
    (S : DivState bits (cm + 1) N r f) :
    let g

theorem topStepRunning_mod_N (cm N r : Nat) :
    topStepRunning cm N r % N = r % N

theorem topStepRunning_div_N (cm N r : Nat) (hN : 0 < N) :
    r / N = topStepRunning cm N r / N + 2 ^ cm * (r / 2 ^ cm / N)

theorem topStepRunning_div_N_lt (cm N r : Nat) (hN : 0 < N) :
    topStepRunning cm N r / N < 2 ^ cm

theorem testBit_add_mul_two_pow_low (x t cm k : Nat) (hk : k < cm) :
    (x + 2 ^ cm * t).testBit k = x.testBit k

theorem quot_low_testBit (cm N r k : Nat) (hN : 0 < N) (hk : k < cm) :
    (r / N).testBit k = (topStepRunning cm N r / N).testBit k

theorem quot_top_bit (cm N r : Nat) (_hN : 0 < N) (hlt : r / 2 ^ cm < 2 * N) :
    (r / 2 ^ cm) / N = (if N ≤ r / 2 ^ cm then 1 else 0)

theorem testBit_add_two_pow_mul_high (cm N r : Nat) :
    (topStepRunning cm N r / N + 2 ^ cm * (r / 2 ^ cm / N)).testBit cm
      = (r / 2 ^ cm / N).testBit 0

theorem divModN_decode_gen :
    ∀ (cm bits N r : Nat) (f : Nat → Bool), DivState bits cm N r f →
      let g

def flagW (bits : Nat) : Nat

def divStepAt (bits N k : Nat) : Gate

def divModN (bits : Nat) : Nat → Nat → Gate
  | 0,      _ => Gate.I
  | cm + 1, N => Gate.seq (divStepAt bits N cm) (divModN bits cm N)

theorem divStepAt_wellTyped (bits cm N k : Nat)
    (_hbits : 1 ≤ bits) (hk : k < cm) (hcm : cm ≤ bits) :
    Gate.WellTyped (dimDiv bits cm) (divStepAt bits N k)

theorem wellTyped_mono : ∀ (g : Gate) (d d' : Nat), d ≤ d' →
    Gate.WellTyped d g → Gate.WellTyped d' g

theorem divModN_wellTyped (bits cm N : Nat)
    (hbits : 1 ≤ bits) (hcm : cm ≤ bits) :
    Gate.WellTyped (dimDiv bits cm) (divModN bits cm N)

def dimDiv (bits cm : Nat) : Nat

def qBase (bits : Nat) : Nat

def divStep (bits q_start N flagPos qbit : Nat) : Gate

theorem divStep_arith (bits N r : Nat)
    (hN_pos : 0 < N) (hN2 : 2 * N ≤ 2 ^ bits) (hr : r < 2 * N) :
    (r + if decide (N ≤ r) = true then 2 ^ bits - N else 0) % 2 ^ bits = r % N

theorem divStep_decode
    (bits q_start N flagPos qbit r : Nat)
    (hN_pos : 0 < N) (hN2 : 2 * N ≤ 2 ^ bits) (hr : r < 2 * N)
    (hflag_out : flagPos < q_start ∨ q_start + 2 * bits + 1 ≤ flagPos)
    (hqbit_out : qbit < q_start ∨ q_start + 2 * bits + 1 ≤ qbit)
    (hqf : qbit ≠ flagPos)
    (f : Nat → Bool)
    (h_cin : f q_start = false)
    (h_flag : f flagPos = false)
    (h_qbit : f qbit = false)
    (h_tgt : ∀ i, i < bits → f (q_start + 2 * i + 1) = r.testBit i)
    (h_read : ∀ i, i < bits → f (q_start + 2 * i + 2) = false) :

theorem divStep_wellTyped (bits q_start N flagPos qbit dim : Nat)
    (h_ws : q_start + 2 * bits + 1 ≤ dim) (h_flag : flagPos < dim) (h_qbit : qbit < dim)
    (h_flag_distinct : ∀ i, i < bits → flagPos ≠ q_start + 2 * i + 2)
    (h_flag_top : flagPos ≠ q_start + 2 * bits)
    (hqf : qbit ≠ flagPos) :
    Gate.WellTyped dim (divStep bits q_start N flagPos qbit)

def cgsDim (bits cm : Nat) : Nat

def mulFoot (bits : Nat) : Nat

theorem mulFoot_eq (bits : Nat) :
    mulFoot bits = 1 + 2 * 1 + (2 * bits + 1) + bits * 1 + 1

theorem cgsDim_le_cosetDim (w bits cm : Nat) (hw : 2 ≤ w) (hcm : cm ≤ 2 * w - 3) :
    cgsDim bits cm ≤ cosetDim w bits

def ctrlIdx : Nat

def yBase (bits : Nat) : Nat

def uDiv (i : Nat) : Nat

def vY (bits i : Nat) : Nat

def uQ (bits k : Nat) : Nat

def vQ (bits k : Nat) : Nat

def adapter (bits : Nat) : Gate

def moveQuot (bits cm : Nat) : Gate

def mul (bits N c cinv : Nat) : Gate

def cgsGate (bits cm N c cinv : Nat) : Gate

theorem divModN_wellTyped_cgs (bits cm N : Nat) (hbits : 1 ≤ bits) (hcm : cm ≤ bits) :
    Gate.WellTyped (cgsDim bits cm) (divModN bits cm N)

theorem mul_wellTyped_cgs (bits cm N c cinv : Nat) :
    Gate.WellTyped (cgsDim bits cm) (mul bits N c cinv)

theorem adapter_wellTyped_cgs (bits cm : Nat) (hbits : 1 ≤ bits) :
    Gate.WellTyped (cgsDim bits cm) (adapter bits)

theorem moveQuot_wellTyped_cgs (bits cm : Nat) (hbits : 1 ≤ bits) (hcm : cm ≤ bits) :
    Gate.WellTyped (cgsDim bits cm) (moveQuot bits cm)

theorem cgsGate_wellTyped (bits cm N c cinv : Nat) (hbits : 1 ≤ bits) (hcm : cm ≤ bits) :
    Gate.WellTyped (cgsDim bits cm) (cgsGate bits cm N c cinv)

theorem divider_state (bits cm N z j : Nat)
    (hbits : 1 ≤ bits) (hN : 0 < N) (hcm : cm ≤ bits)
    (hbudget : 2 ^ cm * N ≤ 2 ^ bits) (hz : z < N) (hj : j < 2 ^ cm) :
    let g

theorem vY_inj (bits : Nat) :
    ∀ i k, i < bits → k < bits → i ≠ k → vY bits i ≠ vY bits k

theorem uDiv_ne_vY (bits : Nat) :
    ∀ i k, i < bits → k < bits → uDiv i ≠ vY bits k

theorem uQ_inj (bits : Nat) :
    ∀ i k, i < bits → k < bits → i ≠ k → uQ bits i ≠ uQ bits k

theorem vQ_inj (bits : Nat) :
    ∀ i k, i < bits → k < bits → i ≠ k → vQ bits i ≠ vQ bits k

theorem uQ_ne_vQ (bits cm : Nat) (hcm : cm ≤ bits) :
    ∀ i k, i < cm → k < cm → uQ bits i ≠ vQ bits k

theorem adapter_apply (bits : Nat) (g : Nat → Bool) :
    (∀ i, i < bits → Gate.applyNat (adapter bits) g (uDiv i) = g (vY bits i))
    ∧ (∀ i, i < bits → Gate.applyNat (adapter bits) g (vY bits i) = g (uDiv i))
    ∧ (∀ p, (∀ i, i < bits → p ≠ uDiv i ∧ p ≠ vY bits i) →
        Gate.applyNat (adapter bits) g p = g p)

theorem moveQuot_apply (bits cm : Nat) (hcm : cm ≤ bits) (g : Nat → Bool) :
    (∀ k, k < cm → Gate.applyNat (moveQuot bits cm) g (uQ bits k) = g (vQ bits k))
    ∧ (∀ k, k < cm → Gate.applyNat (moveQuot bits cm) g (vQ bits k) = g (uQ bits k))
    ∧ (∀ p, (∀ k, k < cm → p ≠ uQ bits k ∧ p ≠ vQ bits k) →
        Gate.applyNat (moveQuot bits cm) g p = g p)

theorem mulInputOf_vY (bits x i : Nat) (hi : i < bits) :
    mulInputOf cuccaroAdder 1 bits bits x (vY bits i) = x.testBit i

theorem mulInputOf_ctrl0 (bits x : Nat) :
    mulInputOf cuccaroAdder 1 bits bits x 0 = true

theorem mulInputOf_foot_clean (bits x p : Nat) (hp : p < mulFoot bits)
    (hp0 : p ≠ 0) (hpy : ∀ i, i < bits → p ≠ vY bits i) :
    mulInputOf cuccaroAdder 1 bits bits x p = false

theorem mul_leg (bits N c cinv z : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N) (hN2 : 2 * N ≤ 2 ^ bits)
    (hz : z < N) (hcinv : cinv < N) (hinv : c * cinv % N = 1)
    (s : Nat → Bool)
    (hfoot : ∀ p, p < mulFoot bits → s p = mulInputOf cuccaroAdder 1 bits bits z p) :
    let g

theorem head_state (bits cm N z j : Nat)
    (hbits : 1 ≤ bits) (hN : 0 < N) (hcm : cm ≤ bits)
    (hbudget : 2 ^ cm * N ≤ 2 ^ bits) (hz : z < N) (hj : j < 2 ^ cm) :
    let S4

theorem swapCascade_involution (u v : Nat → Nat) (n : Nat) (f : Nat → Bool)
    (hu_inj : ∀ i k, i < n → k < n → i ≠ k → u i ≠ u k)
    (hv_inj : ∀ i k, i < n → k < n → i ≠ k → v i ≠ v k)
    (huv : ∀ i k, i < n → k < n → u i ≠ v k) :
    Gate.applyNat (swapCascade u v n) (Gate.applyNat (swapCascade u v n) f) = f

theorem adapter_involution (bits : Nat) (f : Nat → Bool) :
    Gate.applyNat (adapter bits) (Gate.applyNat (adapter bits) f) = f

theorem moveQuot_involution (bits cm : Nat) (hcm : cm ≤ bits) (f : Nat → Bool) :
    Gate.applyNat (moveQuot bits cm) (Gate.applyNat (moveQuot bits cm) f) = f

theorem X0_involution (f : Nat → Bool) :
    Gate.applyNat (Gate.X ctrlIdx) (Gate.applyNat (Gate.X ctrlIdx) f) = f

theorem stage_mid_eq (bits cm N c cinv z j : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N) (hN2 : 2 * N ≤ 2 ^ bits) (hcm : cm ≤ bits)
    (hbudget : 2 ^ cm * N ≤ 2 ^ bits)
    (hz : z < N) (hj : j < 2 ^ cm) (hcinv : cinv < N) (hinv : c * cinv % N = 1) :
    Gate.applyNat (moveQuot bits cm)
        (Gate.applyNat (adapter bits)
          (Gate.applyNat (Gate.X ctrlIdx)
            (Gate.applyNat (mul bits N c cinv)
              (Gate.applyNat (Gate.X ctrlIdx)
                (Gate.applyNat (adapter bits)
                  (Gate.applyNat (moveQuot bits cm)
                    (Gate.applyNat (divModN bits cm N) (encDiv bits (z + j * N)))))))))

theorem result_lt (bits cm N c z j : Nat) (hN_pos : 0 < N)
    (hj : j < 2 ^ cm) (hbudget : 2 ^ cm * N ≤ 2 ^ bits) :
    (c * z) % N + j * N < 2 ^ bits

theorem cgsGate_decode
    (bits cm N c cinv z j : Nat)
    (hbits : 1 ≤ bits) (hN : 1 < N) (hN2 : 2 * N ≤ 2 ^ bits) (hcm : cm ≤ bits)
    (hbudget : 2 ^ cm * N ≤ 2 ^ bits)
    (hz : z < N) (hj : j < 2 ^ cm) (hcinv : cinv < N) (hinv : c * cinv % N = 1) :
    Gate.applyNat (cgsGate bits cm N c cinv) (encDiv bits (z + j * N))
        = encDiv bits ((c * z) % N + j * N)
    ∧ cuccaro_target_val bits 0
        (Gate.applyNat (cgsGate bits cm N c cinv) (encDiv bits (z + j * N)))
        = (c * z) % N + j * N
    ∧ guardedShift (2 ^ bits) N c (z + j * N) = (c * z) % N + j * N
    ∧ Gate.WellTyped (cgsDim bits cm) (cgsGate bits cm N c cinv)

theorem column_identity_of_gateToPerm_eq_idealPerm
    (w bits N cm mult kInv z : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (hfull : 2 ^ cm * N ≤ 2 ^ bits) (hz : z < N)
    (g : Gate) (hwt : Gate.WellTyped (cosetDim w bits) g)
    (hperm : gateToPerm g (cosetDim w bits) hwt
              = idealPerm w bits N cm mult kInv hN hfwd hbwd) :
    Framework.uc_eval (Gate.toUCom (cosetDim w bits) g) * cosetInputVec w bits N cm z 0
      = cosetInputVec w bits N cm ((mult * z) % N) 0

noncomputable def runwayIdealFam (m w bits : Nat) (gFam : Nat → Gate) :
    Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits)

theorem runwayIdealFam_align (m w bits : Nat) (gFam : Nat → Gate) (k : Nat) (hk : k < m) :
    runwayIdealFam m w bits gFam (revIndex m k)
      = Gate.toUCom (bits + cosetAnc w bits) (gFam k)

private theorem cast_wd_cw (m w bits : Nat)
    (a : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) :
    Fin.cast (congrArg (fun x => 2 ^ x) (cosetWork_dim_eq w bits))
        (Fin.cast (workDim_eq m bits (cosetAnc w bits)) a)
      = Fin.cast (E2shor_dim_eq m w bits) a

theorem hf_runway_of_column_identity
    (m w bits N cm : Nat) (gFam : Nat → Gate) (mult : Nat → Nat)
    (hcol : ∀ (k : Nat), k < m → ∀ (z : Nat), z < N →
        Framework.uc_eval (Gate.toUCom (cosetDim w bits) (gFam k)) * cosetInputVec w bits N cm z 0
          = cosetInputVec w bits N cm ((mult k * z) % N) 0) :
    ∀ (k : Nat), k < m → ∀ (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
        (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
            Framework.uc_eval (runwayIdealFam m w bits gFam (revIndex m k))
                (Fin.cast (workDim_eq m bits (cosetAnc w bits)) y)
                (Fin.cast (workDim_eq m bits (cosetAnc w bits)) yp)
              * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)

theorem runwayIdealFam_wellTyped (m w bits : Nat) (gFam : Nat → Gate)
    (hwt : ∀ j, Gate.WellTyped (cosetDim w bits) (gFam j)) :
    ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits)
          (runwayIdealFam m w bits gFam j)

abbrev dim' (bits : Nat) : Nat

abbrev encScratch (bits v : Nat) : Nat → Bool

abbrev decBE (bits : Nat) : Nat → Nat

theorem decBE_encScratch (bits v : Nat) (hv : v < 2 ^ bits) :
    decodeReg (decBE bits) bits (encScratch bits v) = v

theorem residueMul_decode (bits N c cinv z : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N) (hN2 : 2 * N ≤ 2 ^ bits)
    (hz : z < N) (hcinv : cinv < N) (hinv : c * cinv % N = 1) :
    decodeReg (decBE bits) bits
        (Gate.applyNat (windowedModNEncodeGate 1 bits N bits c cinv) (encScratch bits z))
      = (c * z) % N

theorem residueMul_wellTyped (bits N c cinv : Nat) :
    Gate.WellTyped (dim' bits) (windowedModNEncodeGate 1 bits N bits c cinv)

def guardedShiftGate (bits cm N c cinv : Nat) : Gate

theorem guardedShiftGate_apply_on_support_cm0
    (bits N c cinv : Nat)
    (hbits : 1 ≤ bits) (hN : 1 < N) (hbudget : 2 ^ 0 * N ≤ 2 ^ bits) (h2N : 2 * N ≤ 2 ^ bits)
    (hcinv : cinv < N) (hinv : c * cinv % N = 1) (hc : c < N)
    (z j : Nat) (hz : z < N) (hj : j < 2 ^ 0) :
    decodeReg (decBE bits) bits
        (Gate.applyNat (guardedShiftGate bits 0 N c cinv) (encScratch bits (z + j * N)))
      = (c * z) % N + j * N
    ∧ guardedShift (2 ^ bits) N c (z + j * N) = (c * z) % N + j * N
    ∧ (∀ p, dim' bits ≤ p →
        Gate.applyNat (guardedShiftGate bits 0 N c cinv) (encScratch bits (z + j * N)) p
          = encScratch bits (z + j * N) p)

theorem guardedShift_target (bits cm N c z j : Nat)
    (hN : 0 < N) (hz : z < N) (hj : j < 2 ^ cm) (hbudget : 2 ^ cm * N ≤ 2 ^ bits) :
    guardedShift (2 ^ bits) N c (z + j * N) = (c * z) % N + j * N

theorem gidney_inplace_coset_shor_succeeds_canonical
    (a r N m w bits numWin cm : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat → Nat) (mult kInv : Nat → Nat)
    (f_runwayIdeal f_residueIdeal :
      Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hm : 0 < m) (hbitsPos : 0 < bits)
    (hwtI : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hwtRes : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_residueIdeal j))
    (hTfamK : ∀ k j addr, TfamK k j addr = tableValue (mult k) N w j addr)
    (hTfamKinv : ∀ k j addr, TfamKinv k j addr = tableValue (kInv k) N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hN1 : 1 < N)
    (hMN : 2 ^ cm * N ≤ 2 ^ bits)

theorem gidney_inplace_coset_shor_succeeds_unconditional_canonical
    (a r N m w bits numWin cm : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat → Nat) (mult kInv : Nat → Nat)
    (f_runwayIdeal f_residueIdeal :
      Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hm : 0 < m) (hbitsPos : 0 < bits)
    (hwtI : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hwtRes : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_residueIdeal j))
    (hTfamK : ∀ k j addr, TfamK k j addr = tableValue (mult k) N w j addr)
    (hTfamKinv : ∀ k j addr, TfamKinv k j addr = tableValue (kInv k) N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hN1 : 1 < N)
    (hMN : 2 ^ cm * N ≤ 2 ^ bits)

theorem gidney_inplace_coset_shor_succeeds_hybrid
    (a r N m w bits numWin cm : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat → Nat) (mult kInv : Nat → Nat)
    (f_runwayIdeal f_residueIdeal :
      Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hm : 0 < m) (hbitsPos : 0 < bits)
    (hwtP : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits)
        (physRunwayOracle m w bits numWin TfamK TfamKinv j))
    (hwtI : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hwtRes : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_residueIdeal j))
    (hTfamK : ∀ k j addr, TfamK k j addr = tableValue (mult k) N w j addr)
    (hTfamKinv : ∀ k j addr, TfamKinv k j addr = tableValue (kInv k) N w j addr)

theorem idealResidue_hf_res_can (w bits N a ainv0 : Nat)
    (hw2 : 2 ≤ w) (hb1 : 1 ≤ bits) (hN1 : 1 < N) (hN2 : 2 * N ≤ 2 ^ bits)
    (h_inv0 : a * ainv0 % N = 1) (m kstep : Nat)
    (p q : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m))
    (hq : q.val % 2 ^ (cosetAnc w bits) = 0 ∧ q.val / 2 ^ (cosetAnc w bits) < N) :
    workMat m bits (cosetAnc w bits) kstep
        (idealResidueFamily w bits N a ainv0 hw2 hb1 hN1 hN2 h_inv0).family p q
      = if p.val = ((a ^ (2 ^ (revIndex m kstep)) % N * (q.val / 2 ^ (cosetAnc w bits))) % N)
            * 2 ^ (cosetAnc w bits)
          then 1 else 0

theorem idealResidue_hf_res_pres (w bits N a ainv0 : Nat)
    (hw2 : 2 ≤ w) (hb1 : 1 ≤ bits) (hN1 : 1 < N) (hN2 : 2 * N ≤ 2 ^ bits)
    (h_inv0 : a * ainv0 % N = 1) (m kstep : Nat)
    (p q : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m))
    (hp : p.val % 2 ^ (cosetAnc w bits) = 0 ∧ p.val / 2 ^ (cosetAnc w bits) < N)
    (hq : ¬ (q.val % 2 ^ (cosetAnc w bits) = 0 ∧ q.val / 2 ^ (cosetAnc w bits) < N)) :
    workMat m bits (cosetAnc w bits) kstep
        (idealResidueFamily w bits N a ainv0 hw2 hb1 hN1 hN2 h_inv0).family p q = 0

theorem idealResidue_hsupp_res (w bits N a ainv0 r m : Nat)
    (hw2 : 2 ≤ w) (hb1 : 1 ≤ bits) (hN1 : 1 < N) (hN2 : 2 * N ≤ 2 ^ bits)
    (h_inv0 : a * ainv0 % N = 1)
    (h_basic : FormalRV.SQIRPort.BasicSetting a r N m bits)
    (x : Fin (2 ^ m))
    (b : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m))
    (hb : ¬ (b.val % 2 ^ (cosetAnc w bits) = 0 ∧ b.val / 2 ^ (cosetAnc w bits) < N)) :
    FormalRV.SQIRPort.Shor_final_state m bits (cosetAnc w bits)
        (idealResidueFamily w bits N a ainv0 hw2 hb1 hN1 hN2 h_inv0).family
        (jointIdx (shorDvd m bits (cosetAnc w bits)) x b) 0 = 0

theorem gidney_inplace_coset_shor_succeeds_fully_unconditional
    (a r N m w bits numWin cm ainv0 : Nat)
    (hm : 0 < m) (hw2 : 2 ≤ w) (hbits : numWin * w = bits) (hb1 : 1 ≤ bits)
    (hN1 : 1 < N) (hN2 : 2 * N ≤ 2 ^ bits) (hMN : 2 ^ cm * N ≤ 2 ^ bits)
    (h_inv0 : a * ainv0 % N = 1)
    (h_basic : FormalRV.SQIRPort.BasicSetting a r N m bits) :
    probability_of_success_E2coset a r N m w bits cm
        (physRunwayOracle m w bits numWin
          (fun k => tableValue (a ^ (2 ^ (revIndex m k)) % N) N w)
          (fun k => tableValue (ainv0 ^ (2 ^ (revIndex m k)) % N) N w))
      ≥ FormalRV.SQIRPort.κ / (Nat.log2 N : ℝ) ^ 4
          - 2 * (m : ℝ) * Real.sqrt (8 * (numWin : ℝ) / 2 ^ cm)

private lemma QState.cast_zero_fn {a b : Nat} (h : a = b) :
    QState.cast h (fun _ _ => (0 : ℂ)) = (fun _ _ => 0)

private lemma qpeStageMap_zero_fn (m n anc : Nat)
    (f : Nat → FormalRV.Framework.BaseUCom (n + anc)) (k : Nat) :
    qpeStageMap m n anc f k (fun _ _ => 0) = (fun _ _ => 0)

private lemma pmDist_zero_eq_pmNorm {d : Nat} (phi : QState d) :
    pmDist phi (fun _ _ => 0) = pmNorm phi

private lemma qpeStageMap_pmNorm_eq (m n anc : Nat) (hm : 0 < m)
    (f : Nat → FormalRV.Framework.BaseUCom (n + anc))
    (hwt : ∀ j, FormalRV.Framework.UCom.WellTyped (n + anc) (f j))
    (k : Nat) (s : QState (2 ^ m * 2 ^ n * 2 ^ anc)) :
    pmNorm (qpeStageMap m n anc f k s) = pmNorm s

private lemma orbitState_pmNorm_eq (m n anc : Nat) (hm : 0 < m)
    (f : Nat → FormalRV.Framework.BaseUCom (n + anc))
    (hwt : ∀ j, FormalRV.Framework.UCom.WellTyped (n + anc) (f j))
    (init : QState (2 ^ m * 2 ^ n * 2 ^ anc)) (numIter : Nat) :
    pmNorm (orbitState (qpeStageMap m n anc f) init numIter) = pmNorm init

private lemma hfit_of_hMN (cm N bits : Nat) (hN1 : 1 < N) (hMN : 2 ^ cm * N ≤ 2 ^ bits)
    (hN2 : 2 * N ≤ 2 ^ bits) :
    1 + (2 ^ cm - 1) * N < 2 ^ bits

theorem coset_final_pmNorm_le (m w bits N cm numWin : Nat)
    (hm : 0 < m) (hw : 0 < w) (hbits : numWin * w = bits) (hN1 : 1 < N) (hN2 : 2 * N ≤ 2 ^ bits)
    (hMN : 2 ^ cm * N ≤ 2 ^ bits)
    (f : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwt : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f j)) :
    pmNorm (Shor_final_state_E2coset m w bits N cm f) ≤ 1

theorem physRunwayOracle_wellTyped (m w bits numWin : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat → Nat) (hw : 0 < w) (hbits : numWin * w = bits) (j : Nat) :
    FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits)
      (physRunwayOracle m w bits numWin TfamK TfamKinv j)

theorem gidney_inplace_coset_shor_succeeds_unconditional
    (a r N m w bits numWin cm : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat → Nat) (mult kInv : Nat → Nat)
    (f_runwayIdeal f_residueIdeal :
      Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hm : 0 < m) (hbitsPos : 0 < bits)
    (hwtI : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hwtRes : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_residueIdeal j))
    (hTfamK : ∀ k j addr, TfamK k j addr = tableValue (mult k) N w j addr)
    (hTfamKinv : ∀ k j addr, TfamKinv k j addr = tableValue (kInv k) N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hN1 : 1 < N)
    (hMN : 2 ^ cm * N ≤ 2 ^ bits)

def mcxClean : List Nat → Nat → List Nat → Gate
  | [],            target, _        => Gate.X target
  | [c],           target, _        => Gate.CX c target
  | c0 :: c1 :: rest, target, a :: anc' =>
      Gate.seq (Gate.CCX c0 c1 a)
        (Gate.seq (mcxClean (a :: rest) target anc') (Gate.CCX c0 c1 a))
  -- Degenerate case: ≥2 controls but no ancilla left.  Ruled out by the length
  -- hypothesis in the theorems; defined as a no-op so the function is total.
  | _ :: _ :: _,   _,      []       => Gate.I

theorem all_cons (c : Nat) (cs : List Nat) (f : Nat → Bool) :
    (c :: cs).all (fun x => f x) = (f c && cs.all (fun x => f x))

theorem all_congr_mem (l : List Nat) (g h : Nat → Bool)
    (hgh : ∀ x ∈ l, g x = h x) : l.all g = l.all h

theorem mcxClean_apply_fuel :
    ∀ (n : Nat) (controls : List Nat) (target : Nat) (anc : List Nat)
      (f : Nat → Bool),
      controls.length ≤ n →
      (controls ++ target :: anc).Nodup →
      controls.length ≤ anc.length + 1 →
      (∀ a ∈ anc, f a = false) →
      Gate.applyNat (mcxClean controls target anc) f
        = update f target (xor (f target) (controls.all (fun c => f c)))

theorem mcxClean_apply
    (controls : List Nat) (target : Nat) (anc : List Nat) (f : Nat → Bool)
    (hnodup : (controls ++ target :: anc).Nodup)
    (hlen : controls.length ≤ anc.length + 1)
    (hclean : ∀ a ∈ anc, f a = false) :
    Gate.applyNat (mcxClean controls target anc) f
      = update f target (xor (f target) (controls.all (fun c => f c)))

theorem mcxClean_wellTyped_fuel :
    ∀ (n : Nat) (controls : List Nat) (target : Nat) (anc : List Nat) (dim : Nat),
      controls.length ≤ n →
      (controls ++ target :: anc).Nodup →
      controls.length ≤ anc.length + 1 →
      (∀ x ∈ controls, x < dim) → target < dim → (∀ x ∈ anc, x < dim) →
      Gate.WellTyped dim (mcxClean controls target anc)

theorem mcxClean_wellTyped
    (controls : List Nat) (target : Nat) (anc : List Nat) (dim : Nat)
    (hnodup : (controls ++ target :: anc).Nodup)
    (hlen : controls.length ≤ anc.length + 1)
    (hcb : ∀ x ∈ controls, x < dim) (htgt : target < dim)
    (hab : ∀ x ∈ anc, x < dim) :
    Gate.WellTyped dim (mcxClean controls target anc)

example (t : Nat) : mcxClean [] t [] = Gate.X t

example (c t : Nat) : mcxClean [c] t [] = Gate.CX c t

example (c0 c1 t a : Nat) :
    mcxClean [c0, c1] t [a]
      = Gate.seq (Gate.CCX c0 c1 a)
          (Gate.seq (Gate.CX a t) (Gate.CCX c0 c1 a))

example (c0 c1 c2 t a0 a1 : Nat) :
    mcxClean [c0, c1, c2] t [a0, a1]
      = Gate.seq (Gate.CCX c0 c1 a0)
          (Gate.seq
            (Gate.seq (Gate.CCX a0 c2 a1)
              (Gate.seq (Gate.CX a1 t) (Gate.CCX a0 c2 a1)))
            (Gate.CCX c0 c1 a0))

def vswap (a b v : Nat) : Nat

theorem vswap_lt (a b : Nat) (k : Nat) (ha : a < 2 ^ k) (hb : b < 2 ^ k)
    (v : Nat) (hv : v < 2 ^ k) : vswap a b v < 2 ^ k

theorem swapGate_RegAct_vswap (reg : List Nat) (x y : Nat) (anc : List Nat)
    (hnd : reg.Nodup) (hanc : anc.Nodup) (hdisj : ∀ a ∈ anc, a ∉ reg)
    (hx : x < 2 ^ reg.length) (hy : y < 2 ^ reg.length)
    (hlen : reg.length ≤ anc.length + 1) :
    RegAct (swapGate reg x y anc) reg anc (vswap x y)

noncomputable def permGateOfList (reg : List Nat) (l : List (Nat × Nat)) (anc : List Nat) : Gate

theorem permGateOfList_cons (reg : List Nat) (p : Nat × Nat) (l : List (Nat × Nat))
    (anc : List Nat) :
    permGateOfList reg (p :: l) anc
      = Gate.seq (swapGate reg p.1 p.2 anc) (permGateOfList reg l anc)

def permOfList (l : List (Nat × Nat)) : Nat → Nat

theorem permOfList_cons (p : Nat × Nat) (l : List (Nat × Nat)) :
    permOfList (p :: l) = (fun v => permOfList l (vswap p.1 p.2 v))

theorem permGateOfList_RegAct (reg : List Nat) (l : List (Nat × Nat)) (anc : List Nat)
    (hnd : reg.Nodup) (hanc : anc.Nodup) (hdisj : ∀ a ∈ anc, a ∉ reg)
    (hlen : reg.length ≤ anc.length + 1)
    (hpairs : ∀ p ∈ l, p.1 < 2 ^ reg.length ∧ p.2 < 2 ^ reg.length) :
    RegAct (permGateOfList reg l anc) reg anc (permOfList l)

theorem permGateOfList_wellTyped (reg : List Nat) (l : List (Nat × Nat)) (anc : List Nat)
    (dim : Nat) (hnd : reg.Nodup) (hanc : anc.Nodup) (hdisj : ∀ a ∈ anc, a ∉ reg)
    (hdim : 0 < dim) (hregb : ∀ q ∈ reg, q < dim) (hancb : ∀ a ∈ anc, a < dim)
    (hlen : reg.length ≤ anc.length + 1)
    (hpairs : ∀ p ∈ l, p.1 < 2 ^ reg.length ∧ p.2 < 2 ^ reg.length) :
    Gate.WellTyped dim (permGateOfList reg l anc)

noncomputable def permToPair (g : Equiv.Perm (Fin (2 ^ k))) : Nat × Nat

theorem permToPair_spec (g : Equiv.Perm (Fin (2 ^ k))) (h : g.IsSwap) :
    ∃ a b : Fin (2 ^ k), a ≠ b ∧ g = Equiv.swap a b ∧
      permToPair g = (a.val, b.val)

theorem vswap_permToPair (g : Equiv.Perm (Fin (2 ^ k))) (h : g.IsSwap)
    (v : Nat) (hv : v < 2 ^ k) :
    vswap (permToPair g).1 (permToPair g).2 v = (g ⟨v, hv⟩ : Fin (2 ^ k)).val

theorem permToPair_mem_lt (L : List (Equiv.Perm (Fin (2 ^ k))))
    (hL : ∀ g ∈ L, g.IsSwap) :
    ∀ p ∈ L.map permToPair, p.1 < 2 ^ k ∧ p.2 < 2 ^ k

theorem permOfList_map_eq_inv_prod (L : List (Equiv.Perm (Fin (2 ^ k))))
    (hL : ∀ g ∈ L, g.IsSwap) (v : Nat) (hv : v < 2 ^ k) :
    permOfList (L.map permToPair) v = ((L.prod)⁻¹ ⟨v, hv⟩ : Fin (2 ^ k)).val

noncomputable def permGate (reg : List Nat) (σ : Equiv.Perm (Fin (2 ^ reg.length)))
    (anc : List Nat) : Gate

def permOnVal (reg : List Nat) (σ : Equiv.Perm (Fin (2 ^ reg.length))) (v : Nat) : Nat

theorem permGate_RegAct (reg : List Nat) (σ : Equiv.Perm (Fin (2 ^ reg.length)))
    (anc : List Nat) (hnd : reg.Nodup) (hanc : anc.Nodup) (hdisj : ∀ a ∈ anc, a ∉ reg)
    (hlen : reg.length ≤ anc.length + 1) :
    RegAct (permGate reg σ anc) reg anc (permOnVal reg σ)

theorem permGate_wellTyped (reg : List Nat) (σ : Equiv.Perm (Fin (2 ^ reg.length)))
    (anc : List Nat) (dim : Nat) (hnd : reg.Nodup) (hanc : anc.Nodup)
    (hdisj : ∀ a ∈ anc, a ∉ reg) (hdim : 0 < dim) (hregb : ∀ q ∈ reg, q < dim)
    (hancb : ∀ a ∈ anc, a < dim) (hlen : reg.length ≤ anc.length + 1) :
    Gate.WellTyped dim (permGate reg σ anc)

def aReg (w bits : Nat) : List Nat

def runAnc (w bits : Nat) : List Nat

theorem aReg_length (w bits : Nat) : (aReg w bits).length = bits

theorem runAnc_length (w bits : Nat) : (runAnc w bits).length = bits

theorem aReg_getElem (w bits : Nat) (i : Nat) (hi : i < (aReg w bits).length) :
    (aReg w bits)[i] = aBase w + i

theorem regIdx_aReg (w bits : Nat) (i : Nat) (hi : i < bits) :
    regIdx (aReg w bits) i = aBase w + i

theorem aReg_nodup (w bits : Nat) : (aReg w bits).Nodup

theorem runAnc_nodup (w bits : Nat) : (runAnc w bits).Nodup

theorem mem_aReg (w bits p : Nat) : p ∈ aReg w bits ↔ ∃ i, i < bits ∧ aBase w + i = p

theorem mem_runAnc (w bits p : Nat) :
    p ∈ runAnc w bits ↔ ∃ i, i < bits ∧ 1 + 2 * w + 2 * bits + i = p

theorem runAnc_disj_aReg (w bits : Nat) : ∀ a ∈ runAnc w bits, a ∉ aReg w bits

noncomputable def runwayGate (w bits N cm mult kInv : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1) : Gate

theorem perm_cast_apply {a b : Nat} (h : a = b) (τ : Equiv.Perm (Fin (2 ^ a)))
    (v : Nat) (hb : v < 2 ^ b) (ha : v < 2 ^ a) :
    ((h ▸ τ) ⟨v, hb⟩ : Fin (2 ^ b)).val = (τ ⟨v, ha⟩).val

theorem runway_permOnVal (w bits N cm mult kInv : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (v : Nat) (hv : v < 2 ^ bits) :
    permOnVal (aReg w bits)
        ((aReg_length w bits).symm ▸ resShiftPerm (2 ^ bits) N mult kInv hN hfwd hbwd) v
      = guardedShift (2 ^ bits) N mult v

theorem runwayGate_RegAct (w bits N cm mult kInv : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1) :
    RegAct (runwayGate w bits N cm mult kInv hN hfwd hbwd) (aReg w bits) (runAnc w bits)
      (permOnVal (aReg w bits)
        ((aReg_length w bits).symm ▸ resShiftPerm (2 ^ bits) N mult kInv hN hfwd hbwd))

theorem aReg_lt_cosetDim (w bits : Nat) : ∀ a ∈ aReg w bits, a < cosetDim w bits

theorem runAnc_lt_cosetDim (w bits : Nat) : ∀ a ∈ runAnc w bits, a < cosetDim w bits

theorem runwayGate_wellTyped (w bits N cm mult kInv : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1) :
    Gate.WellTyped (cosetDim w bits) (runwayGate w bits N cm mult kInv hN hfwd hbwd)

theorem runAnc_clean_of_scratchClean (w bits : Nat) (g : Nat → Bool)
    (hcl : scratchClean w bits g) : ∀ a ∈ runAnc w bits, g a = false

theorem setReg_self (reg : List Nat) (f : Nat → Bool) (hnd : reg.Nodup) :
    setReg reg (regVal reg f) f = f

theorem RegAct_reverse (g : Gate) (reg anc : List Nat) (dim : Nat)
    (σ τ : Nat → Nat) (hnd : reg.Nodup) (hdisj : ∀ a ∈ anc, a ∉ reg)
    (hwt : Gate.WellTyped dim g) (hga : RegAct g reg anc σ)
    (hτrange : ∀ v, v < 2 ^ reg.length → τ v < 2 ^ reg.length)
    (hστ : ∀ v, v < 2 ^ reg.length → σ (τ v) = v) :
    RegAct (GateReversible.Gate.reverse g) reg anc τ

theorem runway_permOnVal_inv (w bits N cm mult kInv : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (v : Nat) (hv : v < 2 ^ bits) :
    permOnVal (aReg w bits)
        ((aReg_length w bits).symm ▸ resShiftPerm (2 ^ bits) N mult kInv hN hfwd hbwd)
        (guardedShift (2 ^ bits) N kInv v)
      = v

theorem reverse_runwayGate_frame_off_aReg (w bits N cm mult kInv : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (g : Nat → Bool) (hcl : scratchClean w bits g) (p : Nat) (hp : p ∉ aReg w bits) :
    Gate.applyNat (GateReversible.Gate.reverse (runwayGate w bits N cm mult kInv hN hfwd hbwd)) g p
      = g p

theorem decodeReg_idx_congr (idx idx' : Nat → Nat) (n : Nat) (f : Nat → Bool)
    (h : ∀ i, i < n → idx i = idx' i) :
    decodeReg idx n f = decodeReg idx' n f

theorem regVal_aReg_eq (w bits : Nat) (g : Nat → Bool) :
    regVal (aReg w bits) g = decodeReg (fun i => aBase w + i) bits g

theorem aDecode_runwayGate (w bits N cm mult kInv : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (g : Nat → Bool) (hcl : scratchClean w bits g) :
    decodeReg (fun i => aBase w + i) bits
        (Gate.applyNat (runwayGate w bits N cm mult kInv hN hfwd hbwd) g)
      = guardedShift (2 ^ bits) N mult
          (decodeReg (fun i => aBase w + i) bits g)

theorem runwayGate_frame_off_aReg (w bits N cm mult kInv : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (g : Nat → Bool) (hcl : scratchClean w bits g) (p : Nat) (hp : p ∉ aReg w bits) :
    Gate.applyNat (runwayGate w bits N cm mult kInv hN hfwd hbwd) g p = g p

theorem not_mem_aReg_of_off (w bits p : Nat) (hoff : ¬ (aBase w ≤ p ∧ p < aBase w + bits)) :
    p ∉ aReg w bits

theorem bDecode_runwayGate (w bits N cm mult kInv : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (g : Nat → Bool) (hcl : scratchClean w bits g) :
    decodeReg (fun i => bBase w bits + i) bits
        (Gate.applyNat (runwayGate w bits N cm mult kInv hN hfwd hbwd) g)
      = decodeReg (fun i => bBase w bits + i) bits g

theorem scratchClean_runwayGate (w bits N cm mult kInv : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (g : Nat → Bool) (hcl : scratchClean w bits g) :
    scratchClean w bits (Gate.applyNat (runwayGate w bits N cm mult kInv hN hfwd hbwd) g)

theorem scratchClean_of_runwayGate (w bits N cm mult kInv : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (g : Nat → Bool)
    (hcl' : scratchClean w bits (Gate.applyNat (runwayGate w bits N cm mult kInv hN hfwd hbwd) g)) :
    scratchClean w bits g

theorem scratchClean_runwayGate_iff (w bits N cm mult kInv : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1) (g : Nat → Bool) :
    scratchClean w bits (Gate.applyNat (runwayGate w bits N cm mult kInv hN hfwd hbwd) g)
      ↔ scratchClean w bits g

theorem support_transport_applyNat (w bits N cm mult kInv z : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (hfull : 2 ^ cm * N ≤ 2 ^ bits) (hz : z < N) (g : Nat → Bool) :
    (scratchClean w bits (Gate.applyNat (runwayGate w bits N cm mult kInv hN hfwd hbwd) g)
      ∧ (⟨decodeReg (fun i => aBase w + i) bits
            (Gate.applyNat (runwayGate w bits N cm mult kInv hN hfwd hbwd) g),
          decodeReg_lt_two_pow _ _ _⟩ : Fin (2 ^ bits))
            ∈ cosetWindow (2 ^ bits) N cm ((mult * z) % N)
      ∧ (⟨decodeReg (fun i => bBase w bits + i) bits
            (Gate.applyNat (runwayGate w bits N cm mult kInv hN hfwd hbwd) g),
          decodeReg_lt_two_pow _ _ _⟩ : Fin (2 ^ bits))
            ∈ cosetWindow (2 ^ bits) N cm 0)

theorem runway_permState_key (w bits N cm mult kInv z : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (hfull : 2 ^ cm * N ≤ 2 ^ bits) (hz : z < N) :
    permState (gateToPerm (runwayGate w bits N cm mult kInv hN hfwd hbwd) (cosetDim w bits)
        (runwayGate_wellTyped w bits N cm mult kInv hN hfwd hbwd))
        (cosetInputVec w bits N cm ((mult * z) % N) 0)
      = cosetInputVec w bits N cm z 0

theorem runwayGate_column_identity (w bits N cm mult kInv z : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (hfull : 2 ^ cm * N ≤ 2 ^ bits) (hz : z < N) :
    Framework.uc_eval (Gate.toUCom (cosetDim w bits)
        (runwayGate w bits N cm mult kInv hN hfwd hbwd))
        * cosetInputVec w bits N cm z 0
      = cosetInputVec w bits N cm ((mult * z) % N) 0

theorem swapGate_RegAct (reg : List Nat) (x y : Nat) (anc : List Nat)
    (hnd : reg.Nodup) (hanc : anc.Nodup) (hdisj : ∀ a ∈ anc, a ∉ reg)
    (hx : x < 2 ^ reg.length) (hy : y < 2 ^ reg.length)
    (hlen : reg.length ≤ anc.length + 1) :
    RegAct (swapGate reg x y anc) reg anc
      (if x = y then id else swapNet reg.length x y)

theorem setReg_regVal_self (reg : List Nat) (f : Nat → Bool) (hnd : reg.Nodup) :
    setReg reg (regVal reg f) f = f

theorem swapGate_apply (reg : List Nat) (x y : Nat) (anc : List Nat) (f : Nat → Bool)
    (hx : x < 2 ^ reg.length) (hy : y < 2 ^ reg.length)
    (hnd : reg.Nodup) (hanc : anc.Nodup) (hdisj : ∀ a ∈ anc, a ∉ reg)
    (hlen : reg.length ≤ anc.length + 1)
    (hclean : ∀ a ∈ anc, f a = false) :
    Gate.applyNat (swapGate reg x y anc) f =
      (if regVal reg f = x then setReg reg y f
       else if regVal reg f = y then setReg reg x f
       else f)

def regIdx (reg : List Nat) : Nat → Nat

def regVal (reg : List Nat) (f : Nat → Bool) : Nat

def setReg (reg : List Nat) (v : Nat) (f : Nat → Bool) : Nat → Bool

theorem regIdx_mem (reg : List Nat) (i : Nat) (hi : i < reg.length) :
    regIdx reg i ∈ reg

theorem regIdx_inj (reg : List Nat) (hnd : reg.Nodup) :
    ∀ i j, i < reg.length → j < reg.length → regIdx reg i = regIdx reg j → i = j

theorem regVal_testBit (reg : List Nat) (f : Nat → Bool) (i : Nat)
    (hi : i < reg.length) :
    (regVal reg f).testBit i = f (regIdx reg i)

theorem regVal_lt (reg : List Nat) (f : Nat → Bool) :
    regVal reg f < 2 ^ reg.length

theorem regVal_congr (reg : List Nat) (f g : Nat → Bool)
    (h : ∀ i, i < reg.length → f (regIdx reg i) = g (regIdx reg i)) :
    regVal reg f = regVal reg g

theorem setReg_frame (reg : List Nat) (v : Nat) (f : Nat → Bool) (p : Nat)
    (hp : p ∉ reg) : setReg reg v f p = f p

theorem setReg_at (reg : List Nat) (v : Nat) (f : Nat → Bool) (hnd : reg.Nodup)
    (i : Nat) (hi : i < reg.length) :
    setReg reg v f (regIdx reg i) = v.testBit i

theorem mem_reg_iff_regIdx (reg : List Nat) (p : Nat) :
    p ∈ reg ↔ ∃ i, i < reg.length ∧ regIdx reg i = p

theorem setReg_setReg (reg : List Nat) (v w : Nat) (f : Nat → Bool)
    (hnd : reg.Nodup) :
    setReg reg w (setReg reg v f) = setReg reg w f

theorem setReg_clean (reg : List Nat) (anc : List Nat) (v : Nat) (f : Nat → Bool)
    (hdisj : ∀ a ∈ anc, a ∉ reg) (hclean : ∀ a ∈ anc, f a = false) :
    ∀ a ∈ anc, setReg reg v f a = false

theorem regVal_setReg (reg : List Nat) (v : Nat) (f : Nat → Bool) (hnd : reg.Nodup)
    (hv : v < 2 ^ reg.length) :
    regVal reg (setReg reg v f) = v

def RegAct (g : Gate) (reg anc : List Nat) (π : Nat → Nat) : Prop

theorem RegAct_id (reg anc : List Nat) (hnd : reg.Nodup) :
    RegAct Gate.I reg anc id

theorem RegAct_seq (g₁ g₂ : Gate) (reg anc : List Nat) (π₁ π₂ : Nat → Nat)
    (hnd : reg.Nodup) (hdisj : ∀ a ∈ anc, a ∉ reg)
    (h₁ : RegAct g₁ reg anc π₁) (h₂ : RegAct g₂ reg anc π₂) :
    RegAct (Gate.seq g₁ g₂) reg anc (fun v => π₂ (π₁ v))

noncomputable def lowestBit (z : Nat) : Nat

theorem testBit_lowestBit (z : Nat) (hz : z ≠ 0) :
    z.testBit (lowestBit z) = true

theorem lowestBit_min (z : Nat) (hz : z ≠ 0) (i : Nat) (hi : i < lowestBit z) :
    z.testBit i = false

theorem lowestBit_lt (z k : Nat) (hz : z ≠ 0) (hzk : z < 2 ^ k) :
    lowestBit z < k

def xfold (reg : List Nat) (cond : Nat → Bool) (L : List Nat) : Gate

theorem xfold_cons (reg : List Nat) (cond : Nat → Bool) (a : Nat) (L : List Nat) :
    xfold reg cond (a :: L)
      = if cond a then Gate.seq (Gate.X (regIdx reg a)) (xfold reg cond L) else xfold reg cond L

theorem xfold_frame (reg : List Nat) (cond : Nat → Bool) (L : List Nat)
    (p : Nat) (hp : ∀ i ∈ L, p ≠ regIdx reg i) :
    ∀ f, Gate.applyNat (xfold reg cond L) f p = f p

theorem xfold_at (reg : List Nat) (cond : Nat → Bool) (L : List Nat)
    (hnd : reg.Nodup) (hL : ∀ i ∈ L, i < reg.length) (hLnd : L.Nodup)
    (j : Nat) (hj : j ∈ L) :
    ∀ f, Gate.applyNat (xfold reg cond L) f (regIdx reg j)
      = xor (f (regIdx reg j)) (cond j)

theorem xfold_RegAct (reg : List Nat) (cond : Nat → Bool) (anc : List Nat) (m : Nat)
    (hnd : reg.Nodup) (hm : m < 2 ^ reg.length)
    (hmc : ∀ i, i < reg.length → m.testBit i = cond i) :
    RegAct (xfold reg cond (List.range reg.length)) reg anc (fun v => v ^^^ m)

def cxfold (reg : List Nat) (ctrl : Nat) (cond : Nat → Bool) (L : List Nat) : Gate

theorem cxfold_cons (reg : List Nat) (ctrl : Nat) (cond : Nat → Bool) (a : Nat) (L : List Nat) :
    cxfold reg ctrl cond (a :: L)
      = if cond a then Gate.seq (Gate.CX ctrl (regIdx reg a)) (cxfold reg ctrl cond L)
        else cxfold reg ctrl cond L

theorem cxfold_frame (reg : List Nat) (ctrl : Nat) (cond : Nat → Bool) (L : List Nat)
    (p : Nat) (hp : ∀ i ∈ L, p ≠ regIdx reg i) :
    ∀ f, Gate.applyNat (cxfold reg ctrl cond L) f p = f p

theorem cxfold_at (reg : List Nat) (ctrl : Nat) (cond : Nat → Bool) (L : List Nat)
    (hnd : reg.Nodup) (hL : ∀ i ∈ L, i < reg.length) (hLnd : L.Nodup)
    (hctrl : ∀ i ∈ L, cond i = true → ctrl ≠ regIdx reg i)
    (j : Nat) (hj : j ∈ L) :
    ∀ f, Gate.applyNat (cxfold reg ctrl cond L) f (regIdx reg j)
      = xor (f (regIdx reg j)) (if cond j then f ctrl else false)

theorem cxfold_RegAct (reg : List Nat) (anc : List Nat) (p m : Nat)
    (hnd : reg.Nodup) (hp : p < reg.length) (hm : m < 2 ^ reg.length)
    (cond : Nat → Bool) (hcp : cond p = false)
    (hmc : ∀ i, i < reg.length → m.testBit i = cond i) :
    RegAct (cxfold reg (regIdx reg p) cond (List.range reg.length)) reg anc
      (fun v => if v.testBit p then v ^^^ m else v)

example (reg anc : List Nat) (x : Nat) : swapGate reg x x anc = Gate.I

example : lowestBit 1 = 0

def xmaskGate (reg : List Nat) (x : Nat) : Gate

def reduceCNOTGate (reg : List Nat) (z p : Nat) : Gate

def xallExceptGate (reg : List Nat) (p : Nat) : Gate

def ctrlIdxs (k p : Nat) : List Nat

def andExceptP (v p k : Nat) : Bool

def antiCtrlXGate (reg : List Nat) (p : Nat) (anc : List Nat) : Gate

noncomputable def swapGate (reg : List Nat) (x y : Nat) (anc : List Nat) : Gate

theorem xmaskGate_RegAct (reg : List Nat) (x : Nat) (anc : List Nat)
    (hnd : reg.Nodup) (hx : x < 2 ^ reg.length) :
    RegAct (xmaskGate reg x) reg anc (fun v => v ^^^ x)

def clearBit (z p : Nat) : Nat

theorem clearBit_testBit (z p i : Nat) :
    (clearBit z p).testBit i = (decide (i ≠ p) && z.testBit i)

theorem clearBit_lt (z p k : Nat) (hz : z < 2 ^ k) : clearBit z p < 2 ^ k

theorem reduceCNOTGate_RegAct (reg : List Nat) (z p : Nat) (anc : List Nat)
    (hnd : reg.Nodup) (hp : p < reg.length) (hz : z < 2 ^ reg.length) :
    RegAct (reduceCNOTGate reg z p) reg anc
      (fun v => if v.testBit p then v ^^^ clearBit z p else v)

theorem mem_ctrlIdxs (k p i : Nat) : i ∈ ctrlIdxs k p ↔ i < k ∧ i ≠ p

theorem ctrlIdxs_nodup (k p : Nat) : (ctrlIdxs k p).Nodup

theorem ctrlIdxs_lt (k p i : Nat) (hi : i ∈ ctrlIdxs k p) : i < k

theorem p_not_mem_ctrlIdxs (k p : Nat) : p ∉ ctrlIdxs k p

theorem ctrlIdxs_length_le (k p : Nat) : (ctrlIdxs k p).length ≤ k

theorem mem_ctrl_wires (reg : List Nat) (p c : Nat)
    (hc : c ∈ (ctrlIdxs reg.length p).map (regIdx reg)) :
    ∃ i, i < reg.length ∧ i ≠ p ∧ regIdx reg i = c

theorem mcx_nodup (reg : List Nat) (p : Nat) (anc : List Nat)
    (hnd : reg.Nodup) (hp : p < reg.length) (hanc : anc.Nodup)
    (hdisj : ∀ a ∈ anc, a ∉ reg) :
    (((ctrlIdxs reg.length p).map (regIdx reg)) ++ (regIdx reg p) :: anc).Nodup

theorem mcx_all_eq_andExceptP (reg : List Nat) (p : Nat) (f : Nat → Bool) :
    (((ctrlIdxs reg.length p).map (regIdx reg)).all (fun c => f c))
      = andExceptP (regVal reg f) p reg.length

def maskAllExceptP (k p : Nat) : Nat

theorem maskAllExceptP_testBit (k p i : Nat) (hi : i < k) :
    (maskAllExceptP k p).testBit i = decide (i ≠ p)

theorem maskAllExceptP_lt (k p : Nat) (hp : p < k) : maskAllExceptP k p < 2 ^ k

theorem xallExceptGate_RegAct (reg : List Nat) (p : Nat) (anc : List Nat)
    (hnd : reg.Nodup) (hp : p < reg.length) :
    RegAct (xallExceptGate reg p) reg anc (fun v => v ^^^ maskAllExceptP reg.length p)

theorem mcxClean_RegAct (reg : List Nat) (p : Nat) (anc : List Nat)
    (hnd : reg.Nodup) (hp : p < reg.length) (hanc : anc.Nodup)
    (hdisj : ∀ a ∈ anc, a ∉ reg)
    (hlen : (ctrlIdxs reg.length p).length ≤ anc.length + 1) :
    RegAct (mcxClean ((ctrlIdxs reg.length p).map (regIdx reg)) (regIdx reg p) anc) reg anc
      (fun v => if andExceptP v p reg.length then v ^^^ 2 ^ p else v)

theorem antiCtrlXGate_RegAct (reg : List Nat) (p : Nat) (anc : List Nat)
    (hnd : reg.Nodup) (hp : p < reg.length) (hanc : anc.Nodup)
    (hdisj : ∀ a ∈ anc, a ∉ reg)
    (hlen : (ctrlIdxs reg.length p).length ≤ anc.length + 1) :
    RegAct (antiCtrlXGate reg p anc) reg anc
      (fun v => if andExceptP (v ^^^ maskAllExceptP reg.length p) p reg.length
                then v ^^^ 2 ^ p else v)

theorem clearBit_eq_xor (z p : Nat) (hzp : z.testBit p = true) :
    clearBit z p = z ^^^ 2 ^ p

theorem andExceptP_maskAllExceptP (k p : Nat) :
    andExceptP (maskAllExceptP k p) p k = true

theorem andExceptP_two_pow_xor_mask (k p : Nat) (_hp : p < k) :
    andExceptP (2 ^ p ^^^ maskAllExceptP k p) p k = true

def piReduce (z p : Nat) (v : Nat) : Nat

def piAnti (k p : Nat) (v : Nat) : Nat

theorem clearBit_testBit_self (z p : Nat) : (clearBit z p).testBit p = false

theorem piReduce_testBit_p (z p v : Nat) : (piReduce z p v).testBit p = v.testBit p

theorem piReduce_involutive (z p v : Nat) : piReduce z p (piReduce z p v) = v

theorem piAnti_fix (k p w : Nat) (_hp : p < k)
    (hne : ¬ andExceptP (w ^^^ maskAllExceptP k p) p k) : piAnti k p w = w

noncomputable def swapNet (k x y : Nat) (v : Nat) : Nat

theorem swapNet_x (k x y : Nat) (hxy : x ≠ y) (_hp : lowestBit (x ^^^ y) < k) :
    swapNet k x y x = y

theorem swapNet_y (k x y : Nat) (hxy : x ≠ y) (hp : lowestBit (x ^^^ y) < k) :
    swapNet k x y y = x

theorem andExceptP_xor_mask_cases (k p w : Nat) (hp : p < k) (hw : w < 2 ^ k)
    (hcond : andExceptP (w ^^^ maskAllExceptP k p) p k = true) :
    w = 0 ∨ w = 2 ^ p

theorem swapNet_other (k x y : Nat) (hxy : x ≠ y)
    (hp : lowestBit (x ^^^ y) < k) (hx : x < 2 ^ k) (hy : y < 2 ^ k)
    (v : Nat) (hv : v < 2 ^ k) (hvx : v ≠ x) (hvy : v ≠ y) :
    swapNet k x y v = v

theorem xfold_wellTyped (reg : List Nat) (cond : Nat → Bool) (L : List Nat) (dim : Nat)
    (hdim : 0 < dim) (hb : ∀ i ∈ L, regIdx reg i < dim) :
    Gate.WellTyped dim (xfold reg cond L)

theorem cxfold_wellTyped (reg : List Nat) (ctrl : Nat) (cond : Nat → Bool) (L : List Nat)
    (dim : Nat) (hdim : 0 < dim) (hctrl : ctrl < dim) (hb : ∀ i ∈ L, regIdx reg i < dim)
    (hne : ∀ i ∈ L, cond i = true → ctrl ≠ regIdx reg i) :
    Gate.WellTyped dim (cxfold reg ctrl cond L)

theorem antiCtrlXGate_wellTyped (reg : List Nat) (p : Nat) (anc : List Nat) (dim : Nat)
    (hnd : reg.Nodup) (hanc : anc.Nodup) (hdisj : ∀ a ∈ anc, a ∉ reg) (hdim : 0 < dim)
    (hp : p < reg.length) (hridx : ∀ i, i < reg.length → regIdx reg i < dim)
    (hancb : ∀ a ∈ anc, a < dim) (hlen : (ctrlIdxs reg.length p).length ≤ anc.length + 1) :
    Gate.WellTyped dim (antiCtrlXGate reg p anc)

theorem swapGate_wellTyped (reg : List Nat) (x y : Nat) (anc : List Nat) (dim : Nat)
    (hx : x < 2 ^ reg.length) (hy : y < 2 ^ reg.length)
    (hnd : reg.Nodup) (hanc : anc.Nodup) (hdisj : ∀ a ∈ anc, a ∉ reg)
    (hdim : 0 < dim) (hregb : ∀ q ∈ reg, q < dim) (hancb : ∀ a ∈ anc, a < dim)
    (hlen : reg.length ≤ anc.length + 1) :
    Gate.WellTyped dim (swapGate reg x y anc)

theorem encodeDataZeroAnc_anc_irrelevant {n anc anc' x : Nat}
    (hx : x < 2 ^ n) (h1 : 1 ≤ anc) (h1' : 1 ≤ anc') :
    encodeDataZeroAnc n anc x = encodeDataZeroAnc n anc' x

noncomputable def idealResidueMultiplier (w bits N : Nat)
    (hw2 : 2 ≤ w) (hb1 : 1 ≤ bits) (hN1 : 1 < N) (hN2 : 2 * N ≤ 2 ^ bits) :
    EncodeRoundTripModMul N bits (cosetAnc w bits)

noncomputable def idealResidueFamily (w bits N a ainv0 : Nat)
    (hw2 : 2 ≤ w) (hb1 : 1 ≤ bits) (hN1 : 1 < N) (hN2 : 2 * N ≤ 2 ^ bits)
    (h_inv0 : a * ainv0 % N = 1) :
    VerifiedShor.VerifiedModMulFamily a N bits (cosetAnc w bits)

theorem orbit_E2_pmDist_deviation_no_hisom
    (m w bits numWin N cm : Nat) (hm : 0 < m)
    (TfamK TfamKinv : Nat → Nat → Nat → Nat) (mult kInv : Nat → Nat)
    (f_runwayPhysical f_runwayIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwtP : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayPhysical j))
    (hwtI : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hTfamK : ∀ k j addr, TfamK k j addr = tableValue (mult k) N w j addr)
    (hTfamKinv : ∀ k j addr, TfamKinv k j addr = tableValue (kInv k) N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hN1 : 1 < N)
    (hkkinv : ∀ k, (kInv k * mult k) % N = 1 % N)
    (hfit : ∀ (k z : Nat), z < N → (mult k * z) % N + (2 ^ cm - 1) * N < 2 ^ bits)
    (hxfit : ∀ (z : Nat), z < N → z + (2 ^ cm - 1) * N < 2 ^ bits)

theorem coset_route2_success_hybrid_norm_E2_no_hisom
    (a r N m w bits numWin cm : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat → Nat) (mult kInv : Nat → Nat)
    (f_runwayPhysical f_runwayIdeal f_residueIdeal :
      Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hm : 0 < m) (hbitsPos : 0 < bits)
    (hwtP : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayPhysical j))
    (hwtI : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hwtRes : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_residueIdeal j))
    (hTfamK : ∀ k j addr, TfamK k j addr = tableValue (mult k) N w j addr)
    (hTfamKinv : ∀ k j addr, TfamKinv k j addr = tableValue (kInv k) N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hN1 : 1 < N)

theorem uc_eval_toUCom_dimcast {A B : Nat} (h : A = B) (g : FormalRV.Framework.Gate)
    (i j : Fin (2 ^ A)) :
    FormalRV.Framework.uc_eval (FormalRV.BQAlgo.Gate.toUCom A g) i j
      = FormalRV.Framework.uc_eval (FormalRV.BQAlgo.Gate.toUCom B g)
          (Fin.cast (congrArg (fun x => 2 ^ x) h) i) (Fin.cast (congrArg (fun x => 2 ^ x) h) j)

noncomputable def physRunwayOracle (m w bits numWin : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat → Nat) (j : Nat) :
    FormalRV.Framework.BaseUCom (bits + cosetAnc w bits)

theorem physRunwayOracle_align (m w bits numWin : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat → Nat) (k : Nat) (hk : k < m) :
    physRunwayOracle m w bits numWin TfamK TfamKinv (revIndex m k)
      = Gate.toUCom (bits + cosetAnc w bits)
          (gidneyInPlaceWithSwap w bits (TfamK k) (TfamKinv k) numWin)

private theorem cast_workDim_cosetWork (m w bits : Nat)
    (a : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) :
    Fin.cast (congrArg (fun x => 2 ^ x) (cosetWork_dim_eq w bits))
        (Fin.cast (workDim_eq m bits (cosetAnc w bits)) a)
      = Fin.cast (E2shor_dim_eq m w bits) a

theorem hf_physical_concrete (m w bits numWin N cm : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat → Nat)
    (k : Nat) (hk : k < m) (z : Nat) (_hz : z < N)
    (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) :
    (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
        FormalRV.Framework.uc_eval (physRunwayOracle m w bits numWin TfamK TfamKinv (revIndex m k))
            (Fin.cast (workDim_eq m bits (cosetAnc w bits)) y)
            (Fin.cast (workDim_eq m bits (cosetAnc w bits)) yp)
          * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)
      = (FormalRV.Framework.uc_eval (FormalRV.BQAlgo.Gate.toUCom (cosetDim w bits)
            (gidneyInPlaceWithSwap w bits (TfamK k) (TfamKinv k) numWin))
          * cosetInputVec w bits N cm z 0) (Fin.cast (E2shor_dim_eq m w bits) y) 0

theorem hf_physical_runway (m w bits numWin N cm : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat → Nat) :
    ∀ (k : Nat), k < m → ∀ (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
        (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
            FormalRV.Framework.uc_eval
                (physRunwayOracle m w bits numWin TfamK TfamKinv (revIndex m k))
                (Fin.cast (workDim_eq m bits (cosetAnc w bits)) y)
                (Fin.cast (workDim_eq m bits (cosetAnc w bits)) yp)
              * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)
          = (FormalRV.Framework.uc_eval (Gate.toUCom (cosetDim w bits)
                (gidneyInPlaceWithSwap w bits (TfamK k) (TfamKinv k) numWin))

theorem interior_npar_H (b cm hi : Nat) (hcm : 0 < cm)
    (lo : Matrix (Fin (2 ^ b)) (Fin 1) ℂ) (hiv : Matrix (Fin (2 ^ hi)) (Fin 1) ℂ) :
    Framework.uc_eval
        (map_qubits (fun q => b + q) (npar_H cm : Framework.BaseUCom (cm + hi))
          : Framework.BaseUCom (b + (cm + hi)))
        * kron_vec lo (kron_vec (kron_zeros cm) hiv)
      = kron_vec lo
          (((1 : ℂ) / Real.sqrt (2 ^ cm : ℝ)) •
            ∑ x : Fin (2 ^ cm),
            kron_vec (FormalRV.Framework.basis_vector (2 ^ cm) x.val) hiv)

theorem kronDim_eq (m w bits : Nat) :
    2 ^ (m + cosetDim w bits) = 2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)

theorem cast_jointIdx_eq_combine_runway (m w bits : Nat)
    (x : Fin (2 ^ m)) (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) :
    (Fin.cast (kronDim_eq m w bits).symm (jointIdx (shorDvd m bits (cosetAnc w bits)) x y)
      : Fin (2 ^ (m + cosetDim w bits)))
      = FormalRV.Framework.kron_vec_combine x (Fin.cast (E2shor_dim_eq m w bits) y)

theorem kron_E2runwayInit (m w bits N cm : Nat) :
    QState.cast (kronDim_eq m w bits)
        (kron_vec
          (((1 : ℂ) / Real.sqrt (2 ^ m : ℝ)) •
            ∑ x : Fin (2 ^ m), FormalRV.Framework.basis_vector (2 ^ m) x.val)
          (cosetInputVec w bits N cm 1 0))
      = E2runwayInit m w bits N cm

theorem uc_eval_E2runwayInitPrep_eq_E2runwayInit
    (m w rest cm N : Nat) (hm : 0 < m) (hN : 0 < N) (h1N : 1 < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest))
    (dataH : Framework.BaseUCom (cosetDim w (cm + rest)))
    (hdataH_wt : UCom.WellTyped (cosetDim w (cm + rest)) dataH)
    (hInteriorH : Framework.uc_eval dataH * basis0 (cosetDim w (cm + rest))
      = RunwayPrepFull.doublyHWindowSource w rest cm) :
    QState.cast (kronDim_eq m w (cm + rest))
        (Framework.uc_eval
            (RunwayPrepFull.E2runwayInitPrep m w rest cm N hN h1N hbudget dataH)
          * basis0 (m + cosetDim w (cm + rest)))
      = E2runwayInit m w (cm + rest) N cm

theorem wellTyped_map_qubits_npar_off {src : Nat} (off D k : Nat)
    (g : Nat → Framework.BaseUCom src) (hoff : off < D)
    (hg : ∀ j, j < k → (map_qubits (fun q => off + q) (g j) : Framework.BaseUCom D).WellTyped D) :
    UCom.WellTyped D
      (map_qubits (fun q => off + q)
        (FormalRV.Framework.BaseUCom.npar k g : Framework.BaseUCom src)
        : Framework.BaseUCom D)

theorem wellTyped_map_qubits_npar_H_off (off D cm : Nat)
    (hoff : off < D) (hle : off + cm ≤ D) :
    UCom.WellTyped D
      (map_qubits (fun q => off + q) (npar_H cm : Framework.BaseUCom cm)
        : Framework.BaseUCom D)

noncomputable def runwayDataH (w rest cm : Nat) :
    Framework.BaseUCom (cosetDim w (cm + rest))

theorem runwayDataH_wellTyped (w rest cm : Nat) :
    UCom.WellTyped (cosetDim w (cm + rest)) (runwayDataH w rest cm)

theorem uc_eval_X_zero :
    Framework.uc_eval (UCom.app1 U_X 0 : Framework.BaseUCom 1)
        * FormalRV.Framework.basis_vector 2 0
      = FormalRV.Framework.basis_vector 2 1

theorem kron_zeros_split (a b : Nat) :
    FormalRV.Framework.kron_zeros (a + b)
      = kron_vec (FormalRV.Framework.kron_zeros a) (FormalRV.Framework.kron_zeros b)

theorem basis0_eq_kron_zeros (D : Nat) :
    RunwayPrepCore.basis0 D = FormalRV.Framework.kron_zeros D

theorem uc_eval_X_basis0 (d : Nat) :
    Framework.uc_eval (UCom.app1 U_X 0 : Framework.BaseUCom (1 + d))
        * RunwayPrepCore.basis0 (1 + d)
      = kron_vec (FormalRV.Framework.basis_vector 2 1) (FormalRV.Framework.kron_zeros d)

noncomputable def basis0 (D : Nat) : Matrix (Fin (2 ^ D)) (Fin 1) ℂ

theorem basis0_split (cm rest : Nat) :
    basis0 (cm + rest)
      = kron_vec (FormalRV.Framework.kron_zeros cm) (FormalRV.Framework.kron_zeros rest)

theorem uc_eval_npar_H_basis0 (cm rest : Nat) (hcm : 0 < cm) :
    FormalRV.Framework.uc_eval (npar_H cm : Framework.BaseUCom (cm + rest))
        * basis0 (cm + rest)
      = ((1 : ℂ) / Real.sqrt (2 ^ cm : ℝ)) •
          ∑ x : Fin (2 ^ cm),
            FormalRV.Framework.basis_vector (2 ^ (cm + rest)) (x.val * 2 ^ rest)

abbrev hWindow (rest cm : Nat) : Finset (Fin (2 ^ (cm + rest)))

abbrev cWindow (rest cm N k : Nat) : Finset (Fin (2 ^ (cm + rest)))

theorem hWindow_card (rest cm : Nat) : (hWindow rest cm).card = 2 ^ cm

theorem cWindow_card (rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) : (cWindow rest cm N k).card = 2 ^ cm

noncomputable def windowEquiv (rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) :
    {v : Fin (2 ^ (cm + rest)) // v ∈ hWindow rest cm}
      ≃ {v : Fin (2 ^ (cm + rest)) // v ∈ cWindow rest cm N k}

noncomputable def σ_k (rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) : Equiv.Perm (Fin (2 ^ (cm + rest)))

theorem σ_k_window (rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest))
    (v : Fin (2 ^ (cm + rest))) (hv : v ∈ hWindow rest cm) :
    σ_k rest cm N k hN hk hbudget v ∈ cWindow rest cm N k

theorem σ_k_not_window (rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest))
    (v : Fin (2 ^ (cm + rest))) (hv : v ∉ hWindow rest cm) :
    σ_k rest cm N k hN hk hbudget v ∉ cWindow rest cm N k

theorem σ_k_bijOn (rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) :
    Set.BijOn (σ_k rest cm N k hN hk hbudget) (hWindow rest cm) (cWindow rest cm N k)

theorem affineSrc_lt (cm rest x : Nat) (hx : x < 2 ^ cm) :
    x * 2 ^ rest < 2 ^ (cm + rest)

theorem npar_H_sum_over_hWindow (cm rest : Nat) (hcm : 0 < cm) :
    FormalRV.Framework.uc_eval (npar_H cm : Framework.BaseUCom (cm + rest))
        * basis0 (cm + rest)
      = ((1 : ℂ) / Real.sqrt (2 ^ cm : ℝ)) •
          ∑ v ∈ hWindow rest cm,
            FormalRV.Framework.basis_vector (2 ^ (cm + rest)) (v : Nat)

theorem uniform_window_sum_eq_cosetState (dim N cm r : Nat) :
    ((1 : ℂ) / Real.sqrt (2 ^ cm : ℝ)) •
        ∑ v ∈ cosetWindow dim N cm r,
          FormalRV.Framework.basis_vector dim (v : Nat)
      = cosetState dim N cm r

theorem uc_eval_npar_H_eq_cosetState0 (cm rest : Nat) (hcm : 0 < cm) :
    FormalRV.Framework.uc_eval (npar_H cm : Framework.BaseUCom (cm + rest))
        * basis0 (cm + rest)
      = cosetState (2 ^ (cm + rest)) (2 ^ rest) cm 0

theorem uc_eval_gate_on_hOutput (g : Gate) (cm rest N k : Nat) (hcm : 0 < cm)
    (hwt : Gate.WellTyped (cm + rest) g)
    (hbij : Set.BijOn (gateToPerm g (cm + rest) hwt) (hWindow rest cm) (cWindow rest cm N k)) :
    FormalRV.Framework.uc_eval (Gate.toUCom (cm + rest) g)
        * (FormalRV.Framework.uc_eval (npar_H cm : Framework.BaseUCom (cm + rest))
            * basis0 (cm + rest))
      = cosetState (2 ^ (cm + rest)) N cm k

def prepReg (bits : Nat) : List Nat

def prepAnc (bits : Nat) : List Nat

theorem prepReg_length (bits : Nat) : (prepReg bits).length = bits

theorem prepAnc_length (bits : Nat) : (prepAnc bits).length = bits

theorem prepReg_nodup (bits : Nat) : (prepReg bits).Nodup

theorem prepReg_mem (bits q : Nat) : q ∈ prepReg bits ↔ q < bits

theorem prepAnc_nodup (bits : Nat) : (prepAnc bits).Nodup

theorem prepAnc_disj_prepReg (bits : Nat) : ∀ a ∈ prepAnc bits, a ∉ prepReg bits

theorem prepReg_lt (bits : Nat) : ∀ q ∈ prepReg bits, q < 2 * bits

theorem prepAnc_lt (bits : Nat) : ∀ a ∈ prepAnc bits, a < 2 * bits

noncomputable def prepPerm (cm rest N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) : Equiv.Perm (Fin (2 ^ (cm + rest)))

abbrev prepDim (cm rest : Nat) : Nat

noncomputable def cosetStatePrep (cm rest N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) : Framework.BaseUCom (prepDim cm rest)

noncomputable def prepGate (cm rest N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) : Gate

theorem cosetStatePrep_permGate_wellTyped (cm rest N k : Nat) (hbits : 0 < cm + rest)
    (hN : 0 < N) (hk : k < N) (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) :
    Gate.WellTyped (prepDim cm rest) (prepGate cm rest N k hN hk hbudget)

theorem fbn_add (a b : Nat) (f : Nat → Bool) :
    FormalRV.Framework.funbool_to_nat (a + b) f
      = FormalRV.Framework.funbool_to_nat a f * 2 ^ b
        + FormalRV.Framework.funbool_to_nat b (fun p => f (p + a))

theorem fbn_testBit (n : Nat) (f : Nat → Bool) (i : Nat) (hi : i < n) :
    (FormalRV.Framework.funbool_to_nat n f).testBit i = f (n - 1 - i)

theorem regIdx_prepReg (bits i : Nat) (hi : i < bits) :
    FormalRV.Shor.GidneyInPlace.Capstone.E2RunwaySynthSwap.regIdx (prepReg bits) i = bits - 1 - i

theorem funbool_eq_regVal (bits : Nat) (f : Nat → Bool) :
    FormalRV.Shor.GidneyInPlace.Capstone.E2RunwaySynthSwap.regVal (prepReg bits) f
      = FormalRV.Framework.funbool_to_nat bits f

theorem fbn_zero_of_clean (n : Nat) (g : Nat → Bool) (h : ∀ i, i < n → g i = false) :
    FormalRV.Framework.funbool_to_nat n g = 0

theorem prepDim_eq (cm rest : Nat) : prepDim cm rest = (cm + rest) + (cm + rest)

theorem funbool_of_clean_reg (cm rest : Nat) (h : Nat → Bool)
    (hclean : ∀ a ∈ prepAnc (cm + rest), h a = false) :
    FormalRV.Framework.funbool_to_nat (prepDim cm rest) h
      = FormalRV.Shor.GidneyInPlace.Capstone.E2RunwaySynthSwap.regVal (prepReg (cm + rest)) h
        * 2 ^ (cm + rest)

abbrev prepScale (cm rest : Nat) : Nat

theorem perm_cast_apply {a b : Nat} (hh : a = b) (τ : Equiv.Perm (Fin (2 ^ a)))
    (v : Nat) (hb : v < 2 ^ b) (ha : v < 2 ^ a) :
    ((hh ▸ τ) ⟨v, hb⟩ : Fin (2 ^ b)).val = (τ ⟨v, ha⟩).val

theorem extendBool_clean_of_hwin (cm rest x : Nat) (φ : Fin (prepDim cm rest) → Bool)
    (hval : FormalRV.Framework.funbool_to_nat (prepDim cm rest) (extendBool (prepDim cm rest) φ)
      = x * 2 ^ (cm + 2 * rest)) :
    ∀ a ∈ prepAnc (cm + rest), extendBool (prepDim cm rest) φ a = false

theorem prepGate_bridge (cm rest N k : Nat) (_hcm : 0 < cm) (hbits : 0 < cm + rest)
    (hN : 0 < N) (hk : k < N) (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) :
    Set.BijOn
      (gateToPerm (prepGate cm rest N k hN hk hbudget) (prepDim cm rest)
        (cosetStatePrep_permGate_wellTyped cm rest N k hbits hN hk hbudget))
      (hWindow (cm + 2 * rest) cm)
      (cWindow (cm + 2 * rest) cm (N * prepScale cm rest) (k * prepScale cm rest))

theorem uc_eval_cosetStatePrep_of_bridge (cm rest N k : Nat) (hcm : 0 < cm) (hbits : 0 < cm + rest)
    (hN : 0 < N) (hk : k < N) (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest))
    (hbridge : Set.BijOn
      (gateToPerm (prepGate cm rest N k hN hk hbudget) (prepDim cm rest)
        (cosetStatePrep_permGate_wellTyped cm rest N k hbits hN hk hbudget))
      (hWindow (cm + 2 * rest) cm)
      (cWindow (cm + 2 * rest) cm (N * prepScale cm rest) (k * prepScale cm rest))) :
    FormalRV.Framework.uc_eval (cosetStatePrep cm rest N k hN hk hbudget)
        * basis0 (prepDim cm rest)
      = cosetState (2 ^ prepDim cm rest) (N * prepScale cm rest) cm (k * prepScale cm rest)

theorem uc_eval_cosetStatePrep (cm rest N k : Nat) (hcm : 0 < cm) (hbits : 0 < cm + rest)
    (hN : 0 < N) (hk : k < N) (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) :
    FormalRV.Framework.uc_eval (cosetStatePrep cm rest N k hN hk hbudget)
        * basis0 (prepDim cm rest)
      = cosetState (2 ^ prepDim cm rest) (N * prepScale cm rest) cm (k * prepScale cm rest)

theorem map_qubits_npar_H_dim_irrel (g : Nat → Nat) (n : Nat) (d1 d2 d' : Nat) :
    (map_qubits g (npar_H n : Framework.BaseUCom d1) : Framework.BaseUCom d')
      = (map_qubits g (npar_H n : Framework.BaseUCom d2) : Framework.BaseUCom d')

theorem interior_npar_H_at (off cm hi D : Nat) (hcm : 0 < cm) (hD : D = off + (cm + hi))
    (lo : Matrix (Fin (2 ^ off)) (Fin 1) ℂ) (hiv : Matrix (Fin (2 ^ hi)) (Fin 1) ℂ) :
    Framework.uc_eval
        (map_qubits (fun q => off + q) (npar_H cm : Framework.BaseUCom cm)
          : Framework.BaseUCom D)
        * ((hD.symm ▸ kron_vec lo (kron_vec (FormalRV.Framework.kron_zeros cm) hiv)
            : Matrix (Fin (2 ^ D)) (Fin 1) ℂ))
      = ((hD.symm ▸ (kron_vec lo
          (((1 : ℂ) / Real.sqrt (2 ^ cm : ℝ)) •
            ∑ x : Fin (2 ^ cm),
            kron_vec (FormalRV.Framework.basis_vector (2 ^ cm) x.val) hiv))
          : Matrix (Fin (2 ^ D)) (Fin 1) ℂ))

theorem hStep (off cm hi D lov hiv : Nat) (hcm : 0 < cm) (hD : D = off + (cm + hi))
    (hlov : lov < 2 ^ off) (hhiv : hiv < 2 ^ hi) :
    Framework.uc_eval
        (map_qubits (fun q => off + q) (npar_H cm : Framework.BaseUCom cm)
          : Framework.BaseUCom D)
        * FormalRV.Framework.basis_vector (2 ^ D) (lov * 2 ^ (cm + hi) + hiv)
      = ((1 : ℂ) / Real.sqrt (2 ^ cm : ℝ)) •
          ∑ x : Fin (2 ^ cm),
            FormalRV.Framework.basis_vector (2 ^ D) (lov * 2 ^ (cm + hi) + x.val * 2 ^ hi + hiv)

theorem xStep (D d : Nat) (hD : D = 1 + d) :
    Framework.uc_eval (Framework.UCom.app1 U_X 0 : Framework.BaseUCom D) * basis0 D
      = FormalRV.Framework.basis_vector (2 ^ D) (1 * 2 ^ d + 0)

private theorem tb_low (a b p i : Nat) (hi : i < p) :
    (a + b * 2 ^ p).testBit i = a.testBit i

private theorem tb_high (a b p i : Nat) (ha : a < 2 ^ p) (hi : p ≤ i) :
    (a + b * 2 ^ p).testBit i = b.testBit (i - p)

private noncomputable def gab (w rest cm xa xb : Nat) : Nat → Bool

private theorem Kab_eq_funbool (w rest cm xa xb : Nat) (hxa : xa < 2 ^ cm) (hxb : xb < 2 ^ cm) :
    2 ^ (cosetDim w (cm + rest) - 1) + xa * 2 ^ (1 + 2 * cm + 2 * rest) + xb * 2 ^ (1 + cm + rest)
      = FormalRV.Framework.funbool_to_nat (cosetDim w (cm + rest)) (gab w rest cm xa xb)

private theorem gab_scratchClean (w rest cm xa xb : Nat) :
    scratchClean w (cm + rest) (gab w rest cm xa xb)

private theorem decodeReg_mod (idxf : Nat → Nat) (cm rest : Nat) (g : Nat → Bool) :
    decodeReg idxf (cm + rest) g % 2 ^ rest = decodeReg idxf rest g

private theorem lowrest_zero_iff (idxf : Nat → Nat) (cm rest : Nat) (g : Nat → Bool) :
    decodeReg idxf (cm + rest) g % 2 ^ rest = 0 ↔ ∀ i, i < rest → g (idxf i) = false

private theorem mem_winA_iff_mod (cm rest v : Nat) (hv : v < 2 ^ (cm + rest)) :
    (⟨v, hv⟩ : Fin (2 ^ (cm + rest))) ∈ winA rest cm (2 ^ rest) 0 ↔ v % 2 ^ rest = 0

private noncomputable def Xwin (cd base cm : Nat) (f : Fin cd → Bool) : Nat

private theorem Xwin_lt (cd base cm : Nat) (f : Fin cd → Bool) : Xwin cd base cm f < 2 ^ cm

private theorem gab_aWin_eq (w rest cm : Nat) (f : Fin (cosetDim w (cm + rest)) → Bool)
    (k : Nat) (hk : k < cm) :
    gab w rest cm (Xwin (cosetDim w (cm + rest)) (1 + 2 * w + rest) cm f)
        (Xwin (cosetDim w (cm + rest)) (1 + 2 * w + cm + 2 * rest) cm f) (1 + 2 * w + rest + k)
      = extendBool (cosetDim w (cm + rest)) f (1 + 2 * w + rest + k)

private theorem gab_bWin_eq (w rest cm : Nat) (f : Fin (cosetDim w (cm + rest)) → Bool)
    (k : Nat) (hk : k < cm) :
    gab w rest cm (Xwin (cosetDim w (cm + rest)) (1 + 2 * w + rest) cm f)
        (Xwin (cosetDim w (cm + rest)) (1 + 2 * w + cm + 2 * rest) cm f) (1 + 2 * w + cm + 2 * rest + k)
      = extendBool (cosetDim w (cm + rest)) f (1 + 2 * w + cm + 2 * rest + k)

private theorem Xwin_testBit (cd base cm : Nat) (f : Fin cd → Bool) (k : Nat) (hk : k < cm) :
    (Xwin cd base cm f).testBit k = extendBool cd f (base + (cm - 1 - k))

private theorem agree_iff (w rest cm : Nat)
    (f : Fin (cosetDim w (cm + rest)) → Bool) (xa xb : Nat) (hxa : xa < 2 ^ cm) (hxb : xb < 2 ^ cm) :
    (∀ p, p < cosetDim w (cm + rest) → extendBool (cosetDim w (cm + rest)) f p = gab w rest cm xa xb p)
      ↔ (xa = Xwin (cosetDim w (cm + rest)) (1 + 2 * w + rest) cm f
          ∧ xb = Xwin (cosetDim w (cm + rest)) (1 + 2 * w + cm + 2 * rest) cm f
          ∧ scratchClean w (cm + rest) (extendBool (cosetDim w (cm + rest)) f)
          ∧ decodeReg (fun i => aBase w + i) (cm + rest) (extendBool (cosetDim w (cm + rest)) f) % 2 ^ rest = 0
          ∧ decodeReg (fun i => bBase w (cm + rest) + i) (cm + rest)
              (extendBool (cosetDim w (cm + rest)) f) % 2 ^ rest = 0)

private theorem collapse_abs (cm : Nat) (c : ℂ) (Xa Xb : Nat) (hXa : Xa < 2 ^ cm)
    (hXb : Xb < 2 ^ cm) (G : Prop) [Decidable G] :
    c * ∑ xa : Fin (2 ^ cm), c * ∑ xb : Fin (2 ^ cm),
        (if (xa.val = Xa ∧ xb.val = Xb ∧ G) then (1 : ℂ) else 0)
      = (if G then c * c else 0)

theorem runwayDataH_spec (w rest cm : Nat) (hcm : 0 < cm) :
    Framework.uc_eval (runwayDataH w rest cm) * basis0 (cosetDim w (cm + rest))
      = RunwayPrepFull.doublyHWindowSource w rest cm

theorem uc_eval_E2runwayInitPrep (m w rest cm N : Nat) (hm : 0 < m) (hN : 0 < N) (h1N : 1 < N)
    (hcm : 0 < cm) (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) :
    FormalRV.SQIRPort.QState.cast (RunwayPrepClose.kronDim_eq m w (cm + rest))
        (Framework.uc_eval
            (RunwayPrepFull.E2runwayInitPrep m w rest cm N hN h1N hbudget
              (runwayDataH w rest cm))
          * basis0 (m + cosetDim w (cm + rest)))
      = E2runwayInit m w (cm + rest) N cm

def bReg (w bits : Nat) : List Nat

theorem bReg_length (w bits : Nat) : (bReg w bits).length = bits

theorem bReg_getElem (w bits : Nat) (i : Nat) (hi : i < (bReg w bits).length) :
    (bReg w bits)[i] = bBase w bits + i

theorem regIdx_bReg (w bits : Nat) (i : Nat) (hi : i < bits) :
    FormalRV.Shor.GidneyInPlace.Capstone.E2RunwaySynthSwap.regIdx (bReg w bits) i
      = bBase w bits + i

theorem bReg_nodup (w bits : Nat) : (bReg w bits).Nodup

theorem mem_bReg (w bits p : Nat) : p ∈ bReg w bits ↔ ∃ i, i < bits ∧ bBase w bits + i = p

theorem runAnc_disj_bReg (w bits : Nat) : ∀ a ∈ runAnc w bits, a ∉ bReg w bits

theorem bReg_lt_cosetDim (w bits : Nat) : ∀ a ∈ bReg w bits, a < cosetDim w bits

theorem not_mem_bReg_of_off (w bits p : Nat)
    (hoff : ¬ (bBase w bits ≤ p ∧ p < bBase w bits + bits)) : p ∉ bReg w bits

theorem regVal_bReg_eq (w bits : Nat) (g : Nat → Bool) :
    regVal (bReg w bits) g = decodeReg (fun i => bBase w bits + i) bits g

noncomputable def cosetPrepSubGateB (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) : Gate

theorem cosetPrepSubB_permOnVal (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (vb : Nat) (hvb : vb < 2 ^ (cm + rest)) :
    permOnVal (bReg w (cm + rest))
        ((bReg_length w (cm + rest)).symm ▸ σ_k rest cm N k hN hk hbudget) vb
      = (σ_k rest cm N k hN hk hbudget ⟨vb, hvb⟩).val

theorem cosetPrepSubGateB_RegAct (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) :
    RegAct (cosetPrepSubGateB w rest cm N k hN hk hbudget) (bReg w (cm + rest)) (runAnc w (cm + rest))
      (permOnVal (bReg w (cm + rest))
        ((bReg_length w (cm + rest)).symm ▸ σ_k rest cm N k hN hk hbudget))

theorem cosetPrepSubGateB_wellTyped (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) :
    Gate.WellTyped (cosetDim w (cm + rest)) (cosetPrepSubGateB w rest cm N k hN hk hbudget)

theorem runAnc_clean_of_scratchClean' (w rest cm : Nat) (g : Nat → Bool)
    (hcl : scratchClean w (cm + rest) g) : ∀ a ∈ runAnc w (cm + rest), g a = false

theorem bDecode_cosetPrepSubB (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (g : Nat → Bool)
    (hcl : scratchClean w (cm + rest) g) :
    decodeReg (fun i => bBase w (cm + rest) + i) (cm + rest)
        (Gate.applyNat (cosetPrepSubGateB w rest cm N k hN hk hbudget) g)
      = (σ_k rest cm N k hN hk hbudget
          ⟨decodeReg (fun i => bBase w (cm + rest) + i) (cm + rest) g,
            decodeReg_lt_two_pow _ _ _⟩).val

theorem cosetPrepSubB_frame_off_bReg (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (g : Nat → Bool)
    (hcl : scratchClean w (cm + rest) g) (p : Nat) (hp : p ∉ bReg w (cm + rest)) :
    Gate.applyNat (cosetPrepSubGateB w rest cm N k hN hk hbudget) g p = g p

theorem aDecode_cosetPrepSubB (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (g : Nat → Bool)
    (hcl : scratchClean w (cm + rest) g) :
    decodeReg (fun i => aBase w + i) (cm + rest)
        (Gate.applyNat (cosetPrepSubGateB w rest cm N k hN hk hbudget) g)
      = decodeReg (fun i => aBase w + i) (cm + rest) g

theorem scratchClean_cosetPrepSubB (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (g : Nat → Bool)
    (hcl : scratchClean w (cm + rest) g) :
    scratchClean w (cm + rest)
      (Gate.applyNat (cosetPrepSubGateB w rest cm N k hN hk hbudget) g)

theorem cosetPrepSubB_permOnVal_inv (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (v : Nat) (hv : v < 2 ^ (cm + rest)) :
    permOnVal (bReg w (cm + rest))
        ((bReg_length w (cm + rest)).symm ▸ σ_k rest cm N k hN hk hbudget)
        (permOnVal (bReg w (cm + rest))
          ((bReg_length w (cm + rest)).symm ▸ (σ_k rest cm N k hN hk hbudget).symm) v)
      = v

theorem reverse_cosetPrepSubB_frame_off_bReg (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (g : Nat → Bool)
    (hcl : scratchClean w (cm + rest) g) (p : Nat) (hp : p ∉ bReg w (cm + rest)) :
    Gate.applyNat (GateReversible.Gate.reverse (cosetPrepSubGateB w rest cm N k hN hk hbudget)) g p
      = g p

theorem scratchClean_of_cosetPrepSubB (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (g : Nat → Bool)
    (hcl' : scratchClean w (cm + rest)
      (Gate.applyNat (cosetPrepSubGateB w rest cm N k hN hk hbudget) g)) :
    scratchClean w (cm + rest) g

theorem scratchClean_cosetPrepSubB_iff (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (g : Nat → Bool) :
    scratchClean w (cm + rest) (Gate.applyNat (cosetPrepSubGateB w rest cm N k hN hk hbudget) g)
      ↔ scratchClean w (cm + rest) g

theorem cosetPrepSubB_permState_key (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (Wa : Finset (Fin (2 ^ (cm + rest)))) :
    permState (gateToPerm (cosetPrepSubGateB w rest cm N k hN hk hbudget) (cosetDim w (cm + rest))
        (cosetPrepSubGateB_wellTyped w rest cm N k hN hk hbudget))
        (genTwoReg w (cm + rest) cm Wa (winA rest cm N k))
      = genTwoReg w (cm + rest) cm Wa (winA rest cm (2 ^ rest) 0)

theorem cosetPrepSubGateB_column_identity (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (Wa : Finset (Fin (2 ^ (cm + rest)))) :
    Framework.uc_eval (Gate.toUCom (cosetDim w (cm + rest))
        (cosetPrepSubGateB w rest cm N k hN hk hbudget))
        * genTwoReg w (cm + rest) cm Wa (winA rest cm (2 ^ rest) 0)
      = genTwoReg w (cm + rest) cm Wa (winA rest cm N k)

noncomputable def cosetDataPrepGate (w rest cm N : Nat) (hN : 0 < N) (h1N : 1 < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) : Gate

theorem cosetDataPrepGate_to_cosetInputVec (w rest cm N : Nat) (hN : 0 < N) (h1N : 1 < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) :
    Framework.uc_eval (Gate.toUCom (cosetDim w (cm + rest))
        (cosetDataPrepGate w rest cm N hN h1N hbudget))
        * genTwoReg w (cm + rest) cm (winA rest cm (2 ^ rest) 0) (winA rest cm (2 ^ rest) 0)
      = FormalRV.Shor.GidneyInPlace.InPlaceNormBound.cosetInputVec w (cm + rest) N cm 1 0

noncomputable def doublyHWindowSource (w rest cm : Nat) :
    Matrix (Fin (2 ^ cosetDim w (cm + rest))) (Fin 1) ℂ

noncomputable def dataPrepLeg (w rest cm N : Nat) (hN : 0 < N) (h1N : 1 < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest))
    (dataH : Framework.BaseUCom (cosetDim w (cm + rest))) :
    Framework.BaseUCom (cosetDim w (cm + rest))

theorem dataPrepLeg_to_cosetInputVec (w rest cm N : Nat) (hN : 0 < N) (h1N : 1 < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest))
    (dataH : Framework.BaseUCom (cosetDim w (cm + rest)))
    (hInteriorH : Framework.uc_eval dataH * basis0 (cosetDim w (cm + rest))
      = doublyHWindowSource w rest cm) :
    Framework.uc_eval (dataPrepLeg w rest cm N hN h1N hbudget dataH)
        * basis0 (cosetDim w (cm + rest))
      = FormalRV.Shor.GidneyInPlace.InPlaceNormBound.cosetInputVec w (cm + rest) N cm 1 0

noncomputable def E2runwayInitPrep (m w rest cm N : Nat) (hN : 0 < N) (h1N : 1 < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest))
    (dataH : Framework.BaseUCom (cosetDim w (cm + rest))) :
    Framework.BaseUCom (m + cosetDim w (cm + rest))

theorem basis0_split_m (m D : Nat) :
    basis0 (m + D) = kron_vec (FormalRV.Framework.kron_zeros m) (basis0 D)

theorem uc_eval_E2runwayInitPrep_of_interiorH (m w rest cm N : Nat) (hm : 0 < m)
    (hN : 0 < N) (h1N : 1 < N) (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest))
    (dataH : Framework.BaseUCom (cosetDim w (cm + rest)))
    (hdataH_wt : UCom.WellTyped (cosetDim w (cm + rest)) dataH)
    (hInteriorH : Framework.uc_eval dataH * basis0 (cosetDim w (cm + rest))
      = doublyHWindowSource w rest cm) :
    Framework.uc_eval (E2runwayInitPrep m w rest cm N hN h1N hbudget dataH)
        * basis0 (m + cosetDim w (cm + rest))
      = kron_vec
          (((1 : ℂ) / Real.sqrt (2 ^ m : ℝ)) •
            ∑ x : Fin (2 ^ m), FormalRV.Framework.basis_vector (2 ^ m) x.val)
          (FormalRV.Shor.GidneyInPlace.InPlaceNormBound.cosetInputVec w (cm + rest) N cm 1 0)

noncomputable def genTwoReg (w bits cm : Nat) (Wa Wb : Finset (Fin (2 ^ bits))) :
    Matrix (Fin (2 ^ cosetDim w bits)) (Fin 1) ℂ

theorem genTwoReg_eq_cosetInputTwoReg (w bits N cm xa xb : Nat) :
    genTwoReg w bits cm (cosetWindow (2 ^ bits) N cm xa) (cosetWindow (2 ^ bits) N cm xb)
      = cosetInputTwoReg w bits N cm xa xb

theorem genTwoReg_funboolNat (w bits cm : Nat) (Wa Wb : Finset (Fin (2 ^ bits)))
    (f : Fin (cosetDim w bits) → Bool) :
    genTwoReg w bits cm Wa Wb (funboolNat (cosetDim w bits) f) 0
      = if scratchClean w bits (extendBool (cosetDim w bits) f) then
          (if (⟨decodeReg (fun i => aBase w + i) bits (extendBool (cosetDim w bits) f),
                decodeReg_lt_two_pow _ _ _⟩ : Fin (2 ^ bits)) ∈ Wa
            then ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) else 0)
          * (if (⟨decodeReg (fun i => bBase w bits + i) bits (extendBool (cosetDim w bits) f),
                  decodeReg_lt_two_pow _ _ _⟩ : Fin (2 ^ bits)) ∈ Wb
              then ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) else 0)
        else 0

noncomputable def cosetPrepSubGate (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) : Gate

theorem cosetPrepSub_permOnVal (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (va : Nat) (hva : va < 2 ^ (cm + rest)) :
    permOnVal (aReg w (cm + rest))
        ((aReg_length w (cm + rest)).symm ▸ σ_k rest cm N k hN hk hbudget) va
      = (σ_k rest cm N k hN hk hbudget ⟨va, hva⟩).val

theorem cosetPrepSubGate_RegAct (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) :
    RegAct (cosetPrepSubGate w rest cm N k hN hk hbudget) (aReg w (cm + rest)) (runAnc w (cm + rest))
      (permOnVal (aReg w (cm + rest))
        ((aReg_length w (cm + rest)).symm ▸ σ_k rest cm N k hN hk hbudget))

theorem cosetPrepSubGate_wellTyped (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) :
    Gate.WellTyped (cosetDim w (cm + rest)) (cosetPrepSubGate w rest cm N k hN hk hbudget)

theorem σ_k_window_iff (rest cm N k va : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (hva : va < 2 ^ (cm + rest)) :
    (⟨va, hva⟩ : Fin (2 ^ (cm + rest))) ∈ cosetWindow (2 ^ (cm + rest)) (2 ^ rest) cm 0
      ↔ (σ_k rest cm N k hN hk hbudget ⟨va, hva⟩)
          ∈ cosetWindow (2 ^ (cm + rest)) N cm k

abbrev winA (rest cm M r : Nat) : Finset (Fin (2 ^ (cm + rest)))

theorem runAnc_clean_of_scratchClean' (w rest cm : Nat) (g : Nat → Bool)
    (hcl : scratchClean w (cm + rest) g) : ∀ a ∈ runAnc w (cm + rest), g a = false

theorem aDecode_cosetPrepSub (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (g : Nat → Bool)
    (hcl : scratchClean w (cm + rest) g) :
    decodeReg (fun i => aBase w + i) (cm + rest)
        (Gate.applyNat (cosetPrepSubGate w rest cm N k hN hk hbudget) g)
      = (σ_k rest cm N k hN hk hbudget
          ⟨decodeReg (fun i => aBase w + i) (cm + rest) g, decodeReg_lt_two_pow _ _ _⟩).val

theorem cosetPrepSub_frame_off_aReg (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (g : Nat → Bool)
    (hcl : scratchClean w (cm + rest) g) (p : Nat) (hp : p ∉ aReg w (cm + rest)) :
    Gate.applyNat (cosetPrepSubGate w rest cm N k hN hk hbudget) g p = g p

theorem bDecode_cosetPrepSub (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (g : Nat → Bool)
    (hcl : scratchClean w (cm + rest) g) :
    decodeReg (fun i => bBase w (cm + rest) + i) (cm + rest)
        (Gate.applyNat (cosetPrepSubGate w rest cm N k hN hk hbudget) g)
      = decodeReg (fun i => bBase w (cm + rest) + i) (cm + rest) g

theorem scratchClean_cosetPrepSub (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (g : Nat → Bool)
    (hcl : scratchClean w (cm + rest) g) :
    scratchClean w (cm + rest) (Gate.applyNat (cosetPrepSubGate w rest cm N k hN hk hbudget) g)

theorem cosetPrepSub_permOnVal_inv (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (v : Nat) (hv : v < 2 ^ (cm + rest)) :
    permOnVal (aReg w (cm + rest))
        ((aReg_length w (cm + rest)).symm ▸ σ_k rest cm N k hN hk hbudget)
        (permOnVal (aReg w (cm + rest))
          ((aReg_length w (cm + rest)).symm ▸ (σ_k rest cm N k hN hk hbudget).symm) v)
      = v

theorem reverse_cosetPrepSub_frame_off_aReg (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (g : Nat → Bool)
    (hcl : scratchClean w (cm + rest) g) (p : Nat) (hp : p ∉ aReg w (cm + rest)) :
    Gate.applyNat (GateReversible.Gate.reverse (cosetPrepSubGate w rest cm N k hN hk hbudget)) g p
      = g p

theorem scratchClean_of_cosetPrepSub (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (g : Nat → Bool)
    (hcl' : scratchClean w (cm + rest)
      (Gate.applyNat (cosetPrepSubGate w rest cm N k hN hk hbudget) g)) :
    scratchClean w (cm + rest) g

theorem scratchClean_cosetPrepSub_iff (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (g : Nat → Bool) :
    scratchClean w (cm + rest) (Gate.applyNat (cosetPrepSubGate w rest cm N k hN hk hbudget) g)
      ↔ scratchClean w (cm + rest) g

theorem cosetPrepSub_permState_key (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (Wb : Finset (Fin (2 ^ (cm + rest)))) :
    permState (gateToPerm (cosetPrepSubGate w rest cm N k hN hk hbudget) (cosetDim w (cm + rest))
        (cosetPrepSubGate_wellTyped w rest cm N k hN hk hbudget))
        (genTwoReg w (cm + rest) cm (winA rest cm N k) Wb)
      = genTwoReg w (cm + rest) cm (winA rest cm (2 ^ rest) 0) Wb

theorem cosetPrepSubGate_column_identity (w rest cm N k : Nat) (hN : 0 < N) (hk : k < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) (Wb : Finset (Fin (2 ^ (cm + rest)))) :
    Framework.uc_eval (Gate.toUCom (cosetDim w (cm + rest))
        (cosetPrepSubGate w rest cm N k hN hk hbudget))
        * genTwoReg w (cm + rest) cm (winA rest cm (2 ^ rest) 0) Wb
      = genTwoReg w (cm + rest) cm (winA rest cm N k) Wb

theorem genTwoReg_eq_cosetInputVec (w bits N cm xa xb : Nat) :
    genTwoReg w bits cm (cosetWindow (2 ^ bits) N cm xa) (cosetWindow (2 ^ bits) N cm xb)
      = FormalRV.Shor.GidneyInPlace.InPlaceNormBound.cosetInputVec w bits N cm xa xb

theorem cosetPrepSubGate_to_cosetInputVec (w rest cm N : Nat) (hN : 0 < N) (h1N : 1 < N)
    (hbudget : 2 ^ cm * N ≤ 2 ^ (cm + rest)) :
    Framework.uc_eval (Gate.toUCom (cosetDim w (cm + rest))
        (cosetPrepSubGate w rest cm N 1 hN h1N hbudget))
        * genTwoReg w (cm + rest) cm (winA rest cm (2 ^ rest) 0)
            (cosetWindow (2 ^ (cm + rest)) N cm 0)
      = FormalRV.Shor.GidneyInPlace.InPlaceNormBound.cosetInputVec w (cm + rest) N cm 1 0

theorem pmDist_le_of_agree_off {dim : Nat} (s₁ s₂ : QState dim)
    (B : Finset (Fin dim)) (W : ℝ)
    (hagree : ∀ i, i ∉ B → s₁ i 0 = s₂ i 0)
    (hw₁ : bornWeightOn s₁ B ≤ W) (hw₂ : bornWeightOn s₂ B ≤ W) :
    pmDist s₁ s₂ ≤ Real.sqrt (4 * W)

theorem gidneyInPlaceWithSwap_coset_pmDist_deviation
    (w bits numWin N cm k kInv x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfit : (k * x) % N + (2 ^ cm - 1) * N < 2 ^ bits)
    (hxfit : x + (2 ^ cm - 1) * N < 2 ^ bits) :
    pmDist
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
            (gidneyInPlaceWithSwap w bits TfamK TfamKinv numWin))
          * cosetInputVec w bits N cm x 0)

noncomputable def toEuc {d : Nat} (φ : QState d) : EuclideanSpace ℂ (Fin d)

lemma pmDist_eq_dist {d : Nat} (a b : QState d) :
    pmDist a b = dist (toEuc a) (toEuc b)

theorem pmDist_triangle {d : Nat} (a b c : QState d) :
    pmDist a c ≤ pmDist a b + pmDist b c

theorem pmDist_matrix_unitary_invariant {d : Nat} (M : Matrix (Fin d) (Fin d) ℂ)
    (hU : M.conjTranspose * M = 1) (v w : Matrix (Fin d) (Fin 1) ℂ) :
    pmDist (M * v) (M * w) = pmDist v w

theorem pmDist_cast {a b : Nat} (h : a = b) (φ ψ : QState a) :
    pmDist (QState.cast h φ) (QState.cast h ψ) = pmDist φ ψ

theorem pmDist_orbit_telescope {full_dim : Nat}
    (Fa Fi : Nat → QState full_dim → QState full_dim)
    (init : QState full_dim)
    (δ : Nat → ℝ)
    (hisom : ∀ (k : Nat) (a b : QState full_dim), pmDist (Fa k a) (Fa k b) = pmDist a b)
    (hlocal : ∀ (k : Nat),
        pmDist (Fa k (orbitState Fi init k)) (orbitState Fi init (k + 1)) ≤ δ k) :
    ∀ numIter,
      pmDist (orbitState Fa init numIter) (orbitState Fi init numIter)
        ≤ ∑ k ∈ Finset.range numIter, δ k

theorem qpeStageMap_pmDist_isom (m n anc : Nat)
    (f : Nat → FormalRV.Framework.BaseUCom (n + anc)) (k : Nat)
    (hU : (FormalRV.Framework.uc_eval
              (FormalRV.Shor.GidneyInPlace.QPEStageDecomp.qpeStageUCom m n anc f k)).conjTranspose
            * FormalRV.Framework.uc_eval
              (FormalRV.Shor.GidneyInPlace.QPEStageDecomp.qpeStageUCom m n anc f k) = 1)
    (a b : QState (2 ^ m * 2 ^ n * 2 ^ anc)) :
    pmDist (FormalRV.Shor.GidneyInPlace.QPEStageDecomp.qpeStageMap m n anc f k a)
        (FormalRV.Shor.GidneyInPlace.QPEStageDecomp.qpeStageMap m n anc f k b)
      = pmDist a b

theorem sum_workDim_normSq_sub_eq_pmDist_sq (m w bits : Nat)
    (g h : Matrix (Fin (2 ^ cosetDim w bits)) (Fin 1) ℂ) :
    (∑ y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
        Complex.normSq (g (Fin.cast (E2shor_dim_eq m w bits) y) 0
                        - h (Fin.cast (E2shor_dim_eq m w bits) y) 0))
      = (pmDist g h) ^ 2

private noncomputable def Lbudget (numWin cm : Nat) : ℝ

private theorem Lbudget_nonneg (numWin cm : Nat) : 0 ≤ Lbudget numWin cm

private theorem active_branch_local_le
    (m w bits numWin N cm k kInv : Nat) (hk : k < m)
    (TfamK TfamKinv : Nat → Nat → Nat)
    (f_runwayPhysical f_runwayIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwtP : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayPhysical j))
    (hwtI : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (mult : Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue (mult k) N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N)
    (hkkinv : (kInv * mult k) % N = 1 % N)
    (Φ : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)))

theorem qpeStage_E2_local_pmDist_deviation
    (m w bits numWin N cm k kInv : Nat) (hk : k < m)
    (TfamK TfamKinv : Nat → Nat → Nat)
    (f_runwayPhysical f_runwayIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwtP : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayPhysical j))
    (hwtI : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (mult : Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue (mult k) N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N)
    (hkkinv : (kInv * mult k) % N = 1 % N)
    (hfit : ∀ z : Nat, z < N → (mult k * z) % N + (2 ^ cm - 1) * N < 2 ^ bits)

theorem qpeStageMap_eq_of_ge (m n anc : Nat)
    (f g : Nat → FormalRV.Framework.BaseUCom (n + anc)) (k : Nat) (hk : m ≤ k) :
    qpeStageMap m n anc f k = qpeStageMap m n anc g k

theorem pmDist_orbit_telescope_qftinv {full_dim : Nat} (m : Nat)
    (Fa Fi : Nat → QState full_dim → QState full_dim)
    (init : QState full_dim) (L : ℝ)
    (hisom : ∀ (k : Nat) (a b : QState full_dim), pmDist (Fa k a) (Fa k b) = pmDist a b)
    (hstep : ∀ (k : Nat), k < m →
        pmDist (Fa k (orbitState Fi init k)) (orbitState Fi init (k + 1)) ≤ L)
    (hqftinv : ∀ (k : Nat), m ≤ k → Fa k = Fi k) :
    pmDist (orbitState Fa init (m + 1)) (orbitState Fi init (m + 1)) ≤ (m : ℝ) * L

theorem orbit_E2_pmDist_deviation
    (m w bits numWin N cm : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat → Nat) (mult kInv : Nat → Nat)
    (f_runwayPhysical f_runwayIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwtP : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayPhysical j))
    (hwtI : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hTfamK : ∀ k j addr, TfamK k j addr = tableValue (mult k) N w j addr)
    (hTfamKinv : ∀ k j addr, TfamKinv k j addr = tableValue (kInv k) N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hN1 : 1 < N)
    (hkkinv : ∀ k, (kInv k * mult k) % N = 1 % N)
    (hfit : ∀ (k z : Nat), z < N → (mult k * z) % N + (2 ^ cm - 1) * N < 2 ^ bits)
    (hxfit : ∀ (z : Nat), z < N → z + (2 ^ cm - 1) * N < 2 ^ bits)

noncomputable def E2residueMat (m w bits N cm : Nat)
    (a b : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) : ℂ

noncomputable def E2residueEmbedZ (m w bits N cm : Nat)
    (phi : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits))) :
    QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits))

theorem E2residueEmbedZ_acts (m w bits N cm : Nat)
    (phi : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)))
    (x : Fin (2 ^ m)) (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) :
    E2residueEmbedZ m w bits N cm phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x y) 0
      = ∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
          E2residueMat m w bits N cm y yp
            * phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x yp) 0

theorem E2residueEmbedZ_acts_mat (m w bits N cm : Nat)
    (phi : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)))
    (x : Fin (2 ^ m)) (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) :
    E2residueEmbedZ m w bits N cm phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x y) 0
      = ∑ yp, E2residueMat m w bits N cm y yp
          * phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x yp) 0

theorem E2residueEmbedZ_qpeInit (m w bits N cm : Nat)
    (hm : 0 < m) (hbits : 0 < bits) (hN1 : 1 < N) :
    E2residueEmbedZ m w bits N cm (qpeInit m bits (cosetAnc w bits))
      = E2runwayInit m w bits N cm

noncomputable def E2residueData (m w bits N cm : Nat)
    (ψ : Matrix (Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) (Fin 1) ℂ) :
    Matrix (Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) (Fin 1) ℂ

private theorem normSq_sum_canon_pairwise {ι : Type*} [DecidableEq ι]
    (s : Finset ι) (f : ι → ℂ)
    (hpair : ∀ a ∈ s, ∀ b ∈ s, a ≠ b → f a = 0 ∨ f b = 0) :
    Complex.normSq (∑ i ∈ s, f i) = ∑ i ∈ s, Complex.normSq (f i)

theorem E2residueData_marginal (m w bits numWin N cm : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hN : 0 < N) (hMN : 2 ^ cm * N ≤ 2 ^ bits)
    (ψ : Matrix (Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) (Fin 1) ℂ)
    (hsupp : ∀ z : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
        ¬ (z.val % 2 ^ (cosetAnc w bits) = 0 ∧ z.val / 2 ^ (cosetAnc w bits) < N) → ψ z 0 = 0) :
    (∑ y, Complex.normSq (E2residueData m w bits N cm ψ y 0))
      = ∑ z, Complex.normSq (ψ z 0)

theorem E2residueEmbedZ_hmarg (m w bits numWin N cm : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hN : 0 < N) (hMN : 2 ^ cm * N ≤ 2 ^ bits)
    (phi : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)))
    (hsupp : ∀ (x : Fin (2 ^ m)) (b : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
        ¬ (b.val % 2 ^ (cosetAnc w bits) = 0 ∧ b.val / 2 ^ (cosetAnc w bits) < N) →
        phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x b) 0 = 0)
    (x : Fin (2 ^ m)) :
    prob_partial_meas (basis_vector (2 ^ m) x.val) (E2residueEmbedZ m w bits N cm phi)
      = prob_partial_meas (basis_vector (2 ^ m) x.val) phi

theorem E2residue_hwork_int
    (m w bits N cm kstep : Nat) (mult : Nat → Nat)
    (hN : 0 < N) (hNbits : N ≤ 2 ^ bits)
    (f_runwayIdeal f_residueIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hf_runway : ∀ (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
          (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
              workMat m bits (cosetAnc w bits) kstep f_runwayIdeal y yp
                * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)
            = cosetInputVec w bits N cm ((mult kstep * z) % N) 0
                (Fin.cast (E2shor_dim_eq m w bits) y) 0)
    (hf_residue : ∀ a b : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),

theorem E2residueEmbedZ_intertwine (m w bits N cm kstep : Nat) (hk : kstep < m) (mult : Nat → Nat)
    (hN : 0 < N) (hNbits : N ≤ 2 ^ bits)
    (f_runwayIdeal f_residueIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwt_c : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hwt_i : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_residueIdeal j))
    (hf_runway : ∀ (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
          (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
              workMat m bits (cosetAnc w bits) kstep f_runwayIdeal y yp
                * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)
            = cosetInputVec w bits N cm ((mult kstep * z) % N) 0
                (Fin.cast (E2shor_dim_eq m w bits) y) 0)

theorem qpeStage_qftinv_jointIdx (m n anc : Nat) (hm : 0 < m)
    (f : Nat → FormalRV.Framework.BaseUCom (n + anc))
    (phi : QState (2 ^ m * 2 ^ n * 2 ^ anc))
    (x : Fin (2 ^ m)) (y : Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m)) :
    qpeStageMap m n anc f m phi (jointIdx (shorDvd m n anc) x y) 0
      = ∑ x' : Fin (2 ^ m),
          FormalRV.Framework.uc_eval
              (FormalRV.SQIRPort.real_QFTinv_layer m : FormalRV.Framework.BaseUCom m) x x'
            * phi (jointIdx (shorDvd m n anc) x' y) 0

theorem E2residueEmbedZ_qftinv_comm (m w bits N cm : Nat) (hm : 0 < m)
    (f : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (phi : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)))
    (x : Fin (2 ^ m)) (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) :
    (qpeStageMap m bits (cosetAnc w bits) f m (E2residueEmbedZ m w bits N cm phi))
        (jointIdx (shorDvd m bits (cosetAnc w bits)) x y) 0
      = (E2residueEmbedZ m w bits N cm (qpeStageMap m bits (cosetAnc w bits) f m phi))
          (jointIdx (shorDvd m bits (cosetAnc w bits)) x y) 0

theorem qstate_ext_jointIdx (m bits anc : Nat)
    {Φ Ψ : QState (2 ^ m * 2 ^ bits * 2 ^ anc)}
    (h : ∀ (x : Fin (2 ^ m)) (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ anc) / 2 ^ m)),
        Φ (jointIdx (shorDvd m bits anc) x y) 0 = Ψ (jointIdx (shorDvd m bits anc) x y) 0) :
    Φ = Ψ

theorem qpeStageMap_qftinv_indep (m n anc : Nat)
    (f g : Nat → FormalRV.Framework.BaseUCom (n + anc)) :
    qpeStageMap m n anc f m = qpeStageMap m n anc g m

theorem orbit_oracle_bridge (m w bits N cm : Nat) (hm : 0 < m) (hbits : 0 < bits)
    (mult : Nat → Nat) (hN : 0 < N) (hN1 : 1 < N) (hNbits : N ≤ 2 ^ bits)
    (f_runwayIdeal f_residueIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwt_c : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hwt_i : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_residueIdeal j))
    (hf_runway : ∀ (kstep : Nat), kstep < m → ∀ (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
          (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
              workMat m bits (cosetAnc w bits) kstep f_runwayIdeal y yp
                * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)
            = cosetInputVec w bits N cm ((mult kstep * z) % N) 0
                (Fin.cast (E2shor_dim_eq m w bits) y) 0)

theorem Shor_final_state_E2coset_eq_embed (m w bits N cm : Nat)
    (hm : 0 < m) (hbits : 0 < bits)
    (mult : Nat → Nat) (hN : 0 < N) (hN1 : 1 < N) (hNbits : N ≤ 2 ^ bits)
    (f_runwayIdeal f_residueIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwt_c : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hwt_i : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_residueIdeal j))
    (hf_runway : ∀ (kstep : Nat), kstep < m → ∀ (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
          (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
              workMat m bits (cosetAnc w bits) kstep f_runwayIdeal y yp
                * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)
            = cosetInputVec w bits N cm ((mult kstep * z) % N) 0

theorem probability_of_success_E2coset_eq (a r N m w bits cm : Nat)
    (hm : 0 < m) (hbits : 0 < bits)
    (mult : Nat → Nat) (hN : 0 < N) (hN1 : 1 < N)
    (numWin : Nat) (hw : 0 < w) (hbitsWin : numWin * w = bits) (hMN : 2 ^ cm * N ≤ 2 ^ bits)
    (f_runwayIdeal f_residueIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwt_c : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hwt_i : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_residueIdeal j))
    (hf_runway : ∀ (kstep : Nat), kstep < m → ∀ (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
          (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
              workMat m bits (cosetAnc w bits) kstep f_runwayIdeal y yp
                * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)

theorem prob_success_weighted_diff_le_two_dist
    {m_dim full_dim : Nat} (h_dvd : m_dim ∣ full_dim)
    (c : Fin m_dim → ℝ) (hc0 : ∀ x, 0 ≤ c x) (hc1 : ∀ x, c x ≤ 1)
    (φ ψ : QState full_dim) (hφ : pmNorm φ ≤ 1) (hψ : pmNorm ψ ≤ 1) :
    |(∑ x : Fin m_dim, c x * prob_partial_meas (basis_vector m_dim x.val) φ)
       - (∑ x : Fin m_dim, c x * prob_partial_meas (basis_vector m_dim x.val) ψ)|
      ≤ 2 * pmDist φ ψ

theorem E2coset_prob_success_diff_le
    (a r N m w bits numWin cm : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat → Nat) (mult kInv : Nat → Nat)
    (f_runwayPhysical f_runwayIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwtP : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayPhysical j))
    (hwtI : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hTfamK : ∀ k j addr, TfamK k j addr = tableValue (mult k) N w j addr)
    (hTfamKinv : ∀ k j addr, TfamKinv k j addr = tableValue (kInv k) N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hN1 : 1 < N)
    (hMN : 2 ^ cm * N ≤ 2 ^ bits)
    (hkkinv : ∀ k, (kInv k * mult k) % N = 1 % N)
    (hisom : ∀ (k : Nat) (a b : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits))),

theorem coset_route2_success_hybrid_norm_E2
    (a r N m w bits numWin cm : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat → Nat) (mult kInv : Nat → Nat)
    (f_runwayPhysical f_runwayIdeal f_residueIdeal :
      Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hm : 0 < m) (hbitsPos : 0 < bits)
    (hwtP : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayPhysical j))
    (hwtI : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (hwtRes : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_residueIdeal j))
    (hTfamK : ∀ k j addr, TfamK k j addr = tableValue (mult k) N w j addr)
    (hTfamKinv : ∀ k j addr, TfamKinv k j addr = tableValue (kInv k) N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hN1 : 1 < N)

theorem controlled_oracle_hintertwine_generic (m n anc k : Nat) (hk : k < m)
    (f_coset f_ideal : Nat → FormalRV.Framework.BaseUCom (n + anc))
    (hwt_c : ∀ j, UCom.WellTyped (n + anc) (f_coset j))
    (hwt_i : ∀ j, UCom.WellTyped (n + anc) (f_ideal j))
    (Ephys : QState (2 ^ m * 2 ^ n * 2 ^ anc) → QState (2 ^ m * 2 ^ n * 2 ^ anc))
    (Emat : Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m) → Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m) → ℂ)
    (hEacts : ∀ (psi : QState (2 ^ m * 2 ^ n * 2 ^ anc)) (x : Fin (2 ^ m))
        (yy : Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m)),
        Ephys psi (jointIdx (shorDvd m n anc) x yy) 0
          = ∑ yp, Emat yy yp * psi (jointIdx (shorDvd m n anc) x yp) 0)
    (bad_step : Finset (Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m)))
    (hwork_int : ∀ y, y ∉ bad_step → ∀ y2 : Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m),

theorem E2shorZ_acts_mat (m w bits N cm : Nat)
    (phi : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)))
    (x : Fin (2 ^ m)) (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) :
    E2shorZ m w bits N cm phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x y) 0
      = ∑ yp, E2matZ m w bits N cm y yp
          * phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x yp) 0

theorem controlled_shifted_oracle_hintertwine_E2 (m w bits N cm kstep : Nat) (hk : kstep < m)
    (f_coset f_ideal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwt_c : ∀ j, UCom.WellTyped (bits + cosetAnc w bits) (f_coset j))
    (hwt_i : ∀ j, UCom.WellTyped (bits + cosetAnc w bits) (f_ideal j))
    (bad_step : Finset (Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)))
    (hwork_int : ∀ y, y ∉ bad_step → ∀ y2 : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
        (∑ yp, workMat m bits (cosetAnc w bits) kstep f_coset y yp * E2matZ m w bits N cm yp y2)
          = (∑ yp, E2matZ m w bits N cm y yp
                * workMat m bits (cosetAnc w bits) kstep f_ideal yp y2)) :
    ∀ (phi : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits))) (x : Fin (2 ^ m))
      (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)), y ∉ bad_step →
      (qpeStageMap m bits (cosetAnc w bits) f_coset kstep (E2shorZ m w bits N cm phi))

noncomputable def E2matZ (m w bits N cm : Nat)
    (a b : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) : ℂ

theorem E2_hwork_int
    (m w bits numWin N cm k kInv kstep : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfitAll : ∀ z, z < N → (k * z) % N + (2 ^ cm - 1) * N < 2 ^ bits)
    (hNdata : N ≤ (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)
    (f_coset f_ideal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hf_coset : ∀ a b : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
        workMat m bits (cosetAnc w bits) kstep f_coset a b
          = Framework.uc_eval (Gate.toUCom (cosetDim w bits)

noncomputable def E2shorZ (m w bits N cm : Nat)
    (phi : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits))) :
    QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits))

theorem E2shorZ_acts (m w bits N cm : Nat) (phi : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)))
    (x : Fin (2 ^ m)) (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) :
    E2shorZ m w bits N cm phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x y) 0
      = ∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
          (if yp.val < N then
              cosetInputVec w bits N cm yp.val 0 (Fin.cast (E2shor_dim_eq m w bits) y) 0
            else 0)
            * phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x yp) 0

theorem E2shorZ_eq_canon (m w bits N cm : Nat)
    (phi : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)))
    (hsupp : ∀ (x : Fin (2 ^ m)) (yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
        N ≤ yp.val → phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x yp) 0 = 0)
    (x : Fin (2 ^ m)) (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) :
    E2shorZ m w bits N cm phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x y) 0
      = E2shor m w bits N cm phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x y) 0

theorem E2shorZ_hmarg (m w bits numWin N cm : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hN : 0 < N) (hMN : 2 ^ cm * N ≤ 2 ^ bits)
    (phi : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)))
    (hsupp : ∀ (x : Fin (2 ^ m)) (yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
        N ≤ yp.val → phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x yp) 0 = 0)
    (x : Fin (2 ^ m)) :
    prob_partial_meas (basis_vector (2 ^ m) x.val) (E2shorZ m w bits N cm phi)
      = prob_partial_meas (basis_vector (2 ^ m) x.val) phi

theorem E2shor_dim_eq (m w bits : Nat) :
    (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m = 2 ^ (cosetDim w bits)

noncomputable def E2shor (m w bits N cm : Nat)
    (phi : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits))) :
    QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits))

theorem E2shor_acts (m w bits N cm : Nat) (phi : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)))
    (x : Fin (2 ^ m)) (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) :
    E2shor m w bits N cm phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x y) 0
      = ∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
          cosetInputVec w bits N cm yp.val 0 (Fin.cast (E2shor_dim_eq m w bits) y) 0
            * phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x yp) 0

theorem E2shor_hmarg (m w bits numWin N cm : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hN : 0 < N) (hMN : 2 ^ cm * N ≤ 2 ^ bits)
    (phi : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)))
    (hsupp : ∀ (x : Fin (2 ^ m)) (yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
        N ≤ yp.val → phi (jointIdx (shorDvd m bits (cosetAnc w bits)) x yp) 0 = 0)
    (x : Fin (2 ^ m)) :
    prob_partial_meas (basis_vector (2 ^ m) x.val) (E2shor m w bits N cm phi)
      = prob_partial_meas (basis_vector (2 ^ m) x.val) phi

noncomputable def E2data (w bits N cm : Nat)
    (ψ : Matrix (Fin (2 ^ cosetDim w bits)) (Fin 1) ℂ) :
    Matrix (Fin (2 ^ cosetDim w bits)) (Fin 1) ℂ

private theorem normSq_sum_canon_pairwise {ι : Type*} [DecidableEq ι]
    (s : Finset ι) (f : ι → ℂ)
    (hpair : ∀ a ∈ s, ∀ b ∈ s, a ≠ b → f a = 0 ∨ f b = 0) :
    Complex.normSq (∑ i ∈ s, f i) = ∑ i ∈ s, Complex.normSq (f i)

theorem E2data_marginal (w bits numWin N cm : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hN : 0 < N) (hMN : 2 ^ cm * N ≤ 2 ^ bits)
    (ψ : Matrix (Fin (2 ^ cosetDim w bits)) (Fin 1) ℂ)
    (hsupp : ∀ z : Fin (2 ^ cosetDim w bits), N ≤ z.val → ψ z 0 = 0) :
    (∑ y : Fin (2 ^ cosetDim w bits), Complex.normSq (E2data w bits N cm ψ y 0))
      = ∑ z : Fin (2 ^ cosetDim w bits), Complex.normSq (ψ z 0)

noncomputable def inplaceUnionBad (w bits numWin N cm k : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) : Finset (Fin (2 ^ cosetDim w bits))

theorem inplace_agree_off_union
    (w bits numWin N cm k kInv : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfitAll : ∀ z, z < N → (k * z) % N + (2 ^ cm - 1) * N < 2 ^ bits)
    (y : Fin (2 ^ cosetDim w bits))
    (hy : y ∉ inplaceUnionBad w bits numWin N cm k TfamK TfamKinv hw hbits)
    (z : Nat) (hz : z < N) :
    (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
        (gidneyInPlaceWithSwap w bits TfamK TfamKinv numWin))

theorem cosetState_support_lt_aBlock (dim N cm n z : Nat) (hN : 0 < N)
    (hfit : z + (2 ^ cm - 1) * N < 2 ^ n) (i : Fin dim)
    (h : cosetState dim N cm z i 0 ≠ 0) : (i : Nat) < 2 ^ n

theorem cosetInputVec_embed_isometry (w bits numWin N cm : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hN : 0 < N) (hMN : 2 ^ cm * N ≤ 2 ^ bits) (α : Nat → ℂ) :
    bornWeightOn
        (fun (i : Fin (2 ^ cosetDim w bits)) (_ : Fin 1) =>
          ∑ z ∈ Finset.range N, α z * cosetInputVec w bits N cm z 0 i 0) Finset.univ
      = ∑ z ∈ Finset.range N, Complex.normSq (α z)

theorem cosetInputVec_support_disjoint (w bits N cm z z' : Nat)
    (hN : 0 < N) (hz : z < N) (hz' : z' < N) (hne : z ≠ z')
    (i : Fin (2 ^ cosetDim w bits))
    (h1 : cosetInputVec w bits N cm z 0 i 0 ≠ 0)
    (h2 : cosetInputVec w bits N cm z' 0 i 0 ≠ 0) : False

theorem applyNat_frame : ∀ (g : Gate) (dim : Nat), Gate.WellTyped dim g →
    ∀ (f : Nat → Bool) (p : Nat), dim ≤ p → Gate.applyNat g f p = f p

theorem reverse_wellTyped : ∀ (g : Gate) (dim : Nat), Gate.WellTyped dim g →
    Gate.WellTyped dim (GateReversible.Gate.reverse g)

def extendBool (dim : Nat) (φ : Fin dim → Bool) : Nat → Bool

def applyFin (g : Gate) (dim : Nat) (φ : Fin dim → Bool) : Fin dim → Bool

theorem applyFin_injective (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g) :
    Function.Injective (applyFin g dim)

noncomputable def gateClassicalPerm (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g) :
    Equiv.Perm (Fin dim → Bool)

theorem funbool_to_nat_agree : ∀ (dim : Nat) (f g : Nat → Bool),
    funbool_to_nat dim f = funbool_to_nat dim g → ∀ k, k < dim → f k = g k

def funboolNat (dim : Nat) (φ : Fin dim → Bool) : Fin (2 ^ dim)

theorem funboolNat_injective (dim : Nat) : Function.Injective (funboolNat dim)

noncomputable def funboolEquiv (dim : Nat) : (Fin dim → Bool) ≃ Fin (2 ^ dim)

noncomputable def gateToPerm (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g) :
    Equiv.Perm (Fin (2 ^ dim))

theorem gate_normSqDist_perm (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g)
    (s₁ s₂ : QState (2 ^ dim)) :
    normSqDist (permState (gateToPerm g dim hwt) s₁) (permState (gateToPerm g dim hwt) s₂)
      = normSqDist s₁ s₂

def Gate.reverse : Gate → Gate
  | Gate.I => Gate.I
  | Gate.X q => Gate.X q
  | Gate.CX c t => Gate.CX c t
  | Gate.CCX a b c => Gate.CCX a b c
  | Gate.seq g₁ g₂ => Gate.seq (Gate.reverse g₂) (Gate.reverse g₁)

theorem applyNat_X_involution (q : Nat) (f : Nat → Bool) :
    Gate.applyNat (Gate.X q) (Gate.applyNat (Gate.X q) f) = f

theorem applyNat_CX_involution (c t : Nat) (h : c ≠ t) (f : Nat → Bool) :
    Gate.applyNat (Gate.CX c t) (Gate.applyNat (Gate.CX c t) f) = f

theorem applyNat_CCX_involution (a b c : Nat) (hac : a ≠ c) (hbc : b ≠ c)
    (f : Nat → Bool) :
    Gate.applyNat (Gate.CCX a b c) (Gate.applyNat (Gate.CCX a b c) f) = f

theorem applyNat_reverse_cancel : ∀ (g : Gate) (dim : Nat), Gate.WellTyped dim g →
    ∀ (f : Nat → Bool), Gate.applyNat (Gate.reverse g) (Gate.applyNat g f) = f

theorem applyNat_injective (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g) :
    Function.Injective (Gate.applyNat g)

theorem cosetState_layout_transport {dim : Nat} (L : Equiv.Perm (Fin dim))
    (gAct : QState dim → QState dim) (c N m k : Nat)
    (hconj : gAct (permState L (cosetState dim N m k))
      = permState L (wrapShiftState dim c (cosetState dim N m k)))
    (hN : 0 < N) (hfit : k + c + (2 ^ m - 1) * N < dim) :
    gAct (permState L (cosetState dim N m k)) = permState L (cosetState dim N m (k + c))

theorem permState_agree_off {dim : Nat} (L : Equiv.Perm (Fin dim))
    (s₁ s₂ : QState dim) (B : Finset (Fin dim))
    (hagree : ∀ i, i ∉ B → s₁ i 0 = s₂ i 0) :
    ∀ i, i ∉ B.map L.symm.toEmbedding → permState L s₁ i 0 = permState L s₂ i 0

theorem gateToPerm_funboolNat (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g)
    (φ : Fin dim → Bool) :
    gateToPerm g dim hwt (funboolNat dim φ) = funboolNat dim (applyFin g dim φ)

theorem cuccaro_gateToPerm_spread (bits q_start c x dim : Nat)
    (hc : c < 2 ^ bits) (hx : x < 2 ^ bits) (hdim : q_start + 2 * bits + 1 ≤ dim) :
    gateToPerm (cuccaro_addConstGate bits q_start c) dim
        (cuccaro_addConstGate_wellTyped bits q_start c dim hdim)
        (funboolNat dim (fun i => cuccaro_input_F q_start false 0 x i.val))
      = funboolNat dim (fun i => cuccaro_input_F q_start false 0 ((x + c) % 2 ^ bits) i.val)

theorem cuccaro_addConst_uc_eval_adapter (bits q_start c x dim : Nat)
    (hdim : q_start + 2 * bits + 1 ≤ dim) (hc : c < 2 ^ bits) :
    uc_eval (Gate.toUCom dim (cuccaro_addConstGate bits q_start c))
        * f_to_vec dim (cuccaro_input_F q_start false 0 x)
      = f_to_vec dim (Gate.applyNat (cuccaro_addConstGate bits q_start c)
          (cuccaro_input_F q_start false 0 x))
    ∧ cuccaro_target_val bits q_start
        (Gate.applyNat (cuccaro_addConstGate bits q_start c) (cuccaro_input_F q_start false 0 x))
      = (x + c) % 2 ^ bits

theorem cuccaro_addConstGate_structured_output (bits q_start c x : Nat)
    (hc : c < 2 ^ bits) (hx : x < 2 ^ bits) :
    Gate.applyNat (cuccaro_addConstGate bits q_start c) (cuccaro_input_F q_start false 0 x)
      = cuccaro_input_F q_start false 0 ((x + c) % 2 ^ bits)

theorem add_sub_mod (dim b i : Nat) (hi : i < dim) :
    ((i + b) % dim + (dim - b % dim)) % dim = i

theorem sub_add_mod (dim b i : Nat) (hi : i < dim) :
    ((i + (dim - b % dim)) % dim + b) % dim = i

def addPerm (dim c : Nat) : Equiv.Perm (Fin dim)

theorem wrapShiftState_eq_permState (dim c : Nat) (s : QState dim) :
    wrapShiftState dim c s = permState (addPerm dim c).symm s

theorem uc_eval_eq_wrapShiftState (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g) (c : Nat)
    (hperm : gateToPerm g dim hwt = addPerm (2 ^ dim) c)
    (s : Matrix (Fin (2 ^ dim)) (Fin 1) ℂ) :
    Framework.uc_eval (Gate.toUCom dim g) * s = wrapShiftState (2 ^ dim) c s

theorem uc_eval_addConst_cosetState (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g)
    (c N m k : Nat) (hperm : gateToPerm g dim hwt = addPerm (2 ^ dim) c) (hN : 0 < N)
    (hfit : k + c + (2 ^ m - 1) * N < 2 ^ dim)
    (s : Matrix (Fin (2 ^ dim)) (Fin 1) ℂ) (hs : s = cosetState (2 ^ dim) N m k) :
    Framework.uc_eval (Gate.toUCom dim g) * s = cosetState (2 ^ dim) N m (k + c)

theorem funbool_to_nat_congr : ∀ (dim : Nat) (f g : Nat → Bool),
    (∀ k, k < dim → f k = g k) → funbool_to_nat dim f = funbool_to_nat dim g

theorem uc_eval_basis_agree (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g)
    (i : Fin (2 ^ dim)) :
    Framework.uc_eval (Gate.toUCom dim g) * Framework.basis_vector (2 ^ dim) i.val
      = Framework.basis_vector (2 ^ dim) (gateToPerm g dim hwt i).val

theorem uc_eval_entry (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g)
    (i k : Fin (2 ^ dim)) :
    Framework.uc_eval (Gate.toUCom dim g) i k = if i = gateToPerm g dim hwt k then 1 else 0

theorem uc_eval_eq_permState (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g)
    (s : Matrix (Fin (2 ^ dim)) (Fin 1) ℂ) :
    Framework.uc_eval (Gate.toUCom dim g) * s = permState (gateToPerm g dim hwt).symm s

theorem gate_uc_eval_normSqDist_perm (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g)
    (s₁ s₂ : Matrix (Fin (2 ^ dim)) (Fin 1) ℂ) :
    normSqDist (Framework.uc_eval (Gate.toUCom dim g) * s₁)
        (Framework.uc_eval (Gate.toUCom dim g) * s₂)
      = normSqDist s₁ s₂

theorem eigenstate_from_cyclic_shift {D r : Nat} [NeZero r]
    (U : Matrix (Fin D) (Fin D) ℂ)
    (ψ : ZMod r → Matrix (Fin D) (Fin 1) ℂ) (χ : ZMod r → ℂ) (lam : ℂ)
    (hshift : ∀ t : ZMod r, U * ψ t = ψ (t + 1))
    (hχ : ∀ t : ZMod r, χ (t - 1) = lam * χ t) :
    U * (∑ t : ZMod r, χ t • ψ t) = lam • (∑ t : ZMod r, χ t • ψ t)

theorem addChar_quasi_character {r : Nat} [NeZero r] (χ : AddChar (ZMod r) ℂ) :
    ∀ t : ZMod r, χ (t - 1) = (χ (-1 : ZMod r)) * χ t

theorem rootOfUnity_quasi_character {r : Nat} [NeZero r] {ζ : ℂ} (hζ : ζ ^ r = 1) :
    ∀ t : ZMod r, (AddChar.zmodChar r hζ) (t - 1)
      = ζ⁻¹ * (AddChar.zmodChar r hζ) t

theorem eigenstate_rootOfUnity {D r : Nat} [NeZero r]
    (U : Matrix (Fin D) (Fin D) ℂ)
    (ψ : ZMod r → Matrix (Fin D) (Fin 1) ℂ) {ζ : ℂ} (hζ : ζ ^ r = 1)
    (hshift : ∀ t : ZMod r, U * ψ t = ψ (t + 1)) :
    U * (∑ t : ZMod r, (AddChar.zmodChar r hζ) t • ψ t)
      = ζ⁻¹ • (∑ t : ZMod r, (AddChar.zmodChar r hζ) t • ψ t)

noncomputable def E2cosetInit (m w bits N cm : Nat) :
    QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits))

noncomputable def E2runwayInit (m w bits N cm : Nat) :
    QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits))

theorem E2runwayInit_acts (m w bits N cm : Nat)
    (x : Fin (2 ^ m)) (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) :
    E2runwayInit m w bits N cm (jointIdx (shorDvd m bits (cosetAnc w bits)) x y) 0
      = ((1 : ℂ) / Real.sqrt (2 ^ m : ℝ))
          * cosetInputVec w bits N cm 1 0 (Fin.cast (E2shor_dim_eq m w bits) y) 0

noncomputable def Shor_final_state_E2coset (m w bits N cm : Nat)
    (f : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits)) :
    QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits))

noncomputable def probability_of_success_E2coset
    (a r N m w bits cm : Nat)
    (f : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits)) : ℝ

theorem Shor_final_state_E2coset_def (m w bits N cm : Nat)
    (f : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits)) :
    Shor_final_state_E2coset m w bits N cm f
      = orbitState (qpeStageMap m bits (cosetAnc w bits) f) (E2runwayInit m w bits N cm) (m + 1)

theorem probability_of_success_E2coset_def
    (a r N m w bits cm : Nat)
    (f : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits)) :
    probability_of_success_E2coset a r N m w bits cm f
      = ∑ x ∈ Finset.range (2 ^ m),
          r_found x m r a N *
            prob_partial_meas (basis_vector (2 ^ m) x)
              (Shor_final_state_E2coset m w bits N cm f)

theorem E2runwayInit_normalized (m w bits numWin N cm : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N)
    (hfit : 1 + (2 ^ cm - 1) * N < 2 ^ bits) :
    pmNorm (E2runwayInit m w bits N cm) = 1

theorem E2runwayInit_ne_zero (m w bits numWin N cm : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N)
    (hfit : 1 + (2 ^ cm - 1) * N < 2 ^ bits) :
    E2runwayInit m w bits N cm ≠ (fun _ _ => 0)

noncomputable def idealPerm (w bits N cm mult kInv : Nat)
    (hN : 1 < N) (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1) :
    Equiv.Perm (Fin (2 ^ cosetDim w bits))

theorem nat_to_funbool_eGid (w bits accBase : Nat)
    (haccfit : accBase + bits ≤ cosetDim w bits)
    (ctrl : Fin (2 ^ (cosetDim w bits - bits))) (z : Fin (2 ^ bits))
    (p : Nat) (hp : p < cosetDim w bits) :
    nat_to_funbool (cosetDim w bits) (eGid w bits accBase haccfit (ctrl, z)).val p
      = assembleEGid w bits accBase ctrl.val z.val p

theorem eGid_aDecode (w bits accBase : Nat)
    (haccfit : accBase + bits ≤ cosetDim w bits)
    (ctrl : Fin (2 ^ (cosetDim w bits - bits))) (z : Fin (2 ^ bits)) :
    decodeReg (fun i => accBase + i) bits
        (nat_to_funbool (cosetDim w bits) (eGid w bits accBase haccfit (ctrl, z)).val)
      = z.val

theorem idealPerm_apply (w bits N cm mult kInv : Nat)
    (hN : 1 < N) (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (idx : Fin (2 ^ cosetDim w bits)) :
    idealPerm w bits N cm mult kInv hN hfwd hbwd idx
      = eGid w bits (aBase w) (pass2_accfit w bits)
          (((eGid w bits (aBase w) (pass2_accfit w bits)).symm idx).1,
           resShiftPerm (2 ^ bits) N mult kInv hN hfwd hbwd
             (((eGid w bits (aBase w) (pass2_accfit w bits)).symm idx).2))

theorem resShiftPerm_val (N mult kInv : Nat)
    (hN : 1 < N) (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (aval : Fin (2 ^ bits)) :
    (resShiftPerm (2 ^ bits) N mult kInv hN hfwd hbwd aval).val
      = guardedShift (2 ^ bits) N mult aval.val

theorem aDecode_idealPerm (w bits N cm mult kInv : Nat)
    (hN : 1 < N) (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (idx : Fin (2 ^ cosetDim w bits)) :
    decodeReg (fun i => aBase w + i) bits
        (nat_to_funbool (cosetDim w bits)
          (idealPerm w bits N cm mult kInv hN hfwd hbwd idx).val)
      = guardedShift (2 ^ bits) N mult
          (decodeReg (fun i => aBase w + i) bits
            (nat_to_funbool (cosetDim w bits) idx.val))

theorem nat_to_funbool_idealPerm_off_aBlock (w bits N cm mult kInv : Nat)
    (hN : 1 < N) (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (idx : Fin (2 ^ cosetDim w bits)) (p : Nat) (hp : p < cosetDim w bits)
    (hoff : ¬ (aBase w ≤ p ∧ p < aBase w + bits)) :
    nat_to_funbool (cosetDim w bits)
        (idealPerm w bits N cm mult kInv hN hfwd hbwd idx).val p
      = nat_to_funbool (cosetDim w bits) idx.val p

theorem bDecode_idealPerm (w bits N cm mult kInv : Nat)
    (hN : 1 < N) (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (idx : Fin (2 ^ cosetDim w bits)) :
    decodeReg (fun i => bBase w bits + i) bits
        (nat_to_funbool (cosetDim w bits)
          (idealPerm w bits N cm mult kInv hN hfwd hbwd idx).val)
      = decodeReg (fun i => bBase w bits + i) bits
          (nat_to_funbool (cosetDim w bits) idx.val)

theorem scratchClean_idealPerm (w bits N cm mult kInv : Nat)
    (hN : 1 < N) (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (idx : Fin (2 ^ cosetDim w bits)) :
    scratchClean w bits
        (nat_to_funbool (cosetDim w bits)
          (idealPerm w bits N cm mult kInv hN hfwd hbwd idx).val)
      ↔ scratchClean w bits (nat_to_funbool (cosetDim w bits) idx.val)

theorem kInv_mult_mod (N mult kInv z : Nat) (hN : 1 < N)
    (hbwd : (kInv * mult) % N = 1) (hz : z < N) :
    (kInv * ((mult * z) % N)) % N = z

theorem aWindow_guardedShift (bits N cm mult kInv z va : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (hbudget : 2 ^ cm * N ≤ 2 ^ bits) (hz : z < N) (hva : va < 2 ^ bits) :
    (⟨va, hva⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm z
      ↔ (⟨guardedShift (2 ^ bits) N mult va,
            RunwayShiftPerm.guarded_lt (2 ^ bits) N mult va (by omega) hva⟩ : Fin (2 ^ bits))
          ∈ cosetWindow (2 ^ bits) N cm ((mult * z) % N)

theorem inSupport_idealPerm_fwd (w bits N cm mult kInv z : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (hfull : 2 ^ cm * N ≤ 2 ^ bits) (hz : z < N)
    (idx : Fin (2 ^ cosetDim w bits)) :
    inSupport w bits N cm z 0 idx
      ↔ inSupport w bits N cm ((mult * z) % N) 0
          (idealPerm w bits N cm mult kInv hN hfwd hbwd idx)

theorem inSupport_idealPerm_symm (w bits N cm mult kInv z : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (hfull : 2 ^ cm * N ≤ 2 ^ bits) (hz : z < N)
    (idx : Fin (2 ^ cosetDim w bits)) :
    inSupport w bits N cm z 0
        ((idealPerm w bits N cm mult kInv hN hfwd hbwd).symm idx)
      ↔ inSupport w bits N cm ((mult * z) % N) 0 idx

theorem idealShift_cosetInputVec (w bits N cm mult kInv z : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1)
    (hfull : 2 ^ cm * N ≤ 2 ^ bits) (hz : z < N) :
    permState (idealPerm w bits N cm mult kInv hN hfwd hbwd).symm
        (cosetInputVec w bits N cm z 0)
      = cosetInputVec w bits N cm ((mult * z) % N) 0

def runwayMul (c N v : Nat) : Nat

theorem runwayMul_on_coset (c N k j : Nat) (hk : k < N) :
    runwayMul c N (k + j * N) = (c * k) % N + j * N

theorem runwayMul_residue_injective (c N : Nat) (hN : 0 < N) (hcop : Nat.Coprime c N) :
    Function.Injective
      (fun k : Fin N => (⟨(c * k.val) % N, Nat.mod_lt _ hN⟩ : Fin N))

theorem runwayMul_residue_bijective (c N : Nat) (hN : 0 < N) (hcop : Nat.Coprime c N) :
    Function.Bijective
      (fun k : Fin N => (⟨(c * k.val) % N, Nat.mod_lt _ hN⟩ : Fin N))

theorem runwayMul_window_image (c N k M : Nat) (hk : k < N) :
    (Finset.range M).image (fun j => runwayMul c N (k + j * N))
      = (Finset.range M).image (fun j => (c * k) % N + j * N)

def runwayMulFin (dim c N : Nat) (hdim : 0 < dim) (v : Fin dim) : Fin dim

theorem runwayMulFin_cosetWindow_image (dim N m c k : Nat) (hdim : 0 < dim) (hN : 0 < N)
    (hk : k < N) (hfit : (c * k) % N + (2 ^ m - 1) * N < dim)
    (hsrc : k + (2 ^ m - 1) * N < dim) :
    (cosetWindow dim N m k).image (runwayMulFin dim c N hdim)
      = cosetWindow dim N m ((c * k) % N)

theorem runwayMul_cosetState_shift (dim N m c k : Nat) (hdim : 0 < dim) (hN : 0 < N)
    (hk : k < N) (hfit : (c * k) % N + (2 ^ m - 1) * N < dim)
    (hsrc : k + (2 ^ m - 1) * N < dim)
    (σ : Equiv.Perm (Fin dim))
    (hσ : ∀ v : Fin dim, v ∈ cosetWindow dim N m k →
            σ v = runwayMulFin dim c N hdim v)
    (hσinv : ∀ w : Fin dim, w ∈ cosetWindow dim N m ((c * k) % N) →
            (σ⁻¹ w) ∈ cosetWindow dim N m k) :
    ApproxOp.permState σ⁻¹ (cosetState dim N m k) = cosetState dim N m ((c * k) % N)

def guardedShift (D N c v : Nat) : Nat

theorem guarded_lt (D N c v : Nat) (hN : 0 < N) (hv : v < D) : guardedShift D N c v < D

theorem guarded_div (N c v : Nat) (hN : 0 < N) :
    ((v / N) * N + (c * (v % N)) % N) / N = v / N

theorem guarded_mod (N c v : Nat) (hN : 0 < N) :
    ((v / N) * N + (c * (v % N)) % N) % N = (c * (v % N)) % N

theorem guarded_leftinv (D N mult kInv v : Nat) (hN : 1 < N) (hinv : (mult * kInv) % N = 1) :
    guardedShift D N kInv (guardedShift D N mult v) = v

noncomputable def resShiftPerm (D N mult kInv : Nat) (hN : 1 < N)
    (hfwd : (mult * kInv) % N = 1) (hbwd : (kInv * mult) % N = 1) : Equiv.Perm (Fin D)

theorem guarded_on_support (D N cm mult z j : Nat) (hN : 0 < N) (hz : z < N) (hj : j < 2 ^ cm)
    (hbudget : 2 ^ cm * N ≤ D) :
    guardedShift D N mult (z + j * N) = (mult * z) % N + j * N

def inSupport (w bits N cm xa xb : Nat) (idx : Fin (2 ^ cosetDim w bits)) : Prop

theorem cosetInputVec_amp (w bits N cm xa xb : Nat) (idx : Fin (2 ^ cosetDim w bits)) :
    cosetInputVec w bits N cm xa xb idx 0
      = if inSupport w bits N cm xa xb idx then
          ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) * ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ)
        else 0

theorem cosetAmp_ne_zero (cm : Nat) :
    ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) * ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) ≠ 0

theorem cosetInputVec_ne_zero_iff (w bits N cm xa xb : Nat) (idx : Fin (2 ^ cosetDim w bits)) :
    cosetInputVec w bits N cm xa xb idx 0 ≠ 0 ↔ inSupport w bits N cm xa xb idx

theorem cosetInputVec_eq_zero_of_not_inSupport (w bits N cm xa xb : Nat)
    (idx : Fin (2 ^ cosetDim w bits)) (h : ¬ inSupport w bits N cm xa xb idx) :
    cosetInputVec w bits N cm xa xb idx 0 = 0

theorem cosetInputVec_eq_of_inSupport (w bits N cm xa xb : Nat)
    (idx : Fin (2 ^ cosetDim w bits)) (h : inSupport w bits N cm xa xb idx) :
    cosetInputVec w bits N cm xa xb idx 0
      = ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) * ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ)

theorem cuccaro_addConst_noWrap (bits q_start c x : Nat) (hc : c < 2 ^ bits)
    (hfit : x + c < 2 ^ bits) :
    cuccaro_target_val bits q_start
        (Gate.applyNat (cuccaro_addConstGate bits q_start c)
          (cuccaro_input_F q_start false 0 x))
      = x + c

def IdealCosetForm (m w bits N cm : Nat)
    (Φ : QState (2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits))) : Prop

theorem idealCosetForm_step (m w bits N cm : Nat) (hN : 0 < N)
    (f_runwayIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwt : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (mult : Nat → Nat)
    (hf_runway : ∀ (k : Nat) (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
          (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
              FormalRV.Framework.uc_eval (f_runwayIdeal (revIndex m k))
                  (Fin.cast (workDim_eq m bits (cosetAnc w bits)) y)
                  (Fin.cast (workDim_eq m bits (cosetAnc w bits)) yp)
                * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)
            = cosetInputVec w bits N cm ((mult k * z) % N) 0

theorem idealCosetForm_orbit (m w bits N cm : Nat) (hN : 0 < N)
    (f_runwayIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwt : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (mult : Nat → Nat)
    (hf_runway : ∀ (k : Nat) (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
          (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
              FormalRV.Framework.uc_eval (f_runwayIdeal (revIndex m k))
                  (Fin.cast (workDim_eq m bits (cosetAnc w bits)) y)
                  (Fin.cast (workDim_eq m bits (cosetAnc w bits)) yp)
                * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)
            = cosetInputVec w bits N cm ((mult k * z) % N) 0

theorem shorInitM_eq (m n anc : Nat) :
    shorInitM m n anc
      = kron_vec (kron_zeros m)
          (kron_vec (FormalRV.Framework.basis_vector (2 ^ n) 1) (kron_zeros anc))

theorem qpeRaw_combine (m n anc : Nat) (hm : 0 < m)
    (x : Fin (2 ^ m)) (w : Fin (2 ^ (n + anc))) :
    qpeRaw m n anc (kron_vec_combine x w) 0
      = ((1 : ℂ) / Real.sqrt (2 ^ m : ℝ))
          * (kron_vec (FormalRV.Framework.basis_vector (2 ^ n) 1) (kron_zeros anc)) w 0

theorem workReg_apply (n anc : Nat) (w : Fin (2 ^ (n + anc))) :
    (kron_vec (FormalRV.Framework.basis_vector (2 ^ n) 1) (kron_zeros anc)) w 0
      = (if w.val = 2 ^ anc then 1 else 0)

theorem qpeInit_jointIdx (m w bits : Nat) (hm : 0 < m)
    (x : Fin (2 ^ m))
    (yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)) :
    qpeInit m bits (cosetAnc w bits) (jointIdx (shorDvd m bits (cosetAnc w bits)) x yp) 0
      = ((1 : ℂ) / Real.sqrt (2 ^ m : ℝ))
          * (if yp.val = 2 ^ (cosetAnc w bits) then 1 else 0)

theorem idealCosetForm_base (m w bits N cm : Nat) (hm : 0 < m) (hbits : 0 < bits)
    (hzc : 2 ^ (cosetAnc w bits) < N) :
    IdealCosetForm m w bits N cm (E2cosetInit m w bits N cm)

theorem idealCosetForm_orbit_runway (m w bits N cm : Nat) (hN : 0 < N)
    (hm : 0 < m) (hbits : 0 < bits) (hzc : 2 ^ (cosetAnc w bits) < N)
    (f_runwayIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwt : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (mult : Nat → Nat)
    (hf_runway : ∀ (k : Nat) (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
          (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
              FormalRV.Framework.uc_eval (f_runwayIdeal (revIndex m k))
                  (Fin.cast (workDim_eq m bits (cosetAnc w bits)) y)
                  (Fin.cast (workDim_eq m bits (cosetAnc w bits)) yp)
                * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)

theorem idealCosetForm_base_direct (m w bits N cm : Nat) (hN1 : 1 < N) :
    IdealCosetForm m w bits N cm (E2runwayInit m w bits N cm)

theorem idealCosetForm_orbit_runway_direct (m w bits N cm : Nat) (hN : 0 < N) (hN1 : 1 < N)
    (f_runwayIdeal : Nat → FormalRV.Framework.BaseUCom (bits + cosetAnc w bits))
    (hwt : ∀ j, FormalRV.Framework.UCom.WellTyped (bits + cosetAnc w bits) (f_runwayIdeal j))
    (mult : Nat → Nat)
    (hf_runway : ∀ (k : Nat) (z : Nat), z < N →
        ∀ (y : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m)),
          (∑ yp : Fin ((2 ^ m * 2 ^ bits * 2 ^ (cosetAnc w bits)) / 2 ^ m),
              FormalRV.Framework.uc_eval (f_runwayIdeal (revIndex m k))
                  (Fin.cast (workDim_eq m bits (cosetAnc w bits)) y)
                  (Fin.cast (workDim_eq m bits (cosetAnc w bits)) yp)
                * cosetInputVec w bits N cm z 0 (Fin.cast (E2shor_dim_eq m w bits) yp) 0)
            = cosetInputVec w bits N cm ((mult k * z) % N) 0

noncomputable def cosetVec (dim N m k : Nat) : Matrix (Fin dim) (Fin 1) ℂ

theorem pow_mod_period (a N r n : Nat) (har : a ^ r % N = 1) :
    a ^ n % N = a ^ (n % r) % N

theorem runwayMul_coset_eigenstate {dim N m a r : Nat} [NeZero r]
    (U : Matrix (Fin dim) (Fin dim) ℂ) {ζ : ℂ} (hζ : ζ ^ r = 1)
    (hN : 0 < N) (hr : 1 < r) (har : a ^ r % N = 1)
    (hrun : ∀ k, k < N → U * cosetVec dim N m k = cosetVec dim N m ((a * k) % N)) :
    U * (∑ t : ZMod r, (AddChar.zmodChar r hζ) t • cosetVec dim N m (a ^ t.val % N))
      = ζ⁻¹ • (∑ t : ZMod r, (AddChar.zmodChar r hζ) t • cosetVec dim N m (a ^ t.val % N))

theorem runwayMul_intertwines_Ephys {dim N m : Nat} (a : Nat)
    (ι : Nat → QState dim) (Fa Fi E_phys : QState dim → QState dim)
    (hE : ∀ k, k < N → E_phys (ι k) = cosetState dim N m k)
    (hFa : ∀ k, Fa (cosetState dim N m k) = cosetState dim N m ((a * k) % N))
    (hFi : ∀ k, k < N → Fi (ι k) = ι ((a * k) % N))
    (hmod : ∀ k, (a * k) % N < N)
    (k : Nat) (hk : k < N) :
    Fa (E_phys (ι k)) = E_phys (Fi (ι k))

def pass1 (w bits : Nat) (TfamK : Nat → Nat → Nat) (numWin : Nat) : Gate

def pass2 (w bits : Nat) (TfamKinv : Nat → Nat → Nat) (numWin : Nat) : Gate

def gidneyTwoRegInPlaceCosetMul (w bits : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (numWin : Nat) : Gate

theorem gidneyTwoRegInPlaceCosetMul_unfold (w bits : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (numWin : Nat) :
    gidneyTwoRegInPlaceCosetMul w bits TfamK TfamKinv numWin
      = Gate.seq (pass1 w bits TfamK numWin)
                 (GateReversible.Gate.reverse (pass2 w bits TfamKinv numWin))

theorem gidneyTwoRegInPlaceCosetMul_wellTyped (w bits : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (numWin : Nat) (hw : 0 < w) (hbits : numWin * w = bits) :
    Gate.WellTyped (2 + 2 * w + 3 * bits)
      (gidneyTwoRegInPlaceCosetMul w bits TfamK TfamKinv numWin)

theorem gidneyTwoReg_reverse_leg_cancel (w bits : Nat) (TfamKinv : Nat → Nat → Nat)
    (numWin : Nat) (hw : 0 < w) (hbits : numWin * w = bits) (f : Nat → Bool) :
    Gate.applyNat (GateReversible.Gate.reverse (pass2 w bits TfamKinv numWin))
        (Gate.applyNat (pass2 w bits TfamKinv numWin) f) = f

def basisFinal0 (w bits : Nat) (TfamK : Nat → Nat → Nat) (numWin : Nat) (g : Nat → Bool) :
    Nat → Bool

private theorem hcov1 (w bits numWin : Nat) (_hbits : numWin * w = bits) : ∀ q,
    1 + 2 * w + bits ≤ q → q < 1 + 2 * w + 2 * bits + bits + 1 →
    (∃ i, i < bits ∧ q = 1 + 2 * w + bits + i) ∨ (∃ i, i < bits ∧ q = 1 + 2 * w + 2 * bits + i)
      ∨ q = 1 + 2 * w + 2 * bits + bits ∨ (∃ i, i < numWin * w ∧ q = 1 + 2 * w + i)

private theorem hcov2 (w bits numWin : Nat) (hbits : numWin * w = bits) : ∀ q,
    1 + 2 * w ≤ q → q < 1 + 2 * w + 2 * bits + bits + 1 →
    (∃ i, i < bits ∧ q = 1 + 2 * w + i) ∨ (∃ i, i < bits ∧ q = 1 + 2 * w + 2 * bits + i)
      ∨ q = 1 + 2 * w + 2 * bits + bits ∨ (∃ i, i < numWin * w ∧ q = 1 + 2 * w + bits + i)

theorem gidneyTwoRegInPlace_maps_to_final0 (w bits numWin : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (x : Nat) (hw : 0 < w) (hbits : numWin * w = bits) (g : Nat → Bool)
    (hg : RelocStepInv w bits numWin x (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) 0 g)
    (hInvSum : (∑ k ∈ Finset.range numWin, TfamKinv k (WindowedArith.window w
        ((∑ j ∈ Finset.range numWin, TfamK j (WindowedArith.window w x j)) % 2 ^ bits) k)) % 2 ^ bits = x) :
    Gate.applyNat (gidneyTwoRegInPlaceCosetMul w bits TfamK TfamKinv numWin) g
      = basisFinal0 w bits TfamK numWin g

theorem gidneyTwoRegInPlace_basis_correct (w bits numWin : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (x : Nat) (hw : 0 < w) (hbits : numWin * w = bits) (g : Nat → Bool)
    (hg : RelocStepInv w bits numWin x (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) 0 g)
    (hInvSum : (∑ k ∈ Finset.range numWin, TfamKinv k (WindowedArith.window w
        ((∑ j ∈ Finset.range numWin, TfamK j (WindowedArith.window w x j)) % 2 ^ bits) k)) % 2 ^ bits = x) :
    decodeReg (fun i => 1 + 2 * w + i) bits
        (Gate.applyNat (gidneyTwoRegInPlaceCosetMul w bits TfamK TfamKinv numWin) g) = 0
    ∧ decodeReg (fun i => 1 + 2 * w + bits + i) bits
        (Gate.applyNat (gidneyTwoRegInPlaceCosetMul w bits TfamK TfamKinv numWin) g)
      = (∑ j ∈ Finset.range numWin, TfamK j (WindowedArith.window w x j)) % 2 ^ bits

theorem hInvSum_specialized_basis (bits N k kInv x P1 S2 : Nat)
    (hxN : x < N) (hP1 : P1 = (k * x) % N)
    (hS2N : S2 % N = (kInv * P1) % N) (hS2nowrap : S2 % 2 ^ bits = S2 % N)
    (hkkinv : (kInv * k) % N = 1 % N) :
    S2 % 2 ^ bits = x

theorem gidneyTwoRegInPlace_coset_basis_good_branch (w bits numWin N k kInv x : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat) (hw : 0 < w) (hbits : numWin * w = bits) (g : Nat → Bool)
    (hg : RelocStepInv w bits numWin x (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) 0 g)
    (hxN : x < N)
    (hP1 : (∑ j ∈ Finset.range numWin, TfamK j (WindowedArith.window w x j)) % 2 ^ bits = (k * x) % N)
    (hS2N : (∑ k' ∈ Finset.range numWin, TfamKinv k' (WindowedArith.window w
        ((∑ j ∈ Finset.range numWin, TfamK j (WindowedArith.window w x j)) % 2 ^ bits) k')) % N
        = (kInv * ((∑ j ∈ Finset.range numWin, TfamK j (WindowedArith.window w x j)) % 2 ^ bits)) % N)
    (hS2nowrap : (∑ k' ∈ Finset.range numWin, TfamKinv k' (WindowedArith.window w
          ((∑ j ∈ Finset.range numWin, TfamK j (WindowedArith.window w x j)) % 2 ^ bits) k')) % 2 ^ bits
        = (∑ k' ∈ Finset.range numWin, TfamKinv k' (WindowedArith.window w
          ((∑ j ∈ Finset.range numWin, TfamK j (WindowedArith.window w x j)) % 2 ^ bits) k')) % N)

def inPlaceMul (mulFwd swap mulInv : Gate) : Gate

theorem inPlaceMul_correct (mulFwd swap mulInv : Gate) (dim : Nat)
    (hwt : Gate.WellTyped dim mulInv) (s0 sFinal : Nat → Bool)
    (hchain : Gate.applyNat swap (Gate.applyNat mulFwd s0) = Gate.applyNat mulInv sFinal) :
    Gate.applyNat (inPlaceMul mulFwd swap mulInv) s0 = sFinal

def swapPair (a b : Nat) : Gate

theorem applyNat_swapPair (a b : Nat) (h : a ≠ b) (f : Nat → Bool) (p : Nat) :
    Gate.applyNat (swapPair a b) f p =
      if p = a then f b else if p = b then f a else f p

def swapReg (idxA idxB : Nat → Nat) : Nat → Gate
  | 0 => Gate.I
  | n + 1 => Gate.seq (swapReg idxA idxB n) (swapPair (idxA n) (idxB n))

theorem swapReg_frame (idxA idxB : Nat → Nat) (hAB : ∀ i i', idxA i ≠ idxB i') :
    ∀ (n : Nat) (f : Nat → Bool) (p : Nat),
      (∀ i, i < n → p ≠ idxA i ∧ p ≠ idxB i) →
      Gate.applyNat (swapReg idxA idxB n) f p = f p

theorem swapReg_idxA (idxA idxB : Nat → Nat) (hAB : ∀ i i', idxA i ≠ idxB i')
    (hAinj : ∀ i i', idxA i = idxA i' → i = i') (hBinj : ∀ i i', idxB i = idxB i' → i = i') :
    ∀ (n : Nat) (f : Nat → Bool) (j : Nat), j < n →
      Gate.applyNat (swapReg idxA idxB n) f (idxA j) = f (idxB j)

theorem swapReg_idxB (idxA idxB : Nat → Nat) (hAB : ∀ i i', idxA i ≠ idxB i')
    (hAinj : ∀ i i', idxA i = idxA i' → i = i') (hBinj : ∀ i i', idxB i = idxB i' → i = i') :
    ∀ (n : Nat) (f : Nat → Bool) (j : Nat), j < n →
      Gate.applyNat (swapReg idxA idxB n) f (idxB j) = f (idxA j)

theorem nowrap_of_lt_N (S N bits : Nat) (hSN : S < N) (hN2 : N ≤ 2 ^ bits) :
    S % 2 ^ bits = S % N

theorem offBad_implies_basis_hyps (w bits numWin N k kInv x : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hN : 0 < N) (hN2 : N ≤ 2 ^ bits)
    (hxFit : x < (2 ^ w) ^ numWin)
    (hP1Fit : (k * x) % N < (2 ^ w) ^ numWin)
    (hS1lt : (∑ j ∈ Finset.range numWin, TfamK j (window w x j)) < N)
    (hS2lt : (∑ k' ∈ Finset.range numWin, TfamKinv k' (window w
        ((∑ j ∈ Finset.range numWin, TfamK j (window w x j)) % 2 ^ bits) k')) < N) :
    ((∑ j ∈ Finset.range numWin, TfamK j (window w x j)) % 2 ^ bits = (k * x) % N)
    ∧ ((∑ k' ∈ Finset.range numWin, TfamKinv k' (window w

theorem good_branch_of_nowrap (w bits numWin N k kInv x : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (g : Nat → Bool)
    (hg : RelocStepInv w bits numWin x (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) 0 g)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hN : 0 < N) (hN2 : N ≤ 2 ^ bits) (hxN : x < N)
    (hxFit : x < (2 ^ w) ^ numWin) (hP1Fit : (k * x) % N < (2 ^ w) ^ numWin)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hS1lt : (∑ j ∈ Finset.range numWin, TfamK j (window w x j)) < N)
    (hS2lt : (∑ k' ∈ Finset.range numWin, TfamKinv k' (window w
        ((∑ j ∈ Finset.range numWin, TfamK j (window w x j)) % 2 ^ bits) k')) < N) :

def inplaceCosetGate (w bits N a aInv numWin : Nat) : Gate

theorem inplaceCosetGate_unfold (w bits N a aInv numWin : Nat) :
    inplaceCosetGate w bits N a aInv numWin
      = Gate.seq
          (Gate.seq (cosetModMulCircuitOf cuccaroAdder w bits N a numWin)
                    (accYSwap cuccaroAdder w bits))
          (cosetModMulCircuitOf cuccaroAdder w bits N (N - aInv) numWin)

theorem inplaceCosetGate_cuccaro_wellTyped (w bits N a aInv numWin : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) :
    Gate.WellTyped (cosetDim w bits) (inplaceCosetGate w bits N a aInv numWin)

def cosetAnc (w bits : Nat) : Nat

theorem cosetWork_dim_eq (w bits : Nat) : bits + cosetAnc w bits = cosetDim w bits

def compIdxGid (bits accBase : Nat) (j : Nat) : Nat

theorem compIdxGid_lt (w bits accBase j : Nat)
    (haccfit : accBase + bits ≤ cosetDim w bits) (hj : j < cosetDim w bits - bits) :
    compIdxGid bits accBase j < cosetDim w bits

theorem compIdxGid_inj (bits accBase i j : Nat)
    (h : compIdxGid bits accBase i = compIdxGid bits accBase j) : i = j

theorem compIdxGid_ne_data (bits accBase j i : Nat) (hi : i < bits) :
    compIdxGid bits accBase j ≠ accBase + i

theorem compIdxGid_off_block (bits accBase j : Nat) :
    ¬ (accBase ≤ compIdxGid bits accBase j ∧ compIdxGid bits accBase j < accBase + bits)

theorem coverGid (w bits accBase p : Nat) (haccfit : accBase + bits ≤ cosetDim w bits)
    (hp : p < cosetDim w bits) :
    (∃ i, i < bits ∧ p = accBase + i)
      ∨ (∃ j, j < cosetDim w bits - bits ∧ p = compIdxGid bits accBase j)

def assembleEGid (w bits accBase : Nat) (x z : Nat) : Nat → Bool

theorem assembleEGid_data (w bits accBase x z i : Nat) (hi : i < bits) :
    assembleEGid w bits accBase x z (accBase + i) = z.testBit i

theorem assembleEGid_comp (w bits accBase x z j : Nat) (hj : j < cosetDim w bits - bits) :
    assembleEGid w bits accBase x z (compIdxGid bits accBase j) = x.testBit j

theorem assembleEGid_inj (w bits accBase x z x' z' : Nat)
    (haccfit : accBase + bits ≤ cosetDim w bits)
    (hx : x < 2 ^ (cosetDim w bits - bits)) (hx' : x' < 2 ^ (cosetDim w bits - bits))
    (hz : z < 2 ^ bits) (hz' : z' < 2 ^ bits)
    (h : (fun p : Fin (cosetDim w bits) => assembleEGid w bits accBase x z p.val)
       = (fun p : Fin (cosetDim w bits) => assembleEGid w bits accBase x' z' p.val)) :
    x = x' ∧ z = z'

noncomputable def eFunGid (w bits accBase : Nat) :
    Fin (2 ^ (cosetDim w bits - bits)) × Fin (2 ^ bits) → Fin (2 ^ cosetDim w bits)

theorem eFunGid_injective (w bits accBase : Nat)
    (haccfit : accBase + bits ≤ cosetDim w bits) :
    Function.Injective (eFunGid w bits accBase)

theorem eFunGid_bijective (w bits accBase : Nat)
    (haccfit : accBase + bits ≤ cosetDim w bits) :
    Function.Bijective (eFunGid w bits accBase)

noncomputable def eGid (w bits accBase : Nat) (haccfit : accBase + bits ≤ cosetDim w bits) :
    Fin (2 ^ (cosetDim w bits - bits)) × Fin (2 ^ bits) ≃ Fin (2 ^ cosetDim w bits)

theorem pass1_accfit (w bits : Nat) : (1 + 2 * w + bits) + bits ≤ cosetDim w bits

theorem pass2_accfit (w bits : Nat) : (1 + 2 * w) + bits ≤ cosetDim w bits

def inplaceWorkInput (numWin w yBase y : Nat) : Nat → Bool

def inplaceAccInput (w bits numWin accBase yBase z y : Nat) : Nat → Bool

noncomputable def xCtrlGid (w bits numWin accBase yBase y : Nat) :
    Fin (2 ^ (cosetDim w bits - bits))

theorem assembleEGid_xCtrlGid (w bits numWin accBase yBase y z p : Nat)
    (haccfit : accBase + bits ≤ cosetDim w bits) (hp : p < cosetDim w bits) :
    assembleEGid w bits accBase (xCtrlGid w bits numWin accBase yBase y).val z p
      = inplaceAccInput w bits numWin accBase yBase z y p

theorem xCtrlGid_RelocStepInv (w bits numWin accBase tempBase yBase y z : Nat)
    (hbits : numWin * w = bits)
    (hacc : 2 * w < accBase) (hyy : 2 * w < yBase)
    (hv : accBase + bits ≤ tempBase) (hytemp : yBase + bits ≤ tempBase)
    (haccfit : accBase + bits ≤ cosetDim w bits) (htfit : tempBase + bits < cosetDim w bits)
    (hYAccDisj : yBase + bits ≤ accBase ∨ accBase + bits ≤ yBase) :
    RelocStepInv w bits numWin y accBase tempBase yBase z
      (assembleEGid w bits accBase (xCtrlGid w bits numWin accBase yBase y).val z)

theorem xCtrlGid_pass1_RelocStepInv (w bits numWin y z : Nat) (hbits : numWin * w = bits) :
    RelocStepInv w bits numWin y (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) z
      (assembleEGid w bits (1 + 2 * w + bits)
        (xCtrlGid w bits numWin (1 + 2 * w + bits) (1 + 2 * w) y).val z)

theorem xCtrlGid_pass2_RelocStepInv (w bits numWin y z : Nat) (hbits : numWin * w = bits) :
    RelocStepInv w bits numWin y (1 + 2 * w) (1 + 2 * w + 2 * bits) (1 + 2 * w + bits) z
      (assembleEGid w bits (1 + 2 * w)
        (xCtrlGid w bits numWin (1 + 2 * w) (1 + 2 * w + bits) y).val z)

theorem swapReg_frameB (idxA idxB : Nat → Nat) :
    ∀ (n : Nat) (f : Nat → Bool) (p : Nat),
      (∀ i i', i < n → i' < n → idxA i ≠ idxB i') →
      (∀ i, i < n → p ≠ idxA i ∧ p ≠ idxB i) →
      Gate.applyNat (swapReg idxA idxB n) f p = f p

theorem swapReg_idxAB (idxA idxB : Nat → Nat)
    (hAinj : ∀ i i', idxA i = idxA i' → i = i') (hBinj : ∀ i i', idxB i = idxB i' → i = i') :
    ∀ (n : Nat) (f : Nat → Bool) (j : Nat), j < n →
      (∀ i i', i < n → i' < n → idxA i ≠ idxB i') →
      Gate.applyNat (swapReg idxA idxB n) f (idxA j) = f (idxB j)

theorem swapReg_idxBB (idxA idxB : Nat → Nat)
    (hAinj : ∀ i i', idxA i = idxA i' → i = i') (hBinj : ∀ i i', idxB i = idxB i' → i = i') :
    ∀ (n : Nat) (f : Nat → Bool) (j : Nat), j < n →
      (∀ i i', i < n → i' < n → idxA i ≠ idxB i') →
      Gate.applyNat (swapReg idxA idxB n) f (idxB j) = f (idxA j)

def swapAB (w bits : Nat) : Gate

theorem swapAB_disj (w bits : Nat) :
    ∀ i i', i < bits → i' < bits → (fun i => aBase w + i) i ≠ (fun i => bBase w bits + i) i'

theorem swapAB_injA (w : Nat) : ∀ i i', (fun i => aBase w + i) i = (fun i => aBase w + i) i' → i = i'

theorem swapAB_injB (w bits : Nat) :
    ∀ i i', (fun i => bBase w bits + i) i = (fun i => bBase w bits + i) i' → i = i'

theorem swapAB_posA (w bits : Nat) (g : Nat → Bool) (j : Nat) (hj : j < bits) :
    Gate.applyNat (swapAB w bits) g (aBase w + j) = g (bBase w bits + j)

theorem swapAB_posB (w bits : Nat) (g : Nat → Bool) (j : Nat) (hj : j < bits) :
    Gate.applyNat (swapAB w bits) g (bBase w bits + j) = g (aBase w + j)

theorem swapAB_frameOff (w bits : Nat) (g : Nat → Bool) (p : Nat)
    (hpa : ¬ (aBase w ≤ p ∧ p < aBase w + bits))
    (hpb : ¬ (bBase w bits ≤ p ∧ p < bBase w bits + bits)) :
    Gate.applyNat (swapAB w bits) g p = g p

theorem swapAB_wellTyped (w bits : Nat) :
    Gate.WellTyped (cosetDim w bits) (swapAB w bits)

theorem swapAB_decodeA (w bits : Nat) (g : Nat → Bool) :
    decodeReg (fun i => aBase w + i) bits (Gate.applyNat (swapAB w bits) g)
      = decodeReg (fun i => bBase w bits + i) bits g

theorem swapAB_decodeB (w bits : Nat) (g : Nat → Bool) :
    decodeReg (fun i => bBase w bits + i) bits (Gate.applyNat (swapAB w bits) g)
      = decodeReg (fun i => aBase w + i) bits g

theorem swapAB_scratchClean (w bits : Nat) (g : Nat → Bool) :
    scratchClean w bits (Gate.applyNat (swapAB w bits) g) ↔ scratchClean w bits g

theorem swapAB_cosetInputTwoReg (w bits N cm xa xb : Nat) :
    Framework.uc_eval (Gate.toUCom (cosetDim w bits) (swapAB w bits))
        * cosetInputVec w bits N cm xa xb
      = cosetInputVec w bits N cm xb xa

theorem swapAB_cosetInputTwoReg_symm (w bits N cm xa xb : Nat) :
    Framework.uc_eval (Gate.toUCom (cosetDim w bits) (swapAB w bits))
        * cosetInputVec w bits N cm xb xa
      = cosetInputVec w bits N cm xa xb

def goodPair (w bits numWin N cm k x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (ja jb : Nat) : Prop

theorem gidneyTwoRegInPlace_agree_off
    (w bits numWin N cm k kInv x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfit : (k * x) % N + (2 ^ cm - 1) * N < 2 ^ bits)
    (ja jb : Nat) (hja : ja < 2 ^ bits) (hjb : jb < 2 ^ bits)
    (hja_win : (⟨ja, hja⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm x)
    (hjb_win : (⟨jb, hjb⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm 0)
    (hgood : goodPair w bits numWin N cm k x TfamK TfamKinv ja jb) :
    (∀ h, (⟨(jb + ∑ j ∈ Finset.range numWin, TfamK j (window w ja j)) % 2 ^ bits, h⟩

theorem gidneyInPlaceWithSwap_agree_off_explicit
    (w bits numWin N cm k kInv x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfit : (k * x) % N + (2 ^ cm - 1) * N < 2 ^ bits)
    (i : Fin (2 ^ cosetDim w bits))
    (hiB : i ∉ inplaceBadSetB w bits numWin N cm k x TfamK TfamKinv hw hbits) :
    (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
        (gidneyInPlaceWithSwap w bits TfamK TfamKinv numWin))
      * cosetInputVec w bits N cm x 0) i 0

theorem gidneyInPlaceWithSwap_agree_off'
    (w bits numWin N cm k kInv x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfit : (k * x) % N + (2 ^ cm - 1) * N < 2 ^ bits) :
    ∃ B : Finset (Fin (2 ^ cosetDim w bits)),
      ∀ i : Fin (2 ^ cosetDim w bits), i ∉ B →
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
            (gidneyInPlaceWithSwap w bits TfamK TfamKinv numWin))
          * cosetInputVec w bits N cm x 0) i 0

def inplaceBadSet {dim : Nat} (Bfwd Brev : Finset (Fin dim)) : Finset (Fin dim)

theorem inplaceBadSet_mass_le {dim : Nat} (s : QState dim)
    (Bfwd Brev : Finset (Fin dim)) (numWin cm : Nat)
    (hfwd : bornWeightOn s Bfwd ≤ (numWin : ℝ) / 2 ^ cm)
    (hrev : bornWeightOn s Brev ≤ (numWin : ℝ) / 2 ^ cm) :
    bornWeightOn s (inplaceBadSet Bfwd Brev) ≤ 2 * ((numWin : ℝ) / 2 ^ cm)

theorem revCanonical_eq (N k kInv x : Nat) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N) :
    (kInv * ((k * x) % N)) % N = x

theorem inplaceBadSet_coupled_exists (bits N cm k kInv w numWin x : Nat)
    (hN : 0 < N) (hxN : x < N) (hx : x < (2 ^ w) ^ numWin)
    (hkxFit : (k * x) % N < (2 ^ w) ^ numWin)
    (hkkinv : (kInv * k) % N = 1 % N) :
    ∃ Bfwd Brev : Finset (Fin (2 ^ bits)),
      -- forward leg `b += a·k`, input residue `x`
      (∀ i, i ∉ Bfwd →
        cosetState (2 ^ bits) N cm (runningSum (cosetWindowConst k N w x) numWin) i 0
          = cosetState (2 ^ bits) N cm ((k * x) % N) i 0)
      ∧ bornWeightOn (cosetState (2 ^ bits) N cm ((k * x) % N)) Bfwd ≤ (numWin : ℝ) / 2 ^ cm
      -- reverse leg `a += b·kInv` at the chained input `(k·x)%N`; canonical out = `x`
      ∧ (∀ i, i ∉ Brev →

theorem gateToPerm_seq (a b : Gate) (dim : Nat) (ha : Gate.WellTyped dim a)
    (hb : Gate.WellTyped dim b) (hab : Gate.WellTyped dim (Gate.seq a b)) (idx : Fin (2 ^ dim)) :
    gateToPerm (Gate.seq a b) dim hab idx = gateToPerm b dim hb (gateToPerm a dim ha idx)

def modSub (bits a S : Nat) : Nat

theorem modSub_add (bits a S : Nat) (ha : a < 2 ^ bits) :
    (modSub bits a S + S) % 2 ^ bits = a

theorem gidneyTwoRegInPlace_branch_action (w bits numWin : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (ja jb : Nat) (hw : 0 < w) (hbits : numWin * w = bits) (hja : ja < 2 ^ bits) (hjb : jb < 2 ^ bits)
    (hwt : Gate.WellTyped (cosetDim w bits) (gidneyTwoRegInPlaceCosetMul w bits TfamK TfamKinv numWin)) :
    gateToPerm (gidneyTwoRegInPlaceCosetMul w bits TfamK TfamKinv numWin) (cosetDim w bits) hwt
        (eGid w bits (1 + 2 * w + bits) (pass1_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w + bits) (1 + 2 * w) ja, ⟨jb, hjb⟩))
      = eGid w bits (1 + 2 * w) (pass2_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w) (1 + 2 * w + bits)
              ((jb + ∑ k ∈ Finset.range numWin, TfamK k (window w ja k)) % 2 ^ bits),
            ⟨modSub bits ja (∑ k ∈ Finset.range numWin, TfamKinv k
                (window w ((jb + ∑ k ∈ Finset.range numWin, TfamK k (window w ja k)) % 2 ^ bits) k)),
              Nat.mod_lt _ (by positivity)⟩)

theorem scratchClean_inplaceAccInput_bAcc (w bits numWin z y : Nat) (hbits : numWin * w = bits) :
    scratchClean w bits (inplaceAccInput w bits numWin (bBase w bits) (aBase w) z y)

theorem scratchClean_inplaceAccInput_aAcc (w bits numWin z y : Nat) (hbits : numWin * w = bits) :
    scratchClean w bits (inplaceAccInput w bits numWin (aBase w) (bBase w bits) z y)

theorem betaB_xCtrlGid (w bits numWin N cm xa ja : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hja : ja < 2 ^ bits) :
    betaB w bits N cm xa (xCtrlGid w bits numWin (bBase w bits) (aBase w) ja).val
      = if (⟨ja, hja⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm xa
          then ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) else 0

theorem betaA_xCtrlGid (w bits numWin N cm xb jb : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hjb : jb < 2 ^ bits) :
    betaA w bits N cm xb (xCtrlGid w bits numWin (aBase w) (bBase w bits) jb).val
      = if (⟨jb, hjb⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm xb
          then ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) else 0

theorem cosetInputVec_at_bBase (w bits numWin N cm xa xb ja jb : Nat) (hw : 0 < w)
    (hbits : numWin * w = bits) (hja : ja < 2 ^ bits) (hjb : jb < 2 ^ bits) :
    cosetInputVec w bits N cm xa xb (eGid w bits (bBase w bits) (pass1_accfit w bits)
        (xCtrlGid w bits numWin (bBase w bits) (aBase w) ja, ⟨jb, hjb⟩)) 0
      = (if (⟨ja, hja⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm xa
          then ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) else 0)
      * (if (⟨jb, hjb⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm xb
          then ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) else 0)

theorem cosetInputVec_at_aBase (w bits numWin N cm xa xb mult data : Nat) (hw : 0 < w)
    (hbits : numWin * w = bits) (hmult : mult < 2 ^ bits) (hdata : data < 2 ^ bits) :
    cosetInputVec w bits N cm xa xb (eGid w bits (aBase w) (pass2_accfit w bits)
        (xCtrlGid w bits numWin (aBase w) (bBase w bits) mult, ⟨data, hdata⟩)) 0
      = (if (⟨data, hdata⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm xa
          then ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) else 0)
      * (if (⟨mult, hmult⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm xb
          then ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) else 0)

theorem good_branch_amplitude_eq (w bits numWin N cm x k ja jb jb' modSub : Nat) (hw : 0 < w)
    (hbits : numWin * w = bits) (hja : ja < 2 ^ bits) (hjb : jb < 2 ^ bits)
    (hjb' : jb' < 2 ^ bits) (hmod : modSub < 2 ^ bits)
    (hjaW : (⟨ja, hja⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm x)
    (hjbW : (⟨jb, hjb⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm 0)
    (hjb'W : (⟨jb', hjb'⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm ((k * x) % N))
    (hmodW : (⟨modSub, hmod⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm 0) :
    cosetInputVec w bits N cm x 0 (eGid w bits (bBase w bits) (pass1_accfit w bits)
        (xCtrlGid w bits numWin (bBase w bits) (aBase w) ja, ⟨jb, hjb⟩)) 0
      = cosetInputVec w bits N cm ((k * x) % N) 0 (eGid w bits (aBase w) (pass2_accfit w bits)
          (xCtrlGid w bits numWin (aBase w) (bBase w bits) modSub, ⟨jb', hjb'⟩)) 0

theorem cosetInputVec_nonzero_eq (w bits N cm xa xb : Nat) (idx : Fin (2 ^ cosetDim w bits))
    (h : cosetInputVec w bits N cm xa xb idx 0 ≠ 0) :
    cosetInputVec w bits N cm xa xb idx 0
      = ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) * ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ)

theorem good_input_maps_to_target (w bits numWin N cm k kInv x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfit : (k * x) % N + (2 ^ cm - 1) * N < 2 ^ bits)
    (idx : Fin (2 ^ cosetDim w bits))
    (hidx : cosetInputVec w bits N cm x 0 idx 0 ≠ 0)
    (hgood : goodPair w bits numWin N cm k x TfamK TfamKinv
        (decodeReg (fun i => aBase w + i) bits (nat_to_funbool (cosetDim w bits) idx.val))
        (decodeReg (fun i => bBase w bits + i) bits (nat_to_funbool (cosetDim w bits) idx.val))) :
    cosetInputVec w bits N cm ((k * x) % N) 0

noncomputable def inplaceSigma (w bits numWin : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) : Equiv.Perm (Fin (2 ^ cosetDim w bits))

noncomputable def inplaceInputSupp (w bits N cm x : Nat) : Finset (Fin (2 ^ cosetDim w bits))

noncomputable def inplaceTargetSupp (w bits N cm k x : Nat) : Finset (Fin (2 ^ cosetDim w bits))

noncomputable def inplaceGoodIn (w bits numWin N cm k x : Nat) (TfamK TfamKinv : Nat → Nat → Nat) :
    Finset (Fin (2 ^ cosetDim w bits))

noncomputable def inplaceBadIn (w bits numWin N cm k x : Nat) (TfamK TfamKinv : Nat → Nat → Nat) :
    Finset (Fin (2 ^ cosetDim w bits))

noncomputable def inplaceBadSetB (w bits numWin N cm k x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) : Finset (Fin (2 ^ cosetDim w bits))

theorem inplaceInputSupp_eq_union (w bits numWin N cm k x : Nat) (TfamK TfamKinv : Nat → Nat → Nat) :
    inplaceInputSupp w bits N cm x
      = inplaceGoodIn w bits numWin N cm k x TfamK TfamKinv
        ∪ inplaceBadIn w bits numWin N cm k x TfamK TfamKinv

theorem inplaceGoodIn_disjoint_badIn (w bits numWin N cm k x : Nat) (TfamK TfamKinv : Nat → Nat → Nat) :
    Disjoint (inplaceGoodIn w bits numWin N cm k x TfamK TfamKinv)
      (inplaceBadIn w bits numWin N cm k x TfamK TfamKinv)

noncomputable def inplaceBfwd (w bits numWin N cm k x : Nat) (TfamK TfamKinv : Nat → Nat → Nat) :
    Finset (Fin (2 ^ cosetDim w bits))

noncomputable def inplaceBrev (w bits numWin N cm k x : Nat) (TfamK TfamKinv : Nat → Nat → Nat) :
    Finset (Fin (2 ^ cosetDim w bits))

theorem inplaceBadIn_eq_union (w bits numWin N cm k x : Nat) (TfamK TfamKinv : Nat → Nat → Nat) :
    inplaceBadIn w bits numWin N cm k x TfamK TfamKinv
      = inplaceBfwd w bits numWin N cm k x TfamK TfamKinv
        ∪ inplaceBrev w bits numWin N cm k x TfamK TfamKinv

theorem gidneyInPlaceWithSwap_agree_off (w bits numWin N cm k kInv x : Nat)
    (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfit : (k * x) % N + (2 ^ cm - 1) * N < 2 ^ bits) :
    ∃ B : Finset (Fin (2 ^ cosetDim w bits)),
      ∀ i : Fin (2 ^ cosetDim w bits), i ∉ B →
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
            (gidneyInPlaceWithSwap w bits TfamK TfamKinv numWin))
          * cosetInputVec w bits N cm x 0) i 0

theorem inplace_hred (w bits numWin N cm k x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (j : Fin (2 ^ cosetDim w bits))
    (hj : j ∈ (inplaceBadSetB w bits numWin N cm k x TfamK TfamKinv hw hbits).image
        (inplaceSigma w bits numWin TfamK TfamKinv hw hbits).symm)
    (hjne : cosetInputVec w bits N cm x 0 j 0 ≠ 0) :
    j ∈ inplaceBadIn w bits numWin N cm k x TfamK TfamKinv

theorem extendBool_inplaceAccInput (w bits numWin z y : Nat) (hbits : numWin * w = bits) :
    extendBool (cosetDim w bits)
        (fun p : Fin (cosetDim w bits) =>
          inplaceAccInput w bits numWin (1 + 2 * w) (1 + 2 * w + bits) z y p.val)
      = inplaceAccInput w bits numWin (1 + 2 * w) (1 + 2 * w + bits) z y

theorem applyNat_swapAB_inplaceAccInput (w bits numWin z y : Nat) (hbits : numWin * w = bits) :
    Gate.applyNat (swapAB w bits) (inplaceAccInput w bits numWin (1 + 2 * w) (1 + 2 * w + bits) z y)
      = inplaceAccInput w bits numWin (1 + 2 * w) (1 + 2 * w + bits) y z

theorem swapAB_branch_action (w bits numWin y z : Nat) (hbits : numWin * w = bits)
    (hy : y < 2 ^ bits) (hz : z < 2 ^ bits) :
    gateToPerm (swapAB w bits) (cosetDim w bits) (swapAB_wellTyped w bits)
        (eGid w bits (1 + 2 * w) (pass2_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w) (1 + 2 * w + bits) y, ⟨z, hz⟩))
      = eGid w bits (1 + 2 * w) (pass2_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w) (1 + 2 * w + bits) z, ⟨y, hy⟩)

theorem gidneyInPlaceWithSwap_branch_action (w bits numWin : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (ja jb : Nat) (hw : 0 < w) (hbits : numWin * w = bits) (hja : ja < 2 ^ bits) (hjb : jb < 2 ^ bits) :
    gateToPerm (gidneyInPlaceWithSwap w bits TfamK TfamKinv numWin) (cosetDim w bits)
        (gidneyInPlaceWithSwap_wellTyped w bits TfamK TfamKinv numWin hw hbits)
        (eGid w bits (1 + 2 * w + bits) (pass1_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w + bits) (1 + 2 * w) ja, ⟨jb, hjb⟩))
      = eGid w bits (1 + 2 * w) (pass2_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w) (1 + 2 * w + bits)
              (modSub bits ja (∑ k ∈ Finset.range numWin, TfamKinv k
                (window w ((jb + ∑ k ∈ Finset.range numWin, TfamK k (window w ja k)) % 2 ^ bits) k))),
            ⟨(jb + ∑ k ∈ Finset.range numWin, TfamK k (window w ja k)) % 2 ^ bits,
              Nat.mod_lt _ (by positivity)⟩)

def gidneyInPlaceWithSwap (w bits : Nat) (TfamK TfamKinv : Nat → Nat → Nat) (numWin : Nat) : Gate

theorem gidneyInPlaceWithSwap_wellTyped (w bits : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (numWin : Nat) (hw : 0 < w) (hbits : numWin * w = bits) :
    Gate.WellTyped (cosetDim w bits) (gidneyInPlaceWithSwap w bits TfamK TfamKinv numWin)

theorem eGid_apply (w bits numWin accBase yBase y z : Nat) (hz : z < 2 ^ bits)
    (haccfit : accBase + bits ≤ cosetDim w bits) :
    eGid w bits accBase haccfit (xCtrlGid w bits numWin accBase yBase y, ⟨z, hz⟩)
      = funboolNat (cosetDim w bits)
          (fun p => inplaceAccInput w bits numWin accBase yBase z y p.val)

noncomputable def cosetInputGid (w bits numWin N cm accBase yBase k y : Nat)
    (haccfit : accBase + bits ≤ cosetDim w bits) : QState (2 ^ cosetDim w bits)

theorem branchOfE_cosetInputGid_active (w bits numWin N cm accBase yBase k y : Nat)
    (haccfit : accBase + bits ≤ cosetDim w bits) :
    branchOfE (eGid w bits accBase haccfit)
        (cosetInputGid w bits numWin N cm accBase yBase k y haccfit)
        (xCtrlGid w bits numWin accBase yBase y)
      = cosetState (2 ^ bits) N cm k

theorem branchOfE_cosetInputGid_zero (w bits numWin N cm accBase yBase k y : Nat)
    (haccfit : accBase + bits ≤ cosetDim w bits)
    (x : Fin (2 ^ (cosetDim w bits - bits))) (hx : x ≠ xCtrlGid w bits numWin accBase yBase y) :
    branchOfE (eGid w bits accBase haccfit)
        (cosetInputGid w bits numWin N cm accBase yBase k y haccfit) x
      = fun _ _ => 0

theorem cosetInputGid_at_accInput (w bits numWin N cm accBase yBase k y z : Nat)
    (hz : z < 2 ^ bits) (haccfit : accBase + bits ≤ cosetDim w bits) :
    cosetInputGid w bits numWin N cm accBase yBase k y haccfit
        (funboolNat (cosetDim w bits)
          (fun p => inplaceAccInput w bits numWin accBase yBase z y p.val)) 0
      = cosetState (2 ^ bits) N cm k ⟨z, hz⟩ 0

private theorem normSq_coeff (cm : Nat) :
    Complex.normSq ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) = 1 / 2 ^ cm

theorem betaB_normSq_total (w bits numWin N cm x : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hN : 0 < N) (hfit_x : x + (2 ^ cm - 1) * N < 2 ^ bits) :
    ∑ ctrl : Fin (2 ^ (cosetDim w bits - bits)),
        Complex.normSq (betaB w bits N cm x ctrl.val) = 1

theorem cosetInputVec_normalized (w bits numWin N cm x : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hN : 0 < N) (hfit_x : x + (2 ^ cm - 1) * N < 2 ^ bits) :
    bornWeightOn (cosetInputVec w bits N cm x 0) Finset.univ = 1

def aBase (w : Nat) : Nat

def bBase (w bits : Nat) : Nat

def scratchClean (w bits : Nat) (g : Nat → Bool) : Prop

noncomputable def cosetInputTwoReg (w bits N cm xa xb : Nat) :
    QState (2 ^ cosetDim w bits)

theorem nat_to_funbool_funboolNat_agree (dim : Nat) (f : Fin dim → Bool)
    (p : Nat) (hp : p < dim) :
    nat_to_funbool dim (funboolNat dim f).val p = GatePerm.extendBool dim f p

theorem scratchClean_congr_offBlocks (w bits : Nat) (g h : Nat → Bool)
    (hgh : ∀ p, p < cosetDim w bits →
      ¬ (aBase w ≤ p ∧ p < aBase w + bits) →
      ¬ (bBase w bits ≤ p ∧ p < bBase w bits + bits) → g p = h p) :
    scratchClean w bits g ↔ scratchClean w bits h

theorem cosetInputTwoReg_funboolNat (w bits N cm xa xb : Nat)
    (f : Fin (cosetDim w bits) → Bool) :
    cosetInputTwoReg w bits N cm xa xb (funboolNat (cosetDim w bits) f) 0
      = if scratchClean w bits (GatePerm.extendBool (cosetDim w bits) f) then
          (if (⟨decodeReg (fun i => aBase w + i) bits (GatePerm.extendBool (cosetDim w bits) f),
                decodeReg_lt_two_pow _ _ _⟩ : Fin (2 ^ bits))
              ∈ cosetWindow (2 ^ bits) N cm xa
            then ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) else 0)
          * (if (⟨decodeReg (fun i => bBase w bits + i) bits (GatePerm.extendBool (cosetDim w bits) f),
                  decodeReg_lt_two_pow _ _ _⟩ : Fin (2 ^ bits))
              ∈ cosetWindow (2 ^ bits) N cm xb
              then ((1 / Real.sqrt (2 ^ cm) : ℝ) : ℂ) else 0)

noncomputable def ctrlFunB (w bits ctrl : Nat) : Nat → Bool

noncomputable def betaB (w bits N cm xa ctrl : Nat) : ℂ

noncomputable def ctrlFunA (w bits ctrl : Nat) : Nat → Bool

noncomputable def betaA (w bits N cm xb ctrl : Nat) : ℂ

theorem assembleEGid_off_block_zindep (w bits accBase x z p : Nat)
    (haccfit : accBase + bits ≤ cosetDim w bits) (hp : p < cosetDim w bits)
    (hoff : ¬ (accBase ≤ p ∧ p < accBase + bits)) :
    assembleEGid w bits accBase x z p = assembleEGid w bits accBase x 0 p

theorem branchOfE_cosetInputTwoReg_passB (w bits N cm xa xb : Nat)
    (ctrl : Fin (2 ^ (cosetDim w bits - bits))) :
    branchOfE (eGid w bits (bBase w bits) (pass1_accfit w bits))
        (cosetInputTwoReg w bits N cm xa xb) ctrl
      = fun i z => (betaB w bits N cm xa ctrl.val) * cosetState (2 ^ bits) N cm xb i z

theorem branchOfE_cosetInputTwoReg_passA (w bits N cm xa xb : Nat)
    (ctrl : Fin (2 ^ (cosetDim w bits - bits))) :
    branchOfE (eGid w bits (aBase w) (pass2_accfit w bits))
        (cosetInputTwoReg w bits N cm xa xb) ctrl
      = fun i z => (betaA w bits N cm xb ctrl.val) * cosetState (2 ^ bits) N cm xa i z

theorem cosetMul_stepInv_fold (w bits N c numWin y acc₀ : Nat) (hw : 0 < w)
    (f : Nat → Bool) (hf : StepInv cuccaroAdder w bits numWin y acc₀ f) :
    StepInv cuccaroAdder w bits numWin y
        (acc₀ + ∑ k ∈ Finset.range numWin, tableValue c N w k (window w y k))
        (Gate.applyNat (cosetModMulCircuitOf cuccaroAdder w bits N c numWin) f)

theorem cosetMul_pass_concrete (w bits N c numWin acc₀ y : Nat) (hw : 0 < w) :
    Gate.applyNat (cosetModMulCircuitOf cuccaroAdder w bits N c numWin)
        (mulInputAccOf cuccaroAdder w bits numWin acc₀ y)
      = mulInputAccOf cuccaroAdder w bits numWin
          ((acc₀ + ∑ k ∈ Finset.range numWin, tableValue c N w k (window w y k)) % 2 ^ bits) y

theorem accYSwap_mulInputAccOf (w bits numWin acc₀ y : Nat) (hbits : numWin * w = bits) :
    Gate.applyNat (accYSwap cuccaroAdder w bits)
        (mulInputAccOf cuccaroAdder w bits numWin acc₀ y)
      = mulInputAccOf cuccaroAdder w bits numWin y acc₀

theorem inplaceCosetGate_per_term (w bits N a aInv numWin acc₀ y : Nat) (hw : 0 < w)
    (hbits : numWin * w = bits) :
    Gate.applyNat (inplaceCosetGate w bits N a aInv numWin)
        (mulInputAccOf cuccaroAdder w bits numWin acc₀ y)
      = mulInputAccOf cuccaroAdder w bits numWin
          ((y + ∑ k ∈ Finset.range numWin, tableValue (N - aInv) N w k
              (window w
                ((acc₀ + ∑ k ∈ Finset.range numWin, tableValue a N w k (window w y k)) % 2 ^ bits)
                k)) % 2 ^ bits)
          ((acc₀ + ∑ k ∈ Finset.range numWin, tableValue a N w k (window w y k)) % 2 ^ bits)

theorem cosetMul_clearing_residue (w N a aInv numWin y V : Nat)
    (hN : 0 < N) (hV_lt : V < (2 ^ w) ^ numWin) (hVmod : V % N = (a * y) % N)
    (hy : y < N) (haInv : aInv < N) (hinv : a * aInv % N = 1) :
    (y + ∑ k ∈ Finset.range numWin, tableValue (N - aInv) N w k (window w V k)) % N = 0

theorem inplaceCosetGate_forward_state (w bits N a numWin y cm : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N)
    (hfitAll : runningSum (cosetWindowConst a N w y) numWin + (2 ^ cm - 1) * N < 2 ^ bits) :
    (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
        (cosetModMulCircuitOf cuccaroAdder w bits N a numWin))
      * (id (cosetInput w bits numWin N cm 0 y) :
          Matrix (Fin (2 ^ cosetDim w bits)) (Fin 1) ℂ))
      = cosetInput w bits numWin N cm (runningSum (cosetWindowConst a N w y) numWin) y

theorem inplaceCosetGate_forward_deviation (w bits N a numWin y cm : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N)
    (hy : y < (2 ^ w) ^ numWin) (hfit_engine : N + 2 ^ cm * N ≤ 2 ^ bits)
    (hfitAll : runningSum (cosetWindowConst a N w y) numWin + (2 ^ cm - 1) * N < 2 ^ bits) :
    normSqDist
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
            (cosetModMulCircuitOf cuccaroAdder w bits N a numWin))
          * (id (cosetInput w bits numWin N cm 0 y) :
              Matrix (Fin (2 ^ cosetDim w bits)) (Fin 1) ℂ))
        (cosetInput w bits numWin N cm ((a * y) % N) y)
      ≤ (numWin : ℝ) * (2 / 2 ^ cm)

theorem inplaceAccInput_swap (w bits numWin ja jb' : Nat) (hbits : numWin * w = bits) :
    inplaceAccInput w bits numWin (bBase w bits) (aBase w) jb' ja
      = inplaceAccInput w bits numWin (aBase w) (bBase w bits) ja jb'

theorem eGid_refactor_pass1_to_pass2 (w bits numWin : Nat) (hbits : numWin * w = bits)
    (ja jb' : Nat) (hja : ja < 2 ^ bits) (hjb' : jb' < 2 ^ bits) :
    eGid w bits (bBase w bits) (pass1_accfit w bits)
        (xCtrlGid w bits numWin (bBase w bits) (aBase w) ja, ⟨jb', hjb'⟩)
      = eGid w bits (aBase w) (pass2_accfit w bits)
          (xCtrlGid w bits numWin (aBase w) (bBase w bits) jb', ⟨ja, hja⟩)

theorem pass1_output_as_pass2_branch (w bits numWin : Nat) (TfamK : Nat → Nat → Nat)
    (ja jb : Nat) (hw : 0 < w) (hbits : numWin * w = bits) (hja : ja < 2 ^ bits)
    (hjb : jb < 2 ^ bits)
    (hjb' : (jb + ∑ k ∈ Finset.range numWin, TfamK k (window w ja k)) % 2 ^ bits < 2 ^ bits)
    (hwt : Gate.WellTyped (cosetDim w bits)
      (FormalRV.Shor.GidneyInPlace.ProductAddWrapper.gidneyProductAddTOf w bits TfamK
        (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) numWin)) :
    gateToPerm (FormalRV.Shor.GidneyInPlace.ProductAddWrapper.gidneyProductAddTOf w bits TfamK
        (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) numWin) (cosetDim w bits) hwt
        (eGid w bits (1 + 2 * w + bits) (pass1_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w + bits) (1 + 2 * w) ja, ⟨jb, hjb⟩))
      = eGid w bits (1 + 2 * w) (pass2_accfit w bits)

theorem runningSum_eq_sum (cs : Nat → Nat) (n : Nat) :
    runningSum cs n = ∑ k ∈ Finset.range n, cs k

theorem canonicalSum_eq_runningSum (K N w numWin y : Nat) (Tfam : Nat → Nat → Nat)
    (hTfam : ∀ k addr, Tfam k addr = tableValue K N w k addr) :
    ∑ k ∈ Finset.range numWin, Tfam k (window w y k)
      = runningSum (cosetWindowConst K N w y) numWin

theorem endpoint_residue_modN (K N w numWin y z : Nat) (Tfam : Nat → Nat → Nat)
    (hTfam : ∀ k addr, Tfam k addr = tableValue K N w k addr)
    (hN : 0 < N) (hy : y < (2 ^ w) ^ numWin) :
    (z + ∑ k ∈ Finset.range numWin, Tfam k (window w y k)) % N = (z + K * y) % N

theorem endpoint_embed_off (bits N cm K w numWin y : Nat) (Tfam : Nat → Nat → Nat)
    (hTfam : ∀ k addr, Tfam k addr = tableValue K N w k addr)
    (hN : 0 < N) (hy : y < (2 ^ w) ^ numWin) :
    ∃ B : Finset (Fin (2 ^ bits)),
      (∀ i, i ∉ B →
        cosetState (2 ^ bits) N cm (∑ k ∈ Finset.range numWin, Tfam k (window w y k)) i 0
          = cosetState (2 ^ bits) N cm ((K * y) % N) i 0)
      ∧ bornWeightOn (cosetState (2 ^ bits) N cm
          (∑ k ∈ Finset.range numWin, Tfam k (window w y k))) B ≤ (numWin : ℝ) / 2 ^ cm
      ∧ bornWeightOn (cosetState (2 ^ bits) N cm ((K * y) % N)) B ≤ (numWin : ℝ) / 2 ^ cm

theorem pass1_endpoint_embed_off (bits N cm k w numWin a : Nat) (Tfam : Nat → Nat → Nat)
    (hTfam : ∀ j addr, Tfam j addr = tableValue k N w j addr)
    (hN : 0 < N) (ha : a < (2 ^ w) ^ numWin) :
    ∃ B : Finset (Fin (2 ^ bits)),
      (∀ i, i ∉ B →
        cosetState (2 ^ bits) N cm (∑ j ∈ Finset.range numWin, Tfam j (window w a j)) i 0
          = cosetState (2 ^ bits) N cm ((k * a) % N) i 0)
      ∧ bornWeightOn (cosetState (2 ^ bits) N cm
          (∑ j ∈ Finset.range numWin, Tfam j (window w a j))) B ≤ (numWin : ℝ) / 2 ^ cm
      ∧ bornWeightOn (cosetState (2 ^ bits) N cm ((k * a) % N)) B ≤ (numWin : ℝ) / 2 ^ cm

theorem pass2_endpoint_embed_off (bits N cm k kInv w numWin x : Nat) (Tfam : Nat → Nat → Nat)
    (hTfam : ∀ j addr, Tfam j addr = tableValue kInv N w j addr)
    (hN : 0 < N) (hxN : x < N) (hkkinv : (kInv * k) % N = 1 % N)
    (hkxFit : (k * x) % N < (2 ^ w) ^ numWin) :
    ∃ B : Finset (Fin (2 ^ bits)),
      (∀ i, i ∉ B →
        cosetState (2 ^ bits) N cm
            (∑ j ∈ Finset.range numWin, Tfam j (window w ((k * x) % N) j)) i 0
          = cosetState (2 ^ bits) N cm x i 0)
      ∧ bornWeightOn (cosetState (2 ^ bits) N cm
          (∑ j ∈ Finset.range numWin, Tfam j (window w ((k * x) % N) j))) B ≤ (numWin : ℝ) / 2 ^ cm
      ∧ bornWeightOn (cosetState (2 ^ bits) N cm x) B ≤ (numWin : ℝ) / 2 ^ cm

theorem gidneyProductAddTOf_applyNat (w bits numWin : Nat) (Tfam : Nat → Nat → Nat)
    (y accBase tempBase yBase z : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hz : z < 2 ^ bits)
    (hv : accBase + bits ≤ tempBase) (hacc : 2 * w < accBase) (hyy : 2 * w < yBase)
    (hytemp : yBase + bits ≤ tempBase)
    (hYAccDisj : yBase + bits ≤ accBase ∨ accBase + bits ≤ yBase)
    (hpresY : ∀ (f' : Nat → Bool) i, i < numWin * w →
      Gate.applyNat (FormalRV.BQAlgo.relocatedAdderCircuit accBase tempBase bits) f' (yBase + i)
        = f' (yBase + i))
    (hcover : ∀ q, accBase ≤ q → q < tempBase + bits + 1 →
      (∃ i, i < bits ∧ q = accBase + i) ∨ (∃ i, i < bits ∧ q = tempBase + i)
        ∨ q = tempBase + bits ∨ (∃ i, i < numWin * w ∧ q = yBase + i)) :

theorem gidneyProductAddTOf_perm_through_eGid (w bits numWin : Nat) (Tfam : Nat → Nat → Nat)
    (accBase tempBase yBase y z : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hz : z < 2 ^ bits)
    (hz2 : (z + ∑ k ∈ Finset.range numWin, Tfam k (window w y k)) % 2 ^ bits < 2 ^ bits)
    (hv : accBase + bits ≤ tempBase) (hacc : 2 * w < accBase) (hyy : 2 * w < yBase)
    (hytemp : yBase + bits ≤ tempBase)
    (hYAccDisj : yBase + bits ≤ accBase ∨ accBase + bits ≤ yBase)
    (haccfit : accBase + bits ≤ cosetDim w bits) (htfit : tempBase + bits < cosetDim w bits)
    (hpresY : ∀ (f' : Nat → Bool) i, i < numWin * w →
      Gate.applyNat (FormalRV.BQAlgo.relocatedAdderCircuit accBase tempBase bits) f' (yBase + i)
        = f' (yBase + i))
    (hcover : ∀ q, accBase ≤ q → q < tempBase + bits + 1 →

theorem gidneyProductAddTOf_pass1_perm_through_eGid (w bits numWin : Nat) (Tfam : Nat → Nat → Nat)
    (y z : Nat) (hw : 0 < w) (hbits : numWin * w = bits) (hz : z < 2 ^ bits)
    (hz2 : (z + ∑ k ∈ Finset.range numWin, Tfam k (window w y k)) % 2 ^ bits < 2 ^ bits)
    (hwt : Gate.WellTyped (cosetDim w bits)
      (gidneyProductAddTOf w bits Tfam (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) numWin)) :
    gateToPerm (gidneyProductAddTOf w bits Tfam (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) numWin)
        (cosetDim w bits) hwt
        (eGid w bits (1 + 2 * w + bits) (pass1_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w + bits) (1 + 2 * w) y, ⟨z, hz⟩))
      = eGid w bits (1 + 2 * w + bits) (pass1_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w + bits) (1 + 2 * w) y,
            ⟨(z + ∑ k ∈ Finset.range numWin, Tfam k (window w y k)) % 2 ^ bits, hz2⟩)

theorem gidneyProductAddTOf_pass2_perm_through_eGid (w bits numWin : Nat) (Tfam : Nat → Nat → Nat)
    (y z : Nat) (hw : 0 < w) (hbits : numWin * w = bits) (hz : z < 2 ^ bits)
    (hz2 : (z + ∑ k ∈ Finset.range numWin, Tfam k (window w y k)) % 2 ^ bits < 2 ^ bits)
    (hwt : Gate.WellTyped (cosetDim w bits)
      (gidneyProductAddTOf w bits Tfam (1 + 2 * w) (1 + 2 * w + 2 * bits) (1 + 2 * w + bits) numWin)) :
    gateToPerm (gidneyProductAddTOf w bits Tfam (1 + 2 * w) (1 + 2 * w + 2 * bits) (1 + 2 * w + bits) numWin)
        (cosetDim w bits) hwt
        (eGid w bits (1 + 2 * w) (pass2_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w) (1 + 2 * w + bits) y, ⟨z, hz⟩))
      = eGid w bits (1 + 2 * w) (pass2_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w) (1 + 2 * w + bits) y,
            ⟨(z + ∑ k ∈ Finset.range numWin, Tfam k (window w y k)) % 2 ^ bits, hz2⟩)

theorem fwd_badjb_card_le (w bits numWin N cm k x ja : Nat) (TfamK : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hbits : numWin * w = bits) (hN : 0 < N)
    (hja : ja < 2 ^ bits)
    (hja_win : (⟨ja, hja⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm x) :
    (Finset.univ.filter (fun jb : Fin (2 ^ bits) =>
        jb ∈ cosetWindow (2 ^ bits) N cm 0
        ∧ ¬ (jb.val + (∑ j ∈ Finset.range numWin, TfamK j (window w ja j))
              < (k * x) % N + 2 ^ cm * N))).card ≤ numWin

theorem inplaceBfwd_card_le (w bits numWin N cm k x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N)
    (hxfit : x + (2 ^ cm - 1) * N < 2 ^ bits) :
    (inplaceBfwd w bits numWin N cm k x TfamK TfamKinv).card ≤ numWin * 2 ^ cm

theorem inplaceBfwd_bornWeight_le (w bits numWin N cm k x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N)
    (hxfit : x + (2 ^ cm - 1) * N < 2 ^ bits) :
    bornWeightOn (cosetInputVec w bits N cm x 0)
        (inplaceBfwd w bits numWin N cm k x TfamK TfamKinv) ≤ (numWin : ℝ) / 2 ^ cm

theorem mem_cosetWindow_modSub (bits N cm s : Nat) (hN : 0 < N) (hs : s < 2 ^ bits)
    (hfit : s + (2 ^ cm - 1) * N < 2 ^ bits) (i : Fin (2 ^ bits)) :
    (⟨modSub bits i.val s, Nat.mod_lt _ (by positivity)⟩ : Fin (2 ^ bits))
        ∈ cosetWindow (2 ^ bits) N cm 0
      ↔ i ∈ cosetWindow (2 ^ bits) N cm s

theorem cosetState_modSub_shift (bits N cm s : Nat) (hN : 0 < N) (hs : s < 2 ^ bits)
    (hfit : s + (2 ^ cm - 1) * N < 2 ^ bits) (i : Fin (2 ^ bits)) (z : Fin 1) :
    cosetState (2 ^ bits) N cm 0 ⟨modSub bits i.val s, Nat.mod_lt _ (by positivity)⟩ z
      = cosetState (2 ^ bits) N cm s i z

theorem leg1_branchOfE_dynamics (w bits numWin N cm : Nat) (TfamK : Nat → Nat → Nat)
    (x ja : Nat) (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N)
    (hfit : (∑ k ∈ Finset.range numWin, TfamK k (window w ja k)) + (2 ^ cm - 1) * N < 2 ^ bits)
    (hwt : Gate.WellTyped (cosetDim w bits)
      (gidneyProductAddTOf w bits TfamK (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) numWin)) :
    branchOfE (eGid w bits (1 + 2 * w + bits) (pass1_accfit w bits))
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
            (gidneyProductAddTOf w bits TfamK (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) numWin))
          * cosetInputVec w bits N cm x 0)
        (xCtrlGid w bits numWin (1 + 2 * w + bits) (1 + 2 * w) ja)
      = fun i z => betaB w bits N cm x (xCtrlGid w bits numWin (1 + 2 * w + bits) (1 + 2 * w) ja).val
          * cosetState (2 ^ bits) N cm (∑ k ∈ Finset.range numWin, TfamK k (window w ja k)) i z

theorem leg1_residue (bits N cm k x ja : Nat) (hN : 0 < N) (hja : ja < 2 ^ bits)
    (hmem : (⟨ja, hja⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm x) :
    (k * ja) % N = (k * x) % N

theorem leg1_actualAcc_eq (w bits numWin N cm k ja : Nat) (TfamK : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr) (hN : 0 < N) :
    actualAcc (2 ^ bits) N cm 0 (cosetWindowConst k N w ja) numWin
      = cosetState (2 ^ bits) N cm (∑ j ∈ Finset.range numWin, TfamK j (window w ja j))

theorem leg1_xval_roundtrip (w bits numWin ja : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hja : ja < 2 ^ bits) :
    decodeReg (fun i => aBase w + i) bits
        (ctrlFunB w bits (xCtrlGid w bits numWin (bBase w bits) (aBase w) ja).val) = ja

theorem leg1_hweight (w bits numWin N cm x : Nat) (hN : 0 < N)
    (hfit : x + (2 ^ cm - 1) * N < 2 ^ bits) :
    ∑ ctrl ∈ (cosetWindow (2 ^ bits) N cm x).image
        (fun ja : Fin (2 ^ bits) => xCtrlGid w bits numWin (bBase w bits) (aBase w) ja.val),
      Complex.normSq (betaB w bits N cm x ctrl.val) ≤ 1

theorem clean_ctrl_eq_xCtrlGid (w bits numWin ja : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (ctrl : Fin (2 ^ (cosetDim w bits - bits)))
    (hclean : scratchClean w bits (ctrlFunB w bits ctrl.val))
    (hdec : decodeReg (fun i => aBase w + i) bits (ctrlFunB w bits ctrl.val) = ja) :
    ctrl = xCtrlGid w bits numWin (bBase w bits) (aBase w) ja

theorem cosetInputTwoReg_support_nonzero (w bits N cm xa xb : Nat)
    (idx : Fin (2 ^ cosetDim w bits)) (z : Fin 1)
    (h : cosetInputTwoReg w bits N cm xa xb idx z ≠ 0) :
    scratchClean w bits (nat_to_funbool
        (cosetDim w bits) idx.val)
    ∧ (⟨decodeReg (fun i => aBase w + i) bits
          (nat_to_funbool (cosetDim w bits) idx.val),
        decodeReg_lt_two_pow _ _ _⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm xa
    ∧ (⟨decodeReg (fun i => bBase w bits + i) bits
          (nat_to_funbool (cosetDim w bits) idx.val),
        decodeReg_lt_two_pow _ _ _⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm xb

theorem P_as_eGid_image (w bits numWin ja z : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hz : z < 2 ^ bits) (idx : Fin (2 ^ cosetDim w bits))
    (hclean : scratchClean w bits (nat_to_funbool (cosetDim w bits) idx.val))
    (ha : decodeReg (fun i => aBase w + i) bits (nat_to_funbool (cosetDim w bits) idx.val) = ja)
    (hb : decodeReg (fun i => bBase w bits + i) bits (nat_to_funbool (cosetDim w bits) idx.val) = z) :
    idx = eGid w bits (bBase w bits) (pass1_accfit w bits)
        (xCtrlGid w bits numWin (bBase w bits) (aBase w) ja, ⟨z, hz⟩)

theorem leg1_hzero (w bits numWin N cm k x : Nat) (TfamK : Nat → Nat → Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hwt : Gate.WellTyped (cosetDim w bits)
      (gidneyProductAddTOf w bits TfamK (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) numWin))
    (ctrl : Fin (2 ^ (cosetDim w bits - bits)))
    (hctrl : ctrl ∉ (cosetWindow (2 ^ bits) N cm x).image
        (fun ja : Fin (2 ^ bits) => xCtrlGid w bits numWin (bBase w bits) (aBase w) ja.val)) :
    branchOfE (eGid w bits (bBase w bits) (pass1_accfit w bits))
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
            (gidneyProductAddTOf w bits TfamK (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) numWin))
          * cosetInputVec w bits N cm x 0) ctrl
      = branchOfE (eGid w bits (bBase w bits) (pass1_accfit w bits))

theorem gidneyTwoRegInPlace_leg1_deviation (w bits numWin N cm k x : Nat) (TfamK : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hfit_engine : N + 2 ^ cm * N ≤ 2 ^ bits)
    (hfitAll : ∀ ja : Fin (2 ^ bits),
      runningSum (cosetWindowConst k N w ja.val) numWin + (2 ^ cm - 1) * N < 2 ^ bits)
    (hwt : Gate.WellTyped (cosetDim w bits)
      (gidneyProductAddTOf w bits TfamK (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) numWin)) :
    normSqDist
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
            (gidneyProductAddTOf w bits TfamK (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) numWin))
          * cosetInputVec w bits N cm x 0)

theorem leg2_residue (bits N cm k kInv x jb : Nat) (hN : 0 < N) (hxN : x < N)
    (hkInv : (kInv * k) % N = 1 % N) (hjb : jb < 2 ^ bits)
    (hmem : (⟨jb, hjb⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm ((k * x) % N)) :
    (kInv * jb) % N = x

theorem leg2_branchOfE_dynamics (w bits numWin N cm : Nat) (TfamKinv : Nat → Nat → Nat)
    (xb jb : Nat) (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N)
    (hfit : (∑ k ∈ Finset.range numWin, TfamKinv k (window w jb k)) + (2 ^ cm - 1) * N < 2 ^ bits)
    (hwt : Gate.WellTyped (cosetDim w bits)
      (gidneyProductAddTOf w bits TfamKinv (1 + 2 * w) (1 + 2 * w + 2 * bits) (1 + 2 * w + bits) numWin)) :
    branchOfE (eGid w bits (1 + 2 * w) (pass2_accfit w bits))
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
            (gidneyProductAddTOf w bits TfamKinv (1 + 2 * w) (1 + 2 * w + 2 * bits) (1 + 2 * w + bits) numWin))
          * cosetInputVec w bits N cm 0 xb)
        (xCtrlGid w bits numWin (1 + 2 * w) (1 + 2 * w + bits) jb)
      = fun i z => betaA w bits N cm xb (xCtrlGid w bits numWin (1 + 2 * w) (1 + 2 * w + bits) jb).val
          * cosetState (2 ^ bits) N cm (∑ k ∈ Finset.range numWin, TfamKinv k (window w jb k)) i z

theorem leg2_clean_ctrl (w bits numWin jb : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (ctrl : Fin (2 ^ (cosetDim w bits - bits)))
    (hclean : scratchClean w bits (ctrlFunA w bits ctrl.val))
    (hdec : decodeReg (fun i => bBase w bits + i) bits (ctrlFunA w bits ctrl.val) = jb) :
    ctrl = xCtrlGid w bits numWin (aBase w) (bBase w bits) jb

theorem leg2_xval_roundtrip (w bits numWin jb : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hjb : jb < 2 ^ bits) :
    decodeReg (fun i => bBase w bits + i) bits
        (ctrlFunA w bits (xCtrlGid w bits numWin (aBase w) (bBase w bits) jb).val) = jb

theorem leg2_P_as_eGid_image (w bits numWin jb z : Nat) (hw : 0 < w) (hbits : numWin * w = bits)
    (hz : z < 2 ^ bits) (idx : Fin (2 ^ cosetDim w bits))
    (hclean : scratchClean w bits (nat_to_funbool (cosetDim w bits) idx.val))
    (ha : decodeReg (fun i => aBase w + i) bits (nat_to_funbool (cosetDim w bits) idx.val) = z)
    (hb : decodeReg (fun i => bBase w bits + i) bits (nat_to_funbool (cosetDim w bits) idx.val) = jb) :
    idx = eGid w bits (aBase w) (pass2_accfit w bits)
        (xCtrlGid w bits numWin (aBase w) (bBase w bits) jb, ⟨z, hz⟩)

theorem leg2_hzero (w bits numWin N cm x xb : Nat) (TfamKinv : Nat → Nat → Nat)
    (hw : 0 < w) (hbits : numWin * w = bits)
    (hwt : Gate.WellTyped (cosetDim w bits)
      (gidneyProductAddTOf w bits TfamKinv (1 + 2 * w) (1 + 2 * w + 2 * bits) (1 + 2 * w + bits) numWin))
    (ctrl : Fin (2 ^ (cosetDim w bits - bits)))
    (hctrl : ctrl ∉ (cosetWindow (2 ^ bits) N cm xb).image
        (fun jb : Fin (2 ^ bits) => xCtrlGid w bits numWin (aBase w) (bBase w bits) jb.val)) :
    branchOfE (eGid w bits (aBase w) (pass2_accfit w bits))
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
            (gidneyProductAddTOf w bits TfamKinv (1 + 2 * w) (1 + 2 * w + 2 * bits) (1 + 2 * w + bits) numWin))
          * cosetInputVec w bits N cm 0 xb) ctrl
      = branchOfE (eGid w bits (aBase w) (pass2_accfit w bits))

theorem leg2_hweight (w bits numWin N cm xb : Nat) (hN : 0 < N)
    (hfit : xb + (2 ^ cm - 1) * N < 2 ^ bits) :
    ∑ ctrl ∈ (cosetWindow (2 ^ bits) N cm xb).image
        (fun jb : Fin (2 ^ bits) => xCtrlGid w bits numWin (aBase w) (bBase w bits) jb.val),
      Complex.normSq (betaA w bits N cm xb ctrl.val) ≤ 1

theorem gidneyTwoRegInPlace_leg2_deviation (w bits numWin N cm k kInv x : Nat)
    (TfamKinv : Nat → Nat → Nat)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkInv : (kInv * k) % N = 1 % N)
    (hfit_engine : N + 2 ^ cm * N ≤ 2 ^ bits)
    (hfitAll : ∀ jb : Fin (2 ^ bits),
      runningSum (cosetWindowConst kInv N w jb.val) numWin + (2 ^ cm - 1) * N < 2 ^ bits)
    (hwt : Gate.WellTyped (cosetDim w bits)
      (gidneyProductAddTOf w bits TfamKinv (1 + 2 * w) (1 + 2 * w + 2 * bits) (1 + 2 * w + bits) numWin)) :
    normSqDist
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits)

theorem rev_badja_card_le (w bits numWin N cm k kInv x jbp : Nat) (TfamKinv : Nat → Nat → Nat)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hjbp : jbp < 2 ^ bits)
    (hjbp_win : (⟨jbp, hjbp⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm ((k * x) % N)) :
    (Finset.univ.filter (fun ja : Fin (2 ^ bits) =>
        ja ∈ cosetWindow (2 ^ bits) N cm x
        ∧ ja.val < (∑ j ∈ Finset.range numWin, TfamKinv j (window w jbp j)))).card ≤ numWin

theorem inplaceBrevSdiff_card_le (w bits numWin N cm k kInv x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfit : (k * x) % N + (2 ^ cm - 1) * N < 2 ^ bits) :
    ((inplaceBrev w bits numWin N cm k x TfamK TfamKinv)
      \ (inplaceBfwd w bits numWin N cm k x TfamK TfamKinv)).card ≤ numWin * 2 ^ cm

theorem inplaceBrevSdiff_bornWeight_le (w bits numWin N cm k kInv x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfit : (k * x) % N + (2 ^ cm - 1) * N < 2 ^ bits) :
    bornWeightOn (cosetInputVec w bits N cm x 0)
        ((inplaceBrev w bits numWin N cm k x TfamK TfamKinv)
          \ (inplaceBfwd w bits numWin N cm k x TfamK TfamKinv)) ≤ (numWin : ℝ) / 2 ^ cm

theorem inplaceBadIn_bornWeight_le (w bits numWin N cm k kInv x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfit : (k * x) % N + (2 ^ cm - 1) * N < 2 ^ bits)
    (hxfit : x + (2 ^ cm - 1) * N < 2 ^ bits) :
    bornWeightOn (cosetInputVec w bits N cm x 0)
        (InPlaceComposedAgree.inplaceBadIn w bits numWin N cm k x TfamK TfamKinv)
      ≤ 2 * (numWin : ℝ) / 2 ^ cm

theorem extendBool_applyFin (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g)
    (φ : Fin dim → Bool) :
    extendBool dim (applyFin g dim φ) = Gate.applyNat g (extendBool dim φ)

theorem applyFin_reverse_cancel (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g)
    (φ : Fin dim → Bool) :
    applyFin (GateReversible.Gate.reverse g) dim (applyFin g dim φ) = φ

theorem gateToPerm_reverse_cancel (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g)
    (idx : Fin (2 ^ dim)) :
    gateToPerm (GateReversible.Gate.reverse g) dim (reverse_wellTyped g dim hwt)
        (gateToPerm g dim hwt idx) = idx

theorem forward_to_reverse_applyNat (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g)
    (final0 mid : Nat → Bool) (h : Gate.applyNat g final0 = mid) :
    Gate.applyNat (GateReversible.Gate.reverse g) mid = final0

theorem forward_to_reverse_gateToPerm (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g)
    (idxA idxB : Fin (2 ^ dim)) (h : gateToPerm g dim hwt idxA = idxB) :
    gateToPerm (GateReversible.Gate.reverse g) dim (reverse_wellTyped g dim hwt) idxB = idxA

theorem forward_to_reverse_basis (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g)
    (idxA idxB : Fin (2 ^ dim)) (h : gateToPerm g dim hwt idxA = idxB) :
    Framework.uc_eval (Gate.toUCom dim (GateReversible.Gate.reverse g))
        * Framework.basis_vector (2 ^ dim) idxB.val
      = Framework.basis_vector (2 ^ dim) idxA.val

theorem pass2_forward_to_reverse_applyNat (w bits : Nat) (TfamKinv : Nat → Nat → Nat)
    (numWin : Nat) (hw : 0 < w) (hbits : numWin * w = bits) (final0 mid : Nat → Bool)
    (h : Gate.applyNat (pass2 w bits TfamKinv numWin) final0 = mid) :
    Gate.applyNat (GateReversible.Gate.reverse (pass2 w bits TfamKinv numWin)) mid = final0

theorem pass2_reverse_through_eGid (w bits numWin : Nat) (TfamKinv : Nat → Nat → Nat)
    (y z : Nat) (hw : 0 < w) (hbits : numWin * w = bits) (hz : z < 2 ^ bits)
    (hz2 : (z + ∑ k ∈ Finset.range numWin, TfamKinv k (window w y k)) % 2 ^ bits < 2 ^ bits)
    (hwt : Gate.WellTyped (cosetDim w bits) (pass2 w bits TfamKinv numWin)) :
    gateToPerm (GateReversible.Gate.reverse (pass2 w bits TfamKinv numWin)) (cosetDim w bits)
        (reverse_wellTyped (pass2 w bits TfamKinv numWin) (cosetDim w bits) hwt)
        (eGid w bits (1 + 2 * w) (pass2_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w) (1 + 2 * w + bits) y,
            ⟨(z + ∑ k ∈ Finset.range numWin, TfamKinv k (window w y k)) % 2 ^ bits, hz2⟩))
      = eGid w bits (1 + 2 * w) (pass2_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w) (1 + 2 * w + bits) y, ⟨z, hz⟩)

theorem windowSum_wrap_le (K N w numWin y c m : Nat) (Tfam : Nat → Nat → Nat)
    (hTfam : ∀ j addr, Tfam j addr = tableValue K N w j addr) (hN : 0 < N)
    (heq : (∑ j ∈ Finset.range numWin, Tfam j (window w y j)) = c + m * N) :
    m ≤ numWin

theorem fwd_jbp_landing (w bits numWin N cm k x ja jb : Nat) (TfamK : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hbits : numWin * w = bits) (hN : 0 < N)
    (hfit : (k * x) % N + (2 ^ cm - 1) * N < 2 ^ bits)
    (hja : ja < 2 ^ bits) (hjb : jb < 2 ^ bits)
    (hja_win : (⟨ja, hja⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm x)
    (hjb_win : (⟨jb, hjb⟩ : Fin (2 ^ bits)) ∈ cosetWindow (2 ^ bits) N cm 0)
    (hfwdgood : jb + (∑ j ∈ Finset.range numWin, TfamK j (window w ja j)) < (k * x) % N + 2 ^ cm * N) :
    ∃ r, r < 2 ^ cm
      ∧ jb + (∑ j ∈ Finset.range numWin, TfamK j (window w ja j)) = (k * x) % N + r * N
      ∧ (jb + ∑ j ∈ Finset.range numWin, TfamK j (window w ja j)) % 2 ^ bits = (k * x) % N + r * N

theorem Sinv_residue_decomp (w numWin N k kInv x y : Nat) (TfamKinv : Nat → Nat → Nat)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N) (hy : y < (2 ^ w) ^ numWin) (hymod : y % N = (k * x) % N) :
    ∃ t, t ≤ numWin ∧ (∑ j ∈ Finset.range numWin, TfamKinv j (window w y j)) = x + t * N

theorem inplaceAccInput_RelocStepInv (w bits numWin accBase tempBase yBase y z : Nat)
    (hbits : numWin * w = bits)
    (hacc : 2 * w < accBase) (hyy : 2 * w < yBase)
    (hv : accBase + bits ≤ tempBase) (hytemp : yBase + bits ≤ tempBase)
    (hYAccDisj : yBase + bits ≤ accBase ∨ accBase + bits ≤ yBase) :
    RelocStepInv w bits numWin y accBase tempBase yBase z
      (inplaceAccInput w bits numWin accBase yBase z y)

theorem relocatedProductAddStep_offAcc (w bits numWin : Nat) (T : Nat → Nat)
    (y accBase tempBase yBase j s : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hj : j < numWin)
    (hv : accBase + bits ≤ tempBase) (hacc : 2 * w < accBase) (hyy : 2 * w < yBase)
    (hytemp : yBase + bits ≤ tempBase)
    (hpresY : ∀ (f' : Nat → Bool) i, i < numWin * w →
      Gate.applyNat (FormalRV.BQAlgo.relocatedAdderCircuit accBase tempBase bits) f' (yBase + i)
        = f' (yBase + i))
    (hcover : ∀ q, accBase ≤ q → q < tempBase + bits + 1 →
      (∃ i, i < bits ∧ q = accBase + i) ∨ (∃ i, i < bits ∧ q = tempBase + i)
        ∨ q = tempBase + bits ∨ (∃ i, i < numWin * w ∧ q = yBase + i))
    (g : Nat → Bool) (hg : RelocStepInv w bits numWin y accBase tempBase yBase s g)

theorem relocatedProductAddStep_applyNat (w bits numWin : Nat) (T : Nat → Nat)
    (y accBase tempBase yBase j z : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hj : j < numWin)
    (hv : accBase + bits ≤ tempBase) (hacc : 2 * w < accBase) (hyy : 2 * w < yBase)
    (hytemp : yBase + bits ≤ tempBase)
    (hYAccDisj : yBase + bits ≤ accBase ∨ accBase + bits ≤ yBase)
    (hpresY : ∀ (f' : Nat → Bool) i, i < numWin * w →
      Gate.applyNat (FormalRV.BQAlgo.relocatedAdderCircuit accBase tempBase bits) f' (yBase + i)
        = f' (yBase + i))
    (hcover : ∀ q, accBase ≤ q → q < tempBase + bits + 1 →
      (∃ i, i < bits ∧ q = accBase + i) ∨ (∃ i, i < bits ∧ q = tempBase + i)
        ∨ q = tempBase + bits ∨ (∃ i, i < numWin * w ∧ q = yBase + i)) :

theorem extendBool_inplaceAccInput (w bits numWin accBase tempBase yBase z y : Nat)
    (hbits : numWin * w = bits) (hyy : 2 * w < yBase)
    (hytemp : yBase + bits ≤ tempBase)
    (haccfit : accBase + bits ≤ cosetDim w bits) (htfit : tempBase + bits < cosetDim w bits) :
    extendBool (cosetDim w bits)
        (fun i => inplaceAccInput w bits numWin accBase yBase z y i.val)
      = inplaceAccInput w bits numWin accBase yBase z y

theorem relocatedStep_perm_through_eGid (w bits numWin : Nat) (T : Nat → Nat)
    (accBase tempBase yBase y z j : Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (hj : j < numWin)
    (hz : z < 2 ^ bits) (hz2 : (z + T (window w y j)) % 2 ^ bits < 2 ^ bits)
    (hv : accBase + bits ≤ tempBase) (hacc : 2 * w < accBase) (hyy : 2 * w < yBase)
    (hytemp : yBase + bits ≤ tempBase)
    (hYAccDisj : yBase + bits ≤ accBase ∨ accBase + bits ≤ yBase)
    (haccfit : accBase + bits ≤ cosetDim w bits) (htfit : tempBase + bits < cosetDim w bits)
    (hpresY : ∀ (f' : Nat → Bool) i, i < numWin * w →
      Gate.applyNat (FormalRV.BQAlgo.relocatedAdderCircuit accBase tempBase bits) f' (yBase + i)
        = f' (yBase + i))
    (hcover : ∀ q, accBase ≤ q → q < tempBase + bits + 1 →

theorem relocatedStep_pass1_perm_through_eGid (w bits numWin : Nat) (T : Nat → Nat)
    (y z j : Nat) (hw : 0 < w) (hbits : numWin * w = bits) (hj : j < numWin)
    (hz : z < 2 ^ bits) (hz2 : (z + T (window w y j)) % 2 ^ bits < 2 ^ bits)
    (hwt : Gate.WellTyped (cosetDim w bits)
      (relocatedProductAddStep w bits T (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) j)) :
    gateToPerm (relocatedProductAddStep w bits T (1 + 2 * w + bits) (1 + 2 * w + 2 * bits) (1 + 2 * w) j)
        (cosetDim w bits) hwt
        (eGid w bits (1 + 2 * w + bits) (pass1_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w + bits) (1 + 2 * w) y, ⟨z, hz⟩))
      = eGid w bits (1 + 2 * w + bits) (pass1_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w + bits) (1 + 2 * w) y,
            ⟨(z + T (window w y j)) % 2 ^ bits, hz2⟩)

theorem relocatedStep_pass2_perm_through_eGid (w bits numWin : Nat) (T : Nat → Nat)
    (y z j : Nat) (hw : 0 < w) (hbits : numWin * w = bits) (hj : j < numWin)
    (hz : z < 2 ^ bits) (hz2 : (z + T (window w y j)) % 2 ^ bits < 2 ^ bits)
    (hwt : Gate.WellTyped (cosetDim w bits)
      (relocatedProductAddStep w bits T (1 + 2 * w) (1 + 2 * w + 2 * bits) (1 + 2 * w + bits) j)) :
    gateToPerm (relocatedProductAddStep w bits T (1 + 2 * w) (1 + 2 * w + 2 * bits) (1 + 2 * w + bits) j)
        (cosetDim w bits) hwt
        (eGid w bits (1 + 2 * w) (pass2_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w) (1 + 2 * w + bits) y, ⟨z, hz⟩))
      = eGid w bits (1 + 2 * w) (pass2_accfit w bits)
          (xCtrlGid w bits numWin (1 + 2 * w) (1 + 2 * w + bits) y,
            ⟨(z + T (window w y j)) % 2 ^ bits, hz2⟩)

theorem bornWeightOn_permState_symm {dim : Nat} (σ : Equiv.Perm (Fin dim)) (s : QState dim)
    (B : Finset (Fin dim)) :
    bornWeightOn (permState σ.symm s) B = bornWeightOn s (B.image σ.symm)

theorem bornWeightOn_le_of_support_subset {dim : Nat} (s : QState dim) (S T : Finset (Fin dim))
    (h : ∀ j ∈ S, s j 0 ≠ 0 → j ∈ T) :
    bornWeightOn s S ≤ bornWeightOn s T

theorem bornWeightOn_evolved_le_badInput {dim : Nat} (σ : Equiv.Perm (Fin dim)) (s : QState dim)
    (B badInput : Finset (Fin dim))
    (hred : ∀ j ∈ B.image σ.symm, s j 0 ≠ 0 → j ∈ badInput) :
    bornWeightOn (permState σ.symm s) B ≤ bornWeightOn s badInput

theorem cosetInputVec_bornWeight_le_card (w bits N cm x : Nat)
    (S : Finset (Fin (2 ^ cosetDim w bits))) :
    bornWeightOn (cosetInputVec w bits N cm x 0) S
      ≤ (S.card : ℝ) * (1 / 2 ^ cm * (1 / 2 ^ cm))

theorem inplaceBadSetB_evolved_bornWeight_le
    (w bits numWin N cm k kInv x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfit : (k * x) % N + (2 ^ cm - 1) * N < 2 ^ bits)
    (hxfit : x + (2 ^ cm - 1) * N < 2 ^ bits) :
    bornWeightOn
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
            (gidneyInPlaceWithSwap w bits TfamK TfamKinv numWin))
          * cosetInputVec w bits N cm x 0)

theorem normSqDist_comm {dim : Nat} (s₁ s₂ : QState dim) :
    normSqDist s₁ s₂ = normSqDist s₂ s₁

theorem gidneyTwoRegInPlace_coset_norm_bound
    (w bits numWin N cm k kInv x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkInv : (kInv * k) % N = 1 % N)
    (hfit_engine : N + 2 ^ cm * N ≤ 2 ^ bits)
    (hfitAllK : ∀ ja : Fin (2 ^ bits),
      runningSum (cosetWindowConst k N w ja.val) numWin + (2 ^ cm - 1) * N < 2 ^ bits)
    (hfitAllKinv : ∀ jb : Fin (2 ^ bits),
      runningSum (cosetWindowConst kInv N w jb.val) numWin + (2 ^ cm - 1) * N < 2 ^ bits) :
    normSqDist

noncomputable def cosetInputVec (w bits N cm xa xb : Nat) :
    Matrix (Fin (2 ^ cosetDim w bits)) (Fin 1) ℂ

theorem uc_eval_reverse_cancel (g : Gate) (dim : Nat) (hwt : Gate.WellTyped dim g)
    (s : Matrix (Fin (2 ^ dim)) (Fin 1) ℂ) :
    Framework.uc_eval (Gate.toUCom dim (GateReversible.Gate.reverse g))
        * (Framework.uc_eval (Gate.toUCom dim g) * s) = s

theorem gidneyTwoRegInPlace_coset_norm_bound_of_legs
    (w bits numWin N cm k x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hw : 0 < w) (hbits : numWin * w = bits) (L : ℝ)
    (hleg1 : normSqDist
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits) (pass1 w bits TfamK numWin))
          * cosetInputVec w bits N cm x 0)
        (cosetInputVec w bits N cm x ((k * x) % N)) ≤ L)
    (hleg2 : normSqDist
        (cosetInputVec w bits N cm x ((k * x) % N))
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits) (pass2 w bits TfamKinv numWin))
          * cosetInputVec w bits N cm 0 ((k * x) % N)) ≤ L) :
    normSqDist

theorem bornWeightOn_permState_symm_univ {dim : Nat} (σ : Equiv.Perm (Fin dim)) (s : QState dim) :
    bornWeightOn (permState σ.symm s) Finset.univ = bornWeightOn s Finset.univ

theorem bornWeightOn_eq_of_agree_off_of_total_eq {dim : Nat} (s₁ s₂ : QState dim)
    (B : Finset (Fin dim))
    (hagree : ∀ i, i ∉ B → s₁ i 0 = s₂ i 0)
    (htot : bornWeightOn s₁ Finset.univ = bornWeightOn s₂ Finset.univ) :
    bornWeightOn s₁ B = bornWeightOn s₂ B

theorem inplaceBadSetB_target_bornWeight_le
    (w bits numWin N cm k kInv x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfit : (k * x) % N + (2 ^ cm - 1) * N < 2 ^ bits)
    (hxfit : x + (2 ^ cm - 1) * N < 2 ^ bits)
    (hagreeB : ∀ i : Fin (2 ^ cosetDim w bits),
        i ∉ inplaceBadSetB w bits numWin N cm k x TfamK TfamKinv hw hbits →
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
            (gidneyInPlaceWithSwap w bits TfamK TfamKinv numWin))

theorem inplaceBadSetB_target_bornWeight_le_closed
    (w bits numWin N cm k kInv x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfit : (k * x) % N + (2 ^ cm - 1) * N < 2 ^ bits)
    (hxfit : x + (2 ^ cm - 1) * N < 2 ^ bits) :
    bornWeightOn (cosetInputVec w bits N cm ((k * x) % N) 0)
        (inplaceBadSetB w bits numWin N cm k x TfamK TfamKinv hw hbits)
      ≤ 2 * (numWin : ℝ) / 2 ^ cm

theorem inPlaceMul_deviation_compose {dim : Nat}
    (U_fwd U_rev : QState dim → QState dim) (σ_swap : Equiv.Perm (Fin dim))
    (s_in I_fwd s_out : QState dim) (δf δi : ℝ)
    (hrev_isom : ∀ a b, normSqDist (U_rev a) (U_rev b) = normSqDist a b)
    (hfwd : normSqDist (U_fwd s_in) I_fwd ≤ δf)
    (hrev : normSqDist (U_rev (permState σ_swap I_fwd)) s_out ≤ δi) :
    normSqDist (U_rev (permState σ_swap (U_fwd s_in))) s_out ≤ δf + δi

theorem inPlaceMul_coset_deviation {dim : Nat}
    (U_fwd U_rev : QState dim → QState dim) (σ_swap : Equiv.Perm (Fin dim))
    (s_in I_fwd s_out : QState dim) (numAdds m : Nat)
    (hrev_isom : ∀ a b, normSqDist (U_rev a) (U_rev b) = normSqDist a b)
    (hfwd : normSqDist (U_fwd s_in) I_fwd ≤ (numAdds : ℝ) * (2 / 2 ^ m))
    (hrev : normSqDist (U_rev (permState σ_swap I_fwd)) s_out ≤ (numAdds : ℝ) * (2 / 2 ^ m)) :
    normSqDist (U_rev (permState σ_swap (U_fwd s_in))) s_out
      ≤ 2 * (numAdds : ℝ) * (2 / 2 ^ m)

theorem inPlaceMul_coset_deviation_gates {bits : Nat}
    (U_fwd : QState (2 ^ bits) → QState (2 ^ bits)) (mulInv swapG : Gate)
    (hwt_inv : Gate.WellTyped bits mulInv) (hwt_swap : Gate.WellTyped bits swapG)
    (s_in I_fwd s_out : QState (2 ^ bits)) (numAdds m : Nat)
    (hfwd : normSqDist (U_fwd s_in) I_fwd ≤ (numAdds : ℝ) * (2 / 2 ^ m))
    (hrev : normSqDist
        (permState (gateToPerm (Gate.reverse mulInv) bits
            (reverse_wellTyped mulInv bits hwt_inv))
          (permState (gateToPerm swapG bits hwt_swap) I_fwd)) s_out
        ≤ (numAdds : ℝ) * (2 / 2 ^ m)) :
    normSqDist
        (permState (gateToPerm (Gate.reverse mulInv) bits

theorem inPlaceMul_coset_deviation_sqir {bits : Nat}
    (U_fwd : Matrix (Fin (2 ^ bits)) (Fin 1) ℂ → Matrix (Fin (2 ^ bits)) (Fin 1) ℂ)
    (mulInv swapG : Gate)
    (hwt_inv : Gate.WellTyped bits mulInv) (hwt_swap : Gate.WellTyped bits swapG)
    (s_in I_fwd s_out : Matrix (Fin (2 ^ bits)) (Fin 1) ℂ) (numAdds m : Nat)
    (hfwd : normSqDist (U_fwd s_in) I_fwd ≤ (numAdds : ℝ) * (2 / 2 ^ m))
    (hrev : normSqDist
        (Framework.uc_eval (Gate.toUCom bits (Gate.reverse mulInv)) *
          (Framework.uc_eval (Gate.toUCom bits swapG) * I_fwd)) s_out
        ≤ (numAdds : ℝ) * (2 / 2 ^ m)) :
    normSqDist
        (Framework.uc_eval (Gate.toUCom bits (Gate.reverse mulInv)) *

theorem gidneyInPlaceWithSwap_coset_deviation
    (w bits numWin N cm k kInv x : Nat) (TfamK TfamKinv : Nat → Nat → Nat)
    (hTfamK : ∀ j addr, TfamK j addr = tableValue k N w j addr)
    (hTfamKinv : ∀ j addr, TfamKinv j addr = tableValue kInv N w j addr)
    (hw : 0 < w) (hbits : numWin * w = bits) (hN : 0 < N) (hxN : x < N)
    (hkkinv : (kInv * k) % N = 1 % N)
    (hfit : (k * x) % N + (2 ^ cm - 1) * N < 2 ^ bits)
    (hxfit : x + (2 ^ cm - 1) * N < 2 ^ bits) :
    normSqDist
        (Framework.uc_eval (Gate.toUCom (cosetDim w bits)
            (gidneyInPlaceWithSwap w bits TfamK TfamKinv numWin))
          * cosetInputVec w bits N cm x 0)

def inplaceReducedLookupCosetMul_shift
    (n anc N cm a numWin : Nat) (g : FormalRV.Framework.BaseUCom (n + anc)) : Prop

noncomputable def cosetEmbedMat (d N cm : Nat) (y yp : Fin d) : ℂ

theorem cosetEmbedMat_eq_cosetState (d N cm : Nat) (y yp : Fin d) :
    cosetEmbedMat d N cm y yp = cosetState d N cm yp.val y 0

noncomputable def E_data (d N cm : Nat) (psi : QState d) : QState d

noncomputable def E_phys (m n anc N cm : Nat)
    (phi : QState (2 ^ m * 2 ^ n * 2 ^ anc)) : QState (2 ^ m * 2 ^ n * 2 ^ anc)

theorem E_phys_acts (m n anc N cm : Nat) (phi : QState (2 ^ m * 2 ^ n * 2 ^ anc))
    (x : Fin (2 ^ m)) (y : Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m)) :
    E_phys m n anc N cm phi (jointIdx (shorDvd m n anc) x y) 0
      = ∑ yp : Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m),
          cosetEmbedMat ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m) N cm y yp *
            phi (jointIdx (shorDvd m n anc) x yp) 0

theorem E_phys_comm (m n anc N cm : Nat)
    (P : QState (2 ^ m * 2 ^ n * 2 ^ anc) → QState (2 ^ m * 2 ^ n * 2 ^ anc))
    (hP : PhaseLocal (shorDvd m n anc) P)
    (phi : QState (2 ^ m * 2 ^ n * 2 ^ anc))
    (x : Fin (2 ^ m)) (y : Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m)) :
    (P (E_phys m n anc N cm phi)) (jointIdx (shorDvd m n anc) x y) 0
      = (E_phys m n anc N cm (P phi)) (jointIdx (shorDvd m n anc) x y) 0

theorem cosetWindow_disjoint (d N cm k kp : Nat) (hN : 0 < N)
    (hk : k < N) (hkp : kp < N) (hne : k ≠ kp) :
    Disjoint (cosetWindow d N cm k) (cosetWindow d N cm kp)

private theorem normSq_sum_canon_pairwise {ι : Type*} [DecidableEq ι]
    (s : Finset ι) (f : ι → ℂ)
    (hpair : ∀ a ∈ s, ∀ b ∈ s, a ≠ b → f a = 0 ∨ f b = 0) :
    Complex.normSq (∑ i ∈ s, f i) = ∑ i ∈ s, Complex.normSq (f i)

theorem E_phys_marginal (m n anc N cm : Nat)
    (phi : QState (2 ^ m * 2 ^ n * 2 ^ anc)) (hN : 0 < N)
    (hMN : 2 ^ cm * N ≤ (2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m)
    (hsupp : ∀ (x : Fin (2 ^ m)) (yp : Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m)),
      N ≤ yp.val → phi (jointIdx (shorDvd m n anc) x yp) 0 = 0)
    (x : Fin (2 ^ m)) :
    (∑ y : Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m),
        Complex.normSq (E_phys m n anc N cm phi (jointIdx (shorDvd m n anc) x y) 0))
      = (∑ y : Fin ((2 ^ m * 2 ^ n * 2 ^ anc) / 2 ^ m),
          Complex.normSq (phi (jointIdx (shorDvd m n anc) x y) 0))

noncomputable def branchOfE {m d full : Nat} (e : Fin m × Fin d ≃ Fin full)
    (s : QState full) (x : Fin m) : QState d

theorem sum_prodEquiv_eq {m d full : Nat} (e : Fin m × Fin d ≃ Fin full)
    (g : Fin full → ℝ) :
    ∑ x : Fin m, ∑ y : Fin d, g (e (x, y)) = ∑ i : Fin full, g i

theorem normSqDist_branchOfE_decomp {m d full : Nat} (e : Fin m × Fin d ≃ Fin full)
    (s₁ s₂ : QState full) :
    normSqDist s₁ s₂
      = ∑ x : Fin m, normSqDist (branchOfE e s₁ x) (branchOfE e s₂ x)

theorem normSqDist_branchOfE_controlled_lift {m d full : Nat} (e : Fin m × Fin d ≃ Fin full)
    (s₁ s₂ : QState full) (active : Finset (Fin m)) (dd : Fin m → ℝ)
    (hzero : ∀ x, x ∉ active → branchOfE e s₁ x = branchOfE e s₂ x)
    (hactive : ∀ x, x ∈ active → normSqDist (branchOfE e s₁ x) (branchOfE e s₂ x) ≤ dd x) :
    normSqDist s₁ s₂ ≤ ∑ x ∈ active, dd x

theorem normSqDist_branchOfE_controlled_lift_weighted {m d full : Nat}
    (e : Fin m × Fin d ≃ Fin full)
    (s₁ s₂ : QState full) (active : Finset (Fin m)) (β : Fin m → ℂ) (D : ℝ)
    (a₁ a₂ : Fin m → QState d)
    (hzero : ∀ x, x ∉ active → branchOfE e s₁ x = branchOfE e s₂ x)
    (hfac₁ : ∀ x, x ∈ active → branchOfE e s₁ x = fun i z => β x * a₁ x i z)
    (hfac₂ : ∀ x, x ∈ active → branchOfE e s₂ x = fun i z => β x * a₂ x i z)
    (hdev : ∀ x, x ∈ active → normSqDist (a₁ x) (a₂ x) ≤ D) :
    normSqDist s₁ s₂ ≤ D * ∑ x ∈ active, Complex.normSq (β x)

theorem normSqDist_branchOfE_controlled_lift_subnormalized {m d full : Nat}
    (e : Fin m × Fin d ≃ Fin full)
    (s₁ s₂ : QState full) (active : Finset (Fin m)) (β : Fin m → ℂ) (D : ℝ) (hD : 0 ≤ D)
    (a₁ a₂ : Fin m → QState d)
    (hzero : ∀ x, x ∉ active → branchOfE e s₁ x = branchOfE e s₂ x)
    (hfac₁ : ∀ x, x ∈ active → branchOfE e s₁ x = fun i z => β x * a₁ x i z)
    (hfac₂ : ∀ x, x ∈ active → branchOfE e s₂ x = fun i z => β x * a₂ x i z)
    (hdev : ∀ x, x ∈ active → normSqDist (a₁ x) (a₂ x) ≤ D)
    (hweight : ∑ x ∈ active, Complex.normSq (β x) ≤ 1) :
    normSqDist s₁ s₂ ≤ D

noncomputable def jointEquiv {m_dim full_dim : Nat} (h : m_dim ∣ full_dim) :
    Fin m_dim × Fin (full_dim / m_dim) ≃ Fin full_dim

theorem jointEquiv_apply {m_dim full_dim : Nat} (h : m_dim ∣ full_dim)
    (x : Fin m_dim) (y : Fin (full_dim / m_dim)) :
    jointEquiv h (x, y) = jointIdx h x y

theorem branchOf_eq_branchOfE {m_dim full_dim : Nat} (h : m_dim ∣ full_dim)
    (s : QState full_dim) (x : Fin m_dim) :
    branchOf h s x = branchOfE (jointEquiv h) s x

noncomputable def branchOf {m_dim full_dim : Nat} (h : m_dim ∣ full_dim)
    (s : QState full_dim) (x : Fin m_dim) : QState (full_dim / m_dim)

theorem normSqDist_branch_decomp {m_dim full_dim : Nat} (h : m_dim ∣ full_dim)
    (s₁ s₂ : QState full_dim) :
    normSqDist s₁ s₂
      = ∑ x : Fin m_dim, normSqDist (branchOf h s₁ x) (branchOf h s₂ x)

theorem normSqDist_controlled_lift {m_dim full_dim : Nat} (h : m_dim ∣ full_dim)
    (s₁ s₂ : QState full_dim) (active : Finset (Fin m_dim)) (d : Fin m_dim → ℝ)
    (hzero : ∀ x, x ∉ active → branchOf h s₁ x = branchOf h s₂ x)
    (hactive : ∀ x, x ∈ active → normSqDist (branchOf h s₁ x) (branchOf h s₂ x) ≤ d x) :
    normSqDist s₁ s₂ ≤ ∑ x ∈ active, d x

theorem normSqDist_smul {dim : Nat} (β : ℂ) (s₁ s₂ : QState dim) :
    normSqDist (fun i z => β * s₁ i z) (fun i z => β * s₂ i z)
      = Complex.normSq β * normSqDist s₁ s₂

theorem normSqDist_controlled_lift_weighted {m_dim full_dim : Nat} (h : m_dim ∣ full_dim)
    (s₁ s₂ : QState full_dim) (active : Finset (Fin m_dim))
    (β : Fin m_dim → ℂ) (D : ℝ)
    (a₁ a₂ : Fin m_dim → QState (full_dim / m_dim))
    (hzero : ∀ x, x ∉ active → branchOf h s₁ x = branchOf h s₂ x)
    (hfac₁ : ∀ x, x ∈ active → branchOf h s₁ x = fun i z => β x * a₁ x i z)
    (hfac₂ : ∀ x, x ∈ active → branchOf h s₂ x = fun i z => β x * a₂ x i z)
    (hdev : ∀ x, x ∈ active → normSqDist (a₁ x) (a₂ x) ≤ D) :
    normSqDist s₁ s₂ ≤ D * ∑ x ∈ active, Complex.normSq (β x)

theorem normSqDist_controlled_lift_subnormalized {m_dim full_dim : Nat} (h : m_dim ∣ full_dim)
    (s₁ s₂ : QState full_dim) (active : Finset (Fin m_dim))
    (β : Fin m_dim → ℂ) (D : ℝ) (hD : 0 ≤ D)
    (a₁ a₂ : Fin m_dim → QState (full_dim / m_dim))
    (hzero : ∀ x, x ∉ active → branchOf h s₁ x = branchOf h s₂ x)
    (hfac₁ : ∀ x, x ∈ active → branchOf h s₁ x = fun i z => β x * a₁ x i z)
    (hfac₂ : ∀ x, x ∈ active → branchOf h s₂ x = fun i z => β x * a₂ x i z)
    (hdev : ∀ x, x ∈ active → normSqDist (a₁ x) (a₂ x) ≤ D)
    (hweight : ∑ x ∈ active, Complex.normSq (β x) ≤ 1) :
    normSqDist s₁ s₂ ≤ D

theorem cosetMul_superposition_deviation_E
    {m d full : Nat} (e : Fin m × Fin d ≃ Fin full)
    (s_act s_idl : QState full) (active : Finset (Fin m)) (β : Fin m → ℂ)
    (N cm k₀ numAdds : Nat) (cs : Fin m → Nat → Nat)
    (hN : 0 < N) (hk₀ : k₀ < N) (hcs : ∀ x t, cs x t < N)
    (hfit : N + 2 ^ cm * N ≤ d)
    (hzero : ∀ x, x ∉ active → branchOfE e s_act x = branchOfE e s_idl x)
    (hfac_act : ∀ x, x ∈ active →
        branchOfE e s_act x = fun i z => β x * actualAcc d N cm k₀ (cs x) numAdds i z)
    (hfac_idl : ∀ x, x ∈ active →
        branchOfE e s_idl x = fun i z => β x * cosetState d N cm (idealAcc N k₀ (cs x) numAdds) i z)
    (hweight : ∑ x ∈ active, Complex.normSq (β x) ≤ 1) :

theorem cosetOutOfPlace_hfwd_E {m d full : Nat} (e : Fin m × Fin d ≃ Fin full)
    (s_act s_idl : QState full) (active : Finset (Fin m)) (β : Fin m → ℂ)
    (a N cm w numWin : Nat) (xval : Fin m → Nat)
    (hN : 0 < N) (hxval : ∀ b, b ∈ active → xval b < (2 ^ w) ^ numWin)
    (hfit : N + 2 ^ cm * N ≤ d)
    (hzero : ∀ b, b ∉ active → branchOfE e s_act b = branchOfE e s_idl b)
    (hfac_act : ∀ b, b ∈ active → branchOfE e s_act b
        = fun i z => β b * actualAcc d N cm 0 (cosetWindowConst a N w (xval b)) numWin i z)
    (hfac_idl : ∀ b, b ∈ active → branchOfE e s_idl b
        = fun i z => β b * cosetState d N cm ((a * xval b) % N) i z)
    (hweight : ∑ b ∈ active, Complex.normSq (β b) ≤ 1) :
    normSqDist s_act s_idl ≤ (numWin : ℝ) * (2 / 2 ^ cm)

theorem agree_off_trans {dim : Nat} (A B C : QState dim) (bad1 bad2 : Finset (Fin dim))
    (h1 : ∀ i, i ∉ bad1 → A i 0 = B i 0) (h2 : ∀ i, i ∉ bad2 → B i 0 = C i 0) :
    ∀ i, i ∉ bad1 ∪ bad2 → A i 0 = C i 0

theorem cosetState_bornWeightOn_eq {dim N m a : Nat} (B : Finset (Fin dim)) :
    bornWeightOn (cosetState dim N m a) B
      = ((B.filter (· ∈ cosetWindow dim N m a)).card : ℝ) / 2 ^ m

theorem windowDiff_card_le (dim N m r q : Nat) (hN : 0 < N) :
    ((Finset.univ.filter (· ∈ cosetWindow dim N m (r + q * N)))
     \ (Finset.univ.filter (· ∈ cosetWindow dim N m r))).card ≤ q

theorem windowDiff_card_le' (dim N m r q : Nat) (hN : 0 < N) :
    ((Finset.univ.filter (· ∈ cosetWindow dim N m r))
     \ (Finset.univ.filter (· ∈ cosetWindow dim N m (r + q * N)))).card ≤ q

theorem cosetState_multiWrap_agree_off (dim N m r q : Nat) (hN : 0 < N) :
    ∃ B : Finset (Fin dim),
      (∀ i, i ∉ B → cosetState dim N m (r + q * N) i 0 = cosetState dim N m r i 0)
      ∧ bornWeightOn (cosetState dim N m (r + q * N)) B ≤ (q : ℝ) / 2 ^ m
      ∧ bornWeightOn (cosetState dim N m r) B ≤ (q : ℝ) / 2 ^ m

theorem idealAcc_modEq_runningSum (N : Nat) (cs : Nat → Nat) :
    ∀ t, idealAcc N 0 cs t % N = runningSum cs t % N

theorem runningSum_lt (cs : Nat → Nat) (N : Nat) (hcs : ∀ i, cs i < N) :
    ∀ t, 0 < t → runningSum cs t < t * N

theorem cosetState_windowedMul_embed_off (dim N m a w numWin x : Nat)
    (hN : 0 < N) (hx : x < (2 ^ w) ^ numWin) :
    ∃ B : Finset (Fin dim),
      (∀ i, i ∉ B →
        cosetState dim N m (runningSum (cosetWindowConst a N w x) numWin) i 0
          = cosetState dim N m ((a * x) % N) i 0)
      ∧ bornWeightOn (cosetState dim N m (runningSum (cosetWindowConst a N w x) numWin)) B
          ≤ (numWin : ℝ) / 2 ^ m
      ∧ bornWeightOn (cosetState dim N m ((a * x) % N)) B ≤ (numWin : ℝ) / 2 ^ m

theorem normSqDist_fold_accum {dim : Nat} (act idl : Nat → QState dim)
    (op : Nat → QState dim → QState dim) (d : ℝ)
    (hact : ∀ t, act (t + 1) = op t (act t))
    (hnonexp : ∀ t s₁ s₂, normSqDist (op t s₁) (op t s₂) ≤ normSqDist s₁ s₂)
    (hstep : ∀ t, normSqDist (op t (idl t)) (idl (t + 1)) ≤ d)
    (hbase : act 0 = idl 0) :
    ∀ T, normSqDist (act T) (idl T) ≤ (T : ℝ) * d

def idealAcc (N k₀ : Nat) (cs : Nat → Nat) : Nat → Nat
  | 0 => k₀
  | t + 1 => (idealAcc N k₀ cs t + cs t) % N

noncomputable def actualAcc (dim N m k₀ : Nat) (cs : Nat → Nat) : Nat → QState dim
  | 0 => cosetState dim N m k₀
  | t + 1 => shiftState dim (cs t) (actualAcc dim N m k₀ cs t)

theorem idealAcc_lt (N k₀ : Nat) (cs : Nat → Nat) (hN : 0 < N) (hk₀ : k₀ < N) :
    ∀ t, idealAcc N k₀ cs t < N
  | 0 => hk₀
  | _ + 1 => Nat.mod_lt _ hN

theorem cosetMulOutOfPlace_deviation (dim N m k₀ : Nat) (cs : Nat → Nat)
    (hN : 0 < N) (hk₀ : k₀ < N) (hcs : ∀ t, cs t < N) (hfit : N + 2 ^ m * N ≤ dim)
    (T : Nat) :
    normSqDist (actualAcc dim N m k₀ cs T) (cosetState dim N m (idealAcc N k₀ cs T))
      ≤ (T : ℝ) * (2 / 2 ^ m)

def runningSum (cs : Nat → Nat) : Nat → Nat
  | 0 => 0
  | t + 1 => runningSum cs t + cs t

theorem actualAcc_eq_cosetState_runningSum (dim N m k₀ : Nat) (cs : Nat → Nat) (hN : 0 < N) :
    ∀ T, actualAcc dim N m k₀ cs T = cosetState dim N m (k₀ + runningSum cs T)

noncomputable def wrapActualAcc (dim N m k₀ : Nat) (cs : Nat → Nat) : Nat → QState dim
  | 0 => cosetState dim N m k₀
  | t + 1 => wrapShiftState dim (cs t) (wrapActualAcc dim N m k₀ cs t)

theorem actualAcc_eq_wrapActualAcc (dim N m k₀ : Nat) (cs : Nat → Nat) (hN : 0 < N) :
    ∀ T, (∀ t, t < T → k₀ + runningSum cs t + cs t + (2 ^ m - 1) * N < dim) →
      actualAcc dim N m k₀ cs T = wrapActualAcc dim N m k₀ cs T

theorem cosetMulOutOfPlace_deviation_wrap (dim N m k₀ : Nat) (cs : Nat → Nat)
    (hN : 0 < N) (hk₀ : k₀ < N) (hcs : ∀ t, cs t < N) (hfit : N + 2 ^ m * N ≤ dim)
    (T : Nat) (hrun : ∀ t, t < T → k₀ + runningSum cs t + cs t + (2 ^ m - 1) * N < dim) :
    normSqDist (wrapActualAcc dim N m k₀ cs T) (cosetState dim N m (idealAcc N k₀ cs T))
      ≤ (T : ℝ) * (2 / 2 ^ m)

theorem cosetMul_superposition_deviation
    {m_dim full_dim : Nat} (h : m_dim ∣ full_dim)
    (s_act s_idl : QState full_dim) (active : Finset (Fin m_dim)) (β : Fin m_dim → ℂ)
    (N m k₀ numAdds : Nat) (cs : Fin m_dim → Nat → Nat)
    (hN : 0 < N) (hk₀ : k₀ < N) (hcs : ∀ x t, cs x t < N)
    (hfit : N + 2 ^ m * N ≤ full_dim / m_dim)
    (hzero : ∀ x, x ∉ active → branchOf h s_act x = branchOf h s_idl x)
    (hfac_act : ∀ x, x ∈ active →
        branchOf h s_act x
          = fun i z => β x * actualAcc (full_dim / m_dim) N m k₀ (cs x) numAdds i z)
    (hfac_idl : ∀ x, x ∈ active →
        branchOf h s_idl x

def cosetWindowConst (a N w x : Nat) : Nat → Nat

theorem cosetWindowConst_lt (a N w x : Nat) (hN : 0 < N) (j : Nat) :
    cosetWindowConst a N w x j < N

theorem idealAcc_eq_windowedLookupFold (a N w x acc : Nat) :
    ∀ n, idealAcc N acc (cosetWindowConst a N w x) n
        = windowedLookupFold a N w (window w x) n acc

theorem idealAcc_cosetWindowConst (a N w numWin x : Nat) (hN : 0 < N)
    (hx : x < (2 ^ w) ^ numWin) :
    idealAcc N 0 (cosetWindowConst a N w x) numWin = (a * x) % N

theorem cosetOutOfPlace_hfwd {m_dim full_dim : Nat} (h : m_dim ∣ full_dim)
    (s_act s_idl : QState full_dim) (active : Finset (Fin m_dim)) (β : Fin m_dim → ℂ)
    (a N m w numWin : Nat) (xval : Fin m_dim → Nat)
    (hN : 0 < N) (hxval : ∀ b, b ∈ active → xval b < (2 ^ w) ^ numWin)
    (hfit : N + 2 ^ m * N ≤ full_dim / m_dim)
    (hzero : ∀ b, b ∉ active → branchOf h s_act b = branchOf h s_idl b)
    (hfac_act : ∀ b, b ∈ active → branchOf h s_act b
        = fun i z => β b * actualAcc (full_dim / m_dim) N m 0 (cosetWindowConst a N w (xval b)) numWin i z)
    (hfac_idl : ∀ b, b ∈ active → branchOf h s_idl b
        = fun i z => β b * cosetState (full_dim / m_dim) N m ((a * xval b) % N) i z)
    (hweight : ∑ b ∈ active, Complex.normSq (β b) ≤ 1) :
    normSqDist s_act s_idl ≤ (numWin : ℝ) * (2 / 2 ^ m)

noncomputable def cosetState (dim N m k : Nat) : QState dim

theorem cosetState_normSq (dim N m k : Nat) (i : Fin dim) :
    Complex.normSq (cosetState dim N m k i 0)
      = if i ∈ cosetWindow dim N m k then (1 / 2 ^ m : ℝ) else 0