structure PhaseRot

noncomputable def compileRot {dim : Nat} (c : Nat) (r : PhaseRot) : BaseUCom dim

noncomputable def compileLadder {dim : Nat} (c : Nat) (rs : List PhaseRot) :
    BaseUCom dim

theorem skip_isCliffordT {dim : Nat} : IsCliffordT (SKIP : BaseUCom dim)

theorem controlled_Rz_isCliffordT {dim : Nat} (q t : Nat) (lam : ℝ)
    (hpos : (U_Rz (lam / 2) = U_H ∨ U_Rz (lam / 2) = U_S ∨ U_Rz (lam / 2) = U_T
              ∨ U_Rz (lam / 2) = U_SDAG ∨ U_Rz (lam / 2) = U_TDAG
              ∨ U_Rz (lam / 2) = U_I))
    (hneg : (U_Rz (-(lam / 2)) = U_H ∨ U_Rz (-(lam / 2)) = U_S
              ∨ U_Rz (-(lam / 2)) = U_T ∨ U_Rz (-(lam / 2)) = U_SDAG
              ∨ U_Rz (-(lam / 2)) = U_TDAG ∨ U_Rz (-(lam / 2)) = U_I)) :
    IsCliffordT (BaseUCom.controlled_Rz q t lam : BaseUCom dim)

theorem controlled_Rz_isCliffordT_depth0 {dim : Nat} (q t : Nat) :
    IsCliffordT (BaseUCom.controlled_Rz q t (-(Real.pi / 2 ^ 0)) : BaseUCom dim)

theorem controlled_Rz_isCliffordT_depth1 {dim : Nat} (q t : Nat) :
    IsCliffordT (BaseUCom.controlled_Rz q t (-(Real.pi / 2 ^ 1)) : BaseUCom dim)

theorem compileLadder_isCliffordT {dim : Nat} (c : Nat) (hc : c ≤ 2)
    (rs : List PhaseRot) :
    IsCliffordT (compileLadder c rs : BaseUCom dim)

theorem compileLadder_error_budget (c n : ℕ) (hcn : c ≤ n) :
    ∑ m ∈ Finset.Ico c n, (Real.pi / 2 ^ m) ≤ 2 * Real.pi / 2 ^ c

theorem controlled_Rz_bridge {dim : Nat} (q t : Nat) (lam : ℝ) :
    (FormalRV.Framework.BaseUCom.controlled_Rz q t lam
        : FormalRV.Framework.BaseUCom dim)
      = FormalRV.SQIRPort.controlled_Rz q t lam

noncomputable def rotScalar (c : Nat) (r : PhaseRot) (f : Nat → Bool) : ℂ

def RotWF (dim : Nat) (r : PhaseRot) : Prop

theorem compileRot_acts_on_basis {dim : Nat} (c : Nat) (r : PhaseRot) (f : Nat → Bool)
    (hpos : 0 < dim) (hq : r.q < dim) (ht : r.t < dim) (hqt : r.q ≠ r.t) :
    uc_eval (compileRot c r : BaseUCom dim) * f_to_vec dim f
      = rotScalar c r f • f_to_vec dim f

noncomputable def ladderScalar (c : Nat) (rs : List PhaseRot) (f : Nat → Bool) : ℂ

theorem compileLadder_acts_on_basis {dim : Nat} (c : Nat) (rs : List PhaseRot) (f : Nat → Bool)
    (hpos : 0 < dim) (hwf : ∀ r ∈ rs, RotWF dim r) :
    uc_eval (compileLadder c rs : BaseUCom dim) * f_to_vec dim f
      = ladderScalar c rs f • f_to_vec dim f

theorem compileLadder_two_acts_on_basis {dim : Nat} (c : Nat) (r1 r2 : PhaseRot)
    (f : Nat → Bool) (hpos : 0 < dim) (hwf1 : RotWF dim r1) (hwf2 : RotWF dim r2) :
    uc_eval (compileLadder c [r1, r2] : BaseUCom dim) * f_to_vec dim f
      = (rotScalar c r1 f * rotScalar c r2 f) • f_to_vec dim f

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

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 Assumption1 (N m f : ℕ) : Prop

theorem assumption1_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 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

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 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

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 =>

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 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

def ctrlGate (cq anc : Nat) : Gate → Gate
  | .I => .I
  | .X q => .CX cq q
  | .CX a b => .CCX cq a b
  | .CCX a b c => .seq (.CCX cq a anc) (.seq (.CCX anc b c) (.CCX cq a anc))
  | .seq g h => .seq (ctrlGate cq anc g) (ctrlGate cq anc h)

theorem numCCX_ctrlGate (cq anc : Nat) (g : Gate) :
    numCCX (ctrlGate cq anc g) = numCX g + 3 * numCCX g

theorem tcount_ctrlGate (cq anc : Nat) (g : Gate) :
    tcount (ctrlGate cq anc g) = 7 * (numCX g + 3 * numCCX g)

def ctrlModExpChain (m cq anc bits N a ainv : Nat) : Gate

theorem numCCX_ctrlModExpChain (m cq anc bits N a ainv : Nat) :
    numCCX (ctrlModExpChain m cq anc bits N a ainv)
      = m * (numCX (sqir_modmult_MCP_gate bits N a ainv)
              + 3 * numCCX (sqir_modmult_MCP_gate bits N a ainv))

theorem tcount_ctrlModExpChain (m cq anc bits N a ainv : Nat) :
    tcount (ctrlModExpChain m cq anc bits N a ainv)
      = 7 * (m * (numCX (sqir_modmult_MCP_gate bits N a ainv)
              + 3 * numCCX (sqir_modmult_MCP_gate bits N a ainv)))

theorem ctrl_oracle_toffoli_core (bits N a ainv : Nat)
    (hcop : Nat.Coprime a N) (hcopinv : Nat.Coprime ainv N)
    (hpos : 0 < ainv) (hlt : ainv < N) (hodd : Odd N) (h1 : 1 < N) :
    numCX (sqir_modmult_MCP_gate bits N a ainv)
        + 3 * numCCX (sqir_modmult_MCP_gate bits N a ainv)
      = numCX (sqir_modmult_MCP_gate bits N a ainv) + 48 * bits ^ 2

theorem numCCX_ctrlModExpChain_shor (m cq anc bits N a ainv : Nat)
    (hcop : Nat.Coprime a N) (hcopinv : Nat.Coprime ainv N)
    (hpos : 0 < ainv) (hlt : ainv < N) (hodd : Odd N) (h1 : 1 < N) :
    numCCX (ctrlModExpChain m cq anc bits N a ainv)
      = m * numCX (sqir_modmult_MCP_gate bits N a ainv) + m * (48 * bits ^ 2)

theorem shor2048_ctrl_magic_core :
    (2 * 2048) * (48 * 2048 ^ 2) = 824633720832

noncomputable def controlled_X {dim : Nat} (q t : Nat) : BaseUCom dim

theorem uc_eval_controlled_X_eq_pad_ctrl {dim : Nat} (q t : Nat) :
    uc_eval (controlled_X q t : BaseUCom dim) = pad_ctrl dim q t σx

theorem controlled_X_acts_on_basis (n q t : Nat) (f : Nat → Bool)
    (hq : q < n) (ht : t < n) (hqt : q ≠ t) :
    uc_eval (controlled_X q t : BaseUCom n) * f_to_vec n f
      = f_to_vec n (update f t (xor (f t) (f q)))

noncomputable def controlled_Rz {dim : Nat} (q t : Nat) (lam : ℝ) : BaseUCom dim

theorem controlled_Rz_acts_on_basis_correct
    (dim q t : Nat) (hq : q < dim) (ht : t < dim) (hqt : q ≠ t)
    (lam : ℝ) (f : Nat → Bool) :
    uc_eval (controlled_Rz q t lam : BaseUCom dim) * f_to_vec dim f
      = (if f q ∧ f t then Complex.exp ((lam : ℂ) * Complex.I) else 1)
        • f_to_vec dim f

theorem matrix_eq_of_f_to_vec_action {dim : Nat}
    (A B : Matrix (Fin (2^dim)) (Fin (2^dim)) ℂ)
    (h : ∀ f : Nat → Bool, A * f_to_vec dim f = B * f_to_vec dim f) :
    A = B

theorem pad_ctrl_Rz_acts_on_basis
    (dim q t : Nat) (hq : q < dim) (ht : t < dim)
    (lam : ℝ) (f : Nat → Bool) :
    pad_ctrl dim q t (rotation 0 0 lam) * f_to_vec dim f
      = (if f q ∧ f t then Complex.exp ((lam : ℂ) * Complex.I) else 1)
        • f_to_vec dim f

theorem uc_eval_controlled_Rz_eq_pad_ctrl {dim : Nat}
    (q t : Nat) (hq : q < dim) (ht : t < dim) (hqt : q ≠ t)
    (lam : ℝ) :
    uc_eval (controlled_Rz q t lam : BaseUCom dim)
      = pad_ctrl dim q t (rotation 0 0 lam)

theorem rotation_eq_exp_smul_ABXBXC (θ φ lam : ℝ) :
    rotation θ φ lam
      = Complex.exp (((φ + lam) / 2 : ℂ) * Complex.I) •
        (rotation (θ/2) φ 0 * σx * rotation (-θ/2) 0 (-(φ + lam)/2) * σx
          * rotation 0 0 ((lam - φ)/2))

private theorem proj0_mul_rotation_phase (α : ℝ) :
    proj0 * rotation 0 0 α = proj0

private theorem proj1_mul_rotation_phase (α : ℝ) :
    proj1 * rotation 0 0 α = Complex.exp ((α : ℂ) * Complex.I) • proj1

theorem pad_ctrl_mul_control_phase {dim : Nat} (q t : Nat) (hqt : q ≠ t)
    (α : ℝ) (M : Matrix (Fin 2) (Fin 2) ℂ) :
    pad_ctrl dim q t M * pad_u dim q (rotation 0 0 α)
      = pad_ctrl dim q t (Complex.exp ((α : ℂ) * Complex.I) • M)

private theorem pad_branch_term (dim q t : Nat) (hqt : q ≠ t)
    (Pa Pb A B : Matrix (Fin 2) (Fin 2) ℂ) :
    pad_u dim q Pa * pad_u dim t A * (pad_u dim q Pb * pad_u dim t B)
      = pad_u dim q (Pa * Pb) * pad_u dim t (A * B)

private theorem pad_ctrl_two_branch_collapse (dim q t : Nat) (hqt : q ≠ t)
    (A0 A1 B0 B1 : Matrix (Fin 2) (Fin 2) ℂ) :
    (pad_u dim q proj0 * pad_u dim t A0 + pad_u dim q proj1 * pad_u dim t A1) *
    (pad_u dim q proj0 * pad_u dim t B0 + pad_u dim q proj1 * pad_u dim t B1)
      = pad_u dim q proj0 * pad_u dim t (A0 * B0)
        + pad_u dim q proj1 * pad_u dim t (A1 * B1)

private theorem pad_ctrl_eq_branch_sum (dim q t : Nat) (ht : t < dim)
    (M : Matrix (Fin 2) (Fin 2) ℂ) :
    pad_ctrl dim q t M
      = pad_u dim q proj0 * pad_u dim t σi + pad_u dim q proj1 * pad_u dim t M

private theorem cnot_sandwich_collapse (dim q t : Nat) (ht : t < dim) (hqt : q ≠ t)
    (N : Matrix (Fin 2) (Fin 2) ℂ) :
    pad_ctrl dim q t σx * pad_u dim t N * pad_ctrl dim q t σx
      = pad_u dim q proj0 * pad_u dim t N
        + pad_u dim q proj1 * pad_u dim t (σx * N * σx)

private theorem absorb_right_branch (dim q t : Nat)
    (A B X : Matrix (Fin 2) (Fin 2) ℂ) :
    (pad_u dim q proj0 * pad_u dim t A + pad_u dim q proj1 * pad_u dim t B) *
      pad_u dim t X
      = pad_u dim q proj0 * pad_u dim t (A * X)
        + pad_u dim q proj1 * pad_u dim t (B * X)

private theorem absorb_left_branch (dim q t : Nat) (hqt : q ≠ t)
    (A B X : Matrix (Fin 2) (Fin 2) ℂ) :
    pad_u dim t X *
      (pad_u dim q proj0 * pad_u dim t A + pad_u dim q proj1 * pad_u dim t B)
      = pad_u dim q proj0 * pad_u dim t (X * A)
        + pad_u dim q proj1 * pad_u dim t (X * B)

theorem pad_ctrl_circuit_collapse {dim : Nat}
    (q t : Nat) (hq : q < dim) (ht : t < dim) (hqt : q ≠ t)
    (M N K : Matrix (Fin 2) (Fin 2) ℂ) (h_abc : K * N * M = 1) :
    pad_u dim t K * pad_ctrl dim q t σx * pad_u dim t N * pad_ctrl dim q t σx *
        pad_u dim t M
      = pad_ctrl dim q t (K * σx * N * σx * M)

private theorem rotation_ABC_eq_one (θ φ lam : ℝ) :
    rotation (θ/2) φ 0 * rotation (-θ/2) 0 (-(φ + lam)/2) * rotation 0 0 ((lam - φ)/2)
      = 1

theorem uc_eval_controlled_R_eq_pad_ctrl {dim : Nat}
    (q t : Nat) (hq : q < dim) (ht : t < dim) (hqt : q ≠ t) (θ φ lam : ℝ) :
    uc_eval (controlled_R q t θ φ lam : BaseUCom dim)
      = pad_ctrl dim q t (rotation θ φ lam)

theorem uc_eval_control_app1_R_eq_pad_ctrl {dim : Nat}
    (q t : Nat) (hq : q < dim) (ht : t < dim) (hqt : q ≠ t)
    (θ φ lam : ℝ) :
    uc_eval (control q (UCom.app1 (BaseUnitary.R θ φ lam) t : BaseUCom dim))
      = pad_ctrl dim q t (rotation θ φ lam)

theorem uc_eval_CCX_eq_controlled_CNOT {dim : Nat} (q m n : Nat)
    (hq : q < dim) (hm : m < dim) (hn : n < dim)
    (hqm : q ≠ m) (hqn : q ≠ n) (hmn : m ≠ n) :
    uc_eval (BaseUCom.CCX q m n : BaseUCom dim)
      = pad_u dim q proj0
          + pad_u dim q proj1 * uc_eval (BaseUCom.CNOT m n : BaseUCom dim)

theorem uc_eval_control_app2_CNOT_eq_proj_decomp {dim : Nat} (q m n : Nat)
    (hq : q < dim) (hm : m < dim) (hn : n < dim)
    (hqm : q ≠ m) (hqn : q ≠ n) (hmn : m ≠ n) :
    uc_eval (control q (UCom.app2 BaseUnitary.CNOT m n : BaseUCom dim))
      = pad_u dim q proj0
          + pad_u dim q proj1 *
            uc_eval (UCom.app2 BaseUnitary.CNOT m n : BaseUCom dim)

theorem pad_u_comm_uc_eval_of_fresh {dim : Nat} (q : Nat) :
    ∀ (c : BaseUCom dim), is_fresh q c →
      ∀ (U : Matrix (Fin 2) (Fin 2) ℂ),
        pad_u dim q U * uc_eval c = uc_eval c * pad_u dim q U

private theorem padq_proj0_mul_proj0 (dim q : Nat) :
    pad_u dim q proj0 * pad_u dim q proj0 = pad_u dim q proj0

private theorem padq_proj1_mul_proj1 (dim q : Nat) :
    pad_u dim q proj1 * pad_u dim q proj1 = pad_u dim q proj1

private theorem padq_proj0_mul_proj1 (dim q : Nat) :
    pad_u dim q proj0 * pad_u dim q proj1 = 0

private theorem padq_proj1_mul_proj0 (dim q : Nat) :
    pad_u dim q proj1 * pad_u dim q proj0 = 0

theorem uc_eval_control_eq_proj_decomp {dim : Nat} (q : Nat) (c : BaseUCom dim)
    (hq : q < dim) (h_fresh : is_fresh q c) (h_wt : UCom.WellTyped dim c) :
    uc_eval (control q c)
      = pad_u dim q proj0 + pad_u dim q proj1 * uc_eval c

theorem uc_eval_control_on_projector_decomp {dim : Nat}
    (q : Nat) (c : BaseUCom dim) (hq : q < dim)
    (h_fresh : is_fresh q c) (h_wt : UCom.WellTyped dim c)
    (ψ : Matrix (Fin (2^dim)) (Fin 1) ℂ)
    (ζ : ℂ) (h_eig : uc_eval c * ψ = ζ • ψ) :
    uc_eval (control q c) * ψ
      = pad_u dim q proj0 * ψ + ζ • (pad_u dim q proj1 * ψ)

theorem uc_eval_controlled_powers_succ_step {dim n : Nat}
    (f : Nat → BaseUCom dim) (hn : n < dim)
    (h_fresh : is_fresh n (f n))
    (h_wt : UCom.WellTyped dim (f n))
    (ψ φ : Matrix (Fin (2^dim)) (Fin 1) ℂ)
    (h_prior : uc_eval (controlled_powers f n) * ψ = φ)
    (ζ : ℂ) (h_eig : uc_eval (f n) * φ = ζ • φ) :
    uc_eval (controlled_powers f (n + 1)) * ψ
      = pad_u dim n proj0 * φ + ζ • (pad_u dim n proj1 * φ)

noncomputable def phase_projector {dim : Nat}
    (i : Nat) (ζ : ℂ) : Matrix (Fin (2^dim)) (Fin (2^dim)) ℂ

theorem phase_projector_apply {dim : Nat} (i : Nat) (ζ : ℂ)
    (ψ : Matrix (Fin (2^dim)) (Fin 1) ℂ) :
    @phase_projector dim i ζ * ψ
      = pad_u dim i proj0 * ψ + ζ • (pad_u dim i proj1 * ψ)

noncomputable def phase_projector_product {dim : Nat}
    (ζ : Nat → ℂ) : Nat → Matrix (Fin (2^dim)) (Fin (2^dim)) ℂ
  | 0 => 1
  | n + 1 => phase_projector n (ζ n) * phase_projector_product ζ n

theorem phase_projector_commutes_uc_eval {dim : Nat}
    (i : Nat) (ζ : ℂ) (M : Matrix (Fin (2^dim)) (Fin (2^dim)) ℂ)
    (h_comm0 : pad_u dim i proj0 * M = M * pad_u dim i proj0)
    (h_comm1 : pad_u dim i proj1 * M = M * pad_u dim i proj1) :
    @phase_projector dim i ζ * M = M * @phase_projector dim i ζ

theorem phase_projector_product_commutes {dim : Nat}
    (ζ : Nat → ℂ) (M : Matrix (Fin (2^dim)) (Fin (2^dim)) ℂ) :
    ∀ n,
      (∀ i, i < n → ∀ b : Matrix (Fin 2) (Fin 2) ℂ,
            pad_u dim i b * M = M * pad_u dim i b) →
      @phase_projector_product dim ζ n * M = M * @phase_projector_product dim ζ n

theorem uc_eval_controlled_powers_on_common_eigenstate_recursive
    {dim : Nat} (hd : 0 < dim) (f : Nat → BaseUCom dim)
    (ψ : Matrix (Fin (2^dim)) (Fin 1) ℂ) (ζ : Nat → ℂ) :
    ∀ m, (∀ i, i < m → i < dim) →
      (∀ i, i < m → is_fresh i (f i)) →
      (∀ i, i < m → UCom.WellTyped dim (f i)) →
      (∀ i j, i < m → j < m →
        ∀ U : Matrix (Fin 2) (Fin 2) ℂ,
          pad_u dim i U * uc_eval (f j) = uc_eval (f j) * pad_u dim i U) →
      (∀ i, i < m → uc_eval (f i) * ψ = ζ i • ψ) →
      uc_eval (controlled_powers f m) * ψ
        = @phase_projector_product dim ζ m * ψ

def ucApp1 {dim : Nat} : BaseUCom dim → Nat
  | .seq a b => ucApp1 a + ucApp1 b
  | .app1 _ _ => 1
  | .app2 _ _ _ => 0
  | .app3 _ _ _ _ => 0

def ucApp2 {dim : Nat} : BaseUCom dim → Nat
  | .seq a b => ucApp2 a + ucApp2 b
  | .app1 _ _ => 0
  | .app2 _ _ _ => 1
  | .app3 _ _ _ _ => 0

def ucApp3 {dim : Nat} : BaseUCom dim → Nat
  | .seq a b => ucApp3 a + ucApp3 b
  | .app1 _ _ => 0
  | .app2 _ _ _ => 0
  | .app3 _ _ _ _ => 1

theorem ucApp2_controlled_R {dim : Nat} (q t : Nat) (θ φ lam : ℝ) :
    ucApp2 (BaseUCom.controlled_R q t θ φ lam : BaseUCom dim) = 2

theorem ucApp1_controlled_R {dim : Nat} (q t : Nat) (θ φ lam : ℝ) :
    ucApp1 (BaseUCom.controlled_R q t θ φ lam : BaseUCom dim) = 4

theorem ucApp2_CCX {dim : Nat} (a b c : Nat) :
    ucApp2 (BaseUCom.CCX a b c : BaseUCom dim) = 6

theorem ucApp1_CCX {dim : Nat} (a b c : Nat) :
    ucApp1 (BaseUCom.CCX a b c : BaseUCom dim) = 9

theorem ucApp2_control {dim : Nat} (q : Nat) (c : BaseUCom dim) :
    ucApp2 (BaseUCom.control q c) = 2 * ucApp1 c + 6 * ucApp2 c

theorem ucApp1_control {dim : Nat} (q : Nat) (c : BaseUCom dim) :
    ucApp1 (BaseUCom.control q c) = 4 * ucApp1 c + 9 * ucApp2 c + ucApp3 c

def gNumI : Gate → Nat
  | .I => 1
  | .seq a b => gNumI a + gNumI b
  | _ => 0

theorem ucApp2_toUCom (dim : Nat) (g : Gate) :
    ucApp2 (Gate.toUCom dim g) = numCX g + 6 * numCCX g

theorem ucApp1_toUCom (dim : Nat) (g : Gate) :
    ucApp1 (Gate.toUCom dim g) = gNumI g + numX g + 9 * numCCX g

theorem ucApp3_toUCom (dim : Nat) (g : Gate) :
    ucApp3 (Gate.toUCom dim g) = 0

theorem ucApp2_control_toUCom (dim : Nat) (q : Nat) (g : Gate) :
    ucApp2 (BaseUCom.control q (Gate.toUCom dim g))
      = 2 * (gNumI g + numX g + 9 * numCCX g) + 6 * (numCX g + 6 * numCCX g)

theorem ucApp1_control_toUCom (dim : Nat) (q : Nat) (g : Gate) :
    ucApp1 (BaseUCom.control q (Gate.toUCom dim g))
      = 4 * (gNumI g + numX g + 9 * numCCX g) + 9 * (numCX g + 6 * numCCX g)

theorem ucApp2_npar {dim : Nat} (g : Nat → BaseUCom dim) (m : Nat) :
    ucApp2 (BaseUCom.npar m g) = ((List.range m).map (fun i => ucApp2 (g i))).sum

theorem ucApp1_npar {dim : Nat} (g : Nat → BaseUCom dim) (m : Nat) :
    ucApp1 (BaseUCom.npar m g) = 1 + ((List.range m).map (fun i => ucApp1 (g i))).sum

theorem fourier_orthogonality_fin (r : Nat) (h_r : 0 < r) (j : Fin r) :
    (∑ k : Fin r, Complex.exp (2 * (Real.pi : ℂ) * Complex.I *
                                (j.val * k.val : ℂ) / (r : ℂ)))
      = if j.val = 0 then (r : ℂ) else 0

noncomputable def character_vector (r : Nat) (k j : Fin r) : ℂ

theorem character_vector_diagonal_norm_sum
    (r : Nat) (h_r : 0 < r) (k : Fin r) :
    (∑ j : Fin r, Complex.normSq (character_vector r k j))
      = 1

theorem fourier_orthogonality_fin_neg (r : Nat) (h_r : 0 < r) (j : Fin r) :
    (∑ k : Fin r, Complex.exp (-(2 * (Real.pi : ℂ) * Complex.I *
                                  (j.val * k.val : ℂ) / (r : ℂ))))
      = if j.val = 0 then (r : ℂ) else 0

theorem character_vector_orthogonality (r : Nat) (h_r : 0 < r)
    (k k' : Fin r) (h_ne : k ≠ k') :
    (∑ j : Fin r, starRingEnd ℂ (character_vector r k' j) *
                  character_vector r k j) = 0

noncomputable def modmult_eigenstate (a r N n : Nat) (k : Fin r) :
    Matrix (Fin (2^n)) (Fin 1) ℂ

theorem modmult_eigenstate_off_orbit_zero
    (a r N n : Nat) (k : Fin r) (y : Fin (2^n)) (j_dummy : Fin 1)
    (h_off : ∀ j : Fin r, y.val ≠ a^j.val % N) :
    modmult_eigenstate a r N n k y j_dummy = 0

theorem modmult_eigenstate_on_orbit_unique
    (a r N n : Nat) (k : Fin r) (y : Fin (2^n)) (j_dummy : Fin 1)
    (j0 : Fin r) (h_match : y.val = a^j0.val % N)
    (h_unique : ∀ j : Fin r, y.val = a^j.val % N → j = j0) :
    modmult_eigenstate a r N n k y j_dummy = character_vector r k j0

theorem coprime_of_pow_mod_eq_one (a r N : Nat)
    (h_r_pos : 0 < r) (h_arN : a^r % N = 1) :
    Nat.gcd a N = 1

theorem modmult_orbit_injective (a r N : Nat)
    (h_r_pos : 0 < r) (h_arN : a^r % N = 1)
    (h_min : ∀ s, 0 < s → s < r → a^s % N ≠ 1) (h_N : 1 < N) :
    Function.Injective (fun j : Fin r => a^j.val % N)

theorem indicator_product_sum_pow_two (n v v' : Nat) (h_v_lt : v < 2^n) :
    (∑ y : Fin (2^n), (if y.val = v then (1 : ℂ) else 0) *
                      (if y.val = v' then (1 : ℂ) else 0))
      = if v = v' then 1 else 0

theorem orbit_indicator_bilinear_orth (a r N n : Nat)
    (h_r_pos : 0 < r) (h_arN : a^r % N = 1)
    (h_min : ∀ s, 0 < s → s < r → a^s % N ≠ 1)
    (h_N : 1 < N) (h_N_lt : N ≤ 2^n)
    (j j' : Fin r) :
    (∑ y : Fin (2^n),
      (if y.val = a^j.val % N then (1 : ℂ) else 0) *
      (if y.val = a^j'.val % N then (1 : ℂ) else 0))
      = if j = j' then 1 else 0

theorem modmult_eigenstate_orthonormal (a r N n : Nat)
    (h_r_pos : 0 < r) (h_arN : a^r % N = 1)
    (h_min : ∀ s, 0 < s → s < r → a^s % N ≠ 1)
    (h_N : 1 < N) (h_N_lt : N ≤ 2^n)
    (k k' : Fin r) :
    (∑ y : Fin (2^n), starRingEnd ℂ (modmult_eigenstate a r N n k' y 0) *
                      modmult_eigenstate a r N n k y 0)
      = if k = k' then 1 else 0

noncomputable def modmult_eigenstate_combined (a r N n anc : Nat) (k : Fin r) :
    Matrix (Fin (2^(n+anc))) (Fin 1) ℂ

theorem kron_vec_inner_split {a b : Nat}
    (α α' : Matrix (Fin (2^a)) (Fin 1) ℂ)
    (β β' : Matrix (Fin (2^b)) (Fin 1) ℂ) :
    (∑ i : Fin (2^(a+b)),
      starRingEnd ℂ (kron_vec α' β' i 0) * kron_vec α β i 0)
      = (∑ j : Fin (2^a), starRingEnd ℂ (α' j 0) * α j 0) *
        (∑ k : Fin (2^b), starRingEnd ℂ (β' k 0) * β k 0)

theorem kron_zeros_self_inner_eq_one (anc : Nat) :
    (∑ k : Fin (2^anc),
      starRingEnd ℂ (kron_zeros anc k 0) * kron_zeros anc k 0) = 1

theorem modmult_eigenstate_combined_orthonormal (a r N n anc : Nat)
    (h_r_pos : 0 < r) (h_arN : a^r % N = 1)
    (h_min : ∀ s, 0 < s → s < r → a^s % N ≠ 1)
    (h_N : 1 < N) (h_N_lt : N ≤ 2^n)
    (k k' : Fin r) :
    (∑ i : Fin (2^(n+anc)),
      starRingEnd ℂ (modmult_eigenstate_combined a r N n anc k' i 0) *
      modmult_eigenstate_combined a r N n anc k i 0)
      = if k = k' then 1 else 0

theorem orbit_decomposition_pointwise (a r N n : Nat)
    (h_r_pos : 0 < r) (_h_arN : a^r % N = 1)
    (_h_min : ∀ s, 0 < s → s < r → a^s % N ≠ 1)
    (h_N : 1 < N) (_h_N_lt : N ≤ 2^n)
    (y : Fin (2^n)) :
    (1 / (Real.sqrt r : ℂ)) *
      (∑ k : Fin r, modmult_eigenstate a r N n k y 0)
      = basis_vector (2^n) 1 y 0

theorem orbit_decomposition_combined_pointwise (a r N n anc : Nat)
    (h_r_pos : 0 < r) (h_arN : a^r % N = 1)
    (h_min : ∀ s, 0 < s → s < r → a^s % N ≠ 1)
    (h_N : 1 < N) (h_N_lt : N ≤ 2^n)
    (i : Fin (2^(n+anc))) :
    (kron_vec (basis_vector (2^n) 1) (kron_zeros anc) i 0 : ℂ)
      = (1 / (Real.sqrt r : ℂ)) *
          (∑ k : Fin r,
            modmult_eigenstate_combined a r N n anc k i 0)

theorem exp_mod_r_shift (r : Nat) (h_r_pos : 0 < r) (k : Fin r) (n : Nat) :
    Complex.exp (-(2 * (Real.pi : ℂ) * Complex.I * ((n % r : Nat) * k.val : ℂ)) / (r : ℂ))
    = Complex.exp (-(2 * (Real.pi : ℂ) * Complex.I * (n * k.val : ℂ)) / (r : ℂ))

theorem sum_fin_add_mod {α : Type*} [AddCommMonoid α]
    (r : Nat) (h_r_pos : 0 < r) (s : Nat) (g : Fin r → α) :
    ∑ j : Fin r, g j = ∑ j : Fin r, g ⟨(j.val + s) % r, Nat.mod_lt _ h_r_pos⟩

theorem a_pow_mod_periodic_in_n (a N r n : Nat) (h_arN : a^r % N = 1) :
    a^(n % r) % N = a^n % N

theorem modmult_eigenstate_as_sum (a r N n : Nat) (k : Fin r) :
    modmult_eigenstate a r N n k
    = ∑ j : Fin r, character_vector r k j • basis_vector (2^n) (a^j.val % N)

theorem exp_mod_r_shift_pos (r : Nat) (h_r_pos : 0 < r) (k : Fin r) (n : Nat) :
    Complex.exp ((2 * (Real.pi : ℂ) * Complex.I * ((n % r : Nat) * k.val : ℂ)) / (r : ℂ))
    = Complex.exp ((2 * (Real.pi : ℂ) * Complex.I * (n * k.val : ℂ)) / (r : ℂ))

theorem character_vector_shift_identity
    (r : Nat) (h_r_pos : 0 < r) (k : Fin r) (j : Fin r) (s : Nat) :
    character_vector r k ⟨(j.val + s) % r, Nat.mod_lt _ h_r_pos⟩
    = character_vector r k j
      * Complex.exp (-(2 * (Real.pi : ℂ) * Complex.I * (s * k.val : ℂ)) / (r : ℂ))

theorem ekera_congruence {p q r : Nat} (hp : 1 ≤ p) (hq : 1 ≤ q)
    (hr : r ∣ (p - 1) * (q - 1)) :
    (p * q + 1) ≡ (p + q) [MOD r]

theorem ekera_short_dl_eq {d p q r : Nat} (hcong : d ≡ (p + q) [MOD r])
    (hd_lt : d < r) (hpq_lt : p + q < r) : d = p + q

theorem ekera_recover {p q d N : Nat} (hq_le_p : q ≤ p)
    (hd : d = p + q) (hN : N = p * q) :
    (d + (d * d - 4 * N).sqrt) / 2 = p ∧ (d - (d * d - 4 * N).sqrt) / 2 = q

theorem ekera_recover_actual {a b d N : Nat} (hab : b ≤ a)
    (hd : d = a + b) (hN : N = (2 * a + 1) * (2 * b + 1)) :
    (d + 1) + ((d + 1) * (d + 1) - N).sqrt = 2 * a + 1 ∧
    (d + 1) - ((d + 1) * (d + 1) - N).sqrt = 2 * b + 1

theorem ekera_factor (p q r d N : Nat) (hp : 1 ≤ p) (hq : 1 ≤ q) (hq_le_p : q ≤ p)
    (hN : N = p * q) (h_ord : r ∣ (p - 1) * (q - 1))
    (h_dl : d ≡ (N + 1) [MOD r]) (hd_lt : d < r) (hpq_lt : p + q < r) :
    (d + (d * d - 4 * N).sqrt) / 2 = p ∧ (d - (d * d - 4 * N).sqrt) / 2 = q

def cresid (u : Int) (n : Nat) : Int

def EHGoodPair (m ℓ d j k : Nat) : Prop

theorem eh_good_vector_within_radius (m s d : Nat) (resid : Fin s → Int)
    (hm : 2 ≤ m) (hd : d < 2 ^ m) (hgood : ∀ i, |resid i| ≤ 2 ^ (m - 2)) :
    4 * ((d : Int) ^ 2 + ∑ i, (resid i) ^ 2) < ((s : Int) + 4) * 2 ^ (2 * m)

structure EHShortDLPSuccess

noncomputable def EHShortDLPSuccess.goodProb (S : EHShortDLPSuccess) : ℝ

theorem EHShortDLPSuccess.goodProb_ge (S : EHShortDLPSuccess) :
    (S.goodJ.card : ℝ) * S.p ≤ S.goodProb

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

theorem EHShortDLPSuccess.goodProb_ge_eighth (S : EHShortDLPSuccess) (ℓ m : Nat)
    (_hℓm : S.ℓm = ℓ + m) (hge1 : 1 ≤ ℓ + m)
    (hcount : (2 : ℝ) ^ (ℓ + m - 1) ≤ (S.goodJ.card : ℝ))
    (hp : S.p = (2 : ℝ) ^ (-(m + ℓ + 2 : ℤ))) :
    (1 / 8 : ℝ) ≤ S.goodProb

theorem success_ge_card_mul {m : Nat} (accept measProb : Nat → ℝ) (p : ℝ)
    (K : Finset Nat)
    (h_measProb_nonneg : ∀ x, 0 ≤ measProb x)
    (h_accept_nonneg : ∀ x, 0 ≤ accept x)
    (h_K_sub : K ⊆ Finset.range (2 ^ m))
    (h_accept_one : ∀ x ∈ K, accept x = 1)
    (h_prob_ge : ∀ x ∈ K, p ≤ measProb x) :
    (K.card : ℝ) * p ≤ ∑ x ∈ Finset.range (2 ^ m), accept x * measProb x

structure ShorPostProcessing (m : Nat)

theorem ShorPostProcessing.bound {m : Nat} (S : ShorPostProcessing m) :
    (S.peaks.card : ℝ) * S.p ≤ ∑ x ∈ Finset.range (2 ^ m), S.accept x * S.measProb x

theorem probability_of_success_ge_peaks
    (a r N m n anc : Nat) (f : Nat → BaseUCom (n + anc))
    (K : Finset Nat) (p : ℝ)
    (h_K_sub : K ⊆ Finset.range (2 ^ m))
    (h_accept : ∀ x ∈ K, r_found x m r a N = 1)
    (h_qpe : ∀ x ∈ K,
      p ≤ prob_partial_meas (basis_vector (2 ^ m) x) (Shor_final_state m n anc f)) :
    (K.card : ℝ) * p ≤ probability_of_success a r N m n anc f

theorem cf_aux_full_matches_mathlib_zero (o m : Nat) (h_m_pos : 0 < m)
    (h_not_term : ¬ (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).TerminatedAt 0) :
    (GenContFract.of ((o : ℝ) / m)).nums 0 = (((cf_aux_full 2 o m 0 1 1 0).1 : Nat) : ℝ) ∧
    (GenContFract.of ((o : ℝ) / m)).nums 1 = (((cf_aux_full 2 o m 0 1 1 0).2.1 : Nat) : ℝ) ∧
    (GenContFract.of ((o : ℝ) / m)).dens 0 = (((cf_aux_full 2 o m 0 1 1 0).2.2.1 : Nat) : ℝ) ∧
    (GenContFract.of ((o : ℝ) / m)).dens 1 = (((cf_aux_full 2 o m 0 1 1 0).2.2.2 : Nat) : ℝ)

theorem cf_aux_full_general_match
    (n : Nat) (o m : Nat) (h_m_pos : 0 < m)
    (v0 : ℝ) (K : Nat)
    (p_prev p_curr q_prev q_curr : Nat)
    (h_state :
      ((p_prev : ℝ) = ((GenContFract.of v0).contsAux K).a) ∧
      ((p_curr : ℝ) = ((GenContFract.of v0).contsAux (K+1)).a) ∧
      ((q_prev : ℝ) = ((GenContFract.of v0).contsAux K).b) ∧
      ((q_curr : ℝ) = ((GenContFract.of v0).contsAux (K+1)).b))
    (_h_eucl : ∀ i : ℕ, ¬ (GenContFract.of v0).TerminatedAt (K + i) →
      (GenContFract.of v0).s.get? (K + i) =
        some ⟨1, (((euclidean_iter i o m).1 / (euclidean_iter i o m).2 : Nat) : ℝ)⟩)

theorem eucl_iter_match_stream (o m : Nat) (h_m_pos : 0 < m) (i : Nat)
    (h_not_term : ¬ (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).TerminatedAt i) :
    (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).s.get? i =
      some ⟨1, (((euclidean_iter (i+1) o m).1 / (euclidean_iter (i+1) o m).2 : Nat) : ℝ)⟩

theorem cf_aux_full_matches_mathlib_strong (o m : Nat) (h_m_pos : 0 < m)
    (n : Nat)
    (h_not_term : ¬ (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).TerminatedAt (n+1)) :
    (((cf_aux_full (n+2) o m 0 1 1 0).1 : Nat) : ℝ) =
        ((GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).contsAux (n+1)).a ∧
    (((cf_aux_full (n+2) o m 0 1 1 0).2.1 : Nat) : ℝ) =
        ((GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).contsAux (n+2)).a ∧
    (((cf_aux_full (n+2) o m 0 1 1 0).2.2.1 : Nat) : ℝ) =
        ((GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).contsAux (n+1)).b ∧
    (((cf_aux_full (n+2) o m 0 1 1 0).2.2.2 : Nat) : ℝ) =
        ((GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).contsAux (n+2)).b

theorem dens_eq_r_at_convs_eq_kr (v : ℝ) (n : Nat) (k r : Nat)
    (h_not_term : ¬ (GenContFract.of v).TerminatedAt n)
    (h_r_pos : 0 < r) (h_coprime : Nat.gcd k r = 1)
    (h_convs : (GenContFract.of v).convs n = (((k:ℚ)/r : ℚ) : ℝ)) :
    (GenContFract.of v).dens n = (r : ℝ)

theorem dens_eq_fib_bound (v : ℝ) (r N_step : Nat)
    (h_dens : (GenContFract.of v).dens N_step = (r : ℝ))
    (h_not_term : N_step = 0 ∨ ¬ (GenContFract.of v).TerminatedAt (N_step - 1)) :
    (Nat.fib (N_step + 1) : ℝ) ≤ (r : ℝ)

theorem pow_two_le_fib (m : Nat) : 2 ^ m ≤ Nat.fib (2 * m + 2)

theorem fib_step_bound (N_step r m : Nat)
    (h_fib : Nat.fib (N_step + 1) ≤ r) (h_r_lt : r < 2^m) :
    N_step ≤ 2 * m + 1

theorem N_step_le_2m_plus_1 (v : ℝ) (N_step r m : Nat)
    (h_dens : (GenContFract.of v).dens N_step = (r : ℝ))
    (h_not_term : N_step = 0 ∨ ¬ (GenContFract.of v).TerminatedAt (N_step - 1))
    (h_r_lt : r < 2^m) :
    N_step ≤ 2 * m + 1

theorem modexp_eq_one_iff_dvd (a N d : Nat) (h_pos : 0 < a) (h_lt : a < N)
    (r : Nat) (h_ord : Order a r N) :
    modexp a d N = 1 ↔ r ∣ d

theorem OF_post'_zero_or_modexp (step a N o m : Nat) :
    OF_post' step a N o m = 0 ∨ modexp a (OF_post' step a N o m) N = 1

theorem OF_post'_dvd_r (step a N o m : Nat)
    (h_pos : 0 < a) (h_lt : a < N) (r : Nat) (h_ord : Order a r N) :
    OF_post' step a N o m = 0 ∨ r ∣ OF_post' step a N o m

theorem OF_post'_nonzero_pre (step a N o m : Nat)
    (h_ne : OF_post' step a N o m ≠ 0) :
    ∃ x, x < step ∧ OF_post_step x o m = OF_post' step a N o m

theorem OF_post'_nonzero_equal (x step a N o m : Nat)
    (h_ne : OF_post' step a N o m ≠ 0) :
    OF_post' (x + step) a N o m = OF_post' step a N o m

theorem of_convs_succ_via_fract (v : ℝ) (n : Nat) :
    (GenContFract.of v).convs (n + 1) =
      (⌊v⌋ : ℝ) + ((GenContFract.of (Int.fract v)⁻¹).convs n)⁻¹

theorem of_convs_succ_lt (o m : Nat) (h_lt : o < m) (h_o_pos : 0 < o)
    (n : Nat) :
    (GenContFract.of (((o : ℝ)) / ((m : Nat) : ℝ))).convs (n + 1) =
      ((GenContFract.of (((m : Nat) : ℝ) / ((o : Nat) : ℝ))).convs n)⁻¹

theorem mathlib_convs_at_term (v : ℝ) (n : Nat)
    (h_term : (GenContFract.of v).TerminatedAt n) :
    (GenContFract.of v).convs n = v

theorem mathlib_dens_int_gen_eq_OF_post_step (n o m : Nat) :
    mathlib_dens_int_gen n o (2^m) = mathlib_OF_post_step n o m

def cf_aux_bridge_invariant : Prop

def cf_aux_step_2_validated : Prop

theorem mathlib_OF_post_step_nat_eq_OF_post_step_div_general
    (n o m : Nat) (h_mod : o % (2^m) = 0) :
    mathlib_OF_post_step_nat n o m = OF_post_step n o m

theorem mathlib_OF_post_step_nat_eq_OF_post_step_nonboundary
    (n o m : Nat)
    (h_not_term : ¬ (GenContFract.of (((o : Nat) : ℝ) / ((2^m : Nat) : ℝ))).TerminatedAt (n+1)) :
    mathlib_OF_post_step_nat n o m = OF_post_step n o m

theorem cf_of_div_succ_step_R (o m n : Nat) (_h_mod_pos : 0 < o % m) :
    (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).s.get? (n+1) =
      (GenContFract.of (((m : Nat) : ℝ) / ((o % m : Nat) : ℝ))).s.get? n

theorem terminated_at_0_when_mod_zero (o m : Nat) (h_om : o % m = 0) :
    (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).TerminatedAt 0

theorem mod_zero_of_terminated_at_0 (o m : Nat) (_h_m_pos : 0 < m)
    (h_term : (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).TerminatedAt 0) :
    o % m = 0

theorem eucl_terminated_of_mathlib_terminated (o m : Nat) (h_m_pos : 0 < m)
    (j : Nat) (h_term : (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).TerminatedAt j) :
    (euclidean_iter (j+1) o m).2 = 0

theorem mathlib_terminated_of_eucl_terminated (o m : Nat) (h_m_pos : 0 < m)
    (j : Nat) (h_eucl : (euclidean_iter (j+1) o m).2 = 0) :
    (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).TerminatedAt j

theorem mathlib_dens_one_div (o m : Nat) (h_mod : o % (2^m) = 0) :
    (GenContFract.of (((o : ℝ)) / ((2^m : Nat) : ℝ))).dens 1 = 1

theorem mathlib_dens_one_nondiv (o m : Nat) (h_mod : o % (2^m) ≠ 0) :
    (GenContFract.of (((o : ℝ)) / ((2^m : Nat) : ℝ))).dens 1
      = (((2^m) / (o % 2^m) : Nat) : ℝ)

theorem of_arg_cast_norm (o m : Nat) :
    (((o : ℝ)) / ((2^m : Nat) : ℝ)) = ((o : ℝ) / (2^m : ℝ))

theorem mathlib_dens_two_div (o m : Nat) (h_mod : o % (2^m) = 0) :
    (GenContFract.of (((o : ℝ)) / ((2^m : Nat) : ℝ))).dens 2 = 1

theorem mathlib_dens_div_general (o m : Nat) (n : Nat) (h_mod : o % (2^m) = 0) :
    (GenContFract.of (((o : ℝ)) / ((2^m : Nat) : ℝ))).dens n = 1

theorem stream_succ_euclidean (o m : Nat) (h_m_pos : 0 < m)
    (h_mod : o % m ≠ 0) (n : Nat) :
    GenContFract.IntFractPair.stream (((o : ℝ)) / ((m : Nat) : ℝ)) (n+1)
      = GenContFract.IntFractPair.stream (((m : Nat) : ℝ) / ((o % m : Nat) : ℝ)) n

noncomputable def mathlib_dens_int_gen (n o m : Nat) : ℤ

theorem mathlib_dens_int_gen_spec (n o m : Nat) :
    (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).dens n =
      ((mathlib_dens_int_gen n o m : ℤ) : ℝ)

theorem mathlib_dens_int_gen_zero (o m : Nat) :
    mathlib_dens_int_gen 0 o m = 1

theorem mathlib_dens_int_gen_nonneg (n o m : Nat) :
    0 ≤ mathlib_dens_int_gen n o m

theorem mathlib_dens_int_gen_fib_ge (o m n : Nat)
    (h_not_term : n = 0 ∨
      ¬ (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).TerminatedAt (n - 1)) :
    (Nat.fib (n + 1) : ℤ) ≤ mathlib_dens_int_gen n o m

theorem mathlib_nums_zero_eq (o m : Nat) (_h_m_pos : 0 < m) :
    (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).nums 0
      = ((o / m : Nat) : ℝ)

theorem mathlib_dens_zero_eq (o m : Nat) :
    (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).dens 0 = 1

theorem mathlib_dens_one_eq_nondiv (o m : Nat) (h_m_pos : 0 < m)
    (h_mod : o % m ≠ 0) :
    (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).dens 1
      = ((m / (o % m) : Nat) : ℝ)

theorem mathlib_nums_one_eq_nondiv (o m : Nat) (h_m_pos : 0 < m)
    (h_mod : o % m ≠ 0) :
    (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).nums 1
      = ((m / (o % m) * (o / m) + 1 : Nat) : ℝ)

noncomputable def mathlib_OF_post_step (step o m : Nat) : ℤ

theorem mathlib_OF_post_step_spec (step o m : Nat) :
    (GenContFract.of ((o : ℝ) / (2 ^ m : ℝ))).dens step =
      ((mathlib_OF_post_step step o m : ℤ) : ℝ)

theorem mathlib_OF_post_step_nonneg (step o m : Nat) :
    0 ≤ mathlib_OF_post_step step o m

noncomputable def mathlib_OF_post_step_nat (step o m : Nat) : Nat

theorem mathlib_OF_post_step_nat_int (step o m : Nat) :
    ((mathlib_OF_post_step_nat step o m : Nat) : ℤ) = mathlib_OF_post_step step o m

theorem mathlib_OF_post_step_mono (step o m : Nat) :
    mathlib_OF_post_step step o m ≤ mathlib_OF_post_step (step+1) o m

theorem mathlib_OF_post_step_nat_mono (step o m : Nat) :
    mathlib_OF_post_step_nat step o m ≤ mathlib_OF_post_step_nat (step+1) o m

theorem mathlib_OF_post_step_nat_mono_le (o m i j : Nat) (h : i ≤ j) :
    mathlib_OF_post_step_nat i o m ≤ mathlib_OF_post_step_nat j o m

theorem mathlib_OF_post_step_fib_ge (o m n : Nat)
    (h_not_term : n = 0 ∨ ¬ (GenContFract.of ((o : ℝ) / (2^m : ℝ))).TerminatedAt (n - 1)) :
    (Nat.fib (n + 1) : ℤ) ≤ mathlib_OF_post_step n o m

theorem mathlib_OF_post_step_nat_fib_ge (o m n : Nat)
    (h_not_term : n = 0 ∨ ¬ (GenContFract.of ((o : ℝ) / (2^m : ℝ))).TerminatedAt (n - 1)) :
    Nat.fib (n + 1) ≤ mathlib_OF_post_step_nat n o m

theorem mathlib_OF_post_step_nat_pos (o m n : Nat)
    (h_not_term : n = 0 ∨ ¬ (GenContFract.of ((o : ℝ) / (2^m : ℝ))).TerminatedAt (n - 1)) :
    0 < mathlib_OF_post_step_nat n o m

theorem OF_post_step_zero (o m : Nat) : OF_post_step 0 o m = 1

theorem OF_post_step_one_div (o m : Nat) (h_mod : o % (2^m) = 0) :
    OF_post_step 1 o m = 1

theorem OF_post_step_one_nondiv (o m : Nat) (h_mod : o % (2^m) ≠ 0) :
    OF_post_step 1 o m = (2^m) / (o % 2^m)

theorem OF_post_step_two_div (o m : Nat) (h_mod : o % (2^m) = 0) :
    OF_post_step 2 o m = 1

theorem OF_post_step_div_general (n o m : Nat) (h_mod : o % (2^m) = 0) :
    OF_post_step n o m = 1

theorem OF_post_step_one_shor (o m : Nat) (h_o_pos : 0 < o)
    (h_o_lt : o < 2^m) :
    OF_post_step 1 o m = (2^m) / o

def shor_case_cf_aux_swap_intent : Prop

theorem eucl_iter_le_two_m_plus_one
    (o m_exp j : Nat)
    (h_term : (euclidean_iter j o (2^m_exp)).2 = 0)
    (h_min  : ∀ j' < j, (euclidean_iter j' o (2^m_exp)).2 ≠ 0) :
    j ≤ 2 * m_exp + 1

theorem eucl_iter_gcd_preserved :
    ∀ (d o m : Nat),
      Nat.gcd (euclidean_iter d o m).1 (euclidean_iter d o m).2 = Nat.gcd o m

theorem cf_aux_full_q_bound (d o m_arg : Nat)
    (h_pos : 0 < (euclidean_iter d o m_arg).1) :
    Nat.gcd o m_arg * (cf_aux_full d o m_arg 0 1 1 0).2.2.2 ≤ m_arg

theorem euclidean_iter_succ_first_eq_prev_second :
    ∀ (d o m : Nat),
      0 < (euclidean_iter d o m).2 →
      (euclidean_iter (d + 1) o m).1 = (euclidean_iter d o m).2

theorem cf_aux_full_q_inv :
    ∀ (N o m p_prev p_curr q_prev q_curr : Nat),
      (cf_aux_full N o m p_prev p_curr q_prev q_curr).2.2.2
        * (euclidean_iter N o m).1
      + (cf_aux_full N o m p_prev p_curr q_prev q_curr).2.2.1
        * (euclidean_iter N o m).2
      = q_curr * o + q_prev * m

theorem eucl_iter_fib_bound :
    ∀ (m : Nat), 0 < m → ∀ (o j : Nat),
      (euclidean_iter j o m).2 = 0 →
      (∀ j' < j, (euclidean_iter j' o m).2 ≠ 0) →
      Nat.fib (j + 1) ≤ m

theorem mathlib_OF_post_step_nat_eq_OF_post_step_at_n
    (n o m : Nat)
    (h_not_term : ¬ (GenContFract.of (((o : Nat) : ℝ) / ((2^m : Nat) : ℝ))).TerminatedAt n) :
    mathlib_OF_post_step_nat n o m = OF_post_step n o m

theorem mathlib_OF_post_step_nat_eq_OF_post_step_one (o m : Nat) :
    mathlib_OF_post_step_nat 1 o m = OF_post_step 1 o m

theorem mathlib_OF_post_step_zero (o m : Nat) :
    mathlib_OF_post_step 0 o m = 1

theorem mathlib_OF_post_step_nat_zero (o m : Nat) :
    mathlib_OF_post_step_nat 0 o m = 1

theorem mathlib_OF_post_step_eq_OF_post_step_zero (o m : Nat) :
    mathlib_OF_post_step 0 o m = ((OF_post_step 0 o m : Nat) : ℤ)

theorem mathlib_OF_post_step_nat_eq_OF_post_step_zero (o m : Nat) :
    mathlib_OF_post_step_nat 0 o m = OF_post_step 0 o m

lemma r_dvd_two_pow_of_exact
    (m k r : Nat) (h_coprime : Nat.gcd k r = 1)
    (h_eq : s_closest m k r * r = k * 2^m) :
    r ∣ 2^m

lemma gcd_s_closest_two_pow_eq
    (m k r : Nat) (h_r_pos : 0 < r) (h_coprime : Nat.gcd k r = 1)
    (h_eq : s_closest m k r * r = k * 2^m) :
    Nat.gcd (s_closest m k r) (2^m) = 2^m / r

noncomputable def partial_meas_index {m_dim full_dim : Nat}
    (h_dvd : m_dim ∣ full_dim) (s : Fin m_dim)
    (y : Fin (full_dim / m_dim)) : Fin full_dim

theorem prob_partial_meas_basis_vector
    {m_dim full_dim : Nat} (s : Nat) (h_s_lt : s < m_dim)
    (h_dvd : m_dim ∣ full_dim) (φ : QState full_dim) :
    prob_partial_meas (basis_vector m_dim s) φ
      = ∑ y : Fin (full_dim / m_dim),
          Complex.normSq (φ (partial_meas_index h_dvd ⟨s, h_s_lt⟩ y) 0)

theorem prob_partial_meas_basis_kron_vec
    {p q : Nat} (s : Nat) (h_s_lt : s < 2^p)
    (a : QState (2^p)) (b : QState (2^q)) :
    prob_partial_meas (basis_vector (2^p) s)
        (FormalRV.Framework.kron_vec a b)
      = Complex.normSq (a ⟨s, h_s_lt⟩ 0) *
        ∑ y : Fin (2^q), Complex.normSq (b y 0)

theorem prob_partial_meas_qpe_phase_state_kron
    {m anc : Nat} (y : Nat) (h_y_lt : y < 2^m) (θ : ℝ)
    (ψ_eigen : QState (2^anc)) :
    prob_partial_meas (basis_vector (2^m) y)
        (FormalRV.Framework.kron_vec
          (FormalRV.Framework.qpe_phase_state m θ) ψ_eigen)
      = FormalRV.Framework.qpe_prob m y θ *
        ∑ z : Fin (2^anc), Complex.normSq (ψ_eigen z 0)

theorem prob_partial_meas_qpe_phase_state_kron_pure
    {m anc : Nat} (y : Nat) (h_y_lt : y < 2^m) (θ : ℝ)
    (ψ_eigen : QState (2^anc))
    (h_pure : FormalRV.Framework.Pure_State_Vector ψ_eigen) :
    prob_partial_meas (basis_vector (2^m) y)
        (FormalRV.Framework.kron_vec
          (FormalRV.Framework.qpe_phase_state m θ) ψ_eigen)
      = FormalRV.Framework.qpe_prob m y θ

theorem prob_partial_meas_basis_sum_kron_orth
    {p q r : Nat} (s : Nat) (h_s_lt : s < 2^p)
    (α : Fin r → QState (2^p)) (β : Fin r → QState (2^q))
    (h_orth : ∀ j j' : Fin r,
       ∑ y : Fin (2^q), starRingEnd ℂ ((β j') y 0) * (β j) y 0
       = if j = j' then (1 : ℂ) else 0) :
    prob_partial_meas (basis_vector (2^p) s)
        ((∑ j : Fin r, FormalRV.Framework.kron_vec (α j) (β j) :
           Matrix (Fin (2^(p+q))) (Fin 1) ℂ))
      = ∑ j : Fin r, Complex.normSq ((α j) ⟨s, h_s_lt⟩ 0)

theorem prob_partial_meas_smul_right
    {m_dim full_dim : Nat}
    (ψ : QState m_dim) (φ : QState full_dim) (c : ℂ) :
    prob_partial_meas ψ (fun i j => c * φ i j)
      = Complex.normSq c * prob_partial_meas ψ φ

theorem normSq_one_div_sqrt (r : Nat) (h_r_pos : 0 < r) :
    Complex.normSq ((1 / (Real.sqrt r : ℂ))) = 1 / (r : ℝ)

theorem prob_partial_meas_qpe_orth_sum
    {p q r : Nat} (s : Nat) (h_s_lt : s < 2^p) (h_r_pos : 0 < r)
    (k : Fin r → ℝ)
    (β : Fin r → QState (2^q))
    (h_orth : ∀ j j' : Fin r,
       ∑ y : Fin (2^q), starRingEnd ℂ ((β j') y 0) * (β j) y 0
       = if j = j' then (1 : ℂ) else 0) :
    prob_partial_meas (basis_vector (2^p) s)
        (fun i j => (1 / (Real.sqrt r : ℂ)) *
          ((∑ j_idx : Fin r,
             FormalRV.Framework.kron_vec
               (FormalRV.Framework.qpe_phase_state p (k j_idx)) (β j_idx) :

theorem QPE_MMI_correct_from_orbit
    {m q r : Nat} (k : Nat) (h_k_lt : k < r) (h_r_pos : 0 < r)
    (h_s_lt : s_closest m k r < 2^m)
    (β : Fin r → Matrix (Fin (2^q)) (Fin 1) ℂ)
    (h_orth : ∀ j j' : Fin r,
       ∑ y : Fin (2^q), starRingEnd ℂ ((β j') y 0) * (β j) y 0
       = if j = j' then (1 : ℂ) else 0) :
    prob_partial_meas (basis_vector (2^m) (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))

theorem QPE_MMI_correct_from_orbit_state_eq
    {m q r : Nat} (k : Nat) (h_k_lt : k < r) (h_r_pos : 0 < r)
    (h_s_lt : s_closest m k r < 2^m)
    (β : Fin r → Matrix (Fin (2^q)) (Fin 1) ℂ)
    (h_orth : ∀ j j' : Fin r,
       ∑ y : Fin (2^q), starRingEnd ℂ ((β j') y 0) * (β j) y 0
       = if j = j' then (1 : ℂ) else 0)
    (actual_state : Matrix (Fin (2^(m + q))) (Fin 1) ℂ)
    (h_state : actual_state =
      fun i j => (1 / (Real.sqrt r : ℂ)) *
        ((∑ j_idx : Fin r,
           FormalRV.Framework.kron_vec

theorem QPE_MMI_correct_from_Shor_orbit_state
    (a r N m n anc k : Nat)
    (f : Nat → BaseUCom (n + anc))
    (β : Fin r → Matrix (Fin (2^(n + anc))) (Fin 1) ℂ)
    (h_basic : BasicSetting a r N m n)
    (_h_mmi : ModMulImpl a N n anc f)
    (_h_wt : ∀ i, i < m → uc_well_typed (f i))
    (h_k_lt : k < r)
    (h_orth : ∀ j j' : Fin r,
       ∑ y : Fin (2^(n + anc)), starRingEnd ℂ ((β j') y 0) * (β j) y 0
       = if j = j' then (1 : ℂ) else 0)
    (actual_state : Matrix (Fin (2^(m + (n + anc)))) (Fin 1) ℂ)

theorem QPE_MMI_correct_assuming_orbit_factorization
    (a r N m n anc k : Nat) (f : Nat → BaseUCom (n + anc))
    (h_basic : BasicSetting a r N m n)
    (h_mmi : ModMulImpl a N n anc f)
    (h_wt : ∀ i, i < m → uc_well_typed (f i))
    (h_k_lt : k < r)
    (h_orbit_exists :
        ∃ (β : Fin r → Matrix (Fin (2^(n + anc))) (Fin 1) ℂ)
          (actual_state : Matrix (Fin (2^(m + (n + anc)))) (Fin 1) ℂ),
          ((∀ j j' : Fin r,
             ∑ y : Fin (2^(n + anc)),
                  starRingEnd ℂ ((β j') y 0) * (β j) y 0

theorem eucl_iter_first_pos_under_min
    (o m : Nat) (h_o_pos : 0 < o) :
    ∀ d, (∀ d' < d, (euclidean_iter d' o m).2 ≠ 0) →
         0 < (euclidean_iter d o m).1

theorem TODO_r_found_1_core_exact_rational
    (a r N m n k : Nat)
    (h_basic : BasicSetting a r N m n)
    (h_k_lt : k < r)
    (h_coprime : Nat.gcd k r = 1)
    (h_eq : s_closest m k r * r = k * 2^m) :
    OF_post a N (s_closest m k r) m = r

theorem TODO_r_found_1_core_generic
    (a r N m n k : Nat)
    (h_basic : BasicSetting a r N m n)
    (h_k_lt : k < r)
    (h_coprime : Nat.gcd k r = 1)
    (h_ne : s_closest m k r * r ≠ k * 2^m) :
    OF_post a N (s_closest m k r) m = r

theorem TODO_r_found_1_core
    (a r N m n k : Nat)
    (h_basic : BasicSetting a r N m n)
    (h_k_lt : k < r)
    (h_coprime : Nat.gcd k r = 1) :
    OF_post a N (s_closest m k r) m = r

theorem r_found_1
    (a r N m n k : Nat)
    (h_basic : BasicSetting a r N m n)
    (h_k_lt : k < r)
    (h_coprime : Nat.gcd k r = 1) :
    r_found (s_closest m k r) m r a N = 1

theorem phi_n_over_n_lowerbound (r N : Nat) (h_r_pos : 0 < r) (h_le : r ≤ N) :
    ((Nat.totient r : ℝ) / (r : ℝ))
      ≥ Real.exp (-2) / (Nat.log2 N : ℝ)^4

theorem prob_partial_meas_nonneg {m_dim full_dim : Nat}
    (ψ : QState m_dim) (φ : QState full_dim) : 0 ≤ prob_partial_meas ψ φ

theorem ContinuedFraction_zero (o m : Nat) (_h_m_pos : 0 < m) :
    ContinuedFraction 0 o m = (o / m, 1)

theorem cf_bridge_nums_zero (o m : Nat) (h_m_pos : 0 < m) :
    let q : ℚ

theorem cf_bridge_dens_zero (o m : Nat) (h_m_pos : 0 < m) :
    let q : ℚ

theorem cf_of_div_succ_step (o m n : Nat) (h_mod_pos : 0 < o % m) :
    (GenContFract.of ((o:ℚ)/m)).s.get? (n+1) =
      (GenContFract.of ((m:ℚ)/((o % m : Nat) : ℚ))).s.get? n

theorem cf_bridge_full_zero (o m : Nat) (h_m_pos : 0 < m) :
    let q : ℚ

theorem cf_bridge_dens_one (o m : Nat) (h_m_pos : 0 < m)
    (h_mod_pos : 0 < o % m) :
    let q : ℚ

theorem cf_bridge_nums_one (o m : Nat) (h_m_pos : 0 < m)
    (h_mod_pos : 0 < o % m) :
    let q : ℚ

noncomputable def OF_post_step (step o m : Nat) : Nat

noncomputable def OF_post' : Nat → Nat → Nat → Nat → Nat → Nat
  | 0, _, _, _, _ => 0
  | step + 1, a, N, o, m =>
      let pre

noncomputable def OF_post (a N o m : Nat) : Nat

noncomputable def r_found (o m r a N : Nat) : ℝ

theorem cf_aux_full_succ_step :
    ∀ (N o m p_prev p_curr q_prev q_curr : Nat),
      0 < (euclidean_iter N o m).2 →
      cf_aux_full (N + 1) o m p_prev p_curr q_prev q_curr =
        let s

theorem cf_aux_full_depth_invariant :
    ∀ N o m p_prev p_curr q_prev q_curr,
      (∃ j, j ≤ N ∧ (euclidean_iter j o m).2 = 0) →
      cf_aux_full (N + 1) o m p_prev p_curr q_prev q_curr
        = cf_aux_full N o m p_prev p_curr q_prev q_curr

theorem eucl_iter_stable :
    ∀ (j : Nat) (o m k : Nat),
      (euclidean_iter j o m).2 = 0 → (euclidean_iter (j + k) o m).2 = 0

def cf_aux_general_invariant_intent : Prop

theorem nondiv_of_not_terminated_zero (o m : Nat)
    (h_not_term : ¬ (GenContFract.of (((o : Nat) : ℝ) / ((m : Nat) : ℝ))).TerminatedAt 0) :
    o % m ≠ 0

theorem dens_int_valued_pair (v : ℝ) :
    ∀ n, (∃ d : ℤ, (GenContFract.of v).dens n = (d : ℝ)) ∧
         (∃ d : ℤ, (GenContFract.of v).dens (n+1) = (d : ℝ))

theorem dens_int_valued (v : ℝ) (n : Nat) :
    ∃ d : ℤ, (GenContFract.of v).dens n = (d : ℝ)

theorem nums_int_valued_pair (v : ℝ) :
    ∀ n, (∃ d : ℤ, (GenContFract.of v).nums n = (d : ℝ)) ∧
         (∃ d : ℤ, (GenContFract.of v).nums (n+1) = (d : ℝ))

theorem nums_int_valued (v : ℝ) (n : Nat) :
    ∃ d : ℤ, (GenContFract.of v).nums n = (d : ℝ)

theorem of_v_determinant (v : ℝ) (n : Nat)
    (h_not_term : ¬ (GenContFract.of v).TerminatedAt n) :
    (GenContFract.of v).nums n * (GenContFract.of v).dens (n+1)
      - (GenContFract.of v).dens n * (GenContFract.of v).nums (n+1)
        = (-1) ^ (n+1)

theorem of_v_nums_dens_coprime (v : ℝ) (n : Nat)
    (h_not_term : ¬ (GenContFract.of v).TerminatedAt n)
    (a b : ℤ) (ha : (GenContFract.of v).nums n = (a : ℝ))
    (hb : (GenContFract.of v).dens n = (b : ℝ)) :
    Int.gcd a b = 1

theorem s_closest_close_to_k_over_r (m k r : Nat) (h_r_pos : 0 < r) :
    |(s_closest m k r : ℝ) / (2^m : ℝ) - (k : ℝ) / (r : ℝ)|
      ≤ 1 / (2 * (2^m : ℝ))

theorem khinchin_precond (r N m : Nat) (h_r_pos : 0 < r)
    (h_r_lt_N : r < N) (h_Nsq_lt : N^2 < 2^m) :
    1 / (2 * (2^m : ℝ)) ≤ 1 / (2 * (r : ℝ)^2)

theorem khinchin_applies_to_s_closest
    (a r N m n k : Nat) (h_basic : BasicSetting a r N m n) (h_k_lt : k < r) :
    |(s_closest m k r : ℝ) / (2^m : ℝ) - (k : ℝ) / (r : ℝ)| < 1 / (2 * (r : ℝ)^2)

theorem k_over_r_is_convergent
    (a r N m n k : Nat) (h_basic : BasicSetting a r N m n) (h_k_lt : k < r)
    (h_coprime : Nat.gcd k r = 1) :
    ∃ N_step, (GenContFract.of ((s_closest m k r : ℝ) / (2^m : ℝ))).convs N_step
                = (((k : ℚ) / r : ℚ) : ℝ)

def Order (a r N : Nat) : Prop

def modexp (a x N : Nat) : Nat

def cf_aux : Nat → Nat → Nat → Nat → Nat → Nat → Nat → Nat × Nat
  | 0, _, _, _, p_curr, _, q_curr => (p_curr, q_curr)
  | n+1, o, m, p_prev, p_curr, q_prev, q_curr =>
      if m = 0 then (p_curr, q_curr)
      else
        let a

def ContinuedFraction (step o m : Nat) : Nat × Nat

theorem cf_aux_zero (o m p_prev p_curr q_prev q_curr : Nat) :
    cf_aux 0 o m p_prev p_curr q_prev q_curr = (p_curr, q_curr)

theorem cf_aux_succ_pos (n o m p_prev p_curr q_prev q_curr : Nat)
    (h_m_pos : 0 < m) :
    cf_aux (n+1) o m p_prev p_curr q_prev q_curr
      = cf_aux n m (o % m) p_curr ((o/m) * p_curr + p_prev)
                                  q_curr ((o/m) * q_curr + q_prev)

theorem cf_aux_succ_zero (n o p_prev p_curr q_prev q_curr : Nat) :
    cf_aux (n+1) o 0 p_prev p_curr q_prev q_curr = (p_curr, q_curr)

def cf_aux_full : Nat → Nat → Nat → Nat → Nat → Nat → Nat → Nat × Nat × Nat × Nat
  | 0, _, _, p_prev, p_curr, q_prev, q_curr => (p_prev, p_curr, q_prev, q_curr)
  | n+1, o, m, p_prev, p_curr, q_prev, q_curr =>
      if m = 0 then (p_prev, p_curr, q_prev, q_curr)
      else
        let a

theorem cf_aux_eq_cf_aux_full_proj (n o m p_prev p_curr q_prev q_curr : Nat) :
    cf_aux n o m p_prev p_curr q_prev q_curr =
      ((cf_aux_full n o m p_prev p_curr q_prev q_curr).2.1,
       (cf_aux_full n o m p_prev p_curr q_prev q_curr).2.2.2)

theorem cf_aux_full_2_nondiv (o m : Nat) (h_m_pos : 0 < m)
    (h_mod : o % m ≠ 0) :
    cf_aux_full 2 o m 0 1 1 0
      = (o / m, m / (o % m) * (o / m) + 1, 1, m / (o % m))

theorem cf_aux_full_3_nondiv2 (o m : Nat) (h_m_pos : 0 < m)
    (h_mod1 : o % m ≠ 0) (h_mod2 : m % (o % m) ≠ 0) :
    cf_aux_full 3 o m 0 1 1 0 =
      (m / (o % m) * (o / m) + 1,
       (o % m) / (m % (o % m)) * (m / (o % m) * (o / m) + 1) + (o / m),
       m / (o % m),
       (o % m) / (m % (o % m)) * (m / (o % m)) + 1)

def euclidean_iter : Nat → Nat → Nat → Nat × Nat
  | 0, o, m => (o, m)
  | n+1, o, m => if m = 0 then (o, m) else euclidean_iter n m (o % m)

theorem cf_aux_full_terminate (n o p_prev p_curr q_prev q_curr : Nat) :
    cf_aux_full n o 0 p_prev p_curr q_prev q_curr = (p_prev, p_curr, q_prev, q_curr)

theorem cf_aux_terminate (n o p_prev p_curr q_prev q_curr : Nat) :
    cf_aux n o 0 p_prev p_curr q_prev q_curr = (p_curr, q_curr)

theorem eucl_iter_terminates (o m : Nat) :
    ∃ j, j ≤ m ∧ (euclidean_iter j o m).2 = 0

theorem qpe_phase_discrepancy_s_closest_le_half
    (m k r : Nat) (h_r_pos : 0 < r) :
    |FormalRV.Framework.qpe_phase_discrepancy m (s_closest m k r)
        ((k : ℝ) / (r : ℝ))| ≤ 1 / 2

theorem qpe_prob_at_s_closest_ge
    (m k r : Nat) (h_r_pos : 0 < r) :
    FormalRV.Framework.qpe_prob m (s_closest m k r) ((k : ℝ) / (r : ℝ))
      ≥ 4 / Real.pi ^ 2

theorem QPE_MMI_correct_conditional
    (a r N m n anc k : Nat) (f : Nat → BaseUCom (n + anc))
    (h_basic : BasicSetting a r N m n)
    (h_mmi : ModMulImpl a N n anc f)
    (h_wt : ∀ i, i < m → uc_well_typed (f i))
    (h_k_lt : k < r)
    (h_QPE_MMI_peak :
      ∀ (a' r' N' m' n' anc' k' : Nat) (f' : Nat → BaseUCom (n' + anc')),
        BasicSetting a' r' N' m' n' →
        ModMulImpl a' N' n' anc' f' →
        (∀ i, i < m' → uc_well_typed (f' i)) →
        k' < r' →

def BaseUCom (n : Nat) : Type

def uc_well_typed {n : Nat} (c : BaseUCom n) : Prop

def QState (dim : Nat) : Type

def basis_vector (dim k : Nat) : QState dim

noncomputable def uc_eval {n : Nat} (c : BaseUCom n) (ψ : QState (2^n)) :
    QState (2^n)

noncomputable def prob_partial_meas {m_dim full_dim : Nat}
    (ψ : QState m_dim) (φ : QState full_dim) : ℝ

def map_qubits {U : Nat → Type} {dim dim' : Nat} (g : Nat → Nat) :
    FormalRV.Framework.UCom U dim → FormalRV.Framework.UCom U dim'
  | FormalRV.Framework.UCom.seq c₁ c₂ =>
      FormalRV.Framework.UCom.seq (map_qubits g c₁) (map_qubits g c₂)
  | FormalRV.Framework.UCom.app1 u n =>
      FormalRV.Framework.UCom.app1 u (g n)
  | FormalRV.Framework.UCom.app2 u m n =>
      FormalRV.Framework.UCom.app2 u (g m) (g n)
  | FormalRV.Framework.UCom.app3 u m n p =>
      FormalRV.Framework.UCom.app3 u (g m) (g n) (g p)

noncomputable def QPE_var (m anc : Nat) (f : Nat → BaseUCom anc) :
    BaseUCom (m + anc)

def revIndex (m j : Nat) : Nat

theorem revIndex_lt (m j : Nat) (hj : j < m) : revIndex m j < m

noncomputable def QPE_var_lsb (m anc : Nat) (f : Nat → BaseUCom anc) :
    BaseUCom (m + anc)

def BasicSetting (a r N m n : Nat) : Prop

def MultiplyCircuitProperty (a N n anc : Nat) (c : BaseUCom (n + anc)) : Prop

def ModMulImpl (a N n anc : Nat) (f : Nat → BaseUCom (n + anc)) : Prop

noncomputable def QState.cast {a b : Nat} (h : a = b) (ψ : QState a) : QState b

noncomputable def Shor_initial_state (m n anc : Nat) :
    QState (2^(m + (n + anc)))

noncomputable def Shor_final_state (m n anc : Nat)
    (f : Nat → BaseUCom (n + anc)) : QState (2^m * 2^n * 2^anc)

noncomputable def probability_of_success
    (a r N m n anc : Nat) (f : Nat → BaseUCom (n + anc)) : ℝ

noncomputable def κ : ℝ

theorem κ_pos : κ > 0

theorem Order_r_lt_N (a r N : Nat) (h_N : 0 < N) (h_ord : Order a r N) : r < N

noncomputable def s_closest (m k r : Nat) : Nat

theorem s_closest_ub (a r N m n k : Nat) (h_basic : BasicSetting a r N m n)
    (h_k_lt : k < r) : s_closest m k r < 2^m

theorem s_closest_injective (a r N m n : Nat)
    (h_basic : BasicSetting a r N m n) :
    ∀ i j : Nat, i < r → j < r → s_closest m i r = s_closest m j r → i = j

theorem MultiplyCircuitProperty_acts_on_orbit_basis
    (a N n anc i j : Nat)
    (f : Nat → BaseUCom (n + anc))
    (h_modmul : ModMulImpl a N n anc f)
    (h_N_pos : 0 < N) :
    uc_eval (f i) (basis_vector (2^(n+anc)) ((a^j % N) * 2^anc))
    = basis_vector (2^(n+anc)) ((a^(2^i + j) % N) * 2^anc)

theorem QPE_var_zero_eq_one (anc : Nat) (h : 0 < anc)
    (f : Nat → BaseUCom anc) :
    FormalRV.Framework.uc_eval (QPE_var 0 anc f) =
      (1 : FormalRV.Framework.Square (0 + anc))

theorem QPE_var_on_eigenstate_zero (anc : Nat) (h : 0 < anc)
    (f : Nat → BaseUCom anc) (θ : ℝ)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval (QPE_var 0 anc f) *
        (FormalRV.Framework.kron_vec
          (FormalRV.Framework.kron_zeros 0) ψ :
         Matrix (Fin (2^(0 + anc))) (Fin 1) ℂ)
      = FormalRV.Framework.kron_vec
          (FormalRV.Framework.qpe_phase_state 0 θ) ψ

theorem dim_assoc_eq (m n anc : Nat) :
    2^(m + (n + anc)) = 2^m * 2^n * 2^anc

theorem prob_partial_meas_cast {m_dim a b : Nat} (h_eq : a = b)
    (ψ : QState m_dim) (φ : QState a) :
    prob_partial_meas ψ (QState.cast h_eq φ : QState b)
      = prob_partial_meas ψ φ

noncomputable def shor_orbit_state (a r N m n anc : Nat) :
    Matrix (Fin (2^(m + (n + anc)))) (Fin 1) ℂ

theorem QPE_MMI_correct_modulo_qpe_semantics
    (a r N m n anc k : Nat) (f : Nat → BaseUCom (n + anc))
    (h_basic : BasicSetting a r N m n)
    (h_mmi : ModMulImpl a N n anc f)
    (h_wt : ∀ i, i < m → uc_well_typed (f i))
    (h_k_lt : k < r)
    (h_qpe_semantics :
      prob_partial_meas (basis_vector (2^m) (s_closest m k r))
          (Shor_final_state m n anc f)
        = prob_partial_meas (basis_vector (2^m) (s_closest m k r))
              (shor_orbit_state a r N m n anc)) :
    prob_partial_meas (basis_vector (2^m) (s_closest m k r))

theorem Shor_correct_var_conditional
    (a r N m n anc : Nat) (u : Nat → BaseUCom (n + anc))
    (h_basic : BasicSetting a r N m n)
    (h_modmul : ModMulImpl a N n anc u)
    (h_wt : ∀ i, i < m → uc_well_typed (u i))
    (h_QPE_MMI_correct :
      ∀ (a' r' N' m' n' anc' k' : Nat) (f' : Nat → BaseUCom (n' + anc')),
        BasicSetting a' r' N' m' n' →
        ModMulImpl a' N' n' anc' f' →
        (∀ i, i < m' → uc_well_typed (f' i)) →
        k' < r' →
        prob_partial_meas (basis_vector (2^m') (s_closest m' k' r'))

theorem Shor_correct_var_from_QPE_and_totient
    (a r N m n anc : Nat) (u : Nat → BaseUCom (n + anc))
    (h_basic : BasicSetting a r N m n)
    (h_modmul : ModMulImpl a N n anc u)
    (h_wt : ∀ i, i < m → uc_well_typed (u i))
    (h_QPE_MMI_correct :
      ∀ (a' r' N' m' n' anc' k' : Nat) (f' : Nat → BaseUCom (n' + anc')),
        BasicSetting a' r' N' m' n' →
        ModMulImpl a' N' n' anc' f' →
        (∀ i, i < m' → uc_well_typed (f' i)) →
        k' < r' →
        prob_partial_meas (basis_vector (2^m') (s_closest m' k' r'))

def modmult_rev_anc (n : Nat) : Nat

axiom f_modmult_circuit :
  (a ainv N n : Nat) → Nat → BaseUCom (n + modmult_rev_anc n)

def modinv (a N : Nat) : Nat

noncomputable def ord (a N : Nat) : Nat

theorem ord_Order (a N : Nat) (h_pos : 0 < a) (h_lt : a < N)
    (h_coprime : Nat.gcd a N = 1) : Order a (ord a N) N

theorem modinv_upper_bound (a N : Nat) (h_pos : 1 < N) : modinv a N < N

theorem Order_modinv_correct (a N r : Nat) (h_ord : Order a r N) (h_lt : a < N) :
    a * modinv a N % N = 1

axiom f_modmult_circuit_MMI
    (a ainv N n : Nat)
    (_h_a_lt : a < N) (_h_ainv_lt : ainv < N)
    (_h_inv : a * ainv % N = 1) :
    ModMulImpl a N n (modmult_rev_anc n) (f_modmult_circuit a ainv N n)

axiom f_modmult_circuit_uc_well_typed
    (a ainv N n : Nat)
    (_h_N : 1 < N) (_h_a_lt : a < N) (_h_ainv_lt : ainv < N) :
    ∀ i, uc_well_typed (f_modmult_circuit a ainv N n i)

theorem uc_eval_mul_sum {dim r : Nat} (U : FormalRV.Framework.BaseUCom dim)
    (v : Fin r → Matrix (Fin (2^dim)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval U * (∑ i : Fin r, v i)
      = ∑ i : Fin r, FormalRV.Framework.uc_eval U * v i

theorem uc_eval_mul_smul {dim : Nat} (U : FormalRV.Framework.BaseUCom dim)
    (c : ℂ) (v : Matrix (Fin (2^dim)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval U * (c • v)
      = c • (FormalRV.Framework.uc_eval U * v)

theorem uc_eval_mul_sum_smul {dim r : Nat} (U : FormalRV.Framework.BaseUCom dim)
    (c : Fin r → ℂ) (v : Fin r → Matrix (Fin (2^dim)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval U * (∑ i : Fin r, c i • v i)
      = ∑ i : Fin r, c i • (FormalRV.Framework.uc_eval U * v i)

inductive EGate

def EGate.applyNat : EGate → (Nat → Bool) → (Nat → Bool)
  | .base g,  f => Gate.applyNat g f
  | .mz q,    f => Function.update f q false
  | .seq a b, f => EGate.applyNat b (EGate.applyNat a f)

def EGate.tcount : EGate → Nat
  | .base g  => Gate.tcount g
  | .mz _    => 0
  | .seq a b => EGate.tcount a + EGate.tcount b

def EGate.toffoli (g : EGate) : Nat

def mzList : List Nat → EGate
  | []      => EGate.base Gate.I
  | q :: qs => EGate.seq (mzList qs) (EGate.mz q)

theorem tcount_mzList (L : List Nat) : EGate.tcount (mzList L) = 0

def measLookupAdd (w W : Nat) (T : Nat → Nat) (bits q_start : Nat) : EGate

theorem toffoli_measLookupAdd (w W : Nat) (T : Nat → Nat) (bits q_start : Nat) :
    EGate.toffoli (measLookupAdd w W T bits q_start) = 2 * w * 2 ^ w + 2 * bits

theorem measUncompute_saves_a_read (w W : Nat) (T : Nat → Nat) (bits q_start : Nat) :
    EGate.toffoli (measLookupAdd w W T bits q_start) + 2 * w * 2 ^ w
      = toffoliCount (lookupAddAt w W T bits q_start)

def unaryIterationCompute (w : Nat) (flips cnots : List Nat) : Gate

theorem tcount_unaryIterationCompute (w : Nat) (flips cnots : List Nat) :
    Gate.tcount (unaryIterationCompute w flips cnots) = 7 * w

def measUnaryIteration (w : Nat) (flips cnots : List Nat) : EGate

theorem tcount_measUnaryIteration (w : Nat) (flips cnots : List Nat) :
    EGate.tcount (measUnaryIteration w flips cnots) = 7 * w

def measUnaryRead (w : Nat) : List (List Nat × List Nat) → EGate
  | []            => EGate.base Gate.I
  | (f, c) :: rest => EGate.seq (measUnaryRead w rest) (measUnaryIteration w f c)

theorem tcount_measUnaryRead (w : Nat) (iters : List (List Nat × List Nat)) :
    EGate.tcount (measUnaryRead w iters) = 7 * w * iters.length

def optLookupAdd (w W : Nat) (T : Nat → Nat) (bits q_start : Nat) : EGate

theorem toffoli_optLookupAdd (w W : Nat) (T : Nat → Nat) (bits q_start : Nat) :
    EGate.toffoli (optLookupAdd w W T bits q_start) = w * 2 ^ w + 2 * bits

def unaryQROM (W : Nat) (T : Nat → Nat) (addrBase ancBase outBase : Nat) :
    Nat → Nat → Nat → EGate
  | 0,     ctrl, base =>
      EGate.base (cx_gates_from_indices ctrl (wordCnotsAt (fun j => outBase + j) W (T base)))
  | d + 1, ctrl, base =>
      EGate.seq (EGate.seq (EGate.seq (EGate.seq (EGate.seq
        (EGate.base (Gate.CCX ctrl (addrBase + d) (ancBase + d)))                 -- anc ← ctrl∧bit_d
        (unaryQROM W T addrBase ancBase outBase d (ancBase + d) (base + 2 ^ d)))  -- bit_d = 1 half
        (EGate.base (Gate.CX ctrl (ancBase + d))))                               -- anc ← ctrl∧¬bit_d
        (unaryQROM W T addrBase ancBase outBase d (ancBase + d) base))           -- bit_d = 0 half
        (EGate.base (Gate.CX ctrl (ancBase + d))))                              -- restore anc ← ctrl∧bit_d
        (EGate.mz (ancBase + d))                                                 -- measure-uncompute anc

theorem tcount_unaryQROM (W : Nat) (T : Nat → Nat) (addrBase ancBase outBase : Nat) :
    ∀ (d ctrl base : Nat),
      EGate.tcount (unaryQROM W T addrBase ancBase outBase d ctrl base) = 7 * (2 ^ d - 1)
  | 0, ctrl, base =>

theorem toffoli_unaryQROM (W : Nat) (T : Nat → Nat) (addrBase ancBase outBase d ctrl base : Nat) :
    EGate.toffoli (unaryQROM W T addrBase ancBase outBase d ctrl base) = 2 ^ d - 1

def babbushLookupAdd (w W : Nat) (T : Nat → Nat) (bits addrBase ancBase outBase q_start : Nat) : EGate

theorem toffoli_babbushLookupAdd (w W : Nat) (T : Nat → Nat)
    (bits addrBase ancBase outBase q_start : Nat) :
    EGate.toffoli (babbushLookupAdd w W T bits addrBase ancBase outBase q_start)
      = (2 ^ w - 1) + 2 * bits

theorem applyNat_mzList_clears (L : List Nat) (f : Nat → Bool) {p : Nat} (hp : p ∈ L) :
    EGate.applyNat (mzList L) f p = false

theorem applyNat_mzList_preserves (L : List Nat) (f : Nat → Bool) {p : Nat} (hp : p ∉ L) :
    EGate.applyNat (mzList L) f p = f p

theorem measLookupAdd_acc_eq (w W : Nat) (T : Nat → Nat) (bits q_start i : Nat)
    (f : Nat → Bool) :
    EGate.applyNat (measLookupAdd w W T bits q_start) f (q_start + 2 * i + 1)
      = Gate.applyNat (Gate.seq (lookupReadAt w (addendIdx q_start) W T)
          (cuccaro_n_bit_adder_full bits q_start)) f (q_start + 2 * i + 1)

def inp (a : Nat) : Nat → Bool

def decOut (f : Nat → Bool) : Nat

def runQROM (T : Nat → Nat) (a : Nat) : Nat

example : runQROM (fun v => v) 0 = 0

example : runQROM (fun v => v) 1 = 1

example : runQROM (fun v => v) 2 = 2

example : runQROM (fun v => v) 3 = 3

example : runQROM (fun v => 5 * v % 8) 3 = 15 % 8

def adderToff (n : Nat) : Nat

theorem adderToff_eq (n : Nat) :
    7 * adderToff (n + 2) = tcount (gidney_adder (n + 2))

def ctrlModAddToff (n : Nat) : Nat

def ctrlModMultToff (n : Nat) : Nat

def modExpToff (n : Nat) : Nat

theorem modExpToff_closed (n : Nat) : modExpToff n = 16 * n ^ 3

def shor2048Toff : Nat

theorem shor2048Toff_eq : shor2048Toff = 137438953472

theorem shor2048_CCZMagic :
    numCCZMagic (circuitToPPM 8 (modmultBlock shor2048Toff 0)) = 137438953472

theorem shor2048_Meas :
    numMeas (circuitToPPM 8 (modmultBlock shor2048Toff 0)) = 412316860416

theorem shor2048_CCZMagic_GE2021published :
    numCCZMagic (circuitToPPM 8 (modmultBlock 2700000000 0)) = 2700000000

theorem shor2048_Meas_GE2021published :
    numMeas (circuitToPPM 8 (modmultBlock 2700000000 0)) = 8100000000

theorem shor2048_vs_GE2021_gap :
    shor2048Toff = 50 * 2700000000 + 2438953472

theorem ppm_shor_pipeline_master
    (a r N m bits ainv : Nat)
    (f_ppm f_comp : Nat → BaseUCom (bits + ModMul.ancillaWidth bits))
    (h_setting : ShorSetting a r N m bits)
    (h_sizing : CircuitSizing N bits)
    (h_inv : a * ainv % N = 1)
    (h_realize :
      Shor_final_state m bits (ModMul.ancillaWidth bits) f_ppm
        = Shor_final_state m bits (ModMul.ancillaWidth bits) f_comp)
    (ε : ℝ)
    (h_eps :
      ApproxTransfer.normSqDist

theorem ppm_shor_pipeline_master_representative
    (a r N m bits ainv : Nat)
    (h_setting : ShorSetting a r N m bits)
    (h_sizing : CircuitSizing N bits)
    (h_inv : a * ainv % N = 1) :
    probability_of_success a r N m bits (ModMul.ancillaWidth bits)
        (ModMul.circuitFamily a ainv N bits)
      ≥ κ / (Nat.log2 N : ℝ) ^ 4 - 0

theorem is_fresh_map_qubits_shift {m anc q : Nat}
    (c : BaseUCom anc) (hq : q < m) :
    is_fresh q (map_qubits (fun x => m + x) c : BaseUCom (m + anc))

theorem wellTyped_map_qubits_shift {m anc : Nat}
    (c : BaseUCom anc) (h_wt : UCom.WellTyped anc c) :
    UCom.WellTyped (m + anc)
      (map_qubits (fun x => m + x) c : BaseUCom (m + anc))

theorem uc_eval_map_qubits_shift_commutes_pad_u {m anc q : Nat}
    (c : BaseUCom anc) (hq : q < m) (U : Matrix (Fin 2) (Fin 2) ℂ) :
    pad_u (m + anc) q U *
        FormalRV.Framework.uc_eval
          (map_qubits (fun x => m + x) c : BaseUCom (m + anc))
      = FormalRV.Framework.uc_eval
          (map_qubits (fun x => m + x) c : BaseUCom (m + anc)) *
          pad_u (m + anc) q U

theorem uc_eval_controlled_powers_shifted_on_common_eigenstate
    {m anc : Nat} (hd : 0 < m + anc)
    (f : Nat → BaseUCom anc)
    (h_wt_all : ∀ i, i < m → UCom.WellTyped anc (f i))
    (ψ : Matrix (Fin (2^(m + anc))) (Fin 1) ℂ) (ζ : Nat → ℂ)
    (h_eig : ∀ i, i < m →
        FormalRV.Framework.uc_eval
          (map_qubits (fun x => m + x) (f i) : BaseUCom (m + anc)) * ψ
          = ζ i • ψ) :
    FormalRV.Framework.uc_eval (controlled_powers
        (fun i => (map_qubits (fun x => m + x) (f i) : BaseUCom (m + anc))) m) * ψ
      = @phase_projector_product (m + anc) ζ m * ψ

abbrev KronVecShiftHyp (m anc : Nat) (f : FormalRV.Framework.BaseUCom anc)
    (χ : Matrix (Fin (2^m)) (Fin 1) ℂ)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) : Prop

theorem lifted_oracle_eigen_on_kron_control_conditional
    {m anc : Nat}
    (f : FormalRV.Framework.BaseUCom anc)
    (χ : Matrix (Fin (2^m)) (Fin 1) ℂ)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ)
    (ζ : ℂ)
    (h_eig : FormalRV.Framework.uc_eval f * ψ = ζ • ψ)
    (h_shift_kron : KronVecShiftHyp m anc f χ ψ) :
    FormalRV.Framework.uc_eval
        (map_qubits (fun q => m + q) f : FormalRV.Framework.BaseUCom (m + anc))
        * kron_vec χ ψ
      = ζ • kron_vec χ ψ

abbrev NparHKronZerosUniformHyp (m anc : Nat)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) : Prop

theorem QPE_pre_QFT_on_eigenstate_conditional
    {m anc : Nat} (hmanc : 0 < m + anc)
    (f : Nat → FormalRV.Framework.BaseUCom anc)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) (ζ : Nat → ℂ)
    (h_wt_all : ∀ i, i < m → UCom.WellTyped anc (f i))
    (h_shift_kron_eig_uniform : ∀ i, i < m →
      FormalRV.Framework.uc_eval
          (map_qubits (fun q => m + q) (f i) :
            FormalRV.Framework.BaseUCom (m + anc))
        * (((1 : ℂ) / Real.sqrt (2 ^ m)) •
            ∑ x : Fin (2^m),
              kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ)

theorem kron_vec_basis_eq_basis_combine (a b : Nat) (x : Fin (2^a)) (y : Fin (2^b)) :
    kron_vec (FormalRV.Framework.basis_vector (2^a) x.val)
             (FormalRV.Framework.basis_vector (2^b) y.val)
      = FormalRV.Framework.basis_vector (2^(a+b)) (kron_vec_combine x y).val

theorem padEquiv_combined_eq_kron_combine
    (m anc n : Nat) (hn : n < anc)
    (h_combined : m + n < m + anc)
    (h_size : m + anc - (m + n) - 1 = anc - n - 1)
    (x : Fin (2^m)) (yH : Fin (2^n)) (yM : Fin 2)
    (yL : Fin (2^(anc-n-1))) :
    (padEquiv (m + anc) (m + n) h_combined
        ((kron_vec_combine x yH, yM), Fin.cast (by rw [h_size]) yL)).val
      = (kron_vec_combine x (padEquiv anc n hn ((yH, yM), yL))).val

theorem pad_u_shifted_kron_basis_factors
    {m anc n : Nat} (hn : n < anc)
    (M : Matrix (Fin 2) (Fin 2) ℂ)
    (x : Fin (2^m)) (y : Fin (2^anc)) :
    pad_u (m + anc) (m + n) M
        * kron_vec (FormalRV.Framework.basis_vector (2^m) x.val)
                   (FormalRV.Framework.basis_vector (2^anc) y.val)
      = kron_vec (FormalRV.Framework.basis_vector (2^m) x.val)
                 (pad_u anc n M *
                   FormalRV.Framework.basis_vector (2^anc) y.val)

theorem vec_eq_sum_basis (n : Nat) (ψ : Matrix (Fin n) (Fin 1) ℂ) :
    ψ = ∑ y : Fin n, ψ y 0 • FormalRV.Framework.basis_vector n y.val

theorem kron_vec_sum_right {a b : Nat} (χ : Matrix (Fin (2^a)) (Fin 1) ℂ)
    {ι : Type*} [Fintype ι] (s : ι → Matrix (Fin (2^b)) (Fin 1) ℂ) :
    kron_vec χ (∑ y, s y) = ∑ y, kron_vec χ (s y)

theorem pad_u_shifted_kron_basis_control_vec {m anc n : Nat} (hn : n < anc)
    (M : Matrix (Fin 2) (Fin 2) ℂ)
    (x : Fin (2^m)) (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    pad_u (m + anc) (m + n) M
        * kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ
      = kron_vec (FormalRV.Framework.basis_vector (2^m) x.val)
                 (pad_u anc n M * ψ)

theorem pad_ctrl_shifted_kron_basis_control_vec {m anc a b : Nat}
    (ha : a < anc) (hb : b < anc)
    (x : Fin (2^m)) (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    pad_ctrl (m + anc) (m + a) (m + b) σx
        * kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ
      = kron_vec (FormalRV.Framework.basis_vector (2^m) x.val)
                 (pad_ctrl anc a b σx * ψ)

theorem uc_eval_map_qubits_shift_kron_basis_control_vec {m anc : Nat}
    (c : FormalRV.Framework.BaseUCom anc)
    (h_wt : UCom.WellTyped anc c)
    (x : Fin (2^m)) (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval
        (map_qubits (fun q => m + q) c : FormalRV.Framework.BaseUCom (m + anc))
      * kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ
    = kron_vec (FormalRV.Framework.basis_vector (2^m) x.val)
               (FormalRV.Framework.uc_eval c * ψ)

theorem lifted_oracle_eigen_on_kron_basis_control_vec {m anc : Nat}
    (f : FormalRV.Framework.BaseUCom anc)
    (x : Fin (2^m)) (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) (ζ : ℂ)
    (h_wt : UCom.WellTyped anc f)
    (h_eig : FormalRV.Framework.uc_eval f * ψ = ζ • ψ) :
    FormalRV.Framework.uc_eval
        (map_qubits (fun q => m + q) f : FormalRV.Framework.BaseUCom (m + anc))
        * kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ
      = ζ • kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ

theorem padEquiv_control_eq_kron_combine (m anc n : Nat) (hn : n < m)
    (h_combined : n < m + anc)
    (h_size : m + anc - n - 1 = (m - n - 1) + anc)
    (xH : Fin (2^n)) (xM : Fin 2) (xL : Fin (2^(m-n-1)))
    (y : Fin (2^anc)) :
    (padEquiv (m + anc) n h_combined
        ((xH, xM), Fin.cast (by rw [h_size]) (kron_vec_combine xL y))).val
      = (kron_vec_combine (padEquiv m n hn ((xH, xM), xL)) y).val

theorem pad_u_control_kron_basis_factors
    {m anc n : Nat} (hn : n < m)
    (M : Matrix (Fin 2) (Fin 2) ℂ)
    (x : Fin (2^m)) (y : Fin (2^anc)) :
    pad_u (m + anc) n M
        * kron_vec (FormalRV.Framework.basis_vector (2^m) x.val)
                   (FormalRV.Framework.basis_vector (2^anc) y.val)
      = kron_vec (pad_u m n M * FormalRV.Framework.basis_vector (2^m) x.val)
                 (FormalRV.Framework.basis_vector (2^anc) y.val)

theorem pad_u_control_kron_basis_control_vec {m anc n : Nat} (hn : n < m)
    (M : Matrix (Fin 2) (Fin 2) ℂ)
    (x : Fin (2^m)) (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    pad_u (m + anc) n M
        * kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ
      = kron_vec (pad_u m n M * FormalRV.Framework.basis_vector (2^m) x.val) ψ

theorem kron_vec_sum_left {a b : Nat}
    {ι : Type*} [Fintype ι] (s : ι → Matrix (Fin (2^a)) (Fin 1) ℂ)
    (φ : Matrix (Fin (2^b)) (Fin 1) ℂ) :
    kron_vec (∑ y, s y) φ = ∑ y, kron_vec (s y) φ

theorem pad_u_control_kron_vec_factors {m anc n : Nat} (hn : n < m)
    (M : Matrix (Fin 2) (Fin 2) ℂ)
    (χ : Matrix (Fin (2^m)) (Fin 1) ℂ) (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    pad_u (m + anc) n M * kron_vec χ ψ
      = kron_vec (pad_u m n M * χ) ψ

theorem uc_eval_app1_control_kron_vec {m anc n : Nat} (hn : n < m)
    (u : FormalRV.Framework.BaseUnitary 1)
    (χ : Matrix (Fin (2^m)) (Fin 1) ℂ) (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval
        (UCom.app1 u n : FormalRV.Framework.BaseUCom (m + anc)) * kron_vec χ ψ
      = kron_vec
          (FormalRV.Framework.uc_eval (UCom.app1 u n : FormalRV.Framework.BaseUCom m) * χ) ψ

theorem uc_eval_npar_H_kron_vec_aux (m anc : Nat) (hm : 0 < m)
    (χ : Matrix (Fin (2^m)) (Fin 1) ℂ) (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    ∀ k, k ≤ m →
      FormalRV.Framework.uc_eval
          (npar_H k : FormalRV.Framework.BaseUCom (m + anc)) * kron_vec χ ψ
        = kron_vec
            (FormalRV.Framework.uc_eval (npar_H k : FormalRV.Framework.BaseUCom m) * χ) ψ

theorem uc_eval_npar_H_kron_vec (m anc : Nat) (hm : 0 < m)
    (χ : Matrix (Fin (2^m)) (Fin 1) ℂ) (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval
        (npar_H m : FormalRV.Framework.BaseUCom (m + anc)) * kron_vec χ ψ
      = kron_vec
          (FormalRV.Framework.uc_eval (npar_H m : FormalRV.Framework.BaseUCom m) * χ) ψ

theorem pad_u_one_zero_eq (M : Matrix (Fin 2) (Fin 2) ℂ) : pad_u 1 0 M = M

theorem hMatrix_mul_basis_zero :
    hMatrix * FormalRV.Framework.basis_vector 2 0
      = ((Real.sqrt 2 / 2 : ℂ)) •
        (FormalRV.Framework.basis_vector 2 0 +
          FormalRV.Framework.basis_vector 2 1)

theorem H_zero_eq_plus :
    FormalRV.Framework.uc_eval
        (FormalRV.Framework.BaseUCom.H 0 : FormalRV.Framework.BaseUCom 1) *
        FormalRV.Framework.kron_zeros 1
      = ((Real.sqrt 2 / 2 : ℂ)) •
        (FormalRV.Framework.basis_vector 2 0 +
          FormalRV.Framework.basis_vector 2 1)

theorem pad_u_shifted_kron_vec_factors {m anc n : Nat} (hn : n < anc)
    (M : Matrix (Fin 2) (Fin 2) ℂ)
    (χ : Matrix (Fin (2^m)) (Fin 1) ℂ) (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    pad_u (m + anc) (m + n) M * kron_vec χ ψ
      = kron_vec χ (pad_u anc n M * ψ)

theorem kron_zeros_succ (m : Nat) :
    FormalRV.Framework.kron_zeros (m + 1)
      = kron_vec (FormalRV.Framework.kron_zeros m)
                 (FormalRV.Framework.kron_zeros 1)

theorem inv_sqrt_pow_two_succ (m : Nat) :
    ((1 : ℂ) / Real.sqrt (2^m : ℝ)) * ((Real.sqrt 2 / 2 : ℂ))
      = (1 : ℂ) / Real.sqrt (2^(m+1) : ℝ)

theorem uniform_sum_succ_split (m : Nat) :
    ∑ z : Fin (2^(m+1)), FormalRV.Framework.basis_vector (2^(m+1)) z.val
      = ∑ x : Fin (2^m),
          (kron_vec (FormalRV.Framework.basis_vector (2^m) x.val)
                    (FormalRV.Framework.basis_vector (2^1) 0)
            + kron_vec (FormalRV.Framework.basis_vector (2^m) x.val)
                       (FormalRV.Framework.basis_vector (2^1) 1))

private theorem inv_sqrt_two_pow_one :
    ((1 : ℂ) / Real.sqrt ((2:ℝ)^1)) = (Real.sqrt 2 / 2 : ℂ)

theorem npar_H_kron_zeros_pure_eq_uniform_sum :
    ∀ (m : Nat), 0 < m →
      FormalRV.Framework.uc_eval
          (npar_H m : FormalRV.Framework.BaseUCom m) *
          FormalRV.Framework.kron_zeros m
        = ((1 : ℂ) / Real.sqrt (2^m : ℝ)) •
          ∑ x : Fin (2^m), FormalRV.Framework.basis_vector (2^m) x.val

theorem npar_H_kron_zeros_eq_uniform_sum {m anc : Nat} (hm : 0 < m)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval (npar_H m : FormalRV.Framework.BaseUCom (m + anc))
        * kron_vec (FormalRV.Framework.kron_zeros m) ψ
      = ((1 : ℂ) / Real.sqrt (2^m : ℝ)) •
          ∑ x : Fin (2^m),
            kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ

theorem shifted_oracle_eigen_on_uniform_control_sum
    {m anc : Nat}
    (f : FormalRV.Framework.BaseUCom anc)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ)
    (ζ : ℂ)
    (h_wt : UCom.WellTyped anc f)
    (h_eig_data : FormalRV.Framework.uc_eval f * ψ = ζ • ψ) :
    FormalRV.Framework.uc_eval
        (map_qubits (fun q => m + q) f : FormalRV.Framework.BaseUCom (m + anc))
      *
    (((1 : ℂ) / Real.sqrt (2^m : ℝ)) •
      ∑ x : Fin (2^m),

theorem QPE_pre_QFT_on_eigenstate
    {m anc : Nat} (hmanc : 0 < m + anc) (hm : 0 < m)
    (f : Nat → FormalRV.Framework.BaseUCom anc)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) (ζ : Nat → ℂ)
    (h_wt_all : ∀ i, i < m → UCom.WellTyped anc (f i))
    (h_eig_data : ∀ i, i < m → FormalRV.Framework.uc_eval (f i) * ψ = ζ i • ψ) :
    FormalRV.Framework.uc_eval (controlled_powers
        (fun i => (map_qubits (fun q => m + q) (f i) :
          FormalRV.Framework.BaseUCom (m + anc))) m)
      * (FormalRV.Framework.uc_eval
            (npar_H m : FormalRV.Framework.BaseUCom (m + anc))
          * kron_vec (FormalRV.Framework.kron_zeros m) ψ)

noncomputable def controlBit (m i : Nat) (hi : i < m) (x : Fin (2^m)) : Bool

theorem controlBit_eq_digit (m i : Nat) (hi : i < m) (x : Fin (2^m)) :
    controlBit m i hi x = ((x.val / 2^(m-i-1)) % 2 = 1)

noncomputable def controlBitNat (m i : Nat) (hi : i < m) (x : Fin (2^m)) : Nat

theorem controlBitNat_eq_digit (m i : Nat) (hi : i < m) (x : Fin (2^m)) :
    controlBitNat m i hi x = (x.val / 2^(m-i-1)) % 2

noncomputable def phase_prefix (ζ : Nat → ℂ) (m : Nat) (x : Fin (2^m)) :
    Nat → ℂ
  | 0 => 1
  | k+1 =>
    (if h : k < m then
       (if controlBit m k h x then ζ k else 1)
     else 1) * phase_prefix ζ m x k

theorem phase_prefix_succ {ζ : Nat → ℂ} {m : Nat} (x : Fin (2^m)) (k : Nat)
    (hk : k < m) :
    phase_prefix ζ m x (k+1) =
      (if controlBit m k hk x then ζ k else 1) * phase_prefix ζ m x k

theorem phase_projector_on_kron_basis
    {m anc i : Nat} (hi : i < m)
    (ζi : ℂ)
    (x : Fin (2^m))
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    @phase_projector (m + anc) i ζi
        * kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ
      = (if controlBit m i hi x then ζi else 1) •
          kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ

theorem phase_projector_product_prefix_on_kron_basis
    {m anc : Nat}
    (ζ : Nat → ℂ)
    (x : Fin (2^m))
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    ∀ k, k ≤ m →
      @phase_projector_product (m + anc) ζ k
        * kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ
      = phase_prefix ζ m x k •
          kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ

theorem phase_projector_product_on_kron_basis
    {m anc : Nat}
    (ζ : Nat → ℂ)
    (x : Fin (2^m))
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    @phase_projector_product (m + anc) ζ m
        * kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ
      = phase_prefix ζ m x m •
          kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ

theorem phase_projector_product_on_uniform_control_sum
    {m anc : Nat}
    (ζ : Nat → ℂ)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    @phase_projector_product (m + anc) ζ m
      * (((1 : ℂ) / Real.sqrt (2^m : ℝ)) •
          ∑ x : Fin (2^m),
            kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ)
    = ((1 : ℂ) / Real.sqrt (2^m : ℝ)) •
        ∑ x : Fin (2^m),
          phase_prefix ζ m x m •
            kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ

lemma binary_expansion_lsb (m n : Nat) (hn : n < 2^m) :
    n = ∑ i ∈ Finset.range m, ((n / 2^i) % 2) * 2^i

lemma binary_expansion_msb (m n : Nat) (hn : n < 2^m) :
    n = ∑ i ∈ Finset.range m, ((n / 2^(m-i-1)) % 2) * 2^(m-i-1)

noncomputable def controlWeightedIndex (m : Nat) (x : Fin (2^m)) : Nat

theorem controlWeightedIndex_eq_val (m : Nat) (x : Fin (2^m)) :
    controlWeightedIndex m x = x.val

noncomputable def qpeEigenvalue (m i : Nat) (θ : ℝ) : ℂ

noncomputable def partialWeightedIndex (m k : Nat) (x : Fin (2^m)) : Nat

theorem partialWeightedIndex_at_m (m : Nat) (x : Fin (2^m)) :
    partialWeightedIndex m m x = x.val

theorem partialWeightedIndex_succ (m k : Nat) (hk : k < m) (x : Fin (2^m)) :
    partialWeightedIndex m (k+1) x
      = partialWeightedIndex m k x
        + controlBitNat m k hk x * 2^(m-k-1)

theorem phase_prefix_qpe_eq_exp_partial (m : Nat) (θ : ℝ) (x : Fin (2^m)) :
    ∀ k, k ≤ m →
      phase_prefix (qpeEigenvalue m · θ) m x k
        = Complex.exp (2 * Real.pi * Complex.I *
            (partialWeightedIndex m k x : ℂ) * (θ : ℂ))

theorem phase_prefix_qpe_eq_exp_val (m : Nat) (θ : ℝ) (x : Fin (2^m)) :
    phase_prefix (qpeEigenvalue m · θ) m x m
      = Complex.exp (2 * Real.pi * Complex.I * (x.val : ℂ) * (θ : ℂ))

theorem QPE_pre_QFT_on_eigenstate_fourier_form
    {m anc : Nat} (hmanc : 0 < m + anc) (hm : 0 < m)
    (f : Nat → FormalRV.Framework.BaseUCom anc)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ)
    (θ : ℝ)
    (h_wt_all : ∀ i, i < m → UCom.WellTyped anc (f i))
    (h_eig_data : ∀ i, i < m →
      FormalRV.Framework.uc_eval (f i) * ψ =
        qpeEigenvalue m i θ • ψ) :
    FormalRV.Framework.uc_eval (controlled_powers
        (fun i => (map_qubits (fun q => m + q) (f i) :
          FormalRV.Framework.BaseUCom (m + anc))) m)

theorem pad_ctrl_control_kron_vec_factors {m anc a b : Nat}
    (ha : a < m) (hb : b < m)
    (χ : Matrix (Fin (2^m)) (Fin 1) ℂ) (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    pad_ctrl (m + anc) a b σx * kron_vec χ ψ
      = kron_vec (pad_ctrl m a b σx * χ) ψ

theorem uc_eval_control_register_circuit_kron_vec
    {m anc : Nat}
    (c : FormalRV.Framework.BaseUCom m)
    (h_wt : UCom.WellTyped m c)
    (χ : Matrix (Fin (2^m)) (Fin 1) ℂ)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval
        (map_qubits (fun q => q) c : FormalRV.Framework.BaseUCom (m + anc))
      * kron_vec χ ψ
    = kron_vec (FormalRV.Framework.uc_eval c * χ) ψ

lemma fourier_weighted_state_apply (m : Nat) (θ : ℝ) (k : Fin (2^m)) :
    (((1 : ℂ) / Real.sqrt (2^m : ℝ)) •
        ∑ x : Fin (2^m),
          Complex.exp (2 * Real.pi * Complex.I * (x.val : ℂ) * (θ : ℂ)) •
            FormalRV.Framework.basis_vector (2^m) x.val) k 0
    = ((1 : ℂ) / Real.sqrt (2^m : ℝ)) *
        Complex.exp (2 * Real.pi * Complex.I * (k.val : ℂ) * (θ : ℂ))

lemma inv_sqrt_two_pow_sq (m : Nat) :
    ((1 : ℂ) / Real.sqrt (2^m : ℝ)) * ((1 : ℂ) / Real.sqrt (2^m : ℝ))
      = 1 / (2^m : ℂ)

theorem IQFT_matrix_on_fourier_weighted_state
    (m : Nat) (θ : ℝ) :
    IQFT_matrix m *
      (((1 : ℂ) / Real.sqrt (2^m : ℝ)) •
        ∑ x : Fin (2^m),
          Complex.exp (2 * Real.pi * Complex.I * (x.val : ℂ) * (θ : ℂ)) •
            FormalRV.Framework.basis_vector (2^m) x.val)
    = qpe_phase_state m θ

theorem real_QFTinv_on_one : real_QFTinv_on 1 = (H 0 : BaseUCom 1)

theorem real_QFTinv_on_zero : real_QFTinv_on 0 = (SKIP : BaseUCom 0)

theorem real_QFTinv_layer_two_eq_candidate :
    FormalRV.Framework.uc_eval (real_QFTinv_layer 2)
      = FormalRV.Framework.uc_eval real_QFTinv2_candidate

lemma sqrt_two_div_two_eq_inv :
    (Real.sqrt 2 : ℂ) / 2 = (Real.sqrt 2 : ℂ)⁻¹

theorem uc_eval_real_QFTinv_eq_IQFT_matrix_one :
    FormalRV.Framework.uc_eval (real_QFTinv_on 1 : BaseUCom 1)
      = IQFT_matrix 1

theorem real_QFTinv_one_on_fourier_state (θ : ℝ) :
    FormalRV.Framework.uc_eval (real_QFTinv_on 1 : BaseUCom 1) *
      (((1 : ℂ) / Real.sqrt (2^1 : ℝ)) •
        ∑ x : Fin (2^1),
          Complex.exp (2 * Real.pi * Complex.I * (x.val : ℂ) * (θ : ℂ)) •
            FormalRV.Framework.basis_vector (2^1) x.val)
    = qpe_phase_state 1 θ

theorem H_one_eq_minus :
    FormalRV.Framework.uc_eval
        (FormalRV.Framework.BaseUCom.H 0 : FormalRV.Framework.BaseUCom 1) *
        FormalRV.Framework.basis_vector 2 1
      = ((Real.sqrt 2 / 2 : ℂ)) •
        (FormalRV.Framework.basis_vector 2 0 -
          FormalRV.Framework.basis_vector 2 1)

theorem uc_eval_H_zero_two_eq_pad_u :
    FormalRV.Framework.uc_eval (BaseUCom.H 0 : FormalRV.Framework.BaseUCom 2)
      = pad_u 2 0 hMatrix

theorem uc_eval_H_one_two_eq_pad_u :
    FormalRV.Framework.uc_eval (BaseUCom.H 1 : FormalRV.Framework.BaseUCom 2)
      = pad_u 2 1 hMatrix

theorem IQFT_matrix_two_on_basis_zero :
    IQFT_matrix 2 * FormalRV.Framework.basis_vector 4 0
      = ((1 : ℂ) / Real.sqrt (2^2 : ℝ)) •
        (FormalRV.Framework.basis_vector 4 0 +
         FormalRV.Framework.basis_vector 4 1 +
         FormalRV.Framework.basis_vector 4 2 +
         FormalRV.Framework.basis_vector 4 3)

theorem IQFT_matrix_two_on_basis_one :
    IQFT_matrix 2 * FormalRV.Framework.basis_vector 4 1
      = ((1 : ℂ) / Real.sqrt (2^2 : ℝ)) •
        (FormalRV.Framework.basis_vector 4 0
         + Complex.exp (-(Real.pi / 2) * Complex.I) • FormalRV.Framework.basis_vector 4 1
         + Complex.exp (-Real.pi * Complex.I) • FormalRV.Framework.basis_vector 4 2
         + Complex.exp (-(3 * Real.pi / 2) * Complex.I) • FormalRV.Framework.basis_vector 4 3)

theorem IQFT_matrix_two_on_basis_two :
    IQFT_matrix 2 * FormalRV.Framework.basis_vector 4 2
      = ((1 : ℂ) / Real.sqrt (2^2 : ℝ)) •
        (FormalRV.Framework.basis_vector 4 0
         + Complex.exp (-Real.pi * Complex.I) • FormalRV.Framework.basis_vector 4 1
         + Complex.exp (-2 * Real.pi * Complex.I) • FormalRV.Framework.basis_vector 4 2
         + Complex.exp (-3 * Real.pi * Complex.I) • FormalRV.Framework.basis_vector 4 3)

theorem IQFT_matrix_two_on_basis_three :
    IQFT_matrix 2 * FormalRV.Framework.basis_vector 4 3
      = ((1 : ℂ) / Real.sqrt (2^2 : ℝ)) •
        (FormalRV.Framework.basis_vector 4 0
         + Complex.exp (-(3 * Real.pi / 2) * Complex.I) • FormalRV.Framework.basis_vector 4 1
         + Complex.exp (-3 * Real.pi * Complex.I) • FormalRV.Framework.basis_vector 4 2
         + Complex.exp (-(9 * Real.pi / 2) * Complex.I) • FormalRV.Framework.basis_vector 4 3)

lemma f_to_vec_two_eq (f : Nat → Bool) :
    f_to_vec 2 f = FormalRV.Framework.basis_vector 4
      ((if f 0 then 2 else 0) + (if f 1 then 1 else 0))

lemma sqrt_two_half_sq :
    (Real.sqrt 2 / 2 : ℂ) * (Real.sqrt 2 / 2 : ℂ) = (1/2 : ℂ)

lemma exp_neg_pi_I : Complex.exp (-((Real.pi : ℂ) * Complex.I)) = -1

lemma exp_neg_two_pi_I : Complex.exp (-(2 * (Real.pi : ℂ) * Complex.I)) = 1

lemma exp_neg_three_pi_I : Complex.exp (-(3 * (Real.pi : ℂ) * Complex.I)) = -1

lemma exp_neg_three_pi_half_I :
    Complex.exp (-(3 * (Real.pi : ℂ) / 2 * Complex.I))
      = -Complex.exp (-((Real.pi : ℂ) / 2 * Complex.I))

lemma exp_neg_nine_pi_half_I :
    Complex.exp (-(9 * (Real.pi : ℂ) / 2 * Complex.I))
      = Complex.exp (-((Real.pi : ℂ) / 2 * Complex.I))

lemma sqrt_two_sq_complex : ((Real.sqrt 2 : ℂ))^2 = (2 : ℂ)

lemma sqrt_two_half_smul_sandwich (e : ℂ) :
    (Real.sqrt 2 / 2 : ℂ) * (e * (Real.sqrt 2 / 2 : ℂ)) = (1/2 : ℂ) * e

theorem real_QFTinv2_candidate_on_basis_zero :
    FormalRV.Framework.uc_eval real_QFTinv2_candidate *
        FormalRV.Framework.basis_vector 4 0
      = IQFT_matrix 2 * FormalRV.Framework.basis_vector 4 0

theorem real_QFTinv2_candidate_on_basis_one :
    FormalRV.Framework.uc_eval real_QFTinv2_candidate *
        FormalRV.Framework.basis_vector 4 1
      = IQFT_matrix 2 * FormalRV.Framework.basis_vector 4 1

theorem real_QFTinv2_candidate_on_basis_two :
    FormalRV.Framework.uc_eval real_QFTinv2_candidate *
        FormalRV.Framework.basis_vector 4 2
      = IQFT_matrix 2 * FormalRV.Framework.basis_vector 4 2

theorem real_QFTinv2_candidate_on_basis_three :
    FormalRV.Framework.uc_eval real_QFTinv2_candidate *
        FormalRV.Framework.basis_vector 4 3
      = IQFT_matrix 2 * FormalRV.Framework.basis_vector 4 3

theorem uc_eval_real_QFTinv2_candidate_eq_IQFT_matrix :
    FormalRV.Framework.uc_eval real_QFTinv2_candidate = IQFT_matrix 2

theorem real_QFTinv_on_two : real_QFTinv_on 2 = real_QFTinv2_candidate

theorem uc_eval_real_QFTinv_eq_IQFT_matrix_two :
    FormalRV.Framework.uc_eval (real_QFTinv_on 2 : BaseUCom 2) = IQFT_matrix 2

theorem real_QFTinv_two_on_fourier_state (θ : ℝ) :
    FormalRV.Framework.uc_eval (real_QFTinv_on 2 : BaseUCom 2) *
      (((1 : ℂ) / Real.sqrt (2^2 : ℝ)) •
        ∑ x : Fin (2^2),
          Complex.exp (2 * Real.pi * Complex.I * (x.val : ℂ) * (θ : ℂ)) •
            FormalRV.Framework.basis_vector (2^2) x.val)
    = qpe_phase_state 2 θ

theorem real_QFTinv_lifted_on_kron
    {m anc : Nat}
    (ψc : Matrix (Fin (2^m)) (Fin 1) ℂ)
    (ψd : Matrix (Fin (2^anc)) (Fin 1) ℂ)
    (h_wt : UCom.WellTyped m (real_QFTinv_on m))
    (h_IQFT : FormalRV.Framework.uc_eval (real_QFTinv_on m : BaseUCom m)
                = IQFT_matrix m) :
    FormalRV.Framework.uc_eval
        (map_qubits (fun q => q) (real_QFTinv_on m) : BaseUCom (m + anc))
      * kron_vec ψc ψd
    = kron_vec (IQFT_matrix m * ψc) ψd

theorem fourier_weighted_kron_sum_eq_kron_vec_fourier_state
    {m anc : Nat} (θ : ℝ) (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    (((1 : ℂ) / Real.sqrt (2^m : ℝ)) •
      ∑ x : Fin (2^m),
        Complex.exp (2 * Real.pi * Complex.I * (x.val : ℂ) * (θ : ℂ)) •
          kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ)
    = kron_vec
        (((1 : ℂ) / Real.sqrt (2^m : ℝ)) •
          ∑ x : Fin (2^m),
            Complex.exp (2 * Real.pi * Complex.I * (x.val : ℂ) * (θ : ℂ)) •
              FormalRV.Framework.basis_vector (2^m) x.val) ψ

theorem real_QFTinv_on_fourier_weighted_kron_state_from_matrix_correct
    {m anc : Nat}
    (θ : ℝ)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ)
    (h_wt : UCom.WellTyped m (real_QFTinv_on m))
    (h_IQFT : FormalRV.Framework.uc_eval (real_QFTinv_on m : BaseUCom m)
                = IQFT_matrix m) :
    FormalRV.Framework.uc_eval
        (map_qubits (fun q => q) (real_QFTinv_on m) : BaseUCom (m + anc))
      *
    (((1 : ℂ) / Real.sqrt (2^m : ℝ)) •
      ∑ x : Fin (2^m),

theorem IQFT_matrix_apply (m : Nat) (y x : Fin (2^m)) :
    IQFT_matrix m y x
      = ((1 : ℂ) / Real.sqrt (2^m : ℝ)) *
        Complex.exp (-(2 * Real.pi * Complex.I) * (x.val : ℂ) * (y.val : ℂ)
                     / (2^m : ℂ))

theorem uc_eval_real_QFTinv_layer_eq_IQFT_matrix_two :
    FormalRV.Framework.uc_eval (real_QFTinv_layer 2 : BaseUCom 2)
      = IQFT_matrix 2

theorem IQFT_index_split (n : Nat) (_hn : 1 ≤ n) (xh yh xl yl : Nat) :
    ((2^n * xh + xl : ℂ) * (2^n * yh + yl) / 2^(n+1) : ℂ)
    = (2^(n-1) * xh * yh : ℂ)
      + ((xh * yl + xl * yh : ℂ)) / 2
      + ((xl * yl : ℂ) / 2^(n+1))

theorem iqft_index_reconstruct (n : Nat) (x : Fin (2^(n+1))) :
    x.val = (iqftHighBit n x).val * 2^n + (iqftLowBits n x).val

theorem exp_neg_two_pi_I_mul_nat (k : Nat) :
    Complex.exp ((-2 * Real.pi * (k : ℝ) : ℂ) * Complex.I) = 1

theorem exp_neg_pi_I_mul_nat (k : Nat) :
    Complex.exp (((-Real.pi * (k : ℝ) : ℝ) : ℂ) * Complex.I) = (-1 : ℂ) ^ k

theorem inv_sqrt_pow_two_succ_factor (n : Nat) :
    (1 : ℂ) / Real.sqrt (2^(n+1) : ℝ)
      = ((1 : ℂ) / Real.sqrt 2) * ((1 : ℂ) / Real.sqrt (2^n : ℝ))

theorem countdown_zero (n : Nat) :
    real_QFTinv_layer.countdown n 0 = (SKIP : FormalRV.Framework.BaseUCom n)

theorem countdown_succ (n k : Nat) :
    real_QFTinv_layer.countdown n (k+1)
      = UCom.seq (inverse_qft_phase_ladder n k) (real_QFTinv_layer.countdown n k)

theorem real_QFTinv_layer_decomp (n : Nat) :
    (real_QFTinv_layer n : FormalRV.Framework.BaseUCom n)
      = UCom.seq (bit_reversal_swaps n) (real_QFTinv_layer.countdown n n)

theorem real_QFTinv_layer_acts (n : Nat) (v : Matrix (Fin (2^n)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval (real_QFTinv_layer n : FormalRV.Framework.BaseUCom n) * v
    = FormalRV.Framework.uc_eval
        (real_QFTinv_layer.countdown n n : FormalRV.Framework.BaseUCom n)
      * (FormalRV.Framework.uc_eval
          (bit_reversal_swaps n : FormalRV.Framework.BaseUCom n) * v)

theorem countdown_zero_acts (n : Nat) (hn : 0 < n) (v : Matrix (Fin (2^n)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval
        (real_QFTinv_layer.countdown n 0 : FormalRV.Framework.BaseUCom n) * v = v

theorem countdown_succ_acts (n k : Nat) (v : Matrix (Fin (2^n)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval
        (real_QFTinv_layer.countdown n (k+1) : FormalRV.Framework.BaseUCom n) * v
    = FormalRV.Framework.uc_eval
        (real_QFTinv_layer.countdown n k : FormalRV.Framework.BaseUCom n)
      * (FormalRV.Framework.uc_eval
          (inverse_qft_phase_ladder n k : FormalRV.Framework.BaseUCom n) * v)

theorem uc_eval_SWAP_on_f_to_vec {n : Nat} (a b : Nat)
    (ha : a < n) (hb : b < n) (hab : a ≠ b) (f : Nat → Bool) :
    FormalRV.Framework.uc_eval
        (FormalRV.Framework.BaseUCom.SWAP a b : FormalRV.Framework.BaseUCom n)
      * f_to_vec n f
    = f_to_vec n (swapBits f a b)

theorem bit_reversal_loop_step (n i : Nat) (hi : i + i + 1 < n) :
    bit_reversal_swaps.loop n i
      = UCom.seq (FormalRV.Framework.BaseUCom.SWAP i (n - 1 - i))
          (bit_reversal_swaps.loop n (i + 1))

theorem bit_reversal_loop_base (n i : Nat) (hi : ¬ i + i + 1 < n) :
    bit_reversal_swaps.loop n i = (SKIP : FormalRV.Framework.BaseUCom n)

theorem applySwapsFrom_step (n k : Nat) (f : Nat → Bool) (hk : 2 * k + 1 < n) :
    applySwapsFrom n k f = applySwapsFrom n (k+1) (swapBits f k (n-1-k))

theorem applySwapsFrom_base (n k : Nat) (f : Nat → Bool) (hk : ¬ 2 * k + 1 < n) :
    applySwapsFrom n k f = f

theorem bit_reversal_loop_acts_on_f_to_vec_aux
    (n : Nat) (hn : 0 < n) : ∀ (m : Nat), ∀ (k : Nat), ∀ (f : Nat → Bool),
    n - 2 * k = m →
    FormalRV.Framework.uc_eval
        (bit_reversal_swaps.loop n k : FormalRV.Framework.BaseUCom n)
      * f_to_vec n f
    = f_to_vec n (applySwapsFrom n k f)

theorem bit_reversal_swaps_acts_on_f_to_vec (n : Nat) (hn : 0 < n) (f : Nat → Bool) :
    FormalRV.Framework.uc_eval (bit_reversal_swaps n : FormalRV.Framework.BaseUCom n)
      * f_to_vec n f
    = f_to_vec n (applySwapsFrom n 0 f)

theorem inverse_qft_ladder_phase_from_succ (n target : Nat) (f : Nat → Bool) (k : Nat)
    (hk : k < n) :
    inverse_qft_ladder_phase_from n target f k
    = (if f k ∧ f target then
         Complex.exp ((((-(Real.pi / 2 ^ (k - target))) : ℝ)) * Complex.I)
       else 1)
      * inverse_qft_ladder_phase_from n target f (k+1)

theorem inverse_qft_ladder_phase_from_at_top (n target : Nat) (f : Nat → Bool) :
    inverse_qft_ladder_phase_from n target f n = 1

theorem ladder_loop_step (n target j : Nat) (hj : j < n) :
    inverse_qft_phase_ladder.loop n target j
      = UCom.seq (controlled_Rz j target (-(Real.pi / (2 ^ (j - target) : ℝ))))
                 (inverse_qft_phase_ladder.loop n target (j + 1))

theorem ladder_loop_base (n target j : Nat) (hj : ¬ j < n) :
    inverse_qft_phase_ladder.loop n target j
      = (FormalRV.Framework.BaseUCom.H target : FormalRV.Framework.BaseUCom n)

theorem ladder_loop_acts_on_f_to_vec_aux
    (n_arg : Nat) (target : Nat) (h_target : target < n_arg)
    (f : Nat → Bool) :
    ∀ m k, k ≤ n_arg → n_arg - k = m → target < k →
      FormalRV.Framework.uc_eval
          (inverse_qft_phase_ladder.loop n_arg target k :
            FormalRV.Framework.BaseUCom n_arg)
        * f_to_vec n_arg f
      = inverse_qft_ladder_phase_from n_arg target f k
        • (FormalRV.Framework.uc_eval
            (FormalRV.Framework.BaseUCom.H target : FormalRV.Framework.BaseUCom n_arg)
            * f_to_vec n_arg f)

theorem inverse_qft_phase_ladder_acts_on_f_to_vec
    (n target : Nat) (h_target : target < n)
    (f : Nat → Bool) :
    FormalRV.Framework.uc_eval
        (inverse_qft_phase_ladder n target : FormalRV.Framework.BaseUCom n)
      * f_to_vec n f
    = inverse_qft_ladder_phase n target f
      • (FormalRV.Framework.uc_eval
          (FormalRV.Framework.BaseUCom.H target : FormalRV.Framework.BaseUCom n)
          * f_to_vec n f)

theorem IQFT_matrix_succ_entry_decomp
    (n : Nat) (hn : 1 ≤ n)
    (y x : Fin (2^(n+1))) :
    IQFT_matrix (n+1) y x
      = ((1 : ℂ) / Real.sqrt (2^(n+1) : ℝ))
        * ((-1 : ℂ) ^
            ((iqftHighBit n x).val * (iqftLowBits n y).val
              + (iqftLowBits n x).val * (iqftHighBit n y).val))
        * Complex.exp (-(Real.pi : ℂ) * Complex.I
            * (iqftLowBits n x).val * (iqftLowBits n y).val / (2^n : ℂ))

theorem real_QPE_on_eigenstate_from_IQFT_correct
    {m anc : Nat} (hmanc : 0 < m + anc) (hm : 0 < m)
    (f : Nat → BaseUCom anc)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ)
    (θ : ℝ)
    (h_wt_all : ∀ i, i < m → UCom.WellTyped anc (f i))
    (h_eig_data : ∀ i, i < m →
      FormalRV.Framework.uc_eval (f i) * ψ =
        qpeEigenvalue m i θ • ψ)
    (h_wt_IQFT : UCom.WellTyped m (real_QFTinv_on m))
    (h_IQFT : FormalRV.Framework.uc_eval (real_QFTinv_on m : BaseUCom m)
                = IQFT_matrix m) :

theorem inverse_qft_phase_ladder_explicit_on_f_to_vec
    (n target : Nat) (h_target : target < n)
    (f : Nat → Bool) :
    FormalRV.Framework.uc_eval
        (inverse_qft_phase_ladder n target : FormalRV.Framework.BaseUCom n)
      * f_to_vec n f
    = inverse_qft_ladder_phase n target f •
      (((Real.sqrt 2 / 2 : ℂ) • f_to_vec n (update f target false))
        + ((if f target then -(Real.sqrt 2 / 2 : ℂ) else (Real.sqrt 2 / 2 : ℂ))
            • f_to_vec n (update f target true)))

theorem countdown_output_zero (n : Nat) (f : Nat → Bool) :
    countdown_output n 0 f = f_to_vec n f

theorem countdown_output_succ (n k : Nat) (f : Nat → Bool) :
    countdown_output n (k+1) f
      = inverse_qft_ladder_phase n k f •
          (((Real.sqrt 2 / 2 : ℂ) • countdown_output n k (update f k false))
            + ((if f k then -(Real.sqrt 2 / 2 : ℂ) else (Real.sqrt 2 / 2 : ℂ))
                • countdown_output n k (update f k true)))

theorem countdown_acts_on_f_to_vec (n : Nat) (hn : 0 < n) :
    ∀ k, k ≤ n → ∀ (f : Nat → Bool),
      FormalRV.Framework.uc_eval
          (real_QFTinv_layer.countdown n k : FormalRV.Framework.BaseUCom n)
        * f_to_vec n f
      = countdown_output n k f

theorem real_QFTinv_layer_output_on_f_to_vec
    (n : Nat) (hn : 0 < n) (f : Nat → Bool) :
    FormalRV.Framework.uc_eval (real_QFTinv_layer n : FormalRV.Framework.BaseUCom n)
      * f_to_vec n f
    = countdown_output n n (applySwapsFrom n 0 f)

theorem uc_eval_real_QFTinv_layer_eq_IQFT_matrix_one :
    FormalRV.Framework.uc_eval (real_QFTinv_layer 1 : FormalRV.Framework.BaseUCom 1)
      = IQFT_matrix 1

theorem IQFT_matrix_mul_basis_apply (n : Nat) (x y : Fin (2^n)) :
    (IQFT_matrix n * FormalRV.Framework.basis_vector (2^n) x.val) y 0
    = IQFT_matrix n y x

theorem countdown_output_eq_IQFT_column_one (x : Fin (2^1)) :
    countdown_output 1 1 (applySwapsFrom 1 0 (nat_to_funbool 1 x.val))
    = IQFT_matrix 1 * FormalRV.Framework.basis_vector (2^1) x.val

theorem countdown_output_eq_IQFT_column_two (x : Fin (2^2)) :
    countdown_output 2 2 (applySwapsFrom 2 0 (nat_to_funbool 2 x.val))
    = IQFT_matrix 2 * FormalRV.Framework.basis_vector (2^2) x.val

theorem countdownColumn_eq_IQFT_column_one (x : Fin (2^1)) :
    countdownColumn 1 x = IQFT_matrix 1 * FormalRV.Framework.basis_vector (2^1) x.val

theorem countdownColumn_eq_IQFT_column_two (x : Fin (2^2)) :
    countdownColumn 2 x = IQFT_matrix 2 * FormalRV.Framework.basis_vector (2^2) x.val

theorem f_to_vec_dim_split (n : Nat) (f : Nat → Bool) :
    f_to_vec (n+1) f
    = kron_vec (f_to_vec n f)
        (FormalRV.Framework.basis_vector 2 (if f n then 1 else 0))

theorem inverse_qft_ladder_phase_dim_split
    (n target : Nat) (h_target : target < n)
    (f : Nat → Bool) :
    inverse_qft_ladder_phase (n+1) target f
    = (if f n ∧ f target then
         Complex.exp ((((-(Real.pi / 2 ^ (n - target))) : ℝ)) * Complex.I)
       else 1)
      * inverse_qft_ladder_phase n target f

theorem embedWithExtraBit_smul (n : Nat) (extra : Bool) (c : ℂ)
    (v : Matrix (Fin (2^n)) (Fin 1) ℂ) :
    embedWithExtraBit n extra (c • v) = c • embedWithExtraBit n extra v

theorem embedWithExtraBit_add (n : Nat) (extra : Bool)
    (v w : Matrix (Fin (2^n)) (Fin 1) ℂ) :
    embedWithExtraBit n extra (v + w)
    = embedWithExtraBit n extra v + embedWithExtraBit n extra w

theorem cumulative_extra_phase_zero (n : Nat) (f : Nat → Bool) :
    cumulative_extra_phase n 0 f = 1

theorem cumulative_extra_phase_succ (n k : Nat) (f : Nat → Bool) :
    cumulative_extra_phase n (k+1) f
    = cumulative_extra_phase n k f *
      (if f n ∧ f k then
        Complex.exp ((((-(Real.pi / 2 ^ (n - k))) : ℝ)) * Complex.I)
      else 1)

theorem extra_bit_update_lt (n k : Nat) (hk : k < n) (f : Nat → Bool) (b : Bool) :
    update f k b n = f n

theorem cumulative_extra_phase_update_branch
    (n k : Nat) (hk : k < n) (f : Nat → Bool) (b : Bool) :
    cumulative_extra_phase n k (update f k b)
    = cumulative_extra_phase n k f

theorem countdown_output_dim_split (n : Nat) :
    ∀ k, k ≤ n → ∀ (f : Nat → Bool),
      countdown_output (n+1) k f
      = cumulative_extra_phase n k f •
        embedWithExtraBit n (f n) (countdown_output n k f)

theorem countdown_output_dim_split_full (n : Nat) (f : Nat → Bool) :
    countdown_output (n+1) n f
    = cumulative_extra_phase n n f •
      embedWithExtraBit n (f n) (countdown_output n n f)

theorem iqft_index_reconstruct_highN_low1 (n : Nat) (y : Fin (2^(n+1))) :
    y.val = (iqftHighBitsN n y).val * 2 + (iqftLowBitLSB n y).val

theorem swapBits_left (f : Nat → Bool) (a b : Nat) :
    swapBits f a b a = f b

theorem swapBits_right (f : Nat → Bool) (a b : Nat) (hab : a ≠ b) :
    swapBits f a b b = f a

theorem swapBits_other (f : Nat → Bool) (a b i : Nat) (hia : i ≠ a) (hib : i ≠ b) :
    swapBits f a b i = f i

theorem applySwapsFrom_apply_region (n : Nat) :
    ∀ (m k : Nat), n - 2 * k = m → ∀ (f : Nat → Bool) (i : Nat),
      applySwapsFrom n k f i =
        if k ≤ i ∧ i ≤ n - 1 - k then f (n - 1 - i) else f i

noncomputable def IQFT_matrix (m : Nat) :
    Matrix (Fin (2^m)) (Fin (2^m)) ℂ

noncomputable def real_QFTinv_on : (n : Nat) → BaseUCom n
  | 0 => SKIP
  | 1 => H 0
  | 2 => UCom.seq
           (UCom.seq
             (UCom.seq (SWAP 0 1) (H 1))
             (controlled_Rz 1 0 (-(Real.pi / 2))))
           (H 0)
  | _+3 => SKIP  -- General case: deferred to `real_QFTinv_layer` (see §4)

noncomputable def real_QFTinv2_candidate : BaseUCom 2

noncomputable def inverse_qft_phase_ladder
    (n target : Nat) : FormalRV.Framework.BaseUCom n

noncomputable def bit_reversal_swaps (n : Nat) : FormalRV.Framework.BaseUCom n

noncomputable def real_QFTinv_layer (n : Nat) : FormalRV.Framework.BaseUCom n

noncomputable def real_QPE (m anc : Nat) (f : Nat → BaseUCom anc) :
    BaseUCom (m + anc)

noncomputable def iqftHighBit (n : Nat) (x : Fin (2^(n+1))) : Fin 2

noncomputable def iqftLowBits (n : Nat) (x : Fin (2^(n+1))) : Fin (2^n)

noncomputable def IQFT_column (n : Nat) (x : Fin (2^n)) :
    Matrix (Fin (2^n)) (Fin 1) ℂ

def swapBits (f : Nat → Bool) (a b : Nat) : Nat → Bool

def applySwapsFrom (n : Nat) : (k : Nat) → (Nat → Bool) → (Nat → Bool)
  | k, f =>
    if h : 2 * k + 1 < n then
      applySwapsFrom n (k+1) (swapBits f k (n-1-k))
    else
      f
  termination_by k _ => n - 2 * k

noncomputable def inverse_qft_ladder_phase_from
    (n target : Nat) (f : Nat → Bool) (k : Nat) : ℂ

noncomputable def inverse_qft_ladder_phase
    (n target : Nat) (f : Nat → Bool) : ℂ

noncomputable def countdown_output
    (n : Nat) : Nat → (Nat → Bool) → Matrix (Fin (2^n)) (Fin 1) ℂ
  | 0, f => f_to_vec n f
  | k+1, f =>
      inverse_qft_ladder_phase n k f •
        (((Real.sqrt 2 / 2 : ℂ) • countdown_output n k (update f k false))
          + ((if f k then -(Real.sqrt 2 / 2 : ℂ) else (Real.sqrt 2 / 2 : ℂ))
              • countdown_output n k (update f k true)))

noncomputable def basisFunOfIndex (n : Nat) (x : Fin (2^n)) : Nat → Bool

noncomputable def bitReversedBasisFun (n : Nat) (x : Fin (2^n)) : Nat → Bool

noncomputable def countdownColumn (n : Nat) (x : Fin (2^n)) :
    Matrix (Fin (2^n)) (Fin 1) ℂ

noncomputable def embedWithExtraBit
    (n : Nat) (extra : Bool)
    (v : Matrix (Fin (2^n)) (Fin 1) ℂ) :
    Matrix (Fin (2^(n+1))) (Fin 1) ℂ

noncomputable def cumulative_extra_phase
    (n k : Nat) (f : Nat → Bool) : ℂ

noncomputable def iqftHighBitsN (n : Nat) (y : Fin (2^(n+1))) : Fin (2^n)

noncomputable def iqftLowBitLSB (n : Nat) (y : Fin (2^(n+1))) : Fin 2

noncomputable def real_QPE_layer (m anc : Nat) (f : Nat → FormalRV.Framework.BaseUCom anc) :
    FormalRV.Framework.BaseUCom (m + anc)

noncomputable def Shor_final_state_lsb (m n anc : Nat)
    (f : Nat → FormalRV.Framework.BaseUCom (n + anc)) :
    QState (2^m * 2^n * 2^anc)

theorem applySwapsFrom_apply (n : Nat) (f : Nat → Bool) (i : Nat) (hi : i < n) :
    applySwapsFrom n 0 f i = f (n - 1 - i)

theorem bitReversedBasisFun_succ_extra (n : Nat) (x : Fin (2^(n+1))) :
    bitReversedBasisFun (n+1) x n = decide ((iqftHighBit n x).val = 1)

theorem f_to_vec_congr (n : Nat) (f g : Nat → Bool)
    (hfg : ∀ i, i < n → f i = g i) :
    f_to_vec n f = f_to_vec n g

theorem inverse_qft_ladder_phase_from_congr (n target : Nat) (htarget : target < n)
    (f g : Nat → Bool) (hfg : ∀ i, i < n → f i = g i) (k : Nat) :
    inverse_qft_ladder_phase_from n target f k
    = inverse_qft_ladder_phase_from n target g k

theorem inverse_qft_ladder_phase_congr (n target : Nat) (htarget : target < n)
    (f g : Nat → Bool) (hfg : ∀ i, i < n → f i = g i) :
    inverse_qft_ladder_phase n target f
    = inverse_qft_ladder_phase n target g

theorem update_congr_lt (n k : Nat) (f g : Nat → Bool) (b : Bool)
    (hfg : ∀ i, i < n → f i = g i) :
    ∀ i, i < n → (update f k b) i = (update g k b) i

theorem countdown_output_congr_input (n : Nat) :
    ∀ k, k ≤ n → ∀ (f g : Nat → Bool), (∀ i, i < n → f i = g i) →
      countdown_output n k f = countdown_output n k g

theorem bitReversedBasisFun_succ_restrict (n : Nat) (x : Fin (2^(n+1))) :
    ∀ i, i < n →
      bitReversedBasisFun (n+1) x i = bitReversedBasisFun n (iqftLowBits n x) i

theorem embedWithExtraBit_apply (n : Nat) (extra : Bool)
    (v : Matrix (Fin (2^n)) (Fin 1) ℂ) (y : Fin (2^(n+1))) :
    embedWithExtraBit n extra v y 0
    = (if (iqftLowBitLSB n y).val = (if extra then 1 else 0)
       then v (iqftHighBitsN n y) 0
       else 0)

theorem cumulative_extra_phase_false_extra
    (n k : Nat) (f : Nat → Bool) (hfn : f n = false) :
    cumulative_extra_phase n k f = 1

theorem inverse_qft_ladder_phase_top (n : Nat) (f : Nat → Bool) :
    inverse_qft_ladder_phase (n+1) n f = 1

theorem update_n_lt_eq (n : Nat) (f : Nat → Bool) (b : Bool) (i : Nat) (hi : i < n) :
    (update f n b) i = f i

theorem update_n_eval_self (n : Nat) (f : Nat → Bool) (b : Bool) :
    (update f n b) n = b

theorem countdownColumn_succ_entry_decomp_corrected
    (n : Nat) (_hn : 0 < n)
    (x y : Fin (2^(n+1))) :
    countdownColumn (n+1) x y 0
    = if (iqftLowBitLSB n y).val = 0 then
        ((Real.sqrt 2 / 2 : ℂ)) *
          countdownColumn n (iqftLowBits n x) (iqftHighBitsN n y) 0
      else
        (if (iqftHighBit n x).val = 1
         then -(Real.sqrt 2 / 2 : ℂ)
         else  (Real.sqrt 2 / 2 : ℂ))
        *

theorem cumulative_extra_phase_update_extra_true
    (n k : Nat) (hk : k ≤ n) (f : Nat → Bool) :
    cumulative_extra_phase n k (update f n true)
    = ∏ t ∈ Finset.range k,
      (if f t then
        Complex.exp ((((-(Real.pi / 2 ^ (n - t))) : ℝ)) * Complex.I)
       else 1)

theorem bitReversedBasisFun_eq_lsb_bit (n : Nat) (xl : Fin (2^n))
    (t : Nat) (ht : t < n) :
    bitReversedBasisFun n xl t = decide ((xl.val / 2^t) % 2 = 1)

theorem prod_exp_bits_eq_exp_sum_aux
    (n : Nat) (b : Nat → Bool) :
    ∀ k, k ≤ n →
      (∏ t ∈ Finset.range k,
        (if b t then
          Complex.exp ((((-(Real.pi / 2 ^ (n - t))) : ℝ)) * Complex.I)
         else 1))
      = Complex.exp
          (((-Real.pi
            * (((∑ t ∈ Finset.range k,
                  (if b t then 1 else 0) * 2^t) : Nat) : ℝ)
            / (2^n : ℝ) : ℝ) : ℂ) * Complex.I)

theorem cumulative_extra_phase_true_branch_eq_exp
    (n : Nat) (_hn : 0 < n) (x : Fin (2^(n+1))) :
    cumulative_extra_phase n n
      (update (bitReversedBasisFun (n+1) x) n true)
    = Complex.exp
        (((-Real.pi
            * ((iqftLowBits n x).val : ℝ)
            / (2^n : ℝ) : ℝ) : ℂ) * Complex.I)

theorem inv_sqrt_two_eq_sqrt_two_div_two :
    (1 : ℂ) / Real.sqrt 2 = (Real.sqrt 2 / 2 : ℂ)

theorem IQFT_matrix_succ_entry_decomp_mixed
    (n : Nat) (_hn : 0 < n) (x y : Fin (2^(n+1))) :
    (IQFT_matrix (n+1) * FormalRV.Framework.basis_vector (2^(n+1)) x.val) y 0
    = if (iqftLowBitLSB n y).val = 0 then
        ((Real.sqrt 2 / 2 : ℂ)) *
          (IQFT_matrix n
            * FormalRV.Framework.basis_vector (2^n) (iqftLowBits n x).val)
            (iqftHighBitsN n y) 0
      else
        (if (iqftHighBit n x).val = 1
         then -(Real.sqrt 2 / 2 : ℂ)
         else  (Real.sqrt 2 / 2 : ℂ))

theorem countdownColumn_succ_entry_eq_IQFT_entry
    (n : Nat) (hn : 0 < n)
    (x y : Fin (2^(n+1)))
    (IH :
      countdownColumn n (iqftLowBits n x)
        =
      IQFT_matrix n * FormalRV.Framework.basis_vector (2^n) (iqftLowBits n x).val) :
    countdownColumn (n+1) x y 0
      =
    (IQFT_matrix (n+1) * FormalRV.Framework.basis_vector (2^(n+1)) x.val) y 0

theorem countdownColumn_eq_IQFT_column
    (n : Nat) (hn : 0 < n) (x : Fin (2^n)) :
    countdownColumn n x
      = IQFT_matrix n * FormalRV.Framework.basis_vector (2^n) x.val

theorem layer_matrix_correctness_iff_countdownColumn (n : Nat) (hn : 0 < n) :
    (FormalRV.Framework.uc_eval (real_QFTinv_layer n : FormalRV.Framework.BaseUCom n)
      = IQFT_matrix n)
    ↔ (∀ x : Fin (2^n),
        countdownColumn n x
          = IQFT_matrix n * FormalRV.Framework.basis_vector (2^n) x.val)

theorem uc_eval_real_QFTinv_layer_eq_IQFT_matrix
    (n : Nat) (hn : 0 < n) :
    FormalRV.Framework.uc_eval
        (real_QFTinv_layer n : FormalRV.Framework.BaseUCom n)
      = IQFT_matrix n

theorem controlled_Rz_well_typed {dim : Nat} (q t : Nat) (lam : ℝ)
    (hq : q < dim) (ht : t < dim) (hqt : q ≠ t) :
    UCom.WellTyped dim (controlled_Rz q t lam : FormalRV.Framework.BaseUCom dim)

theorem inverse_qft_phase_ladder_loop_well_typed
    (n target : Nat) (h_target : target < n) :
    ∀ (m j : Nat), n - j = m → target < j →
      UCom.WellTyped n
          (inverse_qft_phase_ladder.loop n target j
            : FormalRV.Framework.BaseUCom n)

theorem inverse_qft_phase_ladder_well_typed (n target : Nat) (h_target : target < n) :
    UCom.WellTyped n
        (inverse_qft_phase_ladder n target : FormalRV.Framework.BaseUCom n)

theorem real_QFTinv_layer_countdown_well_typed (n : Nat) (hn : 0 < n) :
    ∀ k, k ≤ n →
      UCom.WellTyped n
          (real_QFTinv_layer.countdown n k : FormalRV.Framework.BaseUCom n)

theorem bit_reversal_swaps_loop_well_typed (n : Nat) (hn : 0 < n) :
    ∀ (m k : Nat), n - 2 * k = m →
      UCom.WellTyped n
          (bit_reversal_swaps.loop n k : FormalRV.Framework.BaseUCom n)

theorem bit_reversal_swaps_well_typed (n : Nat) (hn : 0 < n) :
    UCom.WellTyped n (bit_reversal_swaps n : FormalRV.Framework.BaseUCom n)

theorem wellTyped_real_QFTinv_layer (n : Nat) (hn : 0 < n) :
    UCom.WellTyped n (real_QFTinv_layer n : FormalRV.Framework.BaseUCom n)

theorem real_QFTinv_layer_lifted_on_kron
    {m anc : Nat} (hm : 0 < m)
    (ψc : Matrix (Fin (2^m)) (Fin 1) ℂ)
    (ψd : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval
        (map_qubits (fun q => q) (real_QFTinv_layer m)
          : FormalRV.Framework.BaseUCom (m + anc))
      * kron_vec ψc ψd
    = kron_vec (IQFT_matrix m * ψc) ψd

theorem real_QFTinv_layer_on_fourier_weighted_kron_state
    {m anc : Nat} (hm : 0 < m) (θ : ℝ)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval
        (map_qubits (fun q => q) (real_QFTinv_layer m)
          : FormalRV.Framework.BaseUCom (m + anc))
      *
    (((1 : ℂ) / Real.sqrt (2^m : ℝ)) •
      ∑ x : Fin (2^m),
        Complex.exp (2 * Real.pi * Complex.I * (x.val : ℂ) * (θ : ℂ)) •
          kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ)
    = kron_vec (qpe_phase_state m θ) ψ

theorem real_QPE_layer_on_eigenstate
    {m anc : Nat} (hmanc : 0 < m + anc) (hm : 0 < m)
    (f : Nat → FormalRV.Framework.BaseUCom anc)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) (θ : ℝ)
    (h_wt_all : ∀ i, i < m → UCom.WellTyped anc (f i))
    (h_eig_data : ∀ i, i < m →
      FormalRV.Framework.uc_eval (f i) * ψ =
        qpeEigenvalue m i θ • ψ) :
    FormalRV.Framework.uc_eval (real_QPE_layer m anc f)
      * kron_vec (FormalRV.Framework.kron_zeros m) ψ
    = kron_vec (qpe_phase_state m θ) ψ

theorem bit_reversal_loop_bridge (n : Nat) :
    ∀ (m k : Nat), n - 2 * k = m →
      FormalRV.SQIRPort.bit_reversal_swaps.loop n k
      = (@FormalRV.Framework.BaseUCom.bit_reversal_swaps.loop n n k
          : FormalRV.Framework.BaseUCom n)

theorem bit_reversal_swaps_bridge (n : Nat) :
    (FormalRV.SQIRPort.bit_reversal_swaps n : FormalRV.Framework.BaseUCom n)
    = (@FormalRV.Framework.BaseUCom.bit_reversal_swaps n n)

theorem inverse_qft_phase_ladder_loop_bridge (n target : Nat) :
    ∀ (m j : Nat), n - j = m →
      FormalRV.SQIRPort.inverse_qft_phase_ladder.loop n target j
      = (@FormalRV.Framework.BaseUCom.inverse_qft_phase_ladder.loop n n target j
          : FormalRV.Framework.BaseUCom n)

theorem inverse_qft_phase_ladder_bridge (n target : Nat) :
    (FormalRV.SQIRPort.inverse_qft_phase_ladder n target
      : FormalRV.Framework.BaseUCom n)
    = (@FormalRV.Framework.BaseUCom.inverse_qft_phase_ladder n n target)

theorem real_QFTinv_layer_countdown_bridge (n : Nat) :
    ∀ k,
      FormalRV.SQIRPort.real_QFTinv_layer.countdown n k
      = (@FormalRV.Framework.BaseUCom.real_QFTinv_layer.countdown n n k
          : FormalRV.Framework.BaseUCom n)

theorem real_QFTinv_layer_bridge (n : Nat) :
    (FormalRV.SQIRPort.real_QFTinv_layer n : FormalRV.Framework.BaseUCom n)
    = (@FormalRV.Framework.BaseUCom.real_QFTinv_layer n n)

theorem uc_eval_QFTinv_eq_IQFT_matrix (m : Nat) (hm : 0 < m) :
    FormalRV.Framework.uc_eval
        (FormalRV.Framework.BaseUCom.QFTinv m : FormalRV.Framework.BaseUCom m)
      = IQFT_matrix m

theorem wellTyped_QFTinv (m : Nat) (hm : 0 < m) :
    UCom.WellTyped m
        (FormalRV.Framework.BaseUCom.QFTinv m : FormalRV.Framework.BaseUCom m)

theorem bit_reversal_swaps_loop_map_id_bridge (m anc n : Nat) :
    ∀ (m_meas k : Nat), n - 2 * k = m_meas →
      (@FormalRV.Framework.BaseUCom.bit_reversal_swaps.loop (m + anc) n k
        : FormalRV.Framework.BaseUCom (m + anc))
      = map_qubits id
          (@FormalRV.Framework.BaseUCom.bit_reversal_swaps.loop m n k
            : FormalRV.Framework.BaseUCom m)

theorem bit_reversal_swaps_map_id_bridge (m anc n : Nat) :
    (@FormalRV.Framework.BaseUCom.bit_reversal_swaps (m + anc) n
      : FormalRV.Framework.BaseUCom (m + anc))
    = map_qubits id
        (@FormalRV.Framework.BaseUCom.bit_reversal_swaps m n
          : FormalRV.Framework.BaseUCom m)

theorem inverse_qft_phase_ladder_loop_map_id_bridge (m anc n target : Nat) :
    ∀ (m_meas j : Nat), n - j = m_meas →
      (@FormalRV.Framework.BaseUCom.inverse_qft_phase_ladder.loop (m + anc) n target j
        : FormalRV.Framework.BaseUCom (m + anc))
      = map_qubits id
          (@FormalRV.Framework.BaseUCom.inverse_qft_phase_ladder.loop m n target j
            : FormalRV.Framework.BaseUCom m)

theorem inverse_qft_phase_ladder_map_id_bridge (m anc n target : Nat) :
    (@FormalRV.Framework.BaseUCom.inverse_qft_phase_ladder (m + anc) n target
      : FormalRV.Framework.BaseUCom (m + anc))
    = map_qubits id
        (@FormalRV.Framework.BaseUCom.inverse_qft_phase_ladder m n target
          : FormalRV.Framework.BaseUCom m)

theorem real_QFTinv_layer_countdown_map_id_bridge (m anc n : Nat) :
    ∀ k,
      (@FormalRV.Framework.BaseUCom.real_QFTinv_layer.countdown (m + anc) n k
        : FormalRV.Framework.BaseUCom (m + anc))
      = map_qubits id
          (@FormalRV.Framework.BaseUCom.real_QFTinv_layer.countdown m n k
            : FormalRV.Framework.BaseUCom m)

theorem real_QFTinv_layer_map_id_bridge (m anc n : Nat) :
    (@FormalRV.Framework.BaseUCom.real_QFTinv_layer (m + anc) n
      : FormalRV.Framework.BaseUCom (m + anc))
    = map_qubits id
        (@FormalRV.Framework.BaseUCom.real_QFTinv_layer m n
          : FormalRV.Framework.BaseUCom m)

theorem QFTinv_on_fourier_weighted_kron_state
    {m anc : Nat} (hm : 0 < m) (θ : ℝ)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) :
    FormalRV.Framework.uc_eval
        (FormalRV.Framework.BaseUCom.QFTinv m
          : FormalRV.Framework.BaseUCom (m + anc))
      *
    (((1 : ℂ) / Real.sqrt (2^m : ℝ)) •
      ∑ x : Fin (2^m),
        Complex.exp (2 * Real.pi * Complex.I * (x.val : ℂ) * (θ : ℂ)) •
          kron_vec (FormalRV.Framework.basis_vector (2^m) x.val) ψ)
    = kron_vec (qpe_phase_state m θ) ψ

theorem QPE_var_on_eigenstate_from_real_QFTinv
    {m anc : Nat} (hmanc : 0 < m + anc) (hm : 0 < m)
    (f : Nat → FormalRV.Framework.BaseUCom anc)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) (θ : ℝ)
    (h_wt_all : ∀ i, i < m → UCom.WellTyped anc (f i))
    (h_eig_data : ∀ i, i < m →
      FormalRV.Framework.uc_eval (f i) * ψ =
        qpeEigenvalue m i θ • ψ) :
    FormalRV.Framework.uc_eval (FormalRV.SQIRPort.QPE_var m anc f)
      * kron_vec (FormalRV.Framework.kron_zeros m) ψ
    = kron_vec (qpe_phase_state m θ) ψ

theorem qpeEigenvalue_reverse_index_eq_lsb
    (m i : Nat) (_hi : i < m) (θ : ℝ) :
    qpeEigenvalue m (m - 1 - i) θ
      = Complex.exp (((2 * Real.pi * ((2^i : Nat) : ℝ) * θ : ℝ) : ℂ) * Complex.I)

theorem QPE_var_lsb_on_eigenstate_from_real_QFTinv
    {m anc : Nat} (hmanc : 0 < m + anc) (hm : 0 < m)
    (f : Nat → FormalRV.Framework.BaseUCom anc)
    (ψ : Matrix (Fin (2^anc)) (Fin 1) ℂ) (θ : ℝ)
    (h_wt_all : ∀ i, i < m → UCom.WellTyped anc (f i))
    (h_eig_lsb : ∀ i, i < m →
      FormalRV.Framework.uc_eval (f i) * ψ =
        Complex.exp (((2 * Real.pi * ((2^i : Nat) : ℝ) * θ : ℝ) : ℂ) * Complex.I) • ψ) :
    FormalRV.Framework.uc_eval (QPE_var_lsb m anc f)
      * kron_vec (FormalRV.Framework.kron_zeros m) ψ
    = kron_vec (qpe_phase_state m θ) ψ

theorem modmult_eigenstate_combined_as_sum (a r N n anc : Nat) (k : Fin r) :
    modmult_eigenstate_combined a r N n anc k
    = ∑ j : Fin r, character_vector r k j •
        FormalRV.Framework.basis_vector (2^(n+anc)) (a^j.val % N * 2^anc)

theorem modmult_combined_action_as_orbit_sum
    (a r N n anc i : Nat) (k : Fin r)
    (f : Nat → FormalRV.Framework.BaseUCom (n + anc))
    (h_modmul : ModMulImpl a N n anc f)
    (h_arN : a^r % N = 1)
    (h_N_pos : 0 < N) :
    FormalRV.Framework.uc_eval (f i)
      * modmult_eigenstate_combined a r N n anc k
    = ∑ j : Fin r, character_vector r k j •
        FormalRV.Framework.basis_vector (2^(n+anc))
          (a^((2^i + j.val) % r) % N * 2^anc)

theorem modmult_eigenstate_combined_eigen_lsb
    (a r N n anc i : Nat) (k : Fin r)
    (f : Nat → FormalRV.Framework.BaseUCom (n + anc))
    (h_modmul : ModMulImpl a N n anc f)
    (h_r_pos : 0 < r)
    (h_arN : a^r % N = 1)
    (h_N_pos : 0 < N) :
    FormalRV.Framework.uc_eval (f i)
      * modmult_eigenstate_combined a r N n anc k
    = Complex.exp
        (((2 * Real.pi * ((2^i : Nat) : ℝ) * (k.val : ℝ) / (r : ℝ) : ℝ) : ℂ) * Complex.I)
      • modmult_eigenstate_combined a r N n anc k

theorem QPE_var_lsb_on_modmult_eigenstate
    {m n anc : Nat} (a r N : Nat) (k : Fin r)
    (hmanc : 0 < m + (n + anc)) (hm : 0 < m)
    (h_r_pos : 0 < r) (h_arN : a^r % N = 1) (h_N_pos : 0 < N)
    (f : Nat → FormalRV.Framework.BaseUCom (n + anc))
    (h_modmul : ModMulImpl a N n anc f)
    (h_wt_all : ∀ i, i < m → UCom.WellTyped (n + anc) (f i)) :
    FormalRV.Framework.uc_eval (QPE_var_lsb m (n + anc) f)
      * kron_vec (FormalRV.Framework.kron_zeros m)
          (modmult_eigenstate_combined a r N n anc k)
    = kron_vec (qpe_phase_state m ((k.val : ℝ) / (r : ℝ)))
        (modmult_eigenstate_combined a r N n anc k)

theorem orbit_decomposition_combined_matrix
    (a r N n anc : Nat)
    (h_r_pos : 0 < r) (h_arN : a^r % N = 1)
    (h_min : ∀ s, 0 < s → s < r → a^s % N ≠ 1)
    (h_N : 1 < N) (h_N_lt : N ≤ 2^n) :
    kron_vec (FormalRV.Framework.basis_vector (2^n) 1)
             (FormalRV.Framework.kron_zeros anc)
    = (1 / (Real.sqrt r : ℂ)) •
        ∑ k : Fin r, modmult_eigenstate_combined a r N n anc k

theorem QPE_var_lsb_on_orbit_sum
    (a r N : Nat) {m n anc : Nat}
    (hmanc : 0 < m + (n + anc)) (hm : 0 < m)
    (h_r_pos : 0 < r) (h_arN : a^r % N = 1) (h_N_pos : 0 < N)
    (f : Nat → FormalRV.Framework.BaseUCom (n + anc))
    (h_modmul : ModMulImpl a N n anc f)
    (h_wt_all : ∀ i, i < m → UCom.WellTyped (n + anc) (f i)) :
    FormalRV.Framework.uc_eval (QPE_var_lsb m (n + anc) f)
      * kron_vec (FormalRV.Framework.kron_zeros m)
          ((1 / (Real.sqrt r : ℂ)) •
            ∑ k : Fin r, modmult_eigenstate_combined a r N n anc k)
    = (1 / (Real.sqrt r : ℂ)) •

theorem QPE_var_lsb_on_Shor_initial_raw
    (a r N : Nat) {m n anc : Nat}
    (hmanc : 0 < m + (n + anc)) (hm : 0 < m)
    (h_r_pos : 0 < r) (h_arN : a^r % N = 1)
    (h_min : ∀ s, 0 < s → s < r → a^s % N ≠ 1)
    (h_N : 1 < N) (h_N_lt : N ≤ 2^n) (h_N_pos : 0 < N)
    (f : Nat → FormalRV.Framework.BaseUCom (n + anc))
    (h_modmul : ModMulImpl a N n anc f)
    (h_wt_all : ∀ i, i < m → UCom.WellTyped (n + anc) (f i)) :
    FormalRV.Framework.uc_eval (QPE_var_lsb m (n + anc) f)
      * (kron_vec (FormalRV.Framework.kron_zeros m)
           (kron_vec (FormalRV.Framework.basis_vector (2^n) 1)

theorem kron_vec_assoc {a b c : Nat}
    (x : Matrix (Fin (2^a)) (Fin 1) ℂ)
    (y : Matrix (Fin (2^b)) (Fin 1) ℂ)
    (z : Matrix (Fin (2^c)) (Fin 1) ℂ) :
    QState.cast (by rw [Nat.add_assoc])
        (kron_vec (kron_vec x y) z : Matrix (Fin (2^((a+b)+c))) (Fin 1) ℂ)
    = (kron_vec x (kron_vec y z) : Matrix (Fin (2^(a+(b+c)))) (Fin 1) ℂ)

theorem Shor_final_state_lsb_eq_shor_orbit_state
    (a r N m n anc : Nat)
    (hmanc : 0 < m + (n + anc)) (hm : 0 < m)
    (h_r_pos : 0 < r) (h_arN : a^r % N = 1)
    (h_min : ∀ s, 0 < s → s < r → a^s % N ≠ 1)
    (h_N : 1 < N) (h_N_lt : N ≤ 2^n) (h_N_pos : 0 < N)
    (f : Nat → FormalRV.Framework.BaseUCom (n + anc))
    (h_modmul : ModMulImpl a N n anc f)
    (h_wt_all : ∀ i, i < m → UCom.WellTyped (n + anc) (f i)) :
    Shor_final_state_lsb m n anc f
    = QState.cast (by rw [pow_add, pow_add, mul_assoc])
        (shor_orbit_state a r N m n anc)

theorem qpe_semantics_measurement_eq_from_lsb
    (a r N m n anc k : Nat) (f : Nat → FormalRV.SQIRPort.BaseUCom (n + anc))
    (h_basic : BasicSetting a r N m n)
    (h_modmul : ModMulImpl a N n anc f)
    (h_wt : ∀ i, i < m → uc_well_typed (f i)) :
    prob_partial_meas (basis_vector (2^m) (s_closest m k r))
        (Shor_final_state m n anc f)
    = prob_partial_meas (basis_vector (2^m) (s_closest m k r))
        (shor_orbit_state a r N m n anc)

theorem QPE_MMI_correct
    (a r N m n anc k : Nat) (f : Nat → FormalRV.SQIRPort.BaseUCom (n + anc))
    (h_basic : BasicSetting a r N m n)
    (h_mmi : ModMulImpl a N n anc f)
    (h_wt : ∀ i, i < m → uc_well_typed (f i))
    (h_k_lt : k < r) :
    prob_partial_meas (basis_vector (2^m) (s_closest m k r))
        (Shor_final_state m n anc f)
      ≥ 4 / (Real.pi^2 * (r : ℝ))

theorem Shor_correct_var
    (a r N m n anc : Nat) (u : Nat → FormalRV.SQIRPort.BaseUCom (n + anc))
    (h_basic : BasicSetting a r N m n)
    (h_modmul : ModMulImpl a N n anc u)
    (h_wt : ∀ i, i < m → uc_well_typed (u i)) :
    probability_of_success a r N m n anc u ≥ κ / (Nat.log2 N : ℝ)^4

theorem Shor_correct
    (a N : Nat) (h_aN : 0 < a ∧ a < N) (h_coprime : Nat.gcd a N = 1) :
    let m

theorem prob_of_success_congr
    (a r N m n anc : Nat)
    (f₁ f₂ : Nat → BaseUCom (n + anc))
    (h : Shor_final_state m n anc f₁ = Shor_final_state m n anc f₂) :
    probability_of_success a r N m n anc f₁
      = probability_of_success a r N m n anc f₂

theorem prob_of_success_congr_via_uc_eval
    (a r N m n anc : Nat)
    (f₁ f₂ : Nat → BaseUCom (n + anc))
    (h : uc_eval (QPE_var_lsb m (n + anc) f₁) (Shor_initial_state m n anc)
       = uc_eval (QPE_var_lsb m (n + anc) f₂) (Shor_initial_state m n anc)) :
    probability_of_success a r N m n anc f₁
      = probability_of_success a r N m n anc f₂

noncomputable def QFT {dim : Nat} (n : Nat) : BaseUCom dim

noncomputable def controlled_Rz {dim : Nat} (q t : Nat) (lam : ℝ) : BaseUCom dim

noncomputable def inverse_qft_phase_ladder
    {dim : Nat} (n target : Nat) : BaseUCom dim

noncomputable def bit_reversal_swaps {dim : Nat} (n : Nat) : BaseUCom dim

noncomputable def real_QFTinv_layer {dim : Nat} (n : Nat) : BaseUCom dim

noncomputable def QFTinv {dim : Nat} (n : Nat) : BaseUCom dim

theorem QFT_eq_npar_H {dim : Nat} (n : Nat) :
    (QFT n : BaseUCom dim) = npar_H n

theorem uc_eval_QFT_succ {dim : Nat} (n : Nat) :
    uc_eval (QFT (n + 1) : BaseUCom dim)
      = pad_u dim n hMatrix * uc_eval (QFT n)

theorem uc_eval_QFT_zero_eq_one {dim : Nat} (h : 0 < dim) :
    uc_eval (QFT 0 : BaseUCom dim) = (1 : Square dim)

theorem QFT_well_typed {dim : Nat} (n : Nat) (h : n ≤ dim) (hd : 0 < dim) :
    UCom.WellTyped dim (QFT n : BaseUCom dim)

theorem QFTinv_zero_unfold {dim : Nat} :
    (QFTinv 0 : BaseUCom dim) = UCom.seq SKIP SKIP

theorem uc_eval_QFTinv_zero_eq_one {dim : Nat} (h : 0 < dim) :
    uc_eval (QFTinv 0 : BaseUCom dim) = (1 : Square dim)

theorem QFTinv_well_typed_of_layer_well_typed {dim : Nat} (n : Nat)
    (h_layer_wt : UCom.WellTyped dim (real_QFTinv_layer n : BaseUCom dim)) :
    UCom.WellTyped dim (QFTinv n : BaseUCom dim)

noncomputable def controlled_powers {dim : Nat} (f : Nat → BaseUCom dim) (n : Nat) : BaseUCom dim

theorem uc_eval_controlled_powers_zero {dim : Nat} (f : Nat → BaseUCom dim) :
    uc_eval (controlled_powers f 0) = uc_eval (SKIP : BaseUCom dim)

theorem uc_eval_controlled_powers_zero_eq_one {dim : Nat}
    (f : Nat → BaseUCom dim) (hd : 0 < dim) :
    uc_eval (controlled_powers f 0) = (1 : Square dim)

theorem uc_eval_controlled_powers_succ {dim : Nat} (f : Nat → BaseUCom dim) (n : Nat) :
    uc_eval (controlled_powers f (n + 1))
      = uc_eval (control n (f n)) * uc_eval (controlled_powers f n)

noncomputable def QPE (k n : Nat) (c : Nat → BaseUCom (k + n)) : BaseUCom (k + n)

theorem QPE_def_unfold {k n : Nat} (c : Nat → BaseUCom (k + n)) :
    QPE k n c
      = UCom.seq (npar_H k) (UCom.seq (controlled_powers c k) (QFTinv k))

theorem uc_eval_QPE {k n : Nat} (c : Nat → BaseUCom (k + n)) :
    uc_eval (QPE k n c)
      = uc_eval (QFTinv k) * uc_eval (controlled_powers c k) * uc_eval (npar_H k)

axiom QPE_semantics_full
    (k n : Nat) (c : BaseUCom (k + n)) (z : Nat → Bool)
    (ψ : Matrix (Fin (2^n)) (Fin 1) ℂ) (δ : ℝ)
    (hn : 0 < n) (hk : 1 < k)
    (hc : UCom.WellTyped (k + n) c)
    (hψ : Pure_State_Vector ψ)
    (hδ_low  : (-1 : ℝ) / 2^(k+1) ≤ δ)
    (hδ_high : δ < 1 / 2^(k+1))
    (θ : ℝ)
    (θ_def : θ = ((funbool_to_nat k z : ℝ) / 2^k) + δ)
    (h_eigen : uc_eval c * (kron_zeros k ⊗ᵥ ψ) =
               Complex.exp (2 * Real.pi * θ * Complex.I) • (kron_zeros k ⊗ᵥ ψ)) :

noncomputable def qpe_amp (m y : Nat) (θ : ℝ) : ℂ

noncomputable def qpe_prob (m y : Nat) (θ : ℝ) : ℝ

theorem qpe_prob_nonneg (m y : Nat) (θ : ℝ) : 0 ≤ qpe_prob m y θ

theorem qpe_amp_eq_one_of_exact (m y : Nat) (θ : ℝ)
    (h : θ = (y : ℝ) / (2^m : ℝ)) :
    qpe_amp m y θ = 1

theorem qpe_prob_eq_one_of_exact (m y : Nat) (θ : ℝ)
    (h : θ = (y : ℝ) / (2^m : ℝ)) :
    qpe_prob m y θ = 1

noncomputable def qpe_sum (m y : Nat) (θ : ℝ) : ℂ

theorem qpe_amp_eq_inv_pow_two_mul_sum (m y : Nat) (θ : ℝ) :
    qpe_amp m y θ = (1 / (2^m : ℂ)) * qpe_sum m y θ

theorem qpe_sum_eq_sum_phase_diff (m y : Nat) (θ : ℝ) :
    qpe_sum m y θ
      = ∑ x : Fin (2^m),
          Complex.exp (2 * Real.pi * Complex.I * (x.val : ℂ) *
                       (((2^m : ℝ) * θ - (y : ℝ)) / (2^m : ℝ) : ℂ))

theorem qpe_sum_summand_eq_pow (m y : Nat) (θ : ℝ) (x : Fin (2^m)) :
    Complex.exp (2 * Real.pi * Complex.I * (x.val : ℂ) *
                 ((θ : ℂ) - (y : ℂ) / (2^m : ℂ)))
      = (Complex.exp (2 * Real.pi * Complex.I *
                      ((θ : ℂ) - (y : ℂ) / (2^m : ℂ))))^x.val

theorem qpe_sum_eq_sum_pow (m y : Nat) (θ : ℝ) :
    qpe_sum m y θ
      = ∑ k ∈ Finset.range (2^m),
          (Complex.exp (2 * Real.pi * Complex.I *
                        ((θ : ℂ) - (y : ℂ) / (2^m : ℂ))))^k

theorem qpe_sum_geom_eq (m y : Nat) (θ : ℝ)
    (hz : Complex.exp (2 * Real.pi * Complex.I *
                       ((θ : ℂ) - (y : ℂ) / (2^m : ℂ))) ≠ 1) :
    qpe_sum m y θ
      = ((Complex.exp (2 * Real.pi * Complex.I *
                       ((θ : ℂ) - (y : ℂ) / (2^m : ℂ))))^(2^m) - 1) /
        ((Complex.exp (2 * Real.pi * Complex.I *
                       ((θ : ℂ) - (y : ℂ) / (2^m : ℂ)))) - 1)

theorem qpe_sum_eq_card_of_exp_eq_one (m y : Nat) (θ : ℝ)
    (hz : Complex.exp (2 * Real.pi * Complex.I *
                       ((θ : ℂ) - (y : ℂ) / (2^m : ℂ))) = 1) :
    qpe_sum m y θ = (2^m : ℂ)

noncomputable def qpe_phase_discrepancy (m y : Nat) (θ : ℝ) : ℝ

theorem qpe_denom_norm (m y : Nat) (θ : ℝ) :
    ‖Complex.exp (2 * Real.pi * Complex.I *
                   ((θ : ℂ) - (y : ℂ) / (2^m : ℂ))) - 1‖
      = 2 * |Real.sin (Real.pi * (θ - (y : ℝ) / (2^m : ℝ)))|

theorem qpe_num_norm (m y : Nat) (θ : ℝ) :
    ‖(Complex.exp (2 * Real.pi * Complex.I *
                    ((θ : ℂ) - (y : ℂ) / (2^m : ℂ))))^(2^m) - 1‖
      = 2 * |Real.sin (Real.pi * qpe_phase_discrepancy m y θ)|

theorem qpe_denom_norm_eq_sin_phase_diff (m y : Nat) (θ : ℝ) :
    ‖Complex.exp (2 * Real.pi * Complex.I *
                   ((θ : ℂ) - (y : ℂ) / (2^m : ℂ))) - 1‖
      = 2 * |Real.sin (Real.pi * qpe_phase_discrepancy m y θ / (2^m : ℝ))|

theorem qpe_sum_norm (m y : Nat) (θ : ℝ)
    (hz : Complex.exp (2 * Real.pi * Complex.I *
                       ((θ : ℂ) - (y : ℂ) / (2^m : ℂ))) ≠ 1) :
    ‖qpe_sum m y θ‖
      = |Real.sin (Real.pi * qpe_phase_discrepancy m y θ)| /
        |Real.sin (Real.pi * qpe_phase_discrepancy m y θ / (2^m : ℝ))|

theorem qpe_prob_peak_bound
    (m y : Nat) (θ : ℝ)
    (hφ : |qpe_phase_discrepancy m y θ| ≤ 1 / 2) :
    qpe_prob m y θ ≥ 4 / Real.pi^2

noncomputable def qpe_phase_state (m : Nat) (θ : ℝ) :
    Matrix (Fin (2^m)) (Fin 1) ℂ

theorem qpe_phase_state_apply (m : Nat) (θ : ℝ) (y : Fin (2^m)) :
    qpe_phase_state m θ y 0 = qpe_amp m y.val θ

theorem normSq_qpe_phase_state_apply (m : Nat) (θ : ℝ) (y : Fin (2^m)) :
    Complex.normSq (qpe_phase_state m θ y 0) = qpe_prob m y.val θ

theorem normSq_sum_apply_orth {n r : Nat}
    (β : Fin r → Matrix (Fin n) (Fin 1) ℂ)
    (h_orth : ∀ j j' : Fin r,
       ∑ y : Fin n, starRingEnd ℂ (β j' y 0) * β j y 0
       = if j = j' then (1 : ℂ) else 0)
    (a : Fin r → ℂ) :
    ∑ y : Fin n, Complex.normSq (∑ j : Fin r, a j * β j y 0)
      = ∑ j : Fin r, Complex.normSq (a j)

def qA_adder_width : Nat

def ripple_adder_depth : Nat

def lookahead_adder_depth : Nat

def min_cycles_per_toffoli : Nat

def t_cycle_ms : Nat

theorem ripple_adder_carry_chain_floor (τ : Nat) (begin_ : Nat → Nat)
    (hcarry : ∀ i, begin_ i + τ ≤ begin_ (i + 1)) :
    begin_ 0 + qA_adder_width * τ ≤ begin_ qA_adder_width

def inferred_adds_per_mult : Nat

def inferred_mults : Nat

def modexp_floor_depth : Nat

def modexp_floor_cycles : Nat

example : modexp_floor_depth = 6193152

example : modexp_floor_cycles = 247726080

def reported_timeeff_P1160_cycles : Nat

def reported_balanced_cycles : Nat

def reported_spaceeff_cycles : Nat

theorem floor_below_best : modexp_floor_cycles ≤ reported_timeeff_P1160_cycles

theorem best_at_least_30x_above_floor :
    30 * modexp_floor_cycles ≤ reported_timeeff_P1160_cycles

theorem best_within_34x_of_floor :
    reported_timeeff_P1160_cycles ≤ 34 * modexp_floor_cycles

theorem balanced_at_least_3400x_above_floor :
    3400 * modexp_floor_cycles ≤ reported_balanced_cycles

theorem spaceeff_at_least_14000x_above_floor :
    14000 * modexp_floor_cycles ≤ reported_spaceeff_cycles

theorem spaceeff_440x_balanced_or_better :
    440 * reported_timeeff_P1160_cycles ≤ reported_spaceeff_cycles

def shorBits (N : Nat) : Nat

def shorMergeCountBits (bits : Nat) : Nat

def shorMergeCount (N : Nat) : Nat

def shorSchedule (N : Nat) : Schedule

def emitShor (N _a : Nat) : String

def shorSchedulePrefix (N k : Nat) : Schedule

def emitShorPrefix (N _a k : Nat) : String

theorem shorMergeCountBits_4 : shorMergeCountBits 4 = 3072

theorem shorMergeCount_rsa2048 : shorMergeCountBits 2048 = 412_316_860_416

def shorScheduleFootprintBits (bits : Nat) : Nat

theorem rsa2048_emitted_footprint :
    shorScheduleFootprintBits 2048 = 11_544_872_091_648

theorem prefix_length (N k : Nat) (h : k ≤ shorMergeCount N) :
    (shorSchedulePrefix N k).length = k

def surfaceLogX (d : Nat) : BoolVec

def surface_d_x_surgery (d : Nat) : SurgeryGadget

theorem surface_d_x_surgery_verifies_d3 :
    SurgeryGadget.verify_surgery_gadget (surface_d_x_surgery 3) = true

theorem surface_d_x_surgery_verifies_d5 :
    SurgeryGadget.verify_surgery_gadget (surface_d_x_surgery 5) = true

theorem surface_d_x_surgery_verifies_d7 :
    SurgeryGadget.verify_surgery_gadget (surface_d_x_surgery 7) = true

def shorScheduleAtDistance (N d : Nat) : Schedule

def emitShorAtDistance (N _a d : Nat) : String

def emitShorPrefixAtDistance (N _a d k : Nat) : String

theorem shorScheduleAtDistance_length (N d : Nat) :
    (shorScheduleAtDistance N d).length = shorMergeCount N

structure TFactoryModel

def factoryFootprint (f : TFactoryModel) (P : Nat) : Nat

def magicProductionCycles (f : TFactoryModel) (P m : Nat) : Nat

def demoFactory : TFactoryModel

theorem magicProductionCycles_more_factories_faster :
    magicProductionCycles demoFactory 4 8 ≤ magicProductionCycles demoFactory 2 8

def factoryFits (f : TFactoryModel) (P factoryBudget : Nat) : Bool

def totalPhysical (dataQ factoryQ routingQ : Nat) : Nat

theorem data_block_not_sufficient (factoryQ routingQ : Nat) (hf : 0 < factoryQ) :
    rsa2048_dataPhysical 27
      < totalPhysical (rsa2048_dataPhysical 27) factoryQ routingQ

theorem data_only_machine_has_no_factory_room :
    machine100k * 0 + rsa2048_dataPhysical 27 - rsa2048_dataPhysical 27 = 0

theorem rsa2048_full_machine_d27 :
    totalPhysical (rsa2048_dataPhysical 27) 10_278_400 0 = 20_000_000

def shorRuntimeTenthsUs (toffoli d cycleTenthsUs : Nat) : Nat

theorem rsa2048_runtime_windowed :
    shorRuntimeTenthsUs 2_700_000_000 27 10 = 729_000_000_000

theorem rsa2048_runtime_unwindowed :
    shorRuntimeTenthsUs 137_438_953_472 27 10 = 37_108_517_437_440

theorem runtime_is_verified_formula (T L factory : Nat) (hw : Hardware) :
    (estimateWith (surfaceModel factory) hw (shorWorkload T L)
        (surfaceCodeD 27) 0 0).time_us_tenths
      = shorRuntimeTenthsUs T 27 hw.cycle_time_us_tenths

theorem superconducting_local_machine_summary :
    -- 20 M holds data + factory:
    totalPhysical (rsa2048_dataPhysical 27) 10_278_400 0 = 20_000_000
    -- and the data-only 9.72 M leaves nothing for the factory:
    ∧ 9_721_600 - rsa2048_dataPhysical 27 = 0

theorem shorModMul_compiles_to_PPM_with_factory
    (F : TFactoryContract)
    (bits N a ainv x : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2 ^ bits) (hN2 : 2 * N ≤ 2 ^ bits)
    (h_ainv_le : ainv ≤ N) (hx : x < N) (h_inv : (a * ainv) % N = 1) :
    ∃ σ',
      MagicPPMProgramRel F
        (compileArithmeticGateToMagicPPM (ModMul.gateMCP bits N a ainv))
        (encodeWithPool
          (encodeDataZeroAnc bits (ModMul.ancillaWidth bits) x)
          (factoryProvision F
            (shorMagicDemand (ModMul.gateMCP bits N a ainv)))) σ'

theorem shorModMul_factory_resource
    (F : TFactoryContract) (zone period bits N a ainv : Nat) :
    (factoryRequestSchedule zone period
        (shorMagicDemand (ModMul.gateMCP bits N a ainv))).length
        = shorMagicDemand (ModMul.gateMCP bits N a ainv)
    ∧ (factoryProvision F
        (shorMagicDemand (ModMul.gateMCP bits N a ainv))).length
        = shorMagicDemand (ModMul.gateMCP bits N a ainv)
    ∧ shorMagicDemand (ModMul.gateMCP bits N a ainv)
        = gateCCXCount (ModMul.gateMCP bits N a ainv)

theorem shorModMul_PPM_from_atomic_factory
    (spec : AtomicFactorySpec) (fid : Nat)
    (hkind : spec.kind = MagicStateKind.T)
    (hsucc : spec.success_probability_ppm ≤ 1_000_000)
    (bits N a ainv x : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2 ^ bits) (hN2 : 2 * N ≤ 2 ^ bits)
    (h_ainv_le : ainv ≤ N) (hx : x < N) (h_inv : (a * ainv) % N = 1) :
    (TFactoryContract.ofAtomic spec fid).WellFormed
    ∧ ∃ σ',
        MagicPPMProgramRel (TFactoryContract.ofAtomic spec fid)
          (compileArithmeticGateToMagicPPM (ModMul.gateMCP bits N a ainv))
          (encodeWithPool

example (F : TFactoryContract) :
    ∃ σ',
      MagicPPMProgramRel F
        (compileArithmeticGateToMagicPPM (ModMul.gateMCP 3 3 2 2))
        (encodeWithPool
          (encodeDataZeroAnc 3 (ModMul.ancillaWidth 3) 1)
          (factoryProvision F (shorMagicDemand (ModMul.gateMCP 3 3 2 2)))) σ'
      ∧ (magicBasisRefinesApplyNat F).observesBits σ'
          (encodeDataZeroAnc 3 (ModMul.ancillaWidth 3) ((2 * 1) % 3))

theorem shor_succeeds_with_ppm_realized_modmult
    (F : TFactoryContract)
    (a r N m bits ainv x : Nat)
    (h_setting : ShorSetting a r N m bits)
    (h_sizing : CircuitSizing N bits)
    (h_inv : a * ainv % N = 1)
    (h_ainv_le : ainv ≤ N) (hx : x < N) :
    FormalRV.SQIRPort.probability_of_success a r N m bits
        (ModMul.ancillaWidth bits) (ModMul.circuitFamily a ainv N bits)
        ≥ FormalRV.SQIRPort.κ / (Nat.log2 N : ℝ) ^ 4
    ∧ ∃ σ',
        MagicPPMProgramRel F

theorem ppm_clifford_run_eq_applyNat
    (F : TFactoryContract) (g : Gate) (hICX : isICXGate g = true) (f : Nat → Bool)
    (σ' : MagicBasisPPMState)
    (hrun : PPMProgramRel (magicBasisPPMSemanticsModel F) (compileArithmeticGateToPPM g)
              (magicBasisEncodeBits F f) σ') :
    σ'.bits = Gate.applyNat g f

theorem ppm_clifford_run_eq_unitary
    (F : TFactoryContract) (dim : Nat) (g : Gate) (hICX : isICXGate g = true)
    (h_wt : Gate.WellTyped dim g) (f : Nat → Bool)
    (σ' : MagicBasisPPMState)
    (hrun : PPMProgramRel (magicBasisPPMSemanticsModel F) (compileArithmeticGateToPPM g)
              (magicBasisEncodeBits F f) σ') :
    f_to_vec dim σ'.bits = uc_eval (Gate.toUCom dim g) * f_to_vec dim f

theorem ppm_clifford_observes_applyNat
    (F : TFactoryContract) (g : Gate) (hICX : isICXGate g = true) (f : Nat → Bool)
    (σ' : MagicBasisPPMState)
    (hrun : PPMProgramRel (magicBasisPPMSemanticsModel F) (compileArithmeticGateToPPM g)
              (magicBasisEncodeBits F f) σ') :
    magicBasisObservesBits F σ' (Gate.applyNat g f)

theorem ppm_clifford_run_deterministic
    (F : TFactoryContract) (g : Gate) (hICX : isICXGate g = true) (f : Nat → Bool)
    (σ₁ σ₂ : MagicBasisPPMState)
    (h1 : PPMProgramRel (magicBasisPPMSemanticsModel F) (compileArithmeticGateToPPM g)
            (magicBasisEncodeBits F f) σ₁)
    (h2 : PPMProgramRel (magicBasisPPMSemanticsModel F) (compileArithmeticGateToPPM g)
            (magicBasisEncodeBits F f) σ₂) :
    σ₁.bits = σ₂.bits

theorem clifford_ppm_is_a_reduction
    (F : TFactoryContract) (g : Gate) (hICX : isICXGate g = true) (f : Nat → Bool) :
    (∀ σ', PPMProgramRel (magicBasisPPMSemanticsModel F) (compileArithmeticGateToPPM g)
              (magicBasisEncodeBits F f) σ' → σ'.bits = Gate.applyNat g f)

structure ErrorBudget

noncomputable def ε_approx (B : ErrorBudget) : ℝ

noncomputable def ε_logical (B : ErrorBudget) : ℝ

noncomputable def P_raw (B : ErrorBudget) : ℝ

noncomputable def P_lb (B : ErrorBudget) : ℝ

noncomputable def totalError (p_L : ℝ) (opsModel : ℕ → ℝ) (c : ℕ) : ℝ

theorem ε_logical_nonneg (B : ErrorBudget) : 0 ≤ ε_logical B

theorem ε_approx_pos (B : ErrorBudget) : 0 < ε_approx B

theorem ε_approx_bounds_aqft (B : ErrorBudget) (n : ℕ) (hcn : B.cutoff ≤ n) :
    (∑ m ∈ Finset.Ico B.cutoff n, (Real.pi / 2 ^ m)) ≤ ε_approx B

theorem P_lb_nonneg (B : ErrorBudget) : 0 ≤ P_lb B

theorem P_lb_eq_raw_of_nonneg (B : ErrorBudget) (h : 0 ≤ P_raw B) :
    P_lb B = P_raw B

theorem P_lb_antitone_p_L (P_ideal : ℝ) (cutoff : ℕ) (num_ops : ℝ)
    (hnum : 0 ≤ num_ops) :
    Antitone (fun p_L : ℝ =>
      max 0 (P_ideal - 2 * Real.pi / 2 ^ cutoff - num_ops * p_L))

theorem P_lb_antitone_cutoffVal (P_ideal num_ops p_L : ℝ) :
    Antitone (fun ε : ℝ => max 0 (P_ideal - ε - num_ops * p_L))

theorem P_lb_antitone_ops (P_ideal : ℝ) (cutoff : ℕ) (p_L : ℝ) (hp : 0 ≤ p_L) :
    Antitone (fun num_ops : ℝ =>
      max 0 (P_ideal - 2 * Real.pi / 2 ^ cutoff - num_ops * p_L))

theorem ε_approx_antitone_cutoff {c c' : ℕ} (h : c ≤ c') :
    (2 * Real.pi / 2 ^ c' : ℝ) ≤ 2 * Real.pi / 2 ^ c

theorem ε_approx_strict_antitone_cutoff {c c' : ℕ} (h : c < c') :
    (2 * Real.pi / 2 ^ c' : ℝ) < 2 * Real.pi / 2 ^ c

theorem ε_logical_strict_mono_ops (p_L : ℝ) (hp : 0 < p_L) :
    StrictMono (fun nOps : ℕ => (nOps : ℝ) * p_L)

theorem tradeoff_tension (p_L : ℝ) (hp : 0 < p_L) (opsModel : ℕ → ℝ)
    (hops : StrictMono opsModel) {c c' : ℕ} (h : c < c') :
    (2 * Real.pi / 2 ^ c' : ℝ) < 2 * Real.pi / 2 ^ c
      ∧ opsModel c * p_L < opsModel c' * p_L

theorem tradeoff_interior_strict (p_L : ℝ) (opsModel : ℕ → ℝ)
    {c₀ c₁ c₂ : ℕ}
    (hcoarse : totalError p_L opsModel c₁ < totalError p_L opsModel c₀)
    (hfine   : totalError p_L opsModel c₁ < totalError p_L opsModel c₂) :
    totalError p_L opsModel c₁
      < min (totalError p_L opsModel c₀) (totalError p_L opsModel c₂)

theorem tradeoff_interior_witness :
    totalError (1/4) (fun c => (c : ℝ)) 4
      < min (totalError (1/4) (fun c => (c : ℝ)) 0)
            (totalError (1/4) (fun c => (c : ℝ)) 8)

theorem master_success_bound
    (a r N m bits ainv : Nat)
    (h_setting : ShorSetting a r N m bits)
    (h_sizing : CircuitSizing N bits)
    (h_inv : a * ainv % N = 1)
    (cutoff : ℕ) (p_L num_ops : ℝ) (hp_L : 0 ≤ p_L) (hnum : 0 ≤ num_ops) :
    probability_of_success a r N m bits (ModMul.ancillaWidth bits)
        (ModMul.circuitFamily a ainv N bits)
      ≥ κ / (Nat.log2 N : ℝ) ^ 4
          - (2 * Real.pi / 2 ^ cutoff)
          - num_ops * p_L

theorem master_success_bound_bundled
    (a r N m bits ainv : Nat)
    (h_setting : ShorSetting a r N m bits)
    (h_sizing : CircuitSizing N bits)
    (h_inv : a * ainv % N = 1)
    (B : ErrorBudget)
    (hP : B.P_ideal = κ / (Nat.log2 N : ℝ) ^ 4) :
    probability_of_success a r N m bits (ModMul.ancillaWidth bits)
        (ModMul.circuitFamily a ainv N bits)
      ≥ P_raw B

theorem applyNat_CCX_triple (a b c : Nat) (f : Nat → Bool) (hac : a ≠ c) (hbc : b ≠ c) :
    ( Gate.applyNat (Gate.CCX a b c) f a
    , Gate.applyNat (Gate.CCX a b c) f b
    , Gate.applyNat (Gate.CCX a b c) f c )
      = (f a, f b, xor (f c) (f a && f b))

theorem verified_toffoli_basis_action (k : Fin 8) :
    (aOf (ccxPerm k), bOf (ccxPerm k), cOf (ccxPerm k))
      = (aOf k, bOf k, xor (cOf k) (aOf k && bOf k))

theorem teleportCCX_grounded_in_verified_clifford_T
    (F : TFactoryContract) (a b c : Nat) (s t : MagicBasisPPMState)
    (hac : a ≠ c) (hbc : b ≠ c) (h : teleportCCXRel F a b c s t) :
    -- (1) the postulated Boolean action, on the three wires, is the Boolean Toffoli:
    ( t.bits a, t.bits b, t.bits c ) = (s.bits a, s.bits b, xor (s.bits c) (s.bits a && s.bits b))
    -- (2) realised by the VERIFIED Clifford+T Toffoli matrix (8 T-gates → CCZ → H-conjugated):
    ∧ Had3 * tDecompMat * Had3 = ccxPermMat
    -- (3) whose basis action is that same Boolean Toffoli:
    ∧ (∀ k : Fin 8, (aOf (ccxPerm k), bOf (ccxPerm k), cOf (ccxPerm k))
          = (aOf k, bOf k, xor (cOf k) (aOf k && bOf k)))

theorem ccz_magic_state_is_verified (ψ : StateVec 3) :
    projAnc000 * (cnotChain * (ψ ⊗ᵥ cczKet))
      = (1 / (2 * Real.sqrt 2) : ℂ) • (cczMatData ψ ⊗ᵥ (basisState 0 : StateVec 3))

noncomputable def totFactor (p : Nat) : ℝ

private lemma sorted_lower_bound (xs : List Nat) (h_sorted : xs.Pairwise (· < ·))
    (b : Nat) (h_b : ∀ x ∈ xs, b ≤ x)
    (i : Nat) (hi : i < xs.length) :
    i + b ≤ xs[i]'hi

private lemma totFactor_nonneg (p : Nat) (hp : 1 ≤ p) : 0 ≤ totFactor p

private lemma totFactor_ge_one_sub_inv (p s : Nat) (hp : s + 1 ≤ p) (hs : 1 ≤ s) :
    (s : ℝ) / ((s : ℝ) + 1) ≤ totFactor p

private lemma list_prod_one_sub_inv_from
    (xs : List Nat) (h_sorted : xs.Pairwise (· < ·))
    (c : Nat) (h_c : 1 ≤ c) (h_b : ∀ x ∈ xs, c + 1 ≤ x) :
    (c : ℝ) / ((c + xs.length : ℕ) : ℝ) ≤ (xs.map totFactor).prod

private lemma primeFactors_sort_pairwise_lt (n : Nat) :
    (n.primeFactors.sort (· ≤ ·)).Pairwise (· < ·)

private lemma sort_map_totFactor_prod (n : Nat) :
    ((n.primeFactors.sort (· ≤ ·)).map totFactor).prod
      = ∏ p ∈ n.primeFactors, totFactor p

theorem primeFactors_totient_product_ge (n : Nat) :
    (1 : ℝ) / ((n.primeFactors.card + 1 : ℕ) : ℝ)
      ≤ ∏ p ∈ n.primeFactors, totFactor p

theorem card_primeFactors_le_log2 (n : Nat) (hn : 0 < n) :
    n.primeFactors.card ≤ Nat.log2 n

theorem exp_neg_two_div_pow_four_le_one_div_succ (L : Nat) :
    Real.exp (-2) / (L : ℝ)^4 ≤ 1 / ((L : ℝ) + 1)

theorem phi_n_over_n_lowerbound_proved (r N : Nat) (h_r_pos : 0 < r) (h_le : r ≤ N) :
    ((Nat.totient r : ℝ) / (r : ℝ))
      ≥ Real.exp (-2) / (Nat.log2 N : ℝ)^4

theorem canonical (N : Nat) (hN : 0 < N) :
    CircuitSizing N (Nat.log2 (2 * N) + 1)

noncomputable def verifiedSqirModMulFamily
    (a ainv N bits : Nat) (h_sizing : CircuitSizing N bits)
    (h_N_ge_2 : 2 ≤ N) (h_inv : a * ainv % N = 1) :
    VerifiedModMulFamily a N bits (ModMul.ancillaWidth bits)

theorem correct_general_via_interface
    (a r N m bits ainv : Nat)
    (h_setting : ShorSetting a r N m bits)
    (h_sizing : CircuitSizing N bits)
    (h_inv : a * ainv % N = 1) :
    FormalRV.SQIRPort.probability_of_success a r N m bits
      (ModMul.ancillaWidth bits)
      (ModMul.circuitFamily a ainv N bits)
      ≥ FormalRV.SQIRPort.κ / (Nat.log2 N : ℝ)^4

structure MultiplierStepLayout

def sqirCuccaroLayout : MultiplierStepLayout

theorem sqirCuccaro_controlIdx_allowed (bits j : Nat) :
    sqir_mult_control_idx bits j < 2
      ∨ 2 + 2 * bits + 1 ≤ sqir_mult_control_idx bits j

theorem sqirCuccaro_controlIdx_ne_flag (bits j : Nat) :
    sqir_mult_control_idx bits j ≠ 1

theorem sqirCuccaro_controlIdx_ne_topCarry (bits j : Nat) :
    sqir_mult_control_idx bits j ≠ 2 + 2 * bits

theorem sqirCuccaro_controlIdx_lt_dim
    (bits j : Nat) (hj : j < bits) :
    sqir_mult_control_idx bits j < sqir_modmult_rev_anc bits

theorem sqirCuccaro_controlIdx_injective
    (bits j j' : Nat)
    (h : sqir_mult_control_idx bits j = sqir_mult_control_idx bits j') :
    j = j'

theorem sqirCuccaro_targetBitIdx_eq (i : Nat) :
    sqir_target_idx i = 2 + 2 * i + 1

theorem sqirCuccaro_input_targetDecode
    (bits m acc : Nat) (hacc : acc < 2 ^ bits) :
    cuccaro_target_val bits 2 (sqir_mult_input_F bits m acc) = acc

theorem sqirCuccaro_input_readDecode (bits m acc : Nat) :
    cuccaro_read_val bits 2 (sqir_mult_input_F bits m acc) = 0

theorem sqirCuccaro_input_flagFalse (bits m acc : Nat) :
    sqir_mult_input_F bits m acc 1 = false

theorem sqirCuccaro_input_topCarryFalse
    (bits m acc : Nat) (hbits : 1 ≤ bits) :
    sqir_mult_input_F bits m acc (2 + 2 * bits) = false

theorem sqirCuccaro_input_controlBit
    (bits m acc j : Nat) (hj : j < bits) :
    sqir_mult_input_F bits m acc (sqir_mult_control_idx bits j) = m.testBit j

theorem sqirCuccaro_input_eq_install_with_j
    (bits m acc j : Nat) (hj : j < bits) (hacc : acc < 2 ^ bits) :
    sqir_mult_input_F bits m acc
      = install_mult_bits_skip_j bits m j bits
          (update (cuccaro_input_F 2 false 0 acc)
            (sqir_mult_control_idx bits j) (m.testBit j))

theorem sqirCuccaro_targetDecode_through_install
    (bits m j N c num_bits : Nat) (f : Nat → Bool) :
    cuccaro_target_val bits 2
        (Gate.applyNat (sqir_style_controlledModAddConst_gate bits 2 N c
            (sqir_mult_control_idx bits j) 1)
          (install_mult_bits_skip_j bits m j num_bits f))
      = cuccaro_target_val bits 2
          (Gate.applyNat (sqir_style_controlledModAddConst_gate bits 2 N c
            (sqir_mult_control_idx bits j) 1) f)

theorem sqirCuccaro_controlledModAdd_commute_install
    (bits m j N c num_bits : Nat) (f : Nat → Bool) :
    Gate.applyNat (sqir_style_controlledModAddConst_gate bits 2 N c
        (sqir_mult_control_idx bits j) 1)
      (install_mult_bits_skip_j bits m j num_bits f)
      = install_mult_bits_skip_j bits m j num_bits
          (Gate.applyNat (sqir_style_controlledModAddConst_gate bits 2 N c
            (sqir_mult_control_idx bits j) 1) f)

theorem sqirCuccaro_readDecode_through_install
    (bits m j N c num_bits : Nat) (f : Nat → Bool) :
    cuccaro_read_val bits 2
        (Gate.applyNat (sqir_style_controlledModAddConst_gate bits 2 N c
            (sqir_mult_control_idx bits j) 1)
          (install_mult_bits_skip_j bits m j num_bits f))
      = cuccaro_read_val bits 2
          (Gate.applyNat (sqir_style_controlledModAddConst_gate bits 2 N c
            (sqir_mult_control_idx bits j) 1) f)

theorem sqirCuccaro_applyNat_through_install_at_workspace
    (bits m j N c num_bits q : Nat) (f : Nat → Bool)
    (hq_ws : q < 2 + 2 * bits + 1) :
    Gate.applyNat (sqir_style_controlledModAddConst_gate bits 2 N c
        (sqir_mult_control_idx bits j) 1)
      (install_mult_bits_skip_j bits m j num_bits f) q
      = Gate.applyNat (sqir_style_controlledModAddConst_gate bits 2 N c
        (sqir_mult_control_idx bits j) 1) f q

theorem sqirCuccaro_applyNat_through_install_at_j
    (bits m j N c num_bits : Nat) (f : Nat → Bool) :
    Gate.applyNat (sqir_style_controlledModAddConst_gate bits 2 N c
        (sqir_mult_control_idx bits j) 1)
      (install_mult_bits_skip_j bits m j num_bits f) (sqir_mult_control_idx bits j)
      = Gate.applyNat (sqir_style_controlledModAddConst_gate bits 2 N c
        (sqir_mult_control_idx bits j) 1) f (sqir_mult_control_idx bits j)

theorem sqirCuccaro_install_at_mult_k_eq
    (bits m j num_bits k : Nat) (f : Nat → Bool)
    (h_k_lt : k < num_bits) (h_k_ne_j : k ≠ j) :
    install_mult_bits_skip_j bits m j num_bits f (sqir_mult_control_idx bits k)
      = m.testBit k

theorem sqirCuccaro_step_flag0_false
    (bits N a j m acc : Nat) (hbits : 1 ≤ bits) (hj : j < bits) :
    Gate.applyNat
        (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
          (sqirCuccaroLayout.multControlIdx bits j))
        (sqirCuccaroLayout.multInputEncode bits m acc) 0 = false

theorem sqirCuccaro_step_above_layout_false
    (bits N a j m acc q : Nat) (hbits : 1 ≤ bits) (hj : j < bits)
    (hq : q ≥ 2 + 2 * bits + 1 + bits) :
    Gate.applyNat
        (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
          (sqirCuccaroLayout.multControlIdx bits j))
        (sqirCuccaroLayout.multInputEncode bits m acc) q = false

theorem sqirCuccaro_step_carryIn_restored
    (bits N a j m acc : Nat) (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hj : j < bits) (hacc : acc < N) :
    Gate.applyNat
        (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
          (sqirCuccaroLayout.multControlIdx bits j))
        (sqirCuccaroLayout.multInputEncode bits m acc) 2 = false

theorem sqirCuccaro_step_targetBit_extracted
    (bits N a j m acc i : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hj : j < bits) (hacc : acc < N) (hi : i < bits) :
    Gate.applyNat
        (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
          (sqirCuccaroLayout.multControlIdx bits j))
        (sqirCuccaroLayout.multInputEncode bits m acc) (2 + 2 * i + 1)
      = (if m.testBit j then (acc + (a * 2^j) % N) % N else acc).testBit i

theorem sqirCuccaro_step_readBit_zero
    (bits N a j m acc i : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hj : j < bits) (hacc : acc < N) (hi : i < bits) :
    Gate.applyNat
        (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
          (sqirCuccaroLayout.multControlIdx bits j))
        (sqirCuccaroLayout.multInputEncode bits m acc) (2 + 2 * i + 2) = false

theorem sqirCuccaro_controlIdx_controlAllowed (bits j : Nat) :
    ControlledModAdd.sqirCuccaroLayout.controlAllowed bits
      (sqir_mult_control_idx bits j)

theorem sqirCuccaro_multInput_targetDecode
    (bits m acc : Nat) (hacc : acc < 2 ^ bits) :
    ControlledModAdd.sqirCuccaroLayout.targetDecode bits
      (sqir_mult_input_F bits m acc) = acc

theorem sqirCuccaro_step_targetDecode_via_interface
    (bits N a j m acc : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hj : j < bits) (hacc : acc < N) :
    ControlledModAdd.sqirCuccaroLayout.targetDecode bits
        (Gate.applyNat
          (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
            (sqirCuccaroLayout.multControlIdx bits j))
          (sqirCuccaroLayout.multInputEncode bits m acc))
      = if m.testBit j then (acc + (a * 2^j) % N) % N else acc

theorem sqirCuccaro_step_targetDecode_matches_old
    (bits N a j m acc : Nat) :
    ControlledModAdd.sqirCuccaroLayout.targetDecode bits
        (Gate.applyNat
          (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
            (sqirCuccaroLayout.multControlIdx bits j))
          (sqirCuccaroLayout.multInputEncode bits m acc))
      = cuccaro_target_val bits 2
          (Gate.applyNat (sqir_modmult_step_gate bits N a j)
            (sqir_mult_input_F bits m acc))

theorem sqirCuccaro_step_workspace_via_interface
    (bits N a j m acc : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hj : j < bits) (hacc : acc < N) :
    ControlledModAdd.sqirCuccaroLayout.readDecode bits
        (Gate.applyNat
          (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
            (sqirCuccaroLayout.multControlIdx bits j))
          (sqirCuccaroLayout.multInputEncode bits m acc)) = 0
    ∧ Gate.applyNat
          (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
            (sqirCuccaroLayout.multControlIdx bits j))

theorem sqirCuccaro_step_workspace_matches_old
    (bits N a j m acc : Nat) :
    (ControlledModAdd.sqirCuccaroLayout.readDecode bits
        (Gate.applyNat
          (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
            (sqirCuccaroLayout.multControlIdx bits j))
          (sqirCuccaroLayout.multInputEncode bits m acc)) = 0
    ∧ Gate.applyNat
          (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
            (sqirCuccaroLayout.multControlIdx bits j))
          (sqirCuccaroLayout.multInputEncode bits m acc)
          (ControlledModAdd.sqirCuccaroLayout.topCarryPos bits) = false

theorem sqirCuccaro_step_gate_wellTyped_via_interface
    (bits N a j : Nat) (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits) (hj : j < bits) :
    Gate.WellTyped
      (ControlledModAdd.sqirCuccaroLayout.ancillaWidth bits)
      (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
        (sqirCuccaroLayout.multControlIdx bits j))

theorem sqirCuccaro_step_gate_wellTyped_matches_old
    (bits N a j : Nat) :
    Gate.WellTyped
        (ControlledModAdd.sqirCuccaroLayout.ancillaWidth bits)
        (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
          (sqirCuccaroLayout.multControlIdx bits j))
      = Gate.WellTyped (sqir_modmult_rev_anc bits)
          (sqir_modmult_step_gate bits N a j)

theorem sqirCuccaro_step_preserves_all_control_bits_via_interface
    (bits N a m acc j k : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N) (hj : j < bits) (hk : k < bits) :
    Gate.applyNat
        (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
          (sqirCuccaroLayout.multControlIdx bits j))
        (sqirCuccaroLayout.multInputEncode bits m acc)
        (sqirCuccaroLayout.multControlIdx bits k) = m.testBit k

theorem sqirCuccaro_step_preserves_all_control_bits_matches_old
    (bits N a m acc j k : Nat) :
    (Gate.applyNat
        (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
          (sqirCuccaroLayout.multControlIdx bits j))
        (sqirCuccaroLayout.multInputEncode bits m acc)
        (sqirCuccaroLayout.multControlIdx bits k) = m.testBit k)
    = (Gate.applyNat (sqir_modmult_step_gate bits N a j)
        (sqir_mult_input_F bits m acc) (sqir_mult_control_idx bits k)
        = m.testBit k)

theorem sqirCuccaro_step_state_eq_via_interface
    (bits N a j m acc : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hj : j < bits) (hacc : acc < N) :
    Gate.applyNat
        (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
          (sqirCuccaroLayout.multControlIdx bits j))
        (sqirCuccaroLayout.multInputEncode bits m acc)
      = sqirCuccaroLayout.multInputEncode bits m
          (if m.testBit j then (acc + (a * 2^j) % N) % N else acc)

theorem sqirCuccaro_step_state_eq_matches_old
    (bits N a j m acc : Nat) :
    (Gate.applyNat
        (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
          (sqirCuccaroLayout.multControlIdx bits j))
        (sqirCuccaroLayout.multInputEncode bits m acc)
      = sqirCuccaroLayout.multInputEncode bits m
          (if m.testBit j then (acc + (a * 2^j) % N) % N else acc))
    = (Gate.applyNat (sqir_modmult_step_gate bits N a j)
        (sqir_mult_input_F bits m acc)
      = sqir_mult_input_F bits m
          (if m.testBit j then (acc + (a * 2^j) % N) % N else acc))

theorem sqirCuccaro_step_state_eq_real_sqir_form
    (bits N a j m acc : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hj : j < bits) (hacc : acc < N) :
    Gate.applyNat (sqir_modmult_step_gate bits N a j)
        (sqir_mult_input_F bits m acc)
      = sqir_mult_input_F bits m
          (if m.testBit j then (acc + (a * 2^j) % N) % N else acc)

theorem sqirCuccaro_step_state_eq_real_via_interface
    (bits N a j m acc : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hj : j < bits) (hacc : acc < N) :
    Gate.applyNat
        (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
          (sqirCuccaroLayout.multControlIdx bits j))
        (sqirCuccaroLayout.multInputEncode bits m acc)
      = sqirCuccaroLayout.multInputEncode bits m
          (if m.testBit j then (acc + (a * 2^j) % N) % N else acc)

theorem sqirCuccaro_step_state_eq_real_matches_fallback
    (bits N a j m acc : Nat) :
    (Gate.applyNat
        (ControlledModAdd.sqirCuccaroImpl.gate bits N ((a * 2^j) % N)
          (sqirCuccaroLayout.multControlIdx bits j))
        (sqirCuccaroLayout.multInputEncode bits m acc)
      = sqirCuccaroLayout.multInputEncode bits m
          (if m.testBit j then (acc + (a * 2^j) % N) % N else acc))
    = (Gate.applyNat (sqir_modmult_step_gate bits N a j)
        (sqir_mult_input_F bits m acc)
      = sqir_mult_input_F bits m
          (if m.testBit j then (acc + (a * 2^j) % N) % N else acc))

theorem sqirCuccaro_prefix_state_eq_from_via_interface
    (bits N a m acc k : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N) (hk : k ≤ bits) :
    Gate.applyNat (sqir_modmult_prefix_gate bits N a k)
        (sqirCuccaroLayout.multInputEncode bits m acc)
      = sqirCuccaroLayout.multInputEncode bits m
          (sqir_modmult_acc_spec_from N a m acc k)

theorem sqirCuccaro_const_gate_state_eq_from_via_interface
    (bits N a m acc : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N) (hm : m < 2^bits) :
    Gate.applyNat (sqir_modmult_const_gate bits N a)
        (sqirCuccaroLayout.multInputEncode bits m acc)
      = sqirCuccaroLayout.multInputEncode bits m ((acc + a * m) % N)

theorem sqirCuccaro_prefix_state_eq_from_real_sqir_form
    (bits N a m acc k : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N) (hk : k ≤ bits) :
    Gate.applyNat (sqir_modmult_prefix_gate bits N a k)
        (sqir_mult_input_F bits m acc)
      = sqir_mult_input_F bits m (sqir_modmult_acc_spec_from N a m acc k)

theorem sqirCuccaro_prefix_state_eq_from_real_via_interface
    (bits N a m acc k : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N) (hk : k ≤ bits) :
    Gate.applyNat (sqir_modmult_prefix_gate bits N a k)
        (sqirCuccaroLayout.multInputEncode bits m acc)
      = sqirCuccaroLayout.multInputEncode bits m
          (sqir_modmult_acc_spec_from N a m acc k)

theorem sqirCuccaro_const_gate_state_eq_from_real_sqir_form
    (bits N a m acc : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N) (hm : m < 2^bits) :
    Gate.applyNat (sqir_modmult_const_gate bits N a) (sqir_mult_input_F bits m acc)
      = sqir_mult_input_F bits m ((acc + a * m) % N)

theorem sqirCuccaro_const_gate_state_eq_from_real_via_interface
    (bits N a m acc : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N) (hm : m < 2^bits) :
    Gate.applyNat (sqir_modmult_const_gate bits N a)
        (sqirCuccaroLayout.multInputEncode bits m acc)
      = sqirCuccaroLayout.multInputEncode bits m ((acc + a * m) % N)

theorem circuitFamily_modMulImpl_via_interfaces
    (a ainv N bits : Nat) (hbits : 1 ≤ bits) (hN_ge_2 : 2 ≤ N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits) (h_inv : a * ainv % N = 1) :
    ModMulImpl a N bits (ancillaWidth bits)
      (circuitFamily a ainv N bits)

theorem satisfiesMultiplyCircuitProperty_via_interfaces
    (bits N a ainv : Nat) (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_ainv_le : ainv ≤ N) (h_inv : (a * ainv) % N = 1) :
    MultiplyCircuitProperty a N bits (ancillaWidth bits)
      (Gate.toUCom (totalDim bits) (gateMCP bits N a ainv))

def canonicalBits (N : Nat) : Nat

theorem circuitSizing_canonical (N : Nat) (hN : 0 < N) :
    CircuitSizing N (canonicalBits N)

structure ControlledModAddLayout

structure ControlledModAddImpl

def sqirCuccaroLayout : ControlledModAddLayout

noncomputable def sqirCuccaroImpl : ControlledModAddImpl

theorem clean_wellTyped (C : ControlledModAddImpl)
    (bits N c x controlIdx : Nat) (control : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hc : c < N) (hx : x < N)
    (hcontrol_allowed : C.layout.controlAllowed bits controlIdx)
    (hcontrol_ne_flag : controlIdx ≠ C.layout.flagPos bits)
    (h_control_workspace_lt : controlIdx < C.layout.ancillaWidth bits) :
    Gate.WellTyped (C.layout.ancillaWidth bits)
      (C.gate bits N c controlIdx)

theorem clean_targetDecode (C : ControlledModAddImpl)
    (bits N c x controlIdx : Nat) (control : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hc : c < N) (hx : x < N)
    (hcontrol_allowed : C.layout.controlAllowed bits controlIdx)
    (hcontrol_ne_flag : controlIdx ≠ C.layout.flagPos bits)
    (h_control_workspace_lt : controlIdx < C.layout.ancillaWidth bits) :
    C.layout.targetDecode bits
        (Gate.applyNat (C.gate bits N c controlIdx)
          (update (C.layout.inputEncode bits x) controlIdx control))
      = (if control then (x + c) % N else x)

theorem clean_readZero (C : ControlledModAddImpl)
    (bits N c x controlIdx : Nat) (control : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hc : c < N) (hx : x < N)
    (hcontrol_allowed : C.layout.controlAllowed bits controlIdx)
    (hcontrol_ne_flag : controlIdx ≠ C.layout.flagPos bits)
    (h_control_workspace_lt : controlIdx < C.layout.ancillaWidth bits) :
    C.layout.readDecode bits
        (Gate.applyNat (C.gate bits N c controlIdx)
          (update (C.layout.inputEncode bits x) controlIdx control)) = 0

theorem clean_topCarryFalse (C : ControlledModAddImpl)
    (bits N c x controlIdx : Nat) (control : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hc : c < N) (hx : x < N)
    (hcontrol_allowed : C.layout.controlAllowed bits controlIdx)
    (hcontrol_ne_flag : controlIdx ≠ C.layout.flagPos bits)
    (h_control_workspace_lt : controlIdx < C.layout.ancillaWidth bits) :
    Gate.applyNat (C.gate bits N c controlIdx)
        (update (C.layout.inputEncode bits x) controlIdx control)
        (C.layout.topCarryPos bits) = false

theorem clean_flagFalse (C : ControlledModAddImpl)
    (bits N c x controlIdx : Nat) (control : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hc : c < N) (hx : x < N)
    (hcontrol_allowed : C.layout.controlAllowed bits controlIdx)
    (hcontrol_ne_flag : controlIdx ≠ C.layout.flagPos bits)
    (h_control_workspace_lt : controlIdx < C.layout.ancillaWidth bits) :
    Gate.applyNat (C.gate bits N c controlIdx)
        (update (C.layout.inputEncode bits x) controlIdx control)
        (C.layout.flagPos bits) = false

theorem clean_controlPreserved (C : ControlledModAddImpl)
    (bits N c x controlIdx : Nat) (control : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hc : c < N) (hx : x < N)
    (hcontrol_allowed : C.layout.controlAllowed bits controlIdx)
    (hcontrol_ne_flag : controlIdx ≠ C.layout.flagPos bits)
    (h_control_workspace_lt : controlIdx < C.layout.ancillaWidth bits) :
    Gate.applyNat (C.gate bits N c controlIdx)
        (update (C.layout.inputEncode bits x) controlIdx control)
        controlIdx
      = control

theorem ControlledModAddImpl.targetDecode_eq_of_clean
    (C : ControlledModAddImpl)
    (bits N c x controlIdx : Nat) (control : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hc : c < N) (hx : x < N)
    (hcontrol_allowed : C.layout.controlAllowed bits controlIdx)
    (hcontrol_ne_flag : controlIdx ≠ C.layout.flagPos bits)
    (h_control_workspace_lt : controlIdx < C.layout.ancillaWidth bits) :
    C.layout.targetDecode bits
        (Gate.applyNat (C.gate bits N c controlIdx)
          (update (C.layout.inputEncode bits x) controlIdx control))

theorem sqirCuccaroImpl_targetDecode_eq
    (bits N c x controlIdx : Nat) (control : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hc : c < N) (hx : x < N)
    (hcontrol_out : controlIdx < 2 ∨ 2 + 2 * bits + 1 ≤ controlIdx)
    (hcontrol_ne_flag : controlIdx ≠ 1)
    (h_control_workspace_lt :
        controlIdx < sqirCuccaroImpl.layout.ancillaWidth bits) :
    cuccaro_target_val bits 2
        (Gate.applyNat (sqirCuccaroImpl.gate bits N c controlIdx)
          (update (cuccaro_input_F 2 false 0 x) controlIdx control))

structure MCPAdapterLayout

def sqirCuccaroLayout : MCPAdapterLayout

theorem sqirCuccaro_encode_data
    {n anc x i : Nat} (hx : x < 2^n) (hi : i < n) :
    encodeDataZeroAnc n anc x i
      = FormalRV.Framework.nat_to_funbool n x i

theorem sqirCuccaro_encode_anc
    {n anc x j : Nat} (hx : x < 2^n) (hj : j < anc) :
    encodeDataZeroAnc n anc x (n + j) = false

theorem sqirCuccaro_encode_oob
    {n anc x i : Nat} (hanc_pos : 0 < anc) (hi : n + anc ≤ i) :
    encodeDataZeroAnc n anc x i = false

theorem shift_applyNat_at_lo
    (off : Nat) (g : Gate) (f : Nat → Bool) (q : Nat) (hq : q < off) :
    Gate.applyNat (Gate.shift off g) f q = f q

theorem shift_applyNat_at_hi
    (off : Nat) (g : Gate) (f : Nat → Bool) (q : Nat) (hq : off ≤ q) :
    Gate.applyNat (Gate.shift off g) f q
      = Gate.applyNat g (fun r => f (off + r)) (q - off)

theorem shift_wellTyped
    {off dim : Nat} {g : Gate} (h : Gate.WellTyped dim g) :
    Gate.WellTyped (off + dim) (Gate.shift off g)

theorem sqirCuccaro_encodeAdapter_correct
    (bits x : Nat) (hbits : 1 ≤ bits) (hx : x < 2^bits) :
    Gate.applyNat (sqir_encode_to_mult_adapter bits)
        (encodeDataZeroAnc bits (sqir_modmult_rev_anc bits) x)
      = sqir_mult_input_F_shifted bits x 0

theorem sqirCuccaro_encodeAdapter_reverse
    (bits y : Nat) (hbits : 1 ≤ bits) (hy : y < 2^bits) :
    Gate.applyNat (sqir_encode_to_mult_adapter bits)
        (sqir_mult_input_F_shifted bits y 0)
      = encodeDataZeroAnc bits (sqir_modmult_rev_anc bits) y

theorem sqirCuccaro_encodeAdapter_wellTyped
    (bits : Nat) (hbits : 1 ≤ bits) :
    Gate.WellTyped (sqir_total_dim bits) (sqir_encode_to_mult_adapter bits)

theorem sqirCuccaro_gateMCP_apply_encode
    (bits N a ainv x : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_ainv_le : ainv ≤ N) (hx : x < N) (h_inv : (a * ainv) % N = 1) :
    Gate.applyNat (ModMul.gateMCP bits N a ainv)
        (encodeDataZeroAnc bits (ModMul.ancillaWidth bits) x)
      = encodeDataZeroAnc bits (ModMul.ancillaWidth bits) ((a * x) % N)

theorem sqirCuccaro_gateMCP_wellTyped
    (bits N a ainv : Nat) (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits) :
    Gate.WellTyped (ModMul.totalDim bits) (ModMul.gateMCP bits N a ainv)

theorem sqirCuccaro_satisfiesMultiplyCircuitProperty
    (bits N a ainv : Nat) (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_ainv_le : ainv ≤ N) (h_inv : (a * ainv) % N = 1) :
    FormalRV.SQIRPort.MultiplyCircuitProperty a N bits (ModMul.ancillaWidth bits)
      (Gate.toUCom (ModMul.totalDim bits) (ModMul.gateMCP bits N a ainv))

theorem sqirCuccaro_totalDim_eq (bits : Nat) :
    sqirCuccaroLayout.totalDim bits = sqir_total_dim bits

theorem sqirCuccaro_mcpEncode_eq (bits anc x : Nat) :
    sqirCuccaroLayout.mcpEncode bits anc x = encodeDataZeroAnc bits anc x

theorem sqirCuccaro_inplace_candidate_state_eq_via_interface
    (bits N a ainv x : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_ainv_le : ainv ≤ N) (hx : x < N) (h_inv : (a * ainv) % N = 1) :
    Gate.applyNat (sqir_modmult_inplace_candidate bits N a ainv)
        (MultiplierStep.sqirCuccaroLayout.multInputEncode bits x 0)
      = MultiplierStep.sqirCuccaroLayout.multInputEncode bits ((a * x) % N) 0

theorem sqirCuccaro_gateMCP_apply_encode_via_interfaces
    (bits N a ainv x : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_ainv_le : ainv ≤ N) (hx : x < N) (h_inv : (a * ainv) % N = 1) :
    Gate.applyNat (ModMul.gateMCP bits N a ainv)
        (sqirCuccaroLayout.mcpEncode bits (ModMul.ancillaWidth bits) x)
      = sqirCuccaroLayout.mcpEncode bits (ModMul.ancillaWidth bits) ((a * x) % N)

theorem sqirCuccaro_gateMCP_wellTyped_via_interfaces
    (bits N a ainv : Nat) (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits) :
    Gate.WellTyped (sqirCuccaroLayout.totalDim bits)
      (ModMul.gateMCP bits N a ainv)

theorem sqirCuccaro_satisfiesMultiplyCircuitProperty_via_interfaces
    (bits N a ainv : Nat) (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_ainv_le : ainv ≤ N) (h_inv : (a * ainv) % N = 1) :
    FormalRV.SQIRPort.MultiplyCircuitProperty a N bits
      (ModMul.ancillaWidth bits)
      (Gate.toUCom (sqirCuccaroLayout.totalDim bits)
        (ModMul.gateMCP bits N a ainv))

theorem sqirCuccaro_inplace_candidate_state_eq_real_sqir_form
    (bits N a ainv x : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_ainv_le : ainv ≤ N) (hx : x < N)
    (h_inv : (a * ainv) % N = 1) :
    Gate.applyNat (sqir_modmult_inplace_candidate bits N a ainv)
        (sqir_mult_input_F bits x 0)
      = sqir_mult_input_F bits ((a * x) % N) 0

theorem sqirCuccaro_inplace_candidate_state_eq_real_via_interface
    (bits N a ainv x : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_ainv_le : ainv ≤ N) (hx : x < N) (h_inv : (a * ainv) % N = 1) :
    Gate.applyNat (sqir_modmult_inplace_candidate bits N a ainv)
        (MultiplierStep.sqirCuccaroLayout.multInputEncode bits x 0)
      = MultiplierStep.sqirCuccaroLayout.multInputEncode bits ((a * x) % N) 0

theorem sqirCuccaro_inplace_shifted_correct_real_via_interface
    (bits N a ainv x : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_ainv_le : ainv ≤ N) (hx : x < N) (h_inv : (a * ainv) % N = 1) :
    Gate.applyNat (sqir_modmult_inplace_shifted bits N a ainv)
        (sqir_mult_input_F_shifted bits x 0)
      = sqir_mult_input_F_shifted bits ((a * x) % N) 0

theorem sqirCuccaro_gateMCP_apply_encode_real_via_interfaces
    (bits N a ainv x : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_ainv_le : ainv ≤ N) (hx : x < N) (h_inv : (a * ainv) % N = 1) :
    Gate.applyNat (ModMul.gateMCP bits N a ainv)
        (encodeDataZeroAnc bits (ModMul.ancillaWidth bits) x)
      = encodeDataZeroAnc bits (ModMul.ancillaWidth bits) ((a * x) % N)

theorem sqirCuccaro_gateMCP_wellTyped_real_via_interfaces
    (bits N a ainv : Nat) (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits) :
    Gate.WellTyped (sqirCuccaroLayout.totalDim bits)
      (ModMul.gateMCP bits N a ainv)

theorem sqirCuccaro_satisfiesMultiplyCircuitProperty_real_via_interfaces
    (bits N a ainv : Nat) (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_ainv_le : ainv ≤ N) (h_inv : (a * ainv) % N = 1) :
    FormalRV.SQIRPort.MultiplyCircuitProperty a N bits
      (ModMul.ancillaWidth bits)
      (Gate.toUCom (sqirCuccaroLayout.totalDim bits)
        (ModMul.gateMCP bits N a ainv))

theorem data_position_is_source
    (bits numWin q : Nat)
    (h_exact : 2 * numWin = bits)
    (hq : q < bits) :
    (∃ k, k < numWin ∧ q = bits - 1 - 2 * k) ∨
    (∃ k, k < numWin ∧ q = bits - 1 - (2 * k + 1))

theorem cuccaro_input_F_zero_acc_eq_false (q : Nat) :
    cuccaro_input_F 2 false 0 0 q = false

theorem windowed2Input_zero_at_disjoint
    (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (numWin q : Nat)
    (h_b0_disj : ∀ k, k < numWin → q ≠ b0Idx k)
    (h_b1_disj : ∀ k, k < numWin → q ≠ b1Idx k) :
    windowed2Input 0 b0Idx b1Idx b0 b1 numWin q = false

theorem windowed2Input_read_b0_bounded
    (acc : Nat) (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (numWin k : Nat) (hk : k < numWin)
    (h_b0_ne_b1 : ∀ j, j < numWin → b0Idx j ≠ b1Idx j)
    (h_distinct_b0_b0 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b0Idx i ≠ b0Idx j)
    (h_distinct_b0_b1 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b0Idx i ≠ b1Idx j) :
    windowed2Input acc b0Idx b1Idx b0 b1 numWin (b0Idx k) = b0 k

theorem windowed2Input_read_b1_bounded
    (acc : Nat) (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (numWin k : Nat) (hk : k < numWin)
    (h_distinct_b0_b1 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b0Idx i ≠ b1Idx j)
    (h_distinct_b1_b1 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b1Idx i ≠ b1Idx j) :
    windowed2Input acc b0Idx b1Idx b0 b1 numWin (b1Idx k) = b1 k

theorem windowedSwapLoadAdapter_apply_encodeDataZeroAnc
    (bits anc numWin x : Nat) (b0Idx b1Idx : Nat → Nat)
    (hx : x < 2^bits)
    (h_anc_pos : 0 < anc)
    (h_numWin_exact : 2 * numWin = bits)
    (h_b0_above : ∀ k, k < numWin → bits ≤ b0Idx k)
    (h_b1_above : ∀ k, k < numWin → bits ≤ b1Idx k)
    (h_b0_ne_b1 : ∀ k, k < numWin → b0Idx k ≠ b1Idx k)
    (h_distinct_b0_b0 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b0Idx i ≠ b0Idx j)
    (h_distinct_b0_b1 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b0Idx i ≠ b1Idx j)

theorem windowedSwapLoadAdapter_then_selectedAdd_apply
    (bits anc numWin x N a flagIdx : Nat)
    (b0Idx b1Idx : Nat → Nat)
    (hx : x < 2^bits)
    (h_anc_pos : 0 < anc)
    (h_numWin_exact : 2 * numWin = bits)
    (hbits : 1 ≤ bits)
    (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_flag_lo : flagIdx < 2)
    (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)

theorem windowedSwapLoadAdapter_then_selectedAdd_apply_clean
    (bits anc numWin x N a flagIdx : Nat)
    (b0Idx b1Idx : Nat → Nat)
    (hx : x < 2^bits)
    (h_anc_pos : 0 < anc)
    (h_numWin_exact : 2 * numWin = bits)
    (hbits : 1 ≤ bits)
    (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_flag_lo : flagIdx < 2)
    (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)

noncomputable def windowedSwapUnloadAdapterDiag
    (bits : Nat) (b0Idx b1Idx : Nat → Nat) : Nat → Gate
  | 0 => Gate.I
  | n + 1 =>
      Gate.seq
        (Gate.seq
          (FormalRV.BQAlgo.qubit_swap (bits - 1 - 2 * n) (b0Idx n))
          (FormalRV.BQAlgo.qubit_swap (bits - 1 - (2 * n + 1)) (b1Idx n)))
        (windowedSwapUnloadAdapterDiag bits b0Idx b1Idx n)

theorem unloadDiag_data_msb_reads_old_x_at_numWin_1
    (bits y x : Nat) (b0Idx b1Idx : Nat → Nat)
    (hbits : 2 ≤ bits)
    (h_b0_above : bits ≤ b0Idx 0)
    (h_b1_above : bits ≤ b1Idx 0)
    (h_b0_ne_b1 : b0Idx 0 ≠ b1Idx 0) :
    Gate.applyNat (windowedSwapUnloadAdapterDiag bits b0Idx b1Idx 1)
        (windowed2Input y b0Idx b1Idx
          (windowed2_b0_of_x x) (windowed2_b1_of_x x) 1)
        (bits - 1)
      = windowed2_b0_of_x x 0

theorem unloadDiag_ancilla_receives_acc_at_numWin_1_bits_4
    (y x : Nat) (b0Idx b1Idx : Nat → Nat)
    (h_b0_above : 4 ≤ b0Idx 0)
    (h_b1_above : 4 ≤ b1Idx 0)
    (h_b0_ne_b1 : b0Idx 0 ≠ b1Idx 0) :
    Gate.applyNat (windowedSwapUnloadAdapterDiag 4 b0Idx b1Idx 1)
        (windowed2Input y b0Idx b1Idx
          (windowed2_b0_of_x x) (windowed2_b1_of_x x) 1)
        (b0Idx 0)
      = y.testBit 0

def cuccaroBPos (n : Nat) : Nat

def dataPos (bits n : Nat) : Nat

theorem cuccaroBPos_dataPos_eq_iff (bits n : Nat) :
    cuccaroBPos n = dataPos bits n ↔ bits = 3 * n + 4

theorem cuccaroBitsToDataSwap_invalid_at_bits_4 :
    cuccaroBPos 0 = dataPos 4 0

theorem cuccaroBitsToDataSwap_overlap_bits10 :
    cuccaroBPos 1 = dataPos 10 4 ∧
    cuccaroBPos 2 = dataPos 10 2

theorem cuccaroBPos_in_data_range (n bits : Nat)
    (h : 2 * n + 3 < bits) :
    cuccaroBPos n < bits

noncomputable def verifiedSqirModMulFamily_via_interfaces
    (a ainv N bits : Nat) (h_sizing : CircuitSizing N bits)
    (h_N_ge_2 : 2 ≤ N) (h_inv : a * ainv % N = 1) :
    VerifiedModMulFamily a N bits (ModMul.ancillaWidth bits)

theorem verifiedSqirModMulFamily_via_interfaces_eq
    (a ainv N bits : Nat) (h_sizing : CircuitSizing N bits)
    (h_N_ge_2 : 2 ≤ N) (h_inv : a * ainv % N = 1) :
    verifiedSqirModMulFamily a ainv N bits h_sizing h_N_ge_2 h_inv
      = verifiedSqirModMulFamily_via_interfaces a ainv N bits
          h_sizing h_N_ge_2 h_inv

abbrev ShorSetting

abbrev CircuitSizing

theorem ofBasicSetting {a r N m n : Nat}
    (h : FormalRV.SQIRPort.BasicSetting a r N m n) :
    ShorSetting a r N m n

theorem a_pos {a r N m n : Nat} (h : ShorSetting a r N m n) : 0 < a

theorem a_lt {a r N m n : Nat} (h : ShorSetting a r N m n) : a < N

theorem order {a r N m n : Nat} (h : ShorSetting a r N m n) :
    FormalRV.SQIRPort.Order a r N

theorem Nsq_lt {a r N m n : Nat} (h : ShorSetting a r N m n) : N^2 < 2^m

theorem pow_le_two_Nsq {a r N m n : Nat} (h : ShorSetting a r N m n) :
    2^m ≤ 2 * N^2

theorem N_lt_pow_n {a r N m n : Nat} (h : ShorSetting a r N m n) : N < 2^n

theorem N_le_pow_n {a r N m n : Nat} (h : ShorSetting a r N m n) : N ≤ 2^n

theorem N_pos {a r N m n : Nat} (h : ShorSetting a r N m n) : 0 < N

def ancillaWidth (bits : Nat) : Nat

def totalDim (bits : Nat) : Nat

def gateMCP (bits N a ainv : Nat) : Gate

theorem gateMCP_apply_encode
    (bits N a ainv x : Nat) (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_ainv_le : ainv ≤ N) (hx : x < N) (h_inv : (a * ainv) % N = 1) :
    Gate.applyNat (gateMCP bits N a ainv)
        (encodeDataZeroAnc bits (ancillaWidth bits) x)
      = encodeDataZeroAnc bits (ancillaWidth bits) ((a * x) % N)

theorem gateMCP_wellTyped
    (bits N a ainv : Nat) (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits) :
    Gate.WellTyped (totalDim bits) (gateMCP bits N a ainv)

theorem satisfiesMultiplyCircuitProperty
    (bits N a ainv : Nat) (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_ainv_le : ainv ≤ N) (h_inv : (a * ainv) % N = 1) :
    MultiplyCircuitProperty a N bits (ancillaWidth bits)
      (Gate.toUCom (totalDim bits) (gateMCP bits N a ainv))

noncomputable def circuitFamily (a ainv N bits : Nat) :
    Nat → BaseUCom (bits + ancillaWidth bits)

theorem circuitFamily_modMulImpl
    (a ainv N bits : Nat) (hbits : 1 ≤ bits) (hN_ge_2 : 2 ≤ N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits) (h_inv : a * ainv % N = 1) :
    ModMulImpl a N bits (ancillaWidth bits)
      (circuitFamily a ainv N bits)

theorem circuitFamily_perIterate
    (a ainv N bits i : Nat) (hbits : 1 ≤ bits) (hN_ge_2 : 2 ≤ N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_inv : a * ainv % N = 1) :
    MultiplyCircuitProperty (a^(2^i)) N bits (ancillaWidth bits)
      (circuitFamily a ainv N bits i)

theorem circuitFamily_wellTyped
    (a ainv N bits : Nat) (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits) :
    ∀ i, uc_well_typed (circuitFamily a ainv N bits i)

theorem satisfiesMultiplyCircuitProperty_real_via_interfaces
    (bits N a ainv : Nat) (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (h_ainv_le : ainv ≤ N) (h_inv : (a * ainv) % N = 1) :
    MultiplyCircuitProperty a N bits (ancillaWidth bits)
      (Gate.toUCom (totalDim bits) (gateMCP bits N a ainv))

theorem circuitFamily_modMulImpl_real_via_interfaces
    (a ainv N bits : Nat) (hbits : 1 ≤ bits) (hN_ge_2 : 2 ≤ N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits) (h_inv : a * ainv % N = 1) :
    ModMulImpl a N bits (ancillaWidth bits)
      (circuitFamily a ainv N bits)

theorem shorCorrect
    {a N bits anc : Nat} (F : VerifiedModMulFamily a N bits anc)
    (r m : Nat) (h_setting : ShorSetting a r N m bits) :
    FormalRV.SQIRPort.probability_of_success a r N m bits anc F.family
      ≥ FormalRV.SQIRPort.κ / (Nat.log2 N : ℝ)^4

def windowValue (m w k : Nat) : Nat

def numWindows (bits w : Nat) : Nat

def tableValue (a N w k v : Nat) : Nat

def windowedStepSpec (a N w k acc v : Nat) : Nat

theorem windowValue_lt (m w k : Nat) (_hw : 0 < w) :
    windowValue m w k < 2^w

theorem tableValue_lt_N (a N w k v : Nat) (hN_pos : 0 < N) :
    tableValue a N w k v < N

theorem windowedStepSpec_lt_N (a N w k acc v : Nat) (hN_pos : 0 < N) :
    windowedStepSpec a N w k acc v < N

theorem tableValue_zero (a N w k : Nat) :
    tableValue a N w k 0 = 0

theorem windowedStepSpec_zero (a N w k acc : Nat) :
    windowedStepSpec a N w k acc 0 = acc % N

theorem windowValue_zero (m w : Nat) :
    windowValue m w 0 = m % 2^w

theorem windowValue_w_zero (m k : Nat) :
    windowValue m 0 k = 0

structure WindowLayout

structure LookupTableImpl

structure WindowedLookupModMulSpec (a N : Nat)

def identityLookupTable : LookupTableImpl

def trivialSpec (a N : Nat) : WindowedLookupModMulSpec a N

noncomputable def toyWindow2Case3Gate
    (bits N a k : Nat) (flagIdx b0Idx b1Idx : Nat) : Gate

def toyWindow2Case3Input
    (acc : Nat) (b0Idx b1Idx : Nat) (b0 b1 : Bool) : Nat → Bool

structure Window2LookupCase3Spec (a N : Nat)

theorem tableValue_window2_v3_eq (a N k : Nat) :
    tableValue a N 2 k 3 = (a * 2^(k * 2) * 3) % N

theorem windowedStepSpec_window2_v3
    (a N k acc : Nat) (_hN_pos : 0 < N) :
    windowedStepSpec a N 2 k acc 3 = (acc + tableValue a N 2 k 3) % N

theorem toyWindow2Case3Gate_correct
    (bits N a k acc flagIdx b0Idx b1Idx : Nat) (b0 b1 : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    cuccaro_target_val bits 2
        (Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)

noncomputable def toyWindow2Case3SpecImpl (a N : Nat) :
    Window2LookupCase3Spec a N

theorem tableValue_window2_v1_eq (a N k : Nat) :
    tableValue a N 2 k 1 = (a * 2^(k * 2) * 1) % N

theorem tableValue_window2_v2_eq (a N k : Nat) :
    tableValue a N 2 k 2 = (a * 2^(k * 2) * 2) % N

theorem windowedStepSpec_window2_v1
    (a N k acc : Nat) (_hN_pos : 0 < N) :
    windowedStepSpec a N 2 k acc 1 = (acc + tableValue a N 2 k 1) % N

theorem windowedStepSpec_window2_v2
    (a N k acc : Nat) (_hN_pos : 0 < N) :
    windowedStepSpec a N 2 k acc 2 = (acc + tableValue a N 2 k 2) % N

noncomputable def toyWindow2Case1Gate
    (bits N a k : Nat) (flagIdx b0Idx b1Idx : Nat) : Gate

noncomputable def toyWindow2Case2Gate
    (bits N a k : Nat) (flagIdx b0Idx b1Idx : Nat) : Gate

theorem toyWindow2Case1Gate_correct
    (bits N a k acc flagIdx b0Idx b1Idx : Nat) (b0 b1 : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    cuccaro_target_val bits 2
        (Gate.applyNat (toyWindow2Case1Gate bits N a k flagIdx b0Idx b1Idx)

theorem toyWindow2Case2Gate_correct
    (bits N a k acc flagIdx b0Idx b1Idx : Nat) (b0 b1 : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    cuccaro_target_val bits 2
        (Gate.applyNat (toyWindow2Case2Gate bits N a k flagIdx b0Idx b1Idx)

noncomputable def toyWindow2SelectedAddGate
    (bits N a k : Nat) (flagIdx b0Idx b1Idx : Nat) : Gate

theorem windowedStepSpec_window2_v0
    (a N k acc : Nat) (_hN_pos : 0 < N) (hacc : acc < N) :
    windowedStepSpec a N 2 k acc 0 = acc

theorem toyWindow2Case3Gate_preserves_b0Idx
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true true) b0Idx = true

theorem toyWindow2Case3Gate_restores_flagIdx
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true true) flagIdx = false

theorem toyWindow2Case3Gate_preserves_b1Idx
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true true) b1Idx = true

theorem toyWindow2Case3Gate_internalFlagFalse
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true true) 1 = false

theorem toyWindow2Case3Gate_carryInRestored
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true true) 2 = false

theorem toyWindow2Case3Gate_topCarryFalse
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true true) (2 + 2 * bits) = false

theorem toyWindow2Case3Gate_readVal
    (bits N a k acc flagIdx b0Idx b1Idx : Nat) (b0 b1 : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    cuccaro_read_val bits 2
        (Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)

theorem toyWindow2Case3Gate_targetBit
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx)
    (i : Nat) (hi : i < bits) :
    Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)

theorem toyWindow2Case3Gate_readBit
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx)
    (i : Nat) (hi : i < bits) :
    Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)

theorem toyWindow2Case3Gate_aboveLayoutFalse
    (bits N a k acc flagIdx b0Idx b1Idx q : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx)
    (hq_above : 2 + 2 * bits + 1 ≤ q)
    (hq_ne_b0 : q ≠ b0Idx) (hq_ne_b1 : q ≠ b1Idx) (hq_ne_flag : q ≠ flagIdx) :

theorem toyWindow2Case3Gate_state_eq
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true true)

theorem toyWindow2Case1Gate_readVal
    (bits N a k acc flagIdx b0Idx b1Idx : Nat) (b0 b1 : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    cuccaro_read_val bits 2
        (Gate.applyNat (toyWindow2Case1Gate bits N a k flagIdx b0Idx b1Idx)

theorem toyWindow2Case1Gate_aboveLayoutFalse
    (bits N a k acc flagIdx b0Idx b1Idx q : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx)
    (hq_above : 2 + 2 * bits + 1 ≤ q)
    (hq_ne_b0 : q ≠ b0Idx) (hq_ne_b1 : q ≠ b1Idx) (hq_ne_flag : q ≠ flagIdx) :

theorem toyWindow2Case1Gate_preserves_b0Idx
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case1Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true false) b0Idx = true

theorem toyWindow2Case1Gate_targetBit
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx)
    (i : Nat) (hi : i < bits) :
    Gate.applyNat (toyWindow2Case1Gate bits N a k flagIdx b0Idx b1Idx)

theorem toyWindow2Case1Gate_readBit
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx)
    (i : Nat) (hi : i < bits) :
    Gate.applyNat (toyWindow2Case1Gate bits N a k flagIdx b0Idx b1Idx)

theorem toyWindow2Case1Gate_preserves_b1Idx
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case1Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true false) b1Idx = false

theorem toyWindow2Case1Gate_internalFlagFalse
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case1Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true false) 1 = false

theorem toyWindow2Case1Gate_carryInRestored
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case1Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true false) 2 = false

theorem toyWindow2Case1Gate_restores_flagIdx
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case1Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true false) flagIdx = false

theorem toyWindow2Case1Gate_state_eq
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case1Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true false)

theorem toyWindow2Case2Gate_readVal
    (bits N a k acc flagIdx b0Idx b1Idx : Nat) (b0 b1 : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    cuccaro_read_val bits 2
        (Gate.applyNat (toyWindow2Case2Gate bits N a k flagIdx b0Idx b1Idx)

theorem toyWindow2Case2Gate_aboveLayoutFalse
    (bits N a k acc flagIdx b0Idx b1Idx q : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx)
    (hq_above : 2 + 2 * bits + 1 ≤ q)
    (hq_ne_b0 : q ≠ b0Idx) (hq_ne_b1 : q ≠ b1Idx) (hq_ne_flag : q ≠ flagIdx) :

theorem toyWindow2Case2Gate_preserves_b0Idx
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case2Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx false true) b0Idx = false

theorem toyWindow2Case2Gate_preserves_b1Idx
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case2Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx false true) b1Idx = true

theorem toyWindow2Case2Gate_restores_flagIdx
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case2Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx false true) flagIdx = false

theorem correct
    (a r N m ainv : Nat)
    (h_setting : ShorSetting a r N m (canonicalBits N))
    (h_inv : a * ainv % N = 1) :
    FormalRV.SQIRPort.probability_of_success a r N m (canonicalBits N)
      (FormalRV.BQAlgo.sqir_modmult_rev_anc (canonicalBits N))
      (FormalRV.BQAlgo.f_modmult_circuit_verified_bits a ainv N (canonicalBits N))
      ≥ FormalRV.SQIRPort.κ / (Nat.log2 N : ℝ)^4

theorem correct_general
    (a r N m bits ainv : Nat)
    (h_setting : ShorSetting a r N m bits)
    (h_sizing : CircuitSizing N bits)
    (h_inv : a * ainv % N = 1) :
    FormalRV.SQIRPort.probability_of_success a r N m bits
      (FormalRV.BQAlgo.sqir_modmult_rev_anc bits)
      (FormalRV.BQAlgo.f_modmult_circuit_verified_bits a ainv N bits)
      ≥ FormalRV.SQIRPort.κ / (Nat.log2 N : ℝ)^4

theorem correct_parametric
    (a r N m n anc : Nat) (u : Nat → FormalRV.SQIRPort.BaseUCom (n + anc))
    (h_setting : ShorSetting a r N m n)
    (h_modmul : FormalRV.SQIRPort.ModMulImpl a N n anc u)
    (h_wt : ∀ i, i < m → FormalRV.SQIRPort.uc_well_typed (u i)) :
    FormalRV.SQIRPort.probability_of_success a r N m n anc u
      ≥ FormalRV.SQIRPort.κ / (Nat.log2 N : ℝ)^4

structure VerifiedModMulFamily (a N bits anc : Nat)

theorem toyWindow2Case2Gate_internalFlagFalse
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case2Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx false true) 1 = false

theorem toyWindow2Case2Gate_carryInRestored
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case2Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx false true) 2 = false

theorem toyWindow2Case2Gate_targetBit
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx)
    (i : Nat) (hi : i < bits) :
    Gate.applyNat (toyWindow2Case2Gate bits N a k flagIdx b0Idx b1Idx)

theorem toyWindow2Case2Gate_readBit
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx)
    (i : Nat) (hi : i < bits) :
    Gate.applyNat (toyWindow2Case2Gate bits N a k flagIdx b0Idx b1Idx)

theorem toyWindow2Case2Gate_state_eq
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case2Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx false true)

theorem toyWindow2Case1Gate_state_eq_TT_noop
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case1Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true true)

theorem toyWindow2Case1Gate_state_eq_FT_noop
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case1Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx false true)

theorem toyWindow2Case1Gate_state_eq_FF_noop
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case1Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx false false)

theorem windowed2Input_qstart_zero_at_disjoint
    (q_start : Nat) (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (numWin q : Nat)
    (h_base : cuccaro_input_F q_start false 0 0 q = false)
    (h_b0_disj : ∀ k, k < numWin → q ≠ b0Idx k)
    (h_b1_disj : ∀ k, k < numWin → q ≠ b1Idx k) :
    windowed2Input_qstart q_start 0 b0Idx b1Idx b0 b1 numWin q = false

theorem windowed2Input_qstart_read_b0_bounded
    (q_start acc : Nat) (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (numWin k : Nat) (hk : k < numWin)
    (h_b0_ne_b1 : ∀ j, j < numWin → b0Idx j ≠ b1Idx j)
    (h_distinct_b0_b0 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b0Idx i ≠ b0Idx j)
    (h_distinct_b0_b1 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b0Idx i ≠ b1Idx j) :
    windowed2Input_qstart q_start acc b0Idx b1Idx b0 b1 numWin (b0Idx k)
      = b0 k

theorem windowed2Input_qstart_read_b1_bounded
    (q_start acc : Nat) (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (numWin k : Nat) (hk : k < numWin)
    (h_distinct_b0_b1 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b0Idx i ≠ b1Idx j)
    (h_distinct_b1_b1 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b1Idx i ≠ b1Idx j) :
    windowed2Input_qstart q_start acc b0Idx b1Idx b0 b1 numWin (b1Idx k)
      = b1 k

theorem shifted_cuccaro_b_pos_ge
    (bits k : Nat) :
    bits + 1 ≤ bits + 2 * k + 1

theorem shifted_cuccaro_b_above_data
    (bits k : Nat) :
    bits ≤ bits + 2 * k + 1

theorem shifted_cuccaro_b_ne_data
    (bits k q : Nat) (h_q : q < bits) :
    bits + 2 * k + 1 ≠ q

theorem data_ne_shifted_cuccaro_b
    (bits k q : Nat) (h_q : q < bits) :
    q ≠ bits + 2 * k + 1

theorem shifted_swap_src_ne_dst
    (bits k : Nat) (h_k : k < bits) :
    bits + 2 * k + 1 ≠ bits - 1 - k

theorem sqir_modAdd_qstart_commute_update_disjoint
    (bits q_start N c controlIdx flagPos updateIdx : Nat) (v : Bool)
    (f : Nat → Bool)
    (hupdate_out :
      updateIdx < q_start ∨ q_start + 2 * bits + 1 ≤ updateIdx)
    (hupdate_ne_flag : updateIdx ≠ flagPos)
    (hupdate_ne_control : updateIdx ≠ controlIdx) :
    Gate.applyNat
        (sqir_style_controlledModAddConst_gate bits q_start N c controlIdx flagPos)
        (update f updateIdx v)
      = update (Gate.applyNat
          (sqir_style_controlledModAddConst_gate bits q_start N c controlIdx flagPos)

noncomputable def toyWindow2Case3Gate_qstart
    (bits q_start N a k : Nat)
    (flagIdx flagPos b0Idx b1Idx : Nat) : Gate

noncomputable def toyWindow2Case1Gate_qstart
    (bits q_start N a k : Nat)
    (flagIdx flagPos b0Idx b1Idx : Nat) : Gate

noncomputable def toyWindow2Case2Gate_qstart
    (bits q_start N a k : Nat)
    (flagIdx flagPos b0Idx b1Idx : Nat) : Gate

noncomputable def toyWindow2SelectedAddGate_qstart
    (bits q_start N a k : Nat)
    (flagIdx flagPos b0Idx b1Idx : Nat) : Gate

theorem toyWindow2Case3Gate_qstart_commute_update_disjoint
    (bits q_start N a k flagIdx flagPos b0Idx b1Idx p : Nat)
    (v : Bool) (s : Nat → Bool)
    (hp_disj_workspace :
      p < q_start ∨ q_start + 2 * bits + 1 ≤ p)
    (hp_ne_flag : p ≠ flagIdx)
    (hp_ne_flagPos : p ≠ flagPos)
    (hp_ne_b0 : p ≠ b0Idx)
    (hp_ne_b1 : p ≠ b1Idx) :
    Gate.applyNat
        (toyWindow2Case3Gate_qstart bits q_start N a k flagIdx flagPos b0Idx b1Idx)
        (update s p v)

theorem toyWindow2Case1Gate_qstart_commute_update_disjoint
    (bits q_start N a k flagIdx flagPos b0Idx b1Idx p : Nat)
    (v : Bool) (s : Nat → Bool)
    (hp_disj_workspace :
      p < q_start ∨ q_start + 2 * bits + 1 ≤ p)
    (hp_ne_flag : p ≠ flagIdx)
    (hp_ne_flagPos : p ≠ flagPos)
    (hp_ne_b0 : p ≠ b0Idx)
    (hp_ne_b1 : p ≠ b1Idx) :
    Gate.applyNat
        (toyWindow2Case1Gate_qstart bits q_start N a k flagIdx flagPos b0Idx b1Idx)
        (update s p v)

theorem toyWindow2Case2Gate_qstart_commute_update_disjoint
    (bits q_start N a k flagIdx flagPos b0Idx b1Idx p : Nat)
    (v : Bool) (s : Nat → Bool)
    (hp_disj_workspace :
      p < q_start ∨ q_start + 2 * bits + 1 ≤ p)
    (hp_ne_flag : p ≠ flagIdx)
    (hp_ne_flagPos : p ≠ flagPos)
    (hp_ne_b0 : p ≠ b0Idx)
    (hp_ne_b1 : p ≠ b1Idx) :
    Gate.applyNat
        (toyWindow2Case2Gate_qstart bits q_start N a k flagIdx flagPos b0Idx b1Idx)
        (update s p v)

theorem toyWindow2SelectedAddGate_qstart_commute_update_disjoint
    (bits q_start N a k flagIdx flagPos b0Idx b1Idx p : Nat)
    (v : Bool) (s : Nat → Bool)
    (hp_disj_workspace :
      p < q_start ∨ q_start + 2 * bits + 1 ≤ p)
    (hp_ne_flag : p ≠ flagIdx)
    (hp_ne_flagPos : p ≠ flagPos)
    (hp_ne_b0 : p ≠ b0Idx)
    (hp_ne_b1 : p ≠ b1Idx) :
    Gate.applyNat
        (toyWindow2SelectedAddGate_qstart bits q_start N a k flagIdx flagPos b0Idx b1Idx)
        (update s p v)

theorem toyWindow2SelectedAddGate_qstart_commute_update_data_disjoint
    (bits N a k flagIdx flagPos b0Idx b1Idx p : Nat)
    (v : Bool) (s : Nat → Bool)
    (hp_data : p < bits)
    (hp_ne_flag : p ≠ flagIdx)
    (hp_ne_flagPos : p ≠ flagPos)
    (hp_ne_b0 : p ≠ b0Idx)
    (hp_ne_b1 : p ≠ b1Idx) :
    Gate.applyNat
        (toyWindow2SelectedAddGate_qstart bits bits N a k flagIdx flagPos b0Idx b1Idx)
        (update s p v)
      = update (Gate.applyNat

def gidneyB0Idx (bits k : Nat) : Nat

def gidneyB1Idx (bits k : Nat) : Nat

def gidneyFlagPos (bits : Nat) : Nat

def gidneyComputeInput (bits x acc : Nat) : Nat → Bool

theorem gidneyComputeInput_data (bits x acc q : Nat) (hq : q < bits) :
    gidneyComputeInput bits x acc q = x.testBit (bits - 1 - q)

theorem gidneyComputeInput_b0 (bits x acc k : Nat)
    (hwin : 2 * k + 1 < bits) :
    gidneyComputeInput bits x acc (gidneyB0Idx bits k) = x.testBit (2 * k)

theorem gidneyComputeInput_b1 (bits x acc k : Nat)
    (hwin : 2 * k + 1 < bits) :
    gidneyComputeInput bits x acc (gidneyB1Idx bits k) = x.testBit (2 * k + 1)

theorem gidneyComputeInput_at_flagPos (bits x acc : Nat)
    (hbits : 1 ≤ bits) (hacc_lt : acc < 2^bits) :
    gidneyComputeInput bits x acc (gidneyFlagPos bits) = false

theorem gidneyB0_lt_bits (bits k : Nat) (hwin : 2 * k + 1 < bits) :
    gidneyB0Idx bits k < bits

theorem gidneyB1_lt_bits (bits k : Nat) (hwin : 2 * k + 1 < bits) :
    gidneyB1Idx bits k < bits

theorem gidneyB0_ne_gidneyB1 (bits k : Nat) (hwin : 2 * k + 1 < bits) :
    gidneyB0Idx bits k ≠ gidneyB1Idx bits k

theorem gidneyFlag_above_workspace (bits : Nat) :
    bits + 2 * bits + 1 ≤ gidneyFlagPos bits

theorem gidneyFlag_ne_data (bits q : Nat) (hq : q < bits) :
    q ≠ gidneyFlagPos bits

theorem gidneyFlagPos_ne_gidneyB0 (bits k : Nat)
    (hwin : 2 * k + 1 < bits) :
    gidneyFlagPos bits ≠ gidneyB0Idx bits k

theorem gidneyFlagPos_ne_gidneyB1 (bits k : Nat)
    (hwin : 2 * k + 1 < bits) :
    gidneyFlagPos bits ≠ gidneyB1Idx bits k

theorem toyWindow2SelectedAddGate_qstart_preserves_data_at_disjoint
    (bits N a k acc x q : Nat)
    (hwin : 2 * k + 1 < bits)
    (hq : q < bits)
    (hq_ne_b0 : q ≠ gidneyB0Idx bits k)
    (hq_ne_b1 : q ≠ gidneyB1Idx bits k) :
    Gate.applyNat
        (toyWindow2SelectedAddGate_qstart bits bits N a k
          (gidneyFlagPos bits) (gidneyFlagPos bits)
          (gidneyB0Idx bits k) (gidneyB1Idx bits k))
        (gidneyComputeInput bits x acc) q
      = gidneyComputeInput bits x acc q

theorem toyWindow2SelectedAddGate_qstart_preserves_data_outside_window
    (bits N a k acc x q : Nat)
    (hwin : 2 * k + 1 < bits)
    (hq : q < bits)
    (h_outside : q < bits - 1 - (2 * k + 1) ∨ bits - 1 - 2 * k < q) :
    Gate.applyNat
        (toyWindow2SelectedAddGate_qstart bits bits N a k
          (gidneyFlagPos bits) (gidneyFlagPos bits)
          (gidneyB0Idx bits k) (gidneyB1Idx bits k))
        (gidneyComputeInput bits x acc) q
      = gidneyComputeInput bits x acc q

theorem sqir_modAdd_qstart_preserves_at_outside
    (bits q_start N c controlIdx flagPos q : Nat) (s : Nat → Bool)
    (h_q_outside :
      q < q_start ∨ q_start + 2 * bits + 1 ≤ q)
    (h_q_ne_flag : q ≠ flagPos)
    (h_q_ne_control : q ≠ controlIdx) :
    Gate.applyNat
        (sqir_style_controlledModAddConst_gate bits q_start N c controlIdx flagPos) s q
      = s q

theorem mod_add_above_layout_noop_on_F_qstart
    (bits q_start N c flagPos acc q : Nat)
    (hacc : acc < 2^bits)
    (h_q_above : q_start + 2 * bits + 1 ≤ q)
    (h_q_ne_flag : q ≠ flagPos) :
    Gate.applyNat
        (sqir_style_controlledModAddConst_gate bits q_start N c flagPos flagPos)
        (cuccaro_input_F q_start false 0 acc) q
      = false

theorem sqir_modAdd_qstart_preserves_data_on_gidneyComputeInput
    (bits N c x acc q : Nat)
    (hq : q < bits) :
    Gate.applyNat
        (sqir_style_controlledModAddConst_gate
          bits bits N c (gidneyFlagPos bits) (gidneyFlagPos bits))
        (gidneyComputeInput bits x acc) q
      = gidneyComputeInput bits x acc q

theorem sqir_modAdd_qstart_preserves_above_flag_on_gidneyComputeInput
    (bits N c x acc q : Nat)
    (h_q_above : gidneyFlagPos bits < q) :
    Gate.applyNat
        (sqir_style_controlledModAddConst_gate
          bits bits N c (gidneyFlagPos bits) (gidneyFlagPos bits))
        (gidneyComputeInput bits x acc) q
      = gidneyComputeInput bits x acc q

theorem sqir_style_controlledModAddConst_gate_qstart_zero_noop
    (bits q_start N controlIdx flagPos : Nat) (s : Nat → Bool) :
    Gate.applyNat
        (sqir_style_controlledModAddConst_gate bits q_start N 0 controlIdx flagPos) s
      = s

def gidneyFlagPos' (bits : Nat) : Nat

theorem gidneyFlagPos'_ne_gidneyFlagPos (bits : Nat) :
    gidneyFlagPos' bits ≠ gidneyFlagPos bits

theorem gidneyFlagPos'_above_workspace (bits : Nat) :
    bits + 2 * bits + 1 ≤ gidneyFlagPos' bits

theorem sqir_style_controlledModAddConst_candidate_target_decode_control_false_gidney
    (bits N c x : Nat)
    (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hc_pos : 0 < c) (hc : c < N) (hx : x < N) :
    cuccaro_target_val bits bits
        (Gate.applyNat
          (sqir_style_controlledModAddConst_candidate bits bits N c
            (gidneyFlagPos' bits) (gidneyFlagPos bits))
          (update (cuccaro_input_F bits false 0 x) (gidneyFlagPos' bits) false))
      = x

theorem sqir_style_controlledModAddConst_candidate_workspace_control_false_gidney
    (bits N c x : Nat)
    (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hc_pos : 0 < c) (hc : c < N) (hx : x < N) :
    cuccaro_read_val bits bits
          (Gate.applyNat
            (sqir_style_controlledModAddConst_candidate bits bits N c
              (gidneyFlagPos' bits) (gidneyFlagPos bits))
            (update (cuccaro_input_F bits false 0 x) (gidneyFlagPos' bits) false))
        = 0
    ∧ Gate.applyNat

theorem sqir_style_controlledModAddConst_candidate_clean_control_false_gidney
    (bits N c x dim : Nat)
    (hbits : 1 ≤ bits)
    (hN_pos : 0 < N) (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hc_pos : 0 < c) (hc : c < N) (hx : x < N)
    (h_workspace : bits + 2 * bits + 1 ≤ dim)
    (h_flagPos'_lt_dim : gidneyFlagPos' bits < dim)
    (h_flagPos_lt_dim  : gidneyFlagPos bits  < dim) :
    Gate.WellTyped dim
        (sqir_style_controlledModAddConst_candidate bits bits N c
          (gidneyFlagPos' bits) (gidneyFlagPos bits))
    ∧ cuccaro_target_val bits bits

theorem toyWindow2SelectedAddGate_commute_update_inactive
    (bits N a k flagIdx b0Idx b1Idx p : Nat) (v : Bool) (s : Nat → Bool)
    (hp_hi : 2 + 2 * bits + 1 ≤ p)
    (hp_ne_b0 : p ≠ b0Idx)
    (hp_ne_b1 : p ≠ b1Idx)
    (hp_ne_flag : p ≠ flagIdx) :
    Gate.applyNat (toyWindow2SelectedAddGate bits N a k flagIdx b0Idx b1Idx)
        (update s p v)
      = update
          (Gate.applyNat
            (toyWindow2SelectedAddGate bits N a k flagIdx b0Idx b1Idx) s)
          p v

theorem toyWindow2SelectedAddGate_active_extended
    (bits N a acc flagIdx k : Nat)
    (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2)
    (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_hi0 : ∀ i, i ≤ k → 2 + 2 * bits + 1 ≤ b0Idx i)
    (h_hi1 : ∀ i, i ≤ k → 2 + 2 * bits + 1 ≤ b1Idx i)
    (h_b0_ne_b1 : ∀ i, i ≤ k → b0Idx i ≠ b1Idx i)

theorem toyWindow2SelectedAddGate_on_windowed2Input
    (bits N a k acc flagIdx numWin : Nat)
    (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (hk : k < numWin)
    (h_flag_lo : flagIdx < 2)
    (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_hi0 : ∀ i, i < numWin → 2 + 2 * bits + 1 ≤ b0Idx i)
    (h_hi1 : ∀ i, i < numWin → 2 + 2 * bits + 1 ≤ b1Idx i)

noncomputable def verifiedSqirModMulFamily_real_via_interfaces
    (a ainv N bits : Nat) (h_sizing : CircuitSizing N bits)
    (h_N_ge_2 : 2 ≤ N) (h_inv : a * ainv % N = 1) :
    VerifiedModMulFamily a N bits (ModMul.ancillaWidth bits)

theorem verifiedSqirModMulFamily_real_via_interfaces_eq
    (a ainv N bits : Nat) (h_sizing : CircuitSizing N bits)
    (h_N_ge_2 : 2 ≤ N) (h_inv : a * ainv % N = 1) :
    verifiedSqirModMulFamily a ainv N bits h_sizing h_N_ge_2 h_inv
      = verifiedSqirModMulFamily_real_via_interfaces a ainv N bits
          h_sizing h_N_ge_2 h_inv

theorem correct_general_via_real_interface
    {a N bits : Nat} (ainv : Nat)
    (r m : Nat) (h_setting : ShorSetting a r N m bits)
    (h_sizing : CircuitSizing N bits)
    (h_N_ge_2 : 2 ≤ N) (h_inv : a * ainv % N = 1) :
    FormalRV.SQIRPort.probability_of_success a r N m bits
        (ModMul.ancillaWidth bits)
        (verifiedSqirModMulFamily_real_via_interfaces a ainv N bits
          h_sizing h_N_ge_2 h_inv).family
      ≥ FormalRV.SQIRPort.κ / (Nat.log2 N : ℝ)^4

theorem ccx_guard_false_noop
    (b0Idx b1Idx flagIdx : Nat) (state : Nat → Bool)
    (h_guard : (state b0Idx && state b1Idx) = false) :
    Gate.applyNat (Gate.CCX b0Idx b1Idx flagIdx) state = state

theorem x_conjugate_noop
    (q : Nat) (gate : Gate) (state : Nat → Bool)
    (h_inner_noop : Gate.applyNat gate (update state q (!state q))
                  = update state q (!state q)) :
    Gate.applyNat (Gate.seq (Gate.X q) (Gate.seq gate (Gate.X q))) state = state

theorem mod_add_above_layout_noop_on_F
    (bits N c acc flagIdx q : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hc : c < N) (hacc : acc < N)
    (h_flag_lo : flagIdx < 2)
    (hq_above : 2 + 2 * bits + 1 ≤ q) (hq_ne_flag : q ≠ flagIdx) :
    Gate.applyNat (sqir_style_controlledModAddConst_gate bits 2 N c flagIdx 1)
        (cuccaro_input_F 2 false 0 acc) q
      = false

theorem mod_add_state_eq_when_control_false_on_Case3Input
    (bits N c acc flagIdx b0Idx b1Idx : Nat) (b0 b1 : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hc : c < N) (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (sqir_style_controlledModAddConst_gate bits 2 N c flagIdx 1)
        (toyWindow2Case3Input acc b0Idx b1Idx b0 b1)

theorem toyWindow2Case1Gate_state_eq_unified
    (bits N a k acc flagIdx b0Idx b1Idx : Nat) (b0 b1 : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case1Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx b0 b1)

theorem toyWindow2Case2Gate_state_eq_TT_noop
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case2Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true true)

theorem toyWindow2Case2Gate_state_eq_TF_noop
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case2Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true false)

theorem toyWindow2Case2Gate_state_eq_FF_noop
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case2Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx false false)

theorem toyWindow2Case2Gate_state_eq_unified
    (bits N a k acc flagIdx b0Idx b1Idx : Nat) (b0 b1 : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case2Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx b0 b1)

theorem toyWindow2Case3Gate_state_eq_TF_noop
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx true false)

theorem toyWindow2Case3Gate_state_eq_FT_noop
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx false true)

theorem toyWindow2Case3Gate_state_eq_FF_noop
    (bits N a k acc flagIdx b0Idx b1Idx : Nat)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx false false)

theorem toyWindow2Case3Gate_state_eq_unified
    (bits N a k acc flagIdx b0Idx b1Idx : Nat) (b0 b1 : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2Case3Gate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx b0 b1)

theorem cuccaro_target_val_Case3Input
    (bits acc : Nat) (b0Idx b1Idx : Nat) (b0 b1 : Bool)
    (h_b0_out : b0Idx < 2 ∨ 2 + 2 * bits + 1 ≤ b0Idx)
    (h_b1_out : b1Idx < 2 ∨ 2 + 2 * bits + 1 ≤ b1Idx)
    (hacc_lt : acc < 2^bits) :
    cuccaro_target_val bits 2 (toyWindow2Case3Input acc b0Idx b1Idx b0 b1) = acc

theorem toyWindow2SelectedAddGate_correct
    (bits N a k acc flagIdx b0Idx b1Idx : Nat) (b0 b1 : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    cuccaro_target_val bits 2
        (Gate.applyNat (toyWindow2SelectedAddGate bits N a k flagIdx b0Idx b1Idx)

def windowBits2_to_v (b0 b1 : Bool) : Nat

theorem windowedStepSpec_window2_bool
    (a N k acc : Nat) (b0 b1 : Bool) (hN_pos : 0 < N) (hacc : acc < N) :
    windowedStepSpec a N 2 k acc (windowBits2_to_v b0 b1)
      = if b0 && b1 then (acc + tableValue a N 2 k 3) % N
        else if !b0 && b1 then (acc + tableValue a N 2 k 2) % N
        else if b0 && !b1 then (acc + tableValue a N 2 k 1) % N
        else acc

theorem toyWindow2SelectedAddGate_correct_spec
    (bits N a k acc flagIdx b0Idx b1Idx : Nat) (b0 b1 : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    cuccaro_target_val bits 2
        (Gate.applyNat (toyWindow2SelectedAddGate bits N a k flagIdx b0Idx b1Idx)

structure Window2SelectedAddSpec (a N : Nat)

noncomputable def toyWindow2SelectedAddSpecImpl (a N : Nat) :
    Window2SelectedAddSpec a N

def windowBits2_at (b0 b1 : Nat → Bool) (k : Nat) : Nat

theorem windowBits2_to_v_lt_4 (b0 b1 : Bool) :
    windowBits2_to_v b0 b1 < 4

theorem windowBits2_at_lt_4 (b0 b1 : Nat → Bool) (k : Nat) :
    windowBits2_at b0 b1 k < 4

def windowedStepSpecIter2
    (a N : Nat) (b0 b1 : Nat → Bool) : Nat → Nat → Nat
  | 0, acc => acc
  | n + 1, acc =>
      windowedStepSpec a N 2 n
        (windowedStepSpecIter2 a N b0 b1 n acc)
        (windowBits2_at b0 b1 n)

theorem windowedStepSpecIter2_lt_N
    (a N : Nat) (b0 b1 : Nat → Bool) (numWin acc : Nat)
    (hN_pos : 0 < N) (hacc : acc < N) :
    windowedStepSpecIter2 a N b0 b1 numWin acc < N

noncomputable def windowed2SelectedAddGate
    {a N : Nat} (impl : Window2SelectedAddSpec a N)
    (bits flagIdx : Nat) (b0Idx b1Idx : Nat → Nat) : Nat → Gate
  | 0 => Gate.I
  | n + 1 =>
      Gate.seq (windowed2SelectedAddGate impl bits flagIdx b0Idx b1Idx n)
        (impl.gate bits n flagIdx (b0Idx n) (b1Idx n))

theorem toyWindow2SelectedAddGate_state_eq_spec
    (bits N a k acc flagIdx b0Idx b1Idx : Nat) (b0 b1 : Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2) (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_b0_hi : 2 + 2 * bits + 1 ≤ b0Idx) (h_b1_hi : 2 + 2 * bits + 1 ≤ b1Idx)
    (h_b0_ne_b1 : b0Idx ≠ b1Idx)
    (h_b0_ne_flag : b0Idx ≠ flagIdx) (h_b1_ne_flag : b1Idx ≠ flagIdx) :
    Gate.applyNat (toyWindow2SelectedAddGate bits N a k flagIdx b0Idx b1Idx)
        (toyWindow2Case3Input acc b0Idx b1Idx b0 b1)

structure Window2SelectedAddStateSpec (a N : Nat)

noncomputable def Window2SelectedAddStateSpec.toSelectedAddSpec
    {a N : Nat} (impl : Window2SelectedAddStateSpec a N) :
    Window2SelectedAddSpec a N

noncomputable def toyWindow2SelectedAddStateSpecImpl (a N : Nat) :
    Window2SelectedAddStateSpec a N

def windowed2Input
    (acc : Nat) (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool) :
    Nat → (Nat → Bool)
  | 0 => cuccaro_input_F 2 false 0 acc
  | n + 1 =>
      update
        (update (windowed2Input acc b0Idx b1Idx b0 b1 n) (b0Idx n) (b0 n))
        (b1Idx n) (b1 n)

theorem windowed2Input_succ_read_b1
    (acc : Nat) (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool) (n : Nat) :
    windowed2Input acc b0Idx b1Idx b0 b1 (n + 1) (b1Idx n) = b1 n

theorem windowed2Input_succ_read_b0
    (acc : Nat) (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool) (n : Nat)
    (h_ne : b0Idx n ≠ b1Idx n) :
    windowed2Input acc b0Idx b1Idx b0 b1 (n + 1) (b0Idx n) = b0 n

theorem windowed2Input_read_b0
    (acc : Nat) (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (numWin k : Nat) (hk : k < numWin)
    (h_b0_distinct : ∀ i j, i ≠ j → b0Idx i ≠ b0Idx j)
    (h_b0_b1 : ∀ i j, b0Idx i ≠ b1Idx j) :
    windowed2Input acc b0Idx b1Idx b0 b1 numWin (b0Idx k) = b0 k

theorem windowed2Input_read_b1
    (acc : Nat) (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (numWin k : Nat) (hk : k < numWin)
    (h_b1_distinct : ∀ i j, i ≠ j → b1Idx i ≠ b1Idx j)
    (h_b0_b1 : ∀ i j, b0Idx i ≠ b1Idx j) :
    windowed2Input acc b0Idx b1Idx b0 b1 numWin (b1Idx k) = b1 k

theorem cuccaro_target_val_windowed2Input
    (bits acc : Nat) (b0Idx b1Idx : Nat → Nat)
    (b0 b1 : Nat → Bool) (numWin : Nat)
    (hacc_bits : acc < 2^bits)
    (h_hi0 : ∀ k, 2 + 2 * bits + 1 ≤ b0Idx k)
    (h_hi1 : ∀ k, 2 + 2 * bits + 1 ≤ b1Idx k) :
    cuccaro_target_val bits 2 (windowed2Input acc b0Idx b1Idx b0 b1 numWin)
      = acc

theorem windowed2Input_at_low
    (acc bits q : Nat) (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (numWin : Nat) (h_q_low : q < 2 + 2 * bits + 1)
    (h_hi0 : ∀ k, 2 + 2 * bits + 1 ≤ b0Idx k)
    (h_hi1 : ∀ k, 2 + 2 * bits + 1 ≤ b1Idx k) :
    windowed2Input acc b0Idx b1Idx b0 b1 numWin q
      = cuccaro_input_F 2 false 0 acc q

def windowed2Input_qstart
    (q_start acc : Nat) (b0Idx b1Idx : Nat → Nat)
    (b0 b1 : Nat → Bool) : Nat → (Nat → Bool)
  | 0 => cuccaro_input_F q_start false 0 acc
  | n + 1 =>
      update
        (update
          (windowed2Input_qstart q_start acc b0Idx b1Idx b0 b1 n)
          (b0Idx n) (b0 n))
        (b1Idx n) (b1 n)

theorem windowed2Input_eq_qstart_2
    (acc : Nat) (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (numWin : Nat) :
    windowed2Input acc b0Idx b1Idx b0 b1 numWin
      = windowed2Input_qstart 2 acc b0Idx b1Idx b0 b1 numWin

theorem toyWindowed2SelectedAddGate_correct_prefix
    (bits N a flagIdx m totalWin acc : Nat)
    (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (hm_le : m ≤ totalWin)
    (h_flag_lo : flagIdx < 2)
    (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_hi0 : ∀ i, i < totalWin → 2 + 2 * bits + 1 ≤ b0Idx i)
    (h_hi1 : ∀ i, i < totalWin → 2 + 2 * bits + 1 ≤ b1Idx i)

theorem toyWindowed2SelectedAddGate_correct
    (bits N a flagIdx numWin acc : Nat)
    (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2)
    (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_hi0 : ∀ i, i < numWin → 2 + 2 * bits + 1 ≤ b0Idx i)
    (h_hi1 : ∀ i, i < numWin → 2 + 2 * bits + 1 ≤ b1Idx i)
    (h_b0_ne_b1 : ∀ i, i < numWin → b0Idx i ≠ b1Idx i)

def windowed2Value (b0 b1 : Nat → Bool) : Nat → Nat
  | 0 => 0
  | n + 1 => windowed2Value b0 b1 n + windowBits2_at b0 b1 n * 2^(n * 2)

def windowed2TableSum
    (a N : Nat) (b0 b1 : Nat → Bool) : Nat → Nat
  | 0 => 0
  | n + 1 =>
      windowed2TableSum a N b0 b1 n + tableValue a N 2 n (windowBits2_at b0 b1 n)

theorem windowedStepSpecIter2_eq_acc_plus_tableSum_mod
    (a N : Nat) (b0 b1 : Nat → Bool) (numWin acc : Nat)
    (hN_pos : 0 < N) (hacc : acc < N) :
    windowedStepSpecIter2 a N b0 b1 numWin acc
      = (acc + windowed2TableSum a N b0 b1 numWin) % N

theorem windowed2TableSum_mod_eq_mul_windowed2Value_mod
    (a N : Nat) (b0 b1 : Nat → Bool) (numWin : Nat) :
    windowed2TableSum a N b0 b1 numWin % N
      = (a * windowed2Value b0 b1 numWin) % N

theorem windowedStepSpecIter2_eq_mul_mod
    (a N : Nat) (b0 b1 : Nat → Bool) (numWin acc : Nat)
    (hN_pos : 0 < N) (hacc : acc < N) :
    windowedStepSpecIter2 a N b0 b1 numWin acc
      = (acc + a * windowed2Value b0 b1 numWin) % N

theorem cuccaro_target_val_windowed2Input_bounded
    (bits acc : Nat) (b0Idx b1Idx : Nat → Nat)
    (b0 b1 : Nat → Bool) (numWin : Nat)
    (hacc_bits : acc < 2^bits)
    (h_hi0 : ∀ k, k < numWin → 2 + 2 * bits + 1 ≤ b0Idx k)
    (h_hi1 : ∀ k, k < numWin → 2 + 2 * bits + 1 ≤ b1Idx k) :
    cuccaro_target_val bits 2 (windowed2Input acc b0Idx b1Idx b0 b1 numWin)
      = acc

theorem toyWindowed2SelectedAddGate_target_mul_correct
    (bits N a flagIdx numWin acc : Nat)
    (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2)
    (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_hi0 : ∀ i, i < numWin → 2 + 2 * bits + 1 ≤ b0Idx i)
    (h_hi1 : ∀ i, i < numWin → 2 + 2 * bits + 1 ≤ b1Idx i)
    (h_b0_ne_b1 : ∀ i, i < numWin → b0Idx i ≠ b1Idx i)

theorem toyWindowed2SelectedAddGate_state_mul_correct
    (bits N a flagIdx numWin acc : Nat)
    (b0Idx b1Idx : Nat → Nat) (b0 b1 : Nat → Bool)
    (hbits : 1 ≤ bits) (hN_pos : 0 < N)
    (hN : N ≤ 2^bits) (hN2 : 2 * N ≤ 2^bits)
    (hacc : acc < N)
    (h_flag_lo : flagIdx < 2)
    (h_flag_ne_1 : flagIdx ≠ 1)
    (h_flag_lt_dim : flagIdx < sqir_modmult_rev_anc bits)
    (h_hi0 : ∀ i, i < numWin → 2 + 2 * bits + 1 ≤ b0Idx i)
    (h_hi1 : ∀ i, i < numWin → 2 + 2 * bits + 1 ≤ b1Idx i)
    (h_b0_ne_b1 : ∀ i, i < numWin → b0Idx i ≠ b1Idx i)

structure Window2MulAddSpec (a N : Nat)

noncomputable def toyWindow2MulAddSpecImpl (a N : Nat) :
    Window2MulAddSpec a N

def windowed2_b0_of_x (x : Nat) : Nat → Bool

def windowed2_b1_of_x (x : Nat) : Nat → Bool

theorem two_pow_two_mul (k : Nat) : 2^(2 * k) = 4^k

theorem windowBits2_at_of_x (x k : Nat) :
    windowBits2_at (windowed2_b0_of_x x) (windowed2_b1_of_x x) k
      = (x / 4^k) % 4

theorem windowed2Value_of_x_mod (x numWin : Nat) :
    windowed2Value (windowed2_b0_of_x x) (windowed2_b1_of_x x) numWin
      = x % 2^(2 * numWin)

noncomputable def windowedLoadAdapter
    (bits : Nat) (b0Idx b1Idx : Nat → Nat) : Nat → Gate
  | 0 => Gate.I
  | n + 1 =>
      Gate.seq
        (windowedLoadAdapter bits b0Idx b1Idx n)
        (Gate.seq
          (Gate.CX (bits - 1 - 2 * n) (b0Idx n))
          (Gate.CX (bits - 1 - (2 * n + 1)) (b1Idx n)))

theorem windowedLoadAdapter_preserves_disjoint
    (bits : Nat) (b0Idx b1Idx : Nat → Nat) (p : Nat) (numWin : Nat)
    (f : Nat → Bool)
    (h_p_ne_b0 : ∀ k, k < numWin → p ≠ b0Idx k)
    (h_p_ne_b1 : ∀ k, k < numWin → p ≠ b1Idx k) :
    Gate.applyNat (windowedLoadAdapter bits b0Idx b1Idx numWin) f p = f p

def windowed2LoadedInput
    (bits anc x : Nat) (b0Idx b1Idx : Nat → Nat) :
    Nat → (Nat → Bool)
  | 0 => encodeDataZeroAnc bits anc x
  | n + 1 =>
      update
        (update (windowed2LoadedInput bits anc x b0Idx b1Idx n)
          (b0Idx n) (x.testBit (2 * n)))
        (b1Idx n) (x.testBit (2 * n + 1))

theorem windowed2LoadedInput_succ_read_b1
    (bits anc x : Nat) (b0Idx b1Idx : Nat → Nat) (n : Nat) :
    windowed2LoadedInput bits anc x b0Idx b1Idx (n + 1) (b1Idx n)
      = x.testBit (2 * n + 1)

theorem windowed2LoadedInput_succ_read_b0
    (bits anc x : Nat) (b0Idx b1Idx : Nat → Nat) (n : Nat)
    (h_ne : b0Idx n ≠ b1Idx n) :
    windowed2LoadedInput bits anc x b0Idx b1Idx (n + 1) (b0Idx n)
      = x.testBit (2 * n)

theorem windowed2LoadedInput_read_b0
    (bits anc x : Nat) (b0Idx b1Idx : Nat → Nat)
    (numWin k : Nat) (hk : k < numWin)
    (h_b0_distinct : ∀ i j, i ≠ j → b0Idx i ≠ b0Idx j)
    (h_b0_b1 : ∀ i j, b0Idx i ≠ b1Idx j) :
    windowed2LoadedInput bits anc x b0Idx b1Idx numWin (b0Idx k)
      = x.testBit (2 * k)

theorem windowed2LoadedInput_read_b1
    (bits anc x : Nat) (b0Idx b1Idx : Nat → Nat)
    (numWin k : Nat) (hk : k < numWin)
    (h_b1_distinct : ∀ i j, i ≠ j → b1Idx i ≠ b1Idx j)
    (h_b0_b1 : ∀ i j, b0Idx i ≠ b1Idx j) :
    windowed2LoadedInput bits anc x b0Idx b1Idx numWin (b1Idx k)
      = x.testBit (2 * k + 1)

theorem windowed2LoadedInput_at_disjoint
    (bits anc x : Nat) (b0Idx b1Idx : Nat → Nat)
    (numWin p : Nat)
    (h_p_ne_b0 : ∀ k, k < numWin → p ≠ b0Idx k)
    (h_p_ne_b1 : ∀ k, k < numWin → p ≠ b1Idx k) :
    windowed2LoadedInput bits anc x b0Idx b1Idx numWin p
      = encodeDataZeroAnc bits anc x p

noncomputable def windowedSwapLoadAdapter
    (bits : Nat) (b0Idx b1Idx : Nat → Nat) : Nat → Gate
  | 0 => Gate.I
  | n + 1 =>
      Gate.seq
        (windowedSwapLoadAdapter bits b0Idx b1Idx n)
        (Gate.seq
          (FormalRV.BQAlgo.qubit_swap (bits - 1 - 2 * n) (b0Idx n))
          (FormalRV.BQAlgo.qubit_swap (bits - 1 - (2 * n + 1)) (b1Idx n)))

theorem windowedSwapLoadAdapter_preserves_disjoint
    (bits : Nat) (b0Idx b1Idx : Nat → Nat) (p : Nat) (numWin : Nat)
    (f : Nat → Bool)
    (h_swap0_ne : ∀ k, k < numWin → bits - 1 - 2 * k ≠ b0Idx k)
    (h_swap1_ne : ∀ k, k < numWin → bits - 1 - (2 * k + 1) ≠ b1Idx k)
    (h_p_ne_src0 : ∀ k, k < numWin → p ≠ bits - 1 - 2 * k)
    (h_p_ne_src1 : ∀ k, k < numWin → p ≠ bits - 1 - (2 * k + 1))
    (h_p_ne_b0 : ∀ k, k < numWin → p ≠ b0Idx k)
    (h_p_ne_b1 : ∀ k, k < numWin → p ≠ b1Idx k) :
    Gate.applyNat (windowedSwapLoadAdapter bits b0Idx b1Idx numWin) f p
      = f p

theorem src0_lt_bits (bits k : Nat) (h : 2 * k < bits) :
    bits - 1 - 2 * k < bits

theorem src1_lt_bits (bits k : Nat) (h : 2 * k + 1 < bits) :
    bits - 1 - (2 * k + 1) < bits

theorem src0_ne_above (bits k b : Nat)
    (h_src : 2 * k < bits) (h_above : bits ≤ b) :
    bits - 1 - 2 * k ≠ b

theorem src1_ne_above (bits k b : Nat)
    (h_src : 2 * k + 1 < bits) (h_above : bits ≤ b) :
    bits - 1 - (2 * k + 1) ≠ b

theorem src0_ne_src1 (bits k : Nat)
    (h : 2 * k + 1 < bits) :
    bits - 1 - 2 * k ≠ bits - 1 - (2 * k + 1)

theorem testBit_eq_decide (x k : Nat) :
    x.testBit k = decide (x / 2^k % 2 = 1)

theorem nat_to_funbool_eq_testBit
    (n x i : Nat) :
    FormalRV.Framework.nat_to_funbool n x i = x.testBit (n - 1 - i)

theorem windowedSwapLoadAdapter_succ_read_b1
    (bits anc n x : Nat) (b0Idx b1Idx : Nat → Nat)
    (hx : x < 2^bits)
    (h_2n1_lt : 2 * n + 1 < bits)
    (h_b0n_above : bits ≤ b0Idx n)
    (h_b1n_above : bits ≤ b1Idx n)
    (h_prefix_b0_above : ∀ k, k < n → bits ≤ b0Idx k)
    (h_prefix_b1_above : ∀ k, k < n → bits ≤ b1Idx k) :
    Gate.applyNat (windowedSwapLoadAdapter bits b0Idx b1Idx (n + 1))
        (encodeDataZeroAnc bits anc x) (b1Idx n)
      = x.testBit (2 * n + 1)

theorem windowedSwapLoadAdapter_succ_read_b0
    (bits anc n x : Nat) (b0Idx b1Idx : Nat → Nat)
    (hx : x < 2^bits)
    (h_2n_lt : 2 * n < bits)
    (h_2n1_lt : 2 * n + 1 < bits)
    (h_b0n_above : bits ≤ b0Idx n)
    (h_b1n_above : bits ≤ b1Idx n)
    (h_b0n_ne_b1n : b0Idx n ≠ b1Idx n)
    (h_prefix_b0_above : ∀ k, k < n → bits ≤ b0Idx k)
    (h_prefix_b1_above : ∀ k, k < n → bits ≤ b1Idx k) :
    Gate.applyNat (windowedSwapLoadAdapter bits b0Idx b1Idx (n + 1))
        (encodeDataZeroAnc bits anc x) (b0Idx n)

theorem windowedSwapLoadAdapter_read_b1
    (bits anc x : Nat) (b0Idx b1Idx : Nat → Nat)
    (numWin k : Nat)
    (hx : x < 2^bits)
    (hk : k < numWin)
    (h_2numWin_le : 2 * numWin ≤ bits)
    (h_b0_above : ∀ j, j < numWin → bits ≤ b0Idx j)
    (h_b1_above : ∀ j, j < numWin → bits ≤ b1Idx j)
    (h_distinct_b1_b0 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b1Idx i ≠ b0Idx j)
    (h_distinct_b1_b1 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b1Idx i ≠ b1Idx j) :

theorem windowedSwapLoadAdapter_read_b0
    (bits anc x : Nat) (b0Idx b1Idx : Nat → Nat)
    (numWin k : Nat)
    (hx : x < 2^bits)
    (hk : k < numWin)
    (h_2numWin_le : 2 * numWin ≤ bits)
    (h_b0_above : ∀ j, j < numWin → bits ≤ b0Idx j)
    (h_b1_above : ∀ j, j < numWin → bits ≤ b1Idx j)
    (h_b0_ne_b1 : ∀ j, j < numWin → b0Idx j ≠ b1Idx j)
    (h_distinct_b0_b0 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b0Idx i ≠ b0Idx j)
    (h_distinct_b0_b1 :

theorem encodeDataZeroAnc_above
    (bits anc x q : Nat) (hx : x < 2^bits) (hq : bits ≤ q) (hanc_pos : 0 < anc) :
    encodeDataZeroAnc bits anc x q = false

theorem windowedSwapLoadAdapter_clears_data_even
    (bits anc x : Nat) (b0Idx b1Idx : Nat → Nat)
    (numWin k : Nat)
    (hx : x < 2^bits)
    (hk : k < numWin)
    (h_anc_pos : 0 < anc)
    (h_2numWin_le : 2 * numWin ≤ bits)
    (h_b0_above : ∀ j, j < numWin → bits ≤ b0Idx j)
    (h_b1_above : ∀ j, j < numWin → bits ≤ b1Idx j)
    (h_distinct_b0_b0 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b0Idx i ≠ b0Idx j)
    (h_distinct_b0_b1 :

theorem windowedSwapLoadAdapter_clears_data_odd
    (bits anc x : Nat) (b0Idx b1Idx : Nat → Nat)
    (numWin k : Nat)
    (hx : x < 2^bits)
    (hk : k < numWin)
    (h_anc_pos : 0 < anc)
    (h_2numWin_le : 2 * numWin ≤ bits)
    (h_b0_above : ∀ j, j < numWin → bits ≤ b0Idx j)
    (h_b1_above : ∀ j, j < numWin → bits ≤ b1Idx j)
    (h_b0_ne_b1 : ∀ j, j < numWin → b0Idx j ≠ b1Idx j)
    (h_distinct_b1_b0 :
      ∀ i j, i < numWin → j < numWin → i ≠ j → b1Idx i ≠ b0Idx j)

def window (w x j : Nat) : Nat

theorem windowed_expansion (w : Nat) :
    ∀ (n x : Nat), x < (2 ^ w) ^ n →
      x = ∑ j ∈ Finset.range n, window w x j * (2 ^ w) ^ j
  | 0, x, hx =>

theorem windowed_mul (w n k x : Nat) (hx : x < (2 ^ w) ^ n) :
    k * x = ∑ j ∈ Finset.range n, (k * window w x j) * (2 ^ w) ^ j

theorem window_lt (w x j : Nat) : window w x j < 2 ^ w

theorem windowed_exp (cexp n g e : Nat) (he : e < (2 ^ cexp) ^ n) :
    g ^ e = ∏ i ∈ Finset.range n, g ^ (window cexp e i * (2 ^ cexp) ^ i)

theorem windowed_exp_modProduct (cexp n g N e : Nat) (he : e < (2 ^ cexp) ^ n) :
    (∏ i ∈ Finset.range n, g ^ (window cexp e i * (2 ^ cexp) ^ i) % N) % N = g ^ e % N

def tableValue (a N w j v : Nat) : Nat

theorem windowed_modProductAdd (w n a N y : Nat) (hy : y < (2 ^ w) ^ n) :
    (∑ j ∈ Finset.range n, tableValue a N w j (window w y j)) % N = (a * y) % N

theorem windowed_modProductAdd_acc (w n a N y acc : Nat) (hy : y < (2 ^ w) ^ n) :
    (acc + ∑ j ∈ Finset.range n, tableValue a N w j (window w y j)) % N
      = (acc + a * y) % N

def windowedLookupFold (a N w : Nat) (val : Nat → Nat) : Nat → Nat → Nat
  | 0, acc => acc
  | n + 1, acc => (windowedLookupFold a N w val n acc + tableValue a N w n (val n)) % N

theorem windowedLookupFold_eq (a N w : Nat) (val : Nat → Nat) (acc : Nat) (hacc : acc < N) :
    ∀ n, windowedLookupFold a N w val n acc
        = (acc + ∑ j ∈ Finset.range n, tableValue a N w j (val j)) % N

theorem windowedLookupFold_modProductAdd (a N w n y acc : Nat) (hacc : acc < N)
    (hy : y < (2 ^ w) ^ n) :
    windowedLookupFold a N w (window w y) n acc = (acc + a * y) % N

theorem windowedLookupFold_eq_modmul (a N w n x : Nat) (hN : 0 < N) (hx : x < (2 ^ w) ^ n) :
    windowedLookupFold a N w (window w x) n 0 = (a * x) % N

theorem address_concat (mWin ei mi : Nat) (hmi : mi < 2 ^ mWin) :
    (ei * 2 ^ mWin + mi) / 2 ^ mWin = ei ∧ (ei * 2 ^ mWin + mi) % 2 ^ mWin = mi

def modPow (g e N : Nat) : Nat

def WindowedExpCorrect (windowedExp : Nat → Nat → Nat) (g N : Nat) : Prop

theorem windowedMultiplier_verified
    (w bits a numWin N x : Nat) (hN : 0 < N) (hx : x < (2 ^ w) ^ numWin) :
    windowedLookupFold a N w (window w x) numWin 0 = (a * x) % N
    ∧ toffoliCount (windowedMulCircuit w bits a numWin) = numWin * (4 * w * 2 ^ w + 2 * bits)
    ∧ shorMagicDemand (windowedMulCircuit w bits a numWin) = numWin * (4 * w * 2 ^ w + 2 * bits)

def encodeReg (base bits x : Nat) : Nat → Bool

def decodeAcc (f : Nat → Bool) (q_start bits : Nat) : Nat

def addendIdx (q_start j : Nat) : Nat

def wordCnotsAt (pos : Nat → Nat) (W Tv : Nat) : List Nat

def lookupReadAt (w : Nat) (pos : Nat → Nat) (W : Nat) (T : Nat → Nat) : Gate

def lookupAddAt (w W : Nat) (T : Nat → Nat) (bits q_start : Nat) : Gate

def copyWindow (w yBase j : Nat) : Gate

def windowStep (w W a : Nat) (bits q_start yBase j : Nat) : Gate

def windowedMul (w W a : Nat) (bits q_start yBase numWin : Nat) : Gate

def windowedMulCircuit (w bits a numWin : Nat) : Gate

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

def accStart (w : Nat) : Nat

theorem tcount_foldl_seq_const {α : Type} (step : α → Gate) (C : Nat)
    (hstep : ∀ a, tcount (step a) = C) (L : List α) (init : Gate) :
    tcount (L.foldl (fun g a => Gate.seq g (step a)) init) = tcount init + L.length * C

theorem tcount_unary_lookup_iteration (w : Nat) (flips cnots : List Nat) :
    tcount (unary_lookup_iteration w flips cnots) = 14 * w

theorem tcount_unary_lookup_multi_iteration (w : Nat) (iters : List (List Nat × List Nat)) :
    tcount (unary_lookup_multi_iteration w iters) = 14 * w * iters.length

theorem tcount_lookupReadAt (w : Nat) (pos : Nat → Nat) (W : Nat) (T : Nat → Nat) :
    tcount (lookupReadAt w pos W T) = 14 * w * 2 ^ w

theorem tcount_lookupAddAt (w W : Nat) (T : Nat → Nat) (bits q_start : Nat) :
    tcount (lookupAddAt w W T bits q_start) = 2 * (14 * w * 2 ^ w) + 14 * bits

theorem tcount_copyWindow (w yBase j : Nat) : tcount (copyWindow w yBase j) = 0

theorem tcount_windowStep (w W a bits q_start yBase j : Nat) :
    tcount (windowStep w W a bits q_start yBase j) = 2 * (14 * w * 2 ^ w) + 14 * bits

theorem tcount_windowedMul (w W a bits q_start yBase numWin : Nat) :
    tcount (windowedMul w W a bits q_start yBase numWin)
      = numWin * (2 * (14 * w * 2 ^ w) + 14 * bits)

theorem tcount_windowedMulCircuit (w bits a numWin : Nat) :
    tcount (windowedMulCircuit w bits a numWin) = numWin * (28 * w * 2 ^ w + 14 * bits)

def toffoliCount (g : Gate) : Nat

theorem windowedMulCircuit_toffoli (w bits a numWin : Nat) :
    toffoliCount (windowedMulCircuit w bits a numWin) = numWin * (4 * w * 2 ^ w + 2 * bits)

theorem windowedMulCircuit_toffoli_padded (w n pad a numWin : Nat) :
    toffoliCount (windowedMulCircuit w (n + pad) a numWin)
      = numWin * (4 * w * 2 ^ w + 2 * n + 2 * pad)

def maxIdx : Gate → Nat
  | .I          => 0
  | .X q        => q
  | .CX c t     => max c t
  | .CCX a b c  => max a (max b c)
  | .seq g₁ g₂  => max (maxIdx g₁) (maxIdx g₂)

def width (g : Gate) : Nat

theorem width_windowedMulCircuit_2_4_3_2 :
    width (windowedMulCircuit 2 4 3 2) = 18

theorem width_windowedMulCircuit_padding :
    width (windowedMulCircuit 2 (4 + 3) 3 2) = width (windowedMulCircuit 2 4 3 2) + 2 * 3

def composedModExp (numMults w bits a numWin : Nat) : Gate

theorem tcount_composedModExp (numMults w bits a numWin : Nat) :
    tcount (composedModExp numMults w bits a numWin)
      = numMults * tcount (windowedMulCircuit w bits a numWin)

theorem composedModExp_toffoli (numMults w bits a numWin : Nat) :
    toffoliCount (composedModExp numMults w bits a numWin)
      = numMults * (numWin * (4 * w * 2 ^ w + 2 * bits))

def runMul (w bits a numWin y : Nat) : Nat

example : runMul 2 6 3 2 6 = 18

example : runMul 2 6 3 2 7 = 21

example : runMul 2 6 5 2 5 = 25

def seqAll (gs : List EGate) : EGate

theorem tcount_foldl_seq_const (seed : EGate) (gs : List EGate) (c : Nat)
    (h : ∀ g ∈ gs, EGate.tcount g = c) :
    EGate.tcount (gs.foldl EGate.seq seed) = EGate.tcount seed + gs.length * c

theorem tcount_seqAll_const (gs : List EGate) (c : Nat) (h : ∀ g ∈ gs, EGate.tcount g = c) :
    EGate.tcount (seqAll gs) = gs.length * c

theorem tcount_babbushLookupAdd (w W : Nat) (T : Nat → Nat)
    (bits addrBase ancBase outBase q_start : Nat) :
    EGate.tcount (babbushLookupAdd w W T bits addrBase ancBase outBase q_start)
      = 7 * ((2 ^ w - 1) + 2 * bits)

def laK (w W bits : Nat) (T : Nat → Nat) (base k : Nat) : EGate

theorem tcount_laK (w W bits : Nat) (T : Nat → Nat) (base k : Nat) :
    EGate.tcount (laK w W bits T base k) = 7 * ((2 ^ w - 1) + 2 * bits)

def multiplyAdd (w W bits : Nat) (T : Nat → Nat) (base numWin : Nat) : EGate

theorem tcount_multiplyAdd (w W bits : Nat) (T : Nat → Nat) (base numWin : Nat) :
    EGate.tcount (multiplyAdd w W bits T base numWin)
      = numWin * (7 * ((2 ^ w - 1) + 2 * bits))

def multiplication (w W bits : Nat) (T : Nat → Nat) (base numWin : Nat) : EGate

theorem tcount_multiplication (w W bits : Nat) (T : Nat → Nat) (base numWin : Nat) :
    EGate.tcount (multiplication w W bits T base numWin)
      = 2 * (numWin * (7 * ((2 ^ w - 1) + 2 * bits)))

def modExp (w W bits : Nat) (T : Nat → Nat) (numMults numWin : Nat) : EGate

theorem tcount_modExp (w W bits : Nat) (T : Nat → Nat) (numMults numWin : Nat) :
    EGate.tcount (modExp w W bits T numMults numWin)
      = numMults * (2 * (numWin * (7 * ((2 ^ w - 1) + 2 * bits))))

theorem toffoli_modExp (w W bits : Nat) (T : Nat → Nat) (numMults numWin : Nat) :
    EGate.toffoli (modExp w W bits T numMults numWin)
      = numMults * 2 * numWin * ((2 ^ w - 1) + 2 * bits)

def lookupAddCount (numMults numWin : Nat) : Nat

theorem toffoli_modExp_factored (w W bits : Nat) (T : Nat → Nat) (numMults numWin : Nat) :
    EGate.toffoli (modExp w W bits T numMults numWin)
      = lookupAddCount numMults numWin * ((2 ^ w - 1) + 2 * bits)

def structPerLookup (n : ℚ) : ℚ

def structToffoliCount (n n_e : ℚ) : ℚ

theorem perLookup_gap (n L : ℚ) :
    perLookupToffoli n L - structPerLookup n = 1 + n * (3 * L + 10) / 1024

theorem total_gap (n n_e L : ℚ) :
    toffoliCount n n_e L - structToffoliCount n n_e
      = lookupAdditionCount n n_e * (1 + n * (3 * L + 10) / 1024)

theorem structToffoliCount_le_paper (n n_e L : ℚ)
    (hn : 0 ≤ n) (hne : 0 ≤ n_e) (hL : 0 ≤ L) :
    structToffoliCount n n_e ≤ toffoliCount n n_e L

theorem structPerLookup_rsa : structPerLookup 2048 = 5119

theorem perLookup_rsa :
    perLookupToffoli 2048 11 = 5206
    ∧ perLookupToffoli 2048 11 - structPerLookup 2048 = 87

theorem rsa2048_head_to_head :
    structToffoliCount 2048 3072 = 2578993152
    ∧ toffoliCount 2048 3072 11 = 2622824448
    ∧ toffoliCount 2048 3072 11 - structToffoliCount 2048 3072 = 43831296
    ∧ (43831296 : ℚ) = 503808 * 1 + 503808 * 86

theorem rsa2048_structural_circuit_toffoli (W : Nat) (T : Nat → Nat) :
    EGate.toffoli (modExp 10 W 2048 T 246 1024) = 2578993152

theorem rsa2048_circuit_matches_model (W : Nat) (T : Nat → Nat) :
    (EGate.toffoli (modExp 10 W 2048 T 246 1024) : ℚ) = structToffoliCount 2048 3072

def lookupAdditionCount (n n_e : ℚ) : ℚ

def perLookupToffoli (n L : ℚ) : ℚ

def toffoliCount (n n_e L : ℚ) : ℚ

theorem lookupAdditionCount_eq (n n_e : ℚ) :
    lookupAdditionCount n n_e = 41 / 512 * n * n_e

theorem toffoliCount_closed (n L : ℚ) :
    toffoliCount n (3 * n / 2) L
      = 123 / 512 * n ^ 3 + 369 / 1048576 * n ^ 3 * L
        + 1230 / 1048576 * n ^ 3 + 123 * n ^ 2

theorem toffoli_coeffs_le_paper :
    (123 : ℚ) / 512 ≤ 3 / 10 ∧ (369 : ℚ) / 1048576 ≤ 5 / 10000

theorem toffoliCount_le_paper (n L : ℚ) (hn : 2100 ≤ n) (hL : 0 ≤ L) :
    toffoliCount n (3 * n / 2) L ≤ 3 / 10 * n ^ 3 + 5 / 10000 * n ^ 3 * L

theorem toffoliCount_rsa2048 :
    toffoliCount 2048 3072 11 = 2622824448
    ∧ toffoliCount 2048 3072 11 ≤ 3 / 10 * 2048 ^ 3 + 5 / 10000 * 2048 ^ 3 * 11