Datasets:

roseking
/

openAI-math-dataset

import Mathlib
import OAI.Computability.MaxCut.Games.Identities

namespace OAI

namespace OptimalMaxCut.TreeCode

open scoped BigOperators

abbrev Bit := ZMod 2
abbrev Branch (s : ℕ) := Fin s × Bool
abbrev Table (s : ℕ) := (Fin s → Bit) → Bit

@[reducible] def Nodes (s : ℕ) : ℕ → Type
  | 0 => Empty
  | m + 1 => Unit ⊕ (Branch s × Nodes s m)

@[reducible] def Leaves (s : ℕ) : ℕ → Type
  | 0 => Unit
  | m + 1 => Branch s × Leaves s m
instance nodesFintype (s m : ℕ) : Fintype (Nodes s m) := by
  induction m with
  | zero => exact inferInstanceAs (Fintype Empty)
  | succ m ih => exact inferInstanceAs (Fintype (Unit ⊕ (Branch s × Nodes s m)))
instance leavesFintype (s m : ℕ) : Fintype (Leaves s m) := by
  induction m with
  | zero => exact inferInstanceAs (Fintype Unit)
  | succ m ih => exact inferInstanceAs (Fintype (Branch s × Leaves s m))
instance nodesDecidableEq (s m : ℕ) : DecidableEq (Nodes s m) := by
  induction m with
  | zero => exact inferInstanceAs (DecidableEq Empty)
  | succ m ih => exact inferInstanceAs (DecidableEq (Unit ⊕ (Branch s × Nodes s m)))
instance leavesDecidableEq (s m : ℕ) : DecidableEq (Leaves s m) := by
  induction m with
  | zero => exact inferInstanceAs (DecidableEq Unit)
  | succ m ih => exact inferInstanceAs (DecidableEq (Branch s × Leaves s m))
@[simp] theorem card_leaves (s m : ℕ) : Fintype.card (Leaves s m) = (2 * s) ^ m := by
  induction m with
  | zero =>
      change Fintype.card Unit = 1
      exact Fintype.card_unique
  | succ m ih =>
      change Fintype.card (Branch s × Leaves s m) = _
      rw [Fintype.card_prod, Fintype.card_prod, Fintype.card_fin,
        Fintype.card_bool, ih, pow_succ]
      ring
def gate {s : ℕ} (F : Table s) (Z : Branch s → Bit) : Bit :=
  (∑ g, Z (g, false)) + F (fun g => Z (g, false) + Z (g, true))
/-- The same complete 2s-ary tree code, with leaves canonically indexed by
branch words instead of choosing an arbitrary bijection with Fin k. -/
def word {s : ℕ} : {m : ℕ} → (Nodes s m → Table s) → (Leaves s m → Bit) → Bit
  | 0, _, x => x ()
  | _m + 1, F, x => gate (F (.inl ())) (fun gb =>
      word (fun v => F (.inr (gb, v))) (fun i => x (gb, i)))
inductive Slice (s : ℕ) : ℕ → Type
  | root : Slice s 0
  | next {j : ℕ} (pair : Fin s) (child : Bool → Slice s j) : Slice s (j + 1)
/-- Membership in the slice, for a tree of any total depth. -/
def onSlice {s : ℕ} : {j m : ℕ} → Slice s j → Nodes s m → Bool
  | _, 0, _, v => nomatch v
  | 0, _ + 1, .root, .inl _ => true
  | 0, _ + 1, .root, .inr _ => false
  | _ + 1, _ + 1, .next _ _, .inl _ => false
  | _ + 1, _ + 1, .next g child, .inr ((g', b), v) =>
      if g' = g then onSlice (child b) v else false
/-- Negate exactly the whole tables on the fixed slice, and no other table. -/
def flipTables {s j m : ℕ} (S : Slice s j) (F : Nodes s m → Table s) :
    Nodes s m → Table s := fun v z => F v z + if onSlice S v then 1 else 0
@[simp] theorem bit_add_self (a : Bit) : a + a = 0 := by
  have := ZMod.natCast_self 2
  linear_combination a * this
@[simp] theorem bit_one_add_one : (1 + 1 : Bit) = 0 := by decide
/-- Simultaneously multiplying the two children in pair g by -1 leaves all
inputs to the gate table fixed and multiplies its prefactor by -1. -/
theorem gate_pair_flip {s : ℕ} (F : Table s) (Z : Branch s → Bit) (g : Fin s) :
    gate F (fun gb => Z gb + if gb.1 = g then 1 else 0) = gate F Z + 1 := by
  have inputs : (fun h : Fin s =>
        (Z (h, false) + if h = g then 1 else 0) +
        (Z (h, true) + if h = g then 1 else 0)) =
      (fun h => Z (h, false) + Z (h, true)) := by
    funext h
    by_cases hh : h = g
    · simp only [hh, ↓reduceIte]
      calc
        (Z (g, false) + 1) + (Z (g, true) + 1) =
            (Z (g, false) + Z (g, true)) + (1 + 1) := by ring
        _ = _ := by rw [bit_one_add_one, add_zero]
    · simp [hh]
  unfold gate
  simp only at inputs ⊢
  rw [inputs, Finset.sum_add_distrib]
  simp
  ring
theorem word_flipTables {s j m : ℕ} (S : Slice s j) (hjm : j < m)
    (F : Nodes s m → Table s) (x : Leaves s m → Bit) :
    word (flipTables S F) x = word F x + 1 := by
  induction S generalizing m with
  | root =>
      cases m with
      | zero => omega
      | succ m =>
          have hc (gb : Branch s) :
              (fun v => flipTables .root F (.inr (gb, v))) =
              (fun v => F (.inr (gb, v))) := by
            funext v z
            simp [flipTables, onSlice]
          change gate (fun z => F (.inl ()) z + 1) _ = gate (F (.inl ())) _ + 1
          simp_rw [hc]
          unfold gate
          ring
  | @next j g child ih =>
      cases m with
      | zero => omega
      | succ m =>
          have hm : j < m := by omega
          have each (gb : Branch s) :
              word (fun v => flipTables (.next g child) F (.inr (gb, v)))
                  (fun i => x (gb, i)) =
              word (fun v => F (.inr (gb, v))) (fun i => x (gb, i)) +
                if gb.1 = g then 1 else 0 := by
            rcases gb with ⟨g', b⟩
            by_cases hg : g' = g
            · subst g'
              have hc :
                  (fun v => flipTables (.next g child) F (.inr ((g, b), v))) =
                  flipTables (child b) (fun v => F (.inr ((g, b), v))) := by
                funext v z
                simp [flipTables, onSlice]
              rw [hc]
              simpa using ih b hm (fun v => F (.inr ((g, b), v))) (fun i => x ((g, b), i))
            · have hc :
                  (fun v => flipTables (.next g child) F (.inr ((g', b), v))) =
                  (fun v => F (.inr ((g', b), v))) := by
                funext v z
                simp [flipTables, onSlice, hg]
              simp [hc, hg]
          change gate (fun z => F (.inl ()) z + 0) _ = gate (F (.inl ())) _ + 1
          simp only [add_zero]
          simp_rw [each]
          exact gate_pair_flip _ _ g
theorem bit_cases (x : Bit) : x = 0 ∨ x = 1 := by
  fin_cases x
  · exact Or.inl rfl
  · exact Or.inr rfl
def sign (x : Bit) : ℝ := if x = 0 then 1 else -1
@[simp] theorem sign_zero : sign 0 = 1 := by norm_num [sign]
@[simp] theorem sign_one : sign 1 = -1 := by norm_num [sign]
 theorem sign_add (a b : Bit) : sign (a + b) = sign a * sign b := by
  rcases bit_cases a with rfl | rfl <;> rcases bit_cases b with rfl | rfl <;>
    simp []
@[simp] theorem sign_sq (a : Bit) : sign a ^ 2 = 1 := by
  fin_cases a <;> norm_num [sign]
 theorem sign_add_one (a : Bit) : sign (a + 1) = - sign a := by
  rw [sign_add, sign_one]
  ring
 theorem sign_sum {I : Type*} (S : Finset I) (f : I → Bit) :
    sign (∑ i ∈ S, f i) = ∏ i ∈ S, sign (f i) := by
  classical
  induction S using Finset.induction_on with
  | empty => simp
  | @insert a S ha ih => simp [ha, sign_add, ih]
/-- The implemented gate is EXACTLY equation (gate-rule), not a replacement
operator with only the same symmetry. -/
 theorem gate_sign {s : ℕ} (F : Table s) (Z : Branch s → Bit) :
    sign (gate F Z) =
      (∏ g, sign (Z (g, false))) * sign (F (fun g => Z (g, false) + Z (g, true))) := by
  rw [gate, sign_add]
  congr 1
  simpa using sign_sum Finset.univ (fun g => Z (g, false))
def labelWord {A : Type*} {s m : ℕ} (F : Nodes s m → Table s)
    (R : Leaves s m → A → Bit) : A → Bit := fun a => word F (fun i => R i a)
 theorem labelWord_flipTables {A : Type*} {s j m : ℕ} (S : Slice s j)
    (hjm : j < m) (F : Nodes s m → Table s) (R : Leaves s m → A → Bit) :
    labelWord (flipTables S F) R = fun a => labelWord F R a + 1 := by
  funext a
  exact word_flipTables S hjm F _
def Odd {A : Type*} (φ : (A → Bit) → ℝ) : Prop :=
  ∀ w, φ (fun a => w a + 1) = -φ w
 theorem code_flipTables {A : Type*} {s j m : ℕ} (S : Slice s j)
    (hjm : j < m) (F : Nodes s m → Table s) (R : Leaves s m → A → Bit)
    (φ : (A → Bit) → ℝ) (hφ : Odd φ) :
    φ (labelWord (flipTables S F) R) = -φ (labelWord F R) := by
  rw [labelWord_flipTables S hjm]
  exact hφ _
abbrev SliceNode {s j m : ℕ} (S : Slice s j) :=
  {v : Nodes s m // onSlice S v = true}
abbrev SliceTables {s j m : ℕ} (S : Slice s j) := SliceNode (m := m) S → Table s
/-- Fill the slice with independently supplied complete Boolean tables,
leaving all outside tables at their fixed values. -/
def fillTables {s j m : ℕ} (S : Slice s j) (outside : Nodes s m → Table s)
    (inside : SliceTables (m := m) S) : Nodes s m → Table s :=
  fun v => if hv : onSlice S v = true then inside ⟨v, hv⟩ else outside v
/-- The measure-preserving simultaneous negation of all slice-entry signs. -/
def insideFlip {s j m : ℕ} (S : Slice s j) :
    SliceTables (m := m) S ≃ SliceTables (m := m) S where
  toFun F v z := F v z + 1
  invFun F v z := F v z + 1
  left_inv F := by funext v z; dsimp; rw [add_assoc, bit_one_add_one, add_zero]
  right_inv F := by funext v z; dsimp; rw [add_assoc, bit_one_add_one, add_zero]

 theorem fillTables_insideFlip {s j m : ℕ} (S : Slice s j)
    (outside : Nodes s m → Table s) (inside : SliceTables (m := m) S) :
    fillTables S outside (insideFlip S inside) = flipTables S (fillTables S outside inside) := by
  funext v z
  by_cases hv : onSlice S v = true
  · simp [fillTables, insideFlip, flipTables, hv]
  · simp [fillTables, flipTables, hv]

/-- The precise conditional balancing assertion used in extraction Step 1.
Rows, all outside tables, and the fixed slice are arbitrary and NOT averaged.
Only independent uniform slice bits are averaged. -/
 theorem conditional_code_mean_zero {A : Type*} {s j m : ℕ} (S : Slice s j)
    (hjm : j < m) (outside : Nodes s m → Table s) (R : Leaves s m → A → Bit)
    (φ : (A → Bit) → ℝ) (hφ : Odd φ) :
    (𝔼 inside : SliceTables (m := m) S, φ (labelWord (fillTables S outside inside) R)) = 0 := by
  classical
  let f : SliceTables (m := m) S → ℝ :=
    fun inside => φ (labelWord (fillTables S outside inside) R)
  have hx (inside : SliceTables (m := m) S) : f (insideFlip S inside) = - f inside := by
    dsimp [f]
    rw [fillTables_insideFlip]
    exact code_flipTables S hjm _ R φ hφ
  have he := Fintype.expect_equiv (insideFlip (m := m) S)
    (fun x => f (insideFlip S x)) f (fun _ => rfl)
  simp_rw [hx] at he
  rw [Finset.expect_neg_distrib] at he
  change (𝔼 inside, f inside) = 0
  linarith

section RowSmoothing

variable {H I : Type*} [Fintype H] [DecidableEq H] [Nonempty H]
  [Fintype I] [DecidableEq I]

/-- Exactly retain the old whole row with probability r, otherwise draw an
independent uniform whole row. This is not independent noise on its bits. -/
noncomputable def rowKernel (r : ℝ) (x y : H) : ℝ :=
  (if x = y then r else 0) + (1 - r) / Fintype.card H

 theorem rowKernel_nonneg (r : ℝ) (hr : 0 ≤ r) (hr1 : r ≤ 1) (x y : H) :
    0 ≤ rowKernel r x y := by
  unfold rowKernel
  apply add_nonneg
  · split_ifs <;> positivity
  · positivity

 theorem rowKernel_sum (r : ℝ) (x : H) : ∑ y, rowKernel r x y = 1 := by
  have hc : (Fintype.card H : ℝ) ≠ 0 := by exact_mod_cast Fintype.card_ne_zero
  simp only [rowKernel, Finset.sum_add_distrib]
  simp
  field_simp
  ring

omit [Nonempty H] in
 theorem rowKernel_symm (r : ℝ) (x y : H) : rowKernel r x y = rowKernel r y x := by
  simp [rowKernel, eq_comm]

noncomputable def rowsKernel (r : ℝ) (x y : I → H) : ℝ :=
  ∏ i, rowKernel r (x i) (y i)

omit [DecidableEq I] in
 theorem rowsKernel_nonneg (r : ℝ) (hr : 0 ≤ r) (hr1 : r ≤ 1) (x y : I → H) :
    0 ≤ rowsKernel r x y := by
  exact Finset.prod_nonneg (fun i _ => rowKernel_nonneg r hr hr1 (x i) (y i))

 theorem rowsKernel_sum (r : ℝ) (x : I → H) : ∑ y, rowsKernel r x y = 1 := by
  unfold rowsKernel
  rw [← Fintype.prod_sum]
  simp [rowKernel_sum]

noncomputable def rowSmoothing (r : ℝ) (f : (I → H) → ℝ) (R : I → H) : ℝ :=
  ∑ R', rowsKernel r R R' * f R'

 theorem rowSmoothing_range (r : ℝ) (hr : 0 ≤ r) (hr1 : r ≤ 1)
    (f : (I → H) → ℝ) (hf : ∀ R, -1 ≤ f R ∧ f R ≤ 1) (R : I → H) :
    -1 ≤ rowSmoothing r f R ∧ rowSmoothing r f R ≤ 1 := by
  have hk := rowsKernel_nonneg (H := H) (I := I) r hr hr1
  have hs := rowsKernel_sum (I := I) r R
  constructor
  · calc
      -1 = ∑ R', rowsKernel r R R' * (-1) := by simp [hs]
      _ ≤ rowSmoothing r f R := Finset.sum_le_sum (fun i _ =>
        mul_le_mul_of_nonneg_left (hf i).1 (hk R i))
  · calc
      rowSmoothing r f R ≤ ∑ R', rowsKernel r R R' * 1 :=
        Finset.sum_le_sum (fun i _ => mul_le_mul_of_nonneg_left (hf i).2 (hk R i))
      _ = 1 := by simpa using hs

end RowSmoothing

/-- Exact conditional balancing survives whole-row resampling, with fixed
rows/outside tables/slice. No probabilistic averaging of those contexts is used. -/
 theorem conditional_smoothed_code_mean_zero {A H : Type*} [Fintype H]
    [DecidableEq H] [Nonempty H] {s j m : ℕ} (S : Slice s j) (hjm : j < m)
    (outside : Nodes s m → Table s) (evalRow : H → A → Bit) (r : ℝ)
    (R : Leaves s m → H) (φ : (A → Bit) → ℝ) (hφ : Odd φ) :
    (𝔼 inside : SliceTables (m := m) S,
      rowSmoothing r (fun R' => φ (labelWord (fillTables S outside inside)
        (fun i => evalRow (R' i)))) R) = 0 := by
  classical
  unfold rowSmoothing
  rw [Finset.expect_sum_comm]
  simp_rw [← Finset.mul_expect]
  simp [conditional_code_mean_zero S hjm outside _ φ hφ]

section BitWalsh

variable {I : Type*} [Fintype I] [DecidableEq I]

/-- Probability-normalized finite Walsh transform, expressed in the same
sign-bit coordinates as the tree. -/
def character (q x : I → Bit) : ℝ := ∏ i, sign (q i * x i)

 theorem bit_character_orthogonality (q q' : Bit) :
    (∑ x : Bit, sign (q * x) * sign (q' * x)) = if q = q' then 2 else 0 := by
  rcases bit_cases q with rfl | rfl <;>
    rcases bit_cases q' with rfl | rfl <;>
    norm_num [show (Finset.univ : Finset Bit) = {0, 1} by
      ext x; simp only [Finset.mem_univ, Finset.mem_insert, Finset.mem_singleton, true_iff];
      exact bit_cases x, sign]

omit [DecidableEq I] in
 theorem character_symm (q x : I → Bit) : character q x = character x q := by
  simp only [character, mul_comm]

 theorem character_sum_orthogonality (q q' : I → Bit) :
    (∑ x, character q x * character q' x) =
      if q = q' then (Fintype.card (I → Bit) : ℝ) else 0 := by
  classical
  simp only [character, ← Finset.prod_mul_distrib]
  rw [← Fintype.prod_sum (fun (i : I) (b : Bit) => sign (q i * b) * sign (q' i * b))]
  simp only [bit_character_orthogonality]
  by_cases h : q = q'
  · subst q'
    simp [ZMod.card]
  · rw [ite_eq_right h]
    obtain ⟨i, hi⟩ := Function.ne_iff.mp h
    apply Finset.prod_eq_zero (Finset.mem_univ i)
    exact ite_eq_right hi

noncomputable def bitCoefficient (f : (I → Bit) → ℝ) (q : I → Bit) : ℝ :=
  𝔼 x, f x * character q x

 theorem bitWalsh_inversion (f : (I → Bit) → ℝ) (x : I → Bit) :
    (∑ q, bitCoefficient f q * character q x) = f x := by
  classical
  unfold bitCoefficient
  simp_rw [Finset.expect_mul]
  rw [← Finset.expect_sum_comm]
  have h (y : I → Bit) :
      (∑ q, (f y * character q y) * character q x) =
        f y * (if y = x then (Fintype.card (I → Bit) : ℝ) else 0) := by
    simp only [mul_assoc, ← Finset.mul_sum]
    congr 1
    simp_rw [character_symm (x := y), character_symm (x := x)]
    exact character_sum_orthogonality y x
  simp_rw [h]
  rw [Fintype.expect_eq_sum_div_card]
  simp

end BitWalsh

 theorem gate_expansion {s : ℕ} (F : Table s) (Z : Branch s → Bit) :
    sign (gate F Z) = ∑ q : Fin s → Bit,
      bitCoefficient (fun z => sign (F z)) q *
        ∏ g, sign (Z (g, if q g = 0 then false else true)) := by
  classical
  rw [gate_sign, ← bitWalsh_inversion (fun z => sign (F z))
    (fun g => Z (g, false) + Z (g, true)), Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro q _
  rw [mul_left_comm]
  congr 1
  simp only [character, ← Finset.prod_mul_distrib]
  apply Finset.prod_congr rfl
  intro g _
  rcases bit_cases (q g) with hq | hq
  · simp [hq]
  · simp only [hq, one_mul, one_ne_zero, ↓reduceIte, sign_add]
    rw [← mul_assoc, ← pow_two, sign_sq, one_mul]

section TensorSmoothing
variable {I J H : Type*} [Fintype I] [DecidableEq I]
  [Fintype J] [DecidableEq J] [Fintype H] [DecidableEq H] [Nonempty H]

 theorem rowSmoothing_one (r : ℝ) (R : I → H) :
    rowSmoothing r (fun _ : I → H => (1 : ℝ)) R = 1 := by
  simp only [rowSmoothing, mul_one]
  exact rowsKernel_sum r R

omit [Nonempty H] in
 theorem rowSmoothing_sum {K : Type*} [Fintype K]
    (r : ℝ) (f : K → (I → H) → ℝ) (R : I → H) :
    rowSmoothing r (fun x => ∑ k, f k x) R = ∑ k, rowSmoothing r (f k) R := by
  simp only [rowSmoothing, Finset.mul_sum]
  rw [Finset.sum_comm]

omit [Nonempty H] in
 theorem rowSmoothing_smul (r a : ℝ) (f : (I → H) → ℝ) (R : I → H) :
    rowSmoothing r (fun x => a * f x) R = a * rowSmoothing r f R := by
  simp only [rowSmoothing, Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro x _
  ring

omit [Nonempty H] in
/-- Independence of whole-row resampling across disjoint complete subtrees. -/
 theorem rowSmoothing_tensor (r : ℝ) (f : I → (J → H) → ℝ) (R : I × J → H) :
    rowSmoothing r (fun x => ∏ i, f i (fun j => x (i, j))) R =
      ∏ i, rowSmoothing r (f i) (fun j => R (i, j)) := by
  classical
  unfold rowSmoothing rowsKernel
  rw [Fintype.sum_equiv (Equiv.curry I J H)
    (fun x => (∏ i : I × J, rowKernel r (R i) (x i)) * ∏ i, f i (fun j => x (i, j)))
    (fun x => ∏ i, ((∏ j, rowKernel r (R (i, j)) (x i j)) * f i (x i)))]
  · exact (Fintype.prod_sum (fun (i : I) (x : J → H) =>
      (∏ j, rowKernel r (R (i, j)) (x j)) * f i x)).symm
  · intro x
    simp only [Equiv.curry_apply, Function.curry, Fintype.prod_prod_type, Finset.prod_mul_distrib]
    rfl

/-- A tensor product with one chosen member of each ordered pair. The unused
subtrees are integrated with total mass exactly one. -/
 theorem rowSmoothing_pairs {s : ℕ} (r : ℝ) (b : Fin s → Bool)
    (f : Branch s → (J → H) → ℝ) (R : Branch s × J → H) :
    rowSmoothing r (fun x => ∏ g, f (g, b g) (fun j => x ((g, b g), j))) R =
      ∏ g, rowSmoothing r (f (g, b g)) (fun j => R ((g, b g), j)) := by
  classical
  let h : Branch s → (J → H) → ℝ := fun gb x => if gb.2 = b gb.1 then f gb x else 1
  have hp (x : Branch s × J → H) :
      (∏ i : Branch s, h i (fun j => x (i, j))) =
        ∏ g, f (g, b g) (fun j => x ((g, b g), j)) := by
    rw [Fintype.prod_prod_type]
    apply Finset.prod_congr rfl
    intro g _
    cases hb : b g <;> simp [h, hb]
  have hf := funext hp
  rw [← hf, rowSmoothing_tensor, Fintype.prod_prod_type]
  apply Finset.prod_congr rfl
  intro g _
  cases hb : b g <;> simp [h, hb, rowSmoothing_one]

end TensorSmoothing

 theorem sum_sign : ∑ x : Bit, sign x = 0 := by
  rw [show (Finset.univ : Finset Bit) = {0, 1} by
    ext x; simp only [Finset.mem_univ, Finset.mem_insert, Finset.mem_singleton, true_iff]
    exact bit_cases x]
  norm_num

 theorem rowKernel_sign (r : ℝ) (x : Bit) :
    (∑ y, rowKernel r x y * sign y) = r * sign x := by
  simp only [rowKernel, add_mul, Finset.sum_add_distrib, ← Finset.mul_sum, sum_sign,
    mul_zero, add_zero]
  simp

 theorem word_leaf_smoothing {s m : ℕ} (F : Nodes s m → Table s)
    (r : ℝ) (x : Leaves s m → Bit) :
    rowSmoothing r (fun y => sign (word F y)) x = r ^ (s ^ m) * sign (word F x) := by
  induction m with
  | zero =>
      change (∑ y : Unit → Bit, (∏ i : Unit, rowKernel r (x i) (y i)) * sign (y ())) = _
      simp only [Fintype.prod_unique]
      calc
        _ = ∑ y : Bit, rowKernel r (x ()) y * sign y := by
          exact Fintype.sum_equiv (Equiv.funUnique Unit Bit) _ _ (fun _ => rfl)
        _ = _ := by simpa only [pow_zero, pow_one, word] using rowKernel_sign r (x ())
  | succ m ih =>
      have hx (y : Leaves s (m + 1) → Bit) :
          sign (word F y) = ∑ q : Fin s → Bit,
            bitCoefficient (fun z => sign (F (.inl ()) z)) q *
              ∏ g, sign (word (fun v => F (.inr ((g, if q g = 0 then false else true), v)))
                (fun i => y ((g, if q g = 0 then false else true), i))) :=
        gate_expansion _ _
      rw [funext hx, rowSmoothing_sum]
      simp_rw [rowSmoothing_smul]
      have ht (q : Fin s → Bit) := rowSmoothing_pairs (J := Leaves s m) r
        (fun g => if q g = 0 then false else true)
        (fun gb y => sign (word (fun v => F (.inr (gb, v))) y)) x
      simp_rw [ht, ih, Finset.prod_mul_distrib, Finset.prod_const,
        Finset.card_univ, Fintype.card_fin]
      rw [hx]
      simp only [pow_succ, pow_mul]
      rw [Finset.mul_sum]
      apply Finset.sum_congr rfl
      intro q _
      ring

end OptimalMaxCut.TreeCode

end OAI

	import Mathlib
	import OAI.Computability.MaxCut.Games.Identities

	namespace OAI

	namespace OptimalMaxCut.TreeCode

	open scoped BigOperators

	abbrev Bit := ZMod 2
	abbrev Branch (s : ℕ) := Fin s × Bool
	abbrev Table (s : ℕ) := (Fin s → Bit) → Bit

	@[reducible] def Nodes (s : ℕ) : ℕ → Type
	\| 0 => Empty
	\| m + 1 => Unit ⊕ (Branch s × Nodes s m)

	@[reducible] def Leaves (s : ℕ) : ℕ → Type
	\| 0 => Unit
	\| m + 1 => Branch s × Leaves s m

	instance nodesFintype (s m : ℕ) : Fintype (Nodes s m) := by
	induction m with
	\| zero => exact inferInstanceAs (Fintype Empty)
	\| succ m ih => exact inferInstanceAs (Fintype (Unit ⊕ (Branch s × Nodes s m)))

	instance leavesFintype (s m : ℕ) : Fintype (Leaves s m) := by
	induction m with
	\| zero => exact inferInstanceAs (Fintype Unit)
	\| succ m ih => exact inferInstanceAs (Fintype (Branch s × Leaves s m))

	instance nodesDecidableEq (s m : ℕ) : DecidableEq (Nodes s m) := by
	induction m with
	\| zero => exact inferInstanceAs (DecidableEq Empty)
	\| succ m ih => exact inferInstanceAs (DecidableEq (Unit ⊕ (Branch s × Nodes s m)))

	instance leavesDecidableEq (s m : ℕ) : DecidableEq (Leaves s m) := by
	induction m with
	\| zero => exact inferInstanceAs (DecidableEq Unit)
	\| succ m ih => exact inferInstanceAs (DecidableEq (Branch s × Leaves s m))

	@[simp] theorem card_leaves (s m : ℕ) : Fintype.card (Leaves s m) = (2 * s) ^ m := by
	induction m with
	\| zero =>
	change Fintype.card Unit = 1
	exact Fintype.card_unique
	\| succ m ih =>
	change Fintype.card (Branch s × Leaves s m) = _
	rw [Fintype.card_prod, Fintype.card_prod, Fintype.card_fin,
	Fintype.card_bool, ih, pow_succ]
	ring

	def gate {s : ℕ} (F : Table s) (Z : Branch s → Bit) : Bit :=
	(∑ g, Z (g, false)) + F (fun g => Z (g, false) + Z (g, true))

	/-- The same complete 2s-ary tree code, with leaves canonically indexed by
	branch words instead of choosing an arbitrary bijection with Fin k. -/
	def word {s : ℕ} : {m : ℕ} → (Nodes s m → Table s) → (Leaves s m → Bit) → Bit
	\| 0, _, x => x ()
	\| _m + 1, F, x => gate (F (.inl ())) (fun gb =>
	word (fun v => F (.inr (gb, v))) (fun i => x (gb, i)))

	inductive Slice (s : ℕ) : ℕ → Type
	\| root : Slice s 0
	\| next {j : ℕ} (pair : Fin s) (child : Bool → Slice s j) : Slice s (j + 1)

	/-- Membership in the slice, for a tree of any total depth. -/
	def onSlice {s : ℕ} : {j m : ℕ} → Slice s j → Nodes s m → Bool
	\| _, 0, _, v => nomatch v
	\| 0, _ + 1, .root, .inl _ => true
	\| 0, _ + 1, .root, .inr _ => false
	\| _ + 1, _ + 1, .next _ _, .inl _ => false
	\| _ + 1, _ + 1, .next g child, .inr ((g', b), v) =>
	if g' = g then onSlice (child b) v else false

	/-- Negate exactly the whole tables on the fixed slice, and no other table. -/
	def flipTables {s j m : ℕ} (S : Slice s j) (F : Nodes s m → Table s) :
	Nodes s m → Table s := fun v z => F v z + if onSlice S v then 1 else 0

	@[simp] theorem bit_add_self (a : Bit) : a + a = 0 := by
	have := ZMod.natCast_self 2
	linear_combination a * this

	@[simp] theorem bit_one_add_one : (1 + 1 : Bit) = 0 := by decide

	/-- Simultaneously multiplying the two children in pair g by -1 leaves all
	inputs to the gate table fixed and multiplies its prefactor by -1. -/
	theorem gate_pair_flip {s : ℕ} (F : Table s) (Z : Branch s → Bit) (g : Fin s) :
	gate F (fun gb => Z gb + if gb.1 = g then 1 else 0) = gate F Z + 1 := by
	have inputs : (fun h : Fin s =>
	(Z (h, false) + if h = g then 1 else 0) +
	(Z (h, true) + if h = g then 1 else 0)) =
	(fun h => Z (h, false) + Z (h, true)) := by
	funext h
	by_cases hh : h = g
	· simp only [hh, ↓reduceIte]
	calc
	(Z (g, false) + 1) + (Z (g, true) + 1) =
	(Z (g, false) + Z (g, true)) + (1 + 1) := by ring
	_ = _ := by rw [bit_one_add_one, add_zero]
	· simp [hh]
	unfold gate
	simp only at inputs ⊢
	rw [inputs, Finset.sum_add_distrib]
	simp
	ring

	theorem word_flipTables {s j m : ℕ} (S : Slice s j) (hjm : j < m)
	(F : Nodes s m → Table s) (x : Leaves s m → Bit) :
	word (flipTables S F) x = word F x + 1 := by
	induction S generalizing m with
	\| root =>
	cases m with
	\| zero => omega
	\| succ m =>
	have hc (gb : Branch s) :
	(fun v => flipTables .root F (.inr (gb, v))) =
	(fun v => F (.inr (gb, v))) := by
	funext v z
	simp [flipTables, onSlice]
	change gate (fun z => F (.inl ()) z + 1) _ = gate (F (.inl ())) _ + 1
	simp_rw [hc]
	unfold gate
	ring
	\| @next j g child ih =>
	cases m with
	\| zero => omega
	\| succ m =>
	have hm : j < m := by omega
	have each (gb : Branch s) :
	word (fun v => flipTables (.next g child) F (.inr (gb, v)))
	(fun i => x (gb, i)) =
	word (fun v => F (.inr (gb, v))) (fun i => x (gb, i)) +
	if gb.1 = g then 1 else 0 := by
	rcases gb with ⟨g', b⟩
	by_cases hg : g' = g
	· subst g'
	have hc :
	(fun v => flipTables (.next g child) F (.inr ((g, b), v))) =
	flipTables (child b) (fun v => F (.inr ((g, b), v))) := by
	funext v z
	simp [flipTables, onSlice]
	rw [hc]
	simpa using ih b hm (fun v => F (.inr ((g, b), v))) (fun i => x ((g, b), i))
	· have hc :
	(fun v => flipTables (.next g child) F (.inr ((g', b), v))) =
	(fun v => F (.inr ((g', b), v))) := by
	funext v z
	simp [flipTables, onSlice, hg]
	simp [hc, hg]
	change gate (fun z => F (.inl ()) z + 0) _ = gate (F (.inl ())) _ + 1
	simp only [add_zero]
	simp_rw [each]
	exact gate_pair_flip _ _ g

	theorem bit_cases (x : Bit) : x = 0 ∨ x = 1 := by
	fin_cases x
	· exact Or.inl rfl
	· exact Or.inr rfl

	def sign (x : Bit) : ℝ := if x = 0 then 1 else -1

	@[simp] theorem sign_zero : sign 0 = 1 := by norm_num [sign]
	@[simp] theorem sign_one : sign 1 = -1 := by norm_num [sign]

	theorem sign_add (a b : Bit) : sign (a + b) = sign a * sign b := by
	rcases bit_cases a with rfl \| rfl <;> rcases bit_cases b with rfl \| rfl <;>
	simp []

	@[simp] theorem sign_sq (a : Bit) : sign a ^ 2 = 1 := by
	fin_cases a <;> norm_num [sign]

	theorem sign_add_one (a : Bit) : sign (a + 1) = - sign a := by
	rw [sign_add, sign_one]
	ring

	theorem sign_sum {I : Type*} (S : Finset I) (f : I → Bit) :
	sign (∑ i ∈ S, f i) = ∏ i ∈ S, sign (f i) := by
	classical
	induction S using Finset.induction_on with
	\| empty => simp
	\| @insert a S ha ih => simp [ha, sign_add, ih]

	/-- The implemented gate is EXACTLY equation (gate-rule), not a replacement
	operator with only the same symmetry. -/
	theorem gate_sign {s : ℕ} (F : Table s) (Z : Branch s → Bit) :
	sign (gate F Z) =
	(∏ g, sign (Z (g, false))) * sign (F (fun g => Z (g, false) + Z (g, true))) := by
	rw [gate, sign_add]
	congr 1
	simpa using sign_sum Finset.univ (fun g => Z (g, false))

	def labelWord {A : Type*} {s m : ℕ} (F : Nodes s m → Table s)
	(R : Leaves s m → A → Bit) : A → Bit := fun a => word F (fun i => R i a)

	theorem labelWord_flipTables {A : Type*} {s j m : ℕ} (S : Slice s j)
	(hjm : j < m) (F : Nodes s m → Table s) (R : Leaves s m → A → Bit) :
	labelWord (flipTables S F) R = fun a => labelWord F R a + 1 := by
	funext a
	exact word_flipTables S hjm F _

	def Odd {A : Type*} (φ : (A → Bit) → ℝ) : Prop :=
	∀ w, φ (fun a => w a + 1) = -φ w

	theorem code_flipTables {A : Type*} {s j m : ℕ} (S : Slice s j)
	(hjm : j < m) (F : Nodes s m → Table s) (R : Leaves s m → A → Bit)
	(φ : (A → Bit) → ℝ) (hφ : Odd φ) :
	φ (labelWord (flipTables S F) R) = -φ (labelWord F R) := by
	rw [labelWord_flipTables S hjm]
	exact hφ _

	abbrev SliceNode {s j m : ℕ} (S : Slice s j) :=
	{v : Nodes s m // onSlice S v = true}

	abbrev SliceTables {s j m : ℕ} (S : Slice s j) := SliceNode (m := m) S → Table s

	/-- Fill the slice with independently supplied complete Boolean tables,
	leaving all outside tables at their fixed values. -/
	def fillTables {s j m : ℕ} (S : Slice s j) (outside : Nodes s m → Table s)
	(inside : SliceTables (m := m) S) : Nodes s m → Table s :=
	fun v => if hv : onSlice S v = true then inside ⟨v, hv⟩ else outside v

	/-- The measure-preserving simultaneous negation of all slice-entry signs. -/
	def insideFlip {s j m : ℕ} (S : Slice s j) :
	SliceTables (m := m) S ≃ SliceTables (m := m) S where
	toFun F v z := F v z + 1
	invFun F v z := F v z + 1
	left_inv F := by funext v z; dsimp; rw [add_assoc, bit_one_add_one, add_zero]
	right_inv F := by funext v z; dsimp; rw [add_assoc, bit_one_add_one, add_zero]

	theorem fillTables_insideFlip {s j m : ℕ} (S : Slice s j)
	(outside : Nodes s m → Table s) (inside : SliceTables (m := m) S) :
	fillTables S outside (insideFlip S inside) = flipTables S (fillTables S outside inside) := by
	funext v z
	by_cases hv : onSlice S v = true
	· simp [fillTables, insideFlip, flipTables, hv]
	· simp [fillTables, flipTables, hv]

	/-- The precise conditional balancing assertion used in extraction Step 1.
	Rows, all outside tables, and the fixed slice are arbitrary and NOT averaged.
	Only independent uniform slice bits are averaged. -/
	theorem conditional_code_mean_zero {A : Type*} {s j m : ℕ} (S : Slice s j)
	(hjm : j < m) (outside : Nodes s m → Table s) (R : Leaves s m → A → Bit)
	(φ : (A → Bit) → ℝ) (hφ : Odd φ) :
	(𝔼 inside : SliceTables (m := m) S, φ (labelWord (fillTables S outside inside) R)) = 0 := by
	classical
	let f : SliceTables (m := m) S → ℝ :=
	fun inside => φ (labelWord (fillTables S outside inside) R)
	have hx (inside : SliceTables (m := m) S) : f (insideFlip S inside) = - f inside := by
	dsimp [f]
	rw [fillTables_insideFlip]
	exact code_flipTables S hjm _ R φ hφ
	have he := Fintype.expect_equiv (insideFlip (m := m) S)
	(fun x => f (insideFlip S x)) f (fun _ => rfl)
	simp_rw [hx] at he
	rw [Finset.expect_neg_distrib] at he
	change (𝔼 inside, f inside) = 0
	linarith

	section RowSmoothing

	variable {H I : Type*} [Fintype H] [DecidableEq H] [Nonempty H]
	[Fintype I] [DecidableEq I]

	/-- Exactly retain the old whole row with probability r, otherwise draw an
	independent uniform whole row. This is not independent noise on its bits. -/
	noncomputable def rowKernel (r : ℝ) (x y : H) : ℝ :=
	(if x = y then r else 0) + (1 - r) / Fintype.card H

	theorem rowKernel_nonneg (r : ℝ) (hr : 0 ≤ r) (hr1 : r ≤ 1) (x y : H) :
	0 ≤ rowKernel r x y := by
	unfold rowKernel
	apply add_nonneg
	· split_ifs <;> positivity
	· positivity

	theorem rowKernel_sum (r : ℝ) (x : H) : ∑ y, rowKernel r x y = 1 := by
	have hc : (Fintype.card H : ℝ) ≠ 0 := by exact_mod_cast Fintype.card_ne_zero
	simp only [rowKernel, Finset.sum_add_distrib]
	simp
	field_simp
	ring

	omit [Nonempty H] in
	theorem rowKernel_symm (r : ℝ) (x y : H) : rowKernel r x y = rowKernel r y x := by
	simp [rowKernel, eq_comm]

	noncomputable def rowsKernel (r : ℝ) (x y : I → H) : ℝ :=
	∏ i, rowKernel r (x i) (y i)

	omit [DecidableEq I] in
	theorem rowsKernel_nonneg (r : ℝ) (hr : 0 ≤ r) (hr1 : r ≤ 1) (x y : I → H) :
	0 ≤ rowsKernel r x y := by
	exact Finset.prod_nonneg (fun i _ => rowKernel_nonneg r hr hr1 (x i) (y i))

	theorem rowsKernel_sum (r : ℝ) (x : I → H) : ∑ y, rowsKernel r x y = 1 := by
	unfold rowsKernel
	rw [← Fintype.prod_sum]
	simp [rowKernel_sum]

	noncomputable def rowSmoothing (r : ℝ) (f : (I → H) → ℝ) (R : I → H) : ℝ :=
	∑ R', rowsKernel r R R' * f R'

	theorem rowSmoothing_range (r : ℝ) (hr : 0 ≤ r) (hr1 : r ≤ 1)
	(f : (I → H) → ℝ) (hf : ∀ R, -1 ≤ f R ∧ f R ≤ 1) (R : I → H) :
	-1 ≤ rowSmoothing r f R ∧ rowSmoothing r f R ≤ 1 := by
	have hk := rowsKernel_nonneg (H := H) (I := I) r hr hr1
	have hs := rowsKernel_sum (I := I) r R
	constructor
	· calc
	-1 = ∑ R', rowsKernel r R R' * (-1) := by simp [hs]
	_ ≤ rowSmoothing r f R := Finset.sum_le_sum (fun i _ =>
	mul_le_mul_of_nonneg_left (hf i).1 (hk R i))
	· calc
	rowSmoothing r f R ≤ ∑ R', rowsKernel r R R' * 1 :=
	Finset.sum_le_sum (fun i _ => mul_le_mul_of_nonneg_left (hf i).2 (hk R i))
	_ = 1 := by simpa using hs

	end RowSmoothing

	/-- Exact conditional balancing survives whole-row resampling, with fixed
	rows/outside tables/slice. No probabilistic averaging of those contexts is used. -/
	theorem conditional_smoothed_code_mean_zero {A H : Type*} [Fintype H]
	[DecidableEq H] [Nonempty H] {s j m : ℕ} (S : Slice s j) (hjm : j < m)
	(outside : Nodes s m → Table s) (evalRow : H → A → Bit) (r : ℝ)
	(R : Leaves s m → H) (φ : (A → Bit) → ℝ) (hφ : Odd φ) :
	(𝔼 inside : SliceTables (m := m) S,
	rowSmoothing r (fun R' => φ (labelWord (fillTables S outside inside)
	(fun i => evalRow (R' i)))) R) = 0 := by
	classical
	unfold rowSmoothing
	rw [Finset.expect_sum_comm]
	simp_rw [← Finset.mul_expect]
	simp [conditional_code_mean_zero S hjm outside _ φ hφ]

	section BitWalsh

	variable {I : Type*} [Fintype I] [DecidableEq I]

	/-- Probability-normalized finite Walsh transform, expressed in the same
	sign-bit coordinates as the tree. -/
	def character (q x : I → Bit) : ℝ := ∏ i, sign (q i * x i)

	theorem bit_character_orthogonality (q q' : Bit) :
	(∑ x : Bit, sign (q * x) * sign (q' * x)) = if q = q' then 2 else 0 := by
	rcases bit_cases q with rfl \| rfl <;>
	rcases bit_cases q' with rfl \| rfl <;>
	norm_num [show (Finset.univ : Finset Bit) = {0, 1} by
	ext x; simp only [Finset.mem_univ, Finset.mem_insert, Finset.mem_singleton, true_iff];
	exact bit_cases x, sign]

	omit [DecidableEq I] in
	theorem character_symm (q x : I → Bit) : character q x = character x q := by
	simp only [character, mul_comm]

	theorem character_sum_orthogonality (q q' : I → Bit) :
	(∑ x, character q x * character q' x) =
	if q = q' then (Fintype.card (I → Bit) : ℝ) else 0 := by
	classical
	simp only [character, ← Finset.prod_mul_distrib]
	rw [← Fintype.prod_sum (fun (i : I) (b : Bit) => sign (q i * b) * sign (q' i * b))]
	simp only [bit_character_orthogonality]
	by_cases h : q = q'
	· subst q'
	simp [ZMod.card]
	· rw [ite_eq_right h]
	obtain ⟨i, hi⟩ := Function.ne_iff.mp h
	apply Finset.prod_eq_zero (Finset.mem_univ i)
	exact ite_eq_right hi

	noncomputable def bitCoefficient (f : (I → Bit) → ℝ) (q : I → Bit) : ℝ :=
	𝔼 x, f x * character q x

	theorem bitWalsh_inversion (f : (I → Bit) → ℝ) (x : I → Bit) :
	(∑ q, bitCoefficient f q * character q x) = f x := by
	classical
	unfold bitCoefficient
	simp_rw [Finset.expect_mul]
	rw [← Finset.expect_sum_comm]
	have h (y : I → Bit) :
	(∑ q, (f y * character q y) * character q x) =
	f y * (if y = x then (Fintype.card (I → Bit) : ℝ) else 0) := by
	simp only [mul_assoc, ← Finset.mul_sum]
	congr 1
	simp_rw [character_symm (x := y), character_symm (x := x)]
	exact character_sum_orthogonality y x
	simp_rw [h]
	rw [Fintype.expect_eq_sum_div_card]
	simp

	end BitWalsh

	theorem gate_expansion {s : ℕ} (F : Table s) (Z : Branch s → Bit) :
	sign (gate F Z) = ∑ q : Fin s → Bit,
	bitCoefficient (fun z => sign (F z)) q *
	∏ g, sign (Z (g, if q g = 0 then false else true)) := by
	classical
	rw [gate_sign, ← bitWalsh_inversion (fun z => sign (F z))
	(fun g => Z (g, false) + Z (g, true)), Finset.mul_sum]
	apply Finset.sum_congr rfl
	intro q _
	rw [mul_left_comm]
	congr 1
	simp only [character, ← Finset.prod_mul_distrib]
	apply Finset.prod_congr rfl
	intro g _
	rcases bit_cases (q g) with hq \| hq
	· simp [hq]
	· simp only [hq, one_mul, one_ne_zero, ↓reduceIte, sign_add]
	rw [← mul_assoc, ← pow_two, sign_sq, one_mul]

	section TensorSmoothing
	variable {I J H : Type*} [Fintype I] [DecidableEq I]
	[Fintype J] [DecidableEq J] [Fintype H] [DecidableEq H] [Nonempty H]

	theorem rowSmoothing_one (r : ℝ) (R : I → H) :
	rowSmoothing r (fun _ : I → H => (1 : ℝ)) R = 1 := by
	simp only [rowSmoothing, mul_one]
	exact rowsKernel_sum r R

	omit [Nonempty H] in
	theorem rowSmoothing_sum {K : Type*} [Fintype K]
	(r : ℝ) (f : K → (I → H) → ℝ) (R : I → H) :
	rowSmoothing r (fun x => ∑ k, f k x) R = ∑ k, rowSmoothing r (f k) R := by
	simp only [rowSmoothing, Finset.mul_sum]
	rw [Finset.sum_comm]

	omit [Nonempty H] in
	theorem rowSmoothing_smul (r a : ℝ) (f : (I → H) → ℝ) (R : I → H) :
	rowSmoothing r (fun x => a * f x) R = a * rowSmoothing r f R := by
	simp only [rowSmoothing, Finset.mul_sum]
	apply Finset.sum_congr rfl
	intro x _
	ring

	omit [Nonempty H] in
	/-- Independence of whole-row resampling across disjoint complete subtrees. -/
	theorem rowSmoothing_tensor (r : ℝ) (f : I → (J → H) → ℝ) (R : I × J → H) :
	rowSmoothing r (fun x => ∏ i, f i (fun j => x (i, j))) R =
	∏ i, rowSmoothing r (f i) (fun j => R (i, j)) := by
	classical
	unfold rowSmoothing rowsKernel
	rw [Fintype.sum_equiv (Equiv.curry I J H)
	(fun x => (∏ i : I × J, rowKernel r (R i) (x i)) * ∏ i, f i (fun j => x (i, j)))
	(fun x => ∏ i, ((∏ j, rowKernel r (R (i, j)) (x i j)) * f i (x i)))]
	· exact (Fintype.prod_sum (fun (i : I) (x : J → H) =>
	(∏ j, rowKernel r (R (i, j)) (x j)) * f i x)).symm
	· intro x
	simp only [Equiv.curry_apply, Function.curry, Fintype.prod_prod_type, Finset.prod_mul_distrib]
	rfl

	/-- A tensor product with one chosen member of each ordered pair. The unused
	subtrees are integrated with total mass exactly one. -/
	theorem rowSmoothing_pairs {s : ℕ} (r : ℝ) (b : Fin s → Bool)
	(f : Branch s → (J → H) → ℝ) (R : Branch s × J → H) :
	rowSmoothing r (fun x => ∏ g, f (g, b g) (fun j => x ((g, b g), j))) R =
	∏ g, rowSmoothing r (f (g, b g)) (fun j => R ((g, b g), j)) := by
	classical
	let h : Branch s → (J → H) → ℝ := fun gb x => if gb.2 = b gb.1 then f gb x else 1
	have hp (x : Branch s × J → H) :
	(∏ i : Branch s, h i (fun j => x (i, j))) =
	∏ g, f (g, b g) (fun j => x ((g, b g), j)) := by
	rw [Fintype.prod_prod_type]
	apply Finset.prod_congr rfl
	intro g _
	cases hb : b g <;> simp [h, hb]
	have hf := funext hp
	rw [← hf, rowSmoothing_tensor, Fintype.prod_prod_type]
	apply Finset.prod_congr rfl
	intro g _
	cases hb : b g <;> simp [h, hb, rowSmoothing_one]

	end TensorSmoothing

	theorem sum_sign : ∑ x : Bit, sign x = 0 := by
	rw [show (Finset.univ : Finset Bit) = {0, 1} by
	ext x; simp only [Finset.mem_univ, Finset.mem_insert, Finset.mem_singleton, true_iff]
	exact bit_cases x]
	norm_num

	theorem rowKernel_sign (r : ℝ) (x : Bit) :
	(∑ y, rowKernel r x y * sign y) = r * sign x := by
	simp only [rowKernel, add_mul, Finset.sum_add_distrib, ← Finset.mul_sum, sum_sign,
	mul_zero, add_zero]
	simp

	theorem word_leaf_smoothing {s m : ℕ} (F : Nodes s m → Table s)
	(r : ℝ) (x : Leaves s m → Bit) :
	rowSmoothing r (fun y => sign (word F y)) x = r ^ (s ^ m) * sign (word F x) := by
	induction m with
	\| zero =>
	change (∑ y : Unit → Bit, (∏ i : Unit, rowKernel r (x i) (y i)) * sign (y ())) = _
	simp only [Fintype.prod_unique]
	calc
	_ = ∑ y : Bit, rowKernel r (x ()) y * sign y := by
	exact Fintype.sum_equiv (Equiv.funUnique Unit Bit) _ _ (fun _ => rfl)
	_ = _ := by simpa only [pow_zero, pow_one, word] using rowKernel_sign r (x ())
	\| succ m ih =>
	have hx (y : Leaves s (m + 1) → Bit) :
	sign (word F y) = ∑ q : Fin s → Bit,
	bitCoefficient (fun z => sign (F (.inl ()) z)) q *
	∏ g, sign (word (fun v => F (.inr ((g, if q g = 0 then false else true), v)))
	(fun i => y ((g, if q g = 0 then false else true), i))) :=
	gate_expansion _ _
	rw [funext hx, rowSmoothing_sum]
	simp_rw [rowSmoothing_smul]
	have ht (q : Fin s → Bit) := rowSmoothing_pairs (J := Leaves s m) r
	(fun g => if q g = 0 then false else true)
	(fun gb y => sign (word (fun v => F (.inr (gb, v))) y)) x
	simp_rw [ht, ih, Finset.prod_mul_distrib, Finset.prod_const,
	Finset.card_univ, Fintype.card_fin]
	rw [hx]
	simp only [pow_succ, pow_mul]
	rw [Finset.mul_sum]
	apply Finset.sum_congr rfl
	intro q _
	ring

	end OptimalMaxCut.TreeCode

	end OAI