lean/OAI/Probability/CubeShuffle/Basic.lean

import Mathlib

namespace OAI

namespace CubeShuffle

open scoped BigOperators
open Filter

/-!
The physical Thorp chain on every binary position. A tape enumerates independent
fair pair coins; its push-forward is the full permutation distribution.
-/

abbrev Card (d : ℕ) := Fin d → Bool

/-- One coin for each pair, indexed by the unchanged tail of a binary position.
The one-card case is the deterministic extension of the physical definition. -/
def Coins : ℕ → Type
  | 0 => Unit
  | d + 1 => Card d → Bool

instance (d : ℕ) : Fintype (Coins d) := by
  cases d <;> dsimp [Coins] <;> infer_instance

instance (d : ℕ) : Nonempty (Coins d) := by
  cases d <;> dsimp [Coins] <;> infer_instance

/-- Switch the first-coordinate pairs, without rotating. -/
def switchFun {d : ℕ} (ξ : Card d → Bool) (x : Card (d + 1)) : Card (d + 1) :=
  Fin.cons (Bool.xor (x 0) (ξ (Fin.tail x))) (Fin.tail x)

theorem switchFun_involutive {d : ℕ} (ξ : Card d → Bool) :
    Function.Involutive (switchFun ξ) := by
  intro x
  funext i
  refine Fin.cases ?_ (fun j => ?_) i
  · simp only [switchFun, Fin.cons_zero, Fin.tail_cons]
    cases x 0 <;> cases ξ (Fin.tail x) <;> rfl
  · simp [switchFun, Fin.tail]

def pairSwitch {d : ℕ} (ξ : Card d → Bool) : Equiv.Perm (Card (d + 1)) :=
  { toFun := switchFun ξ
    invFun := switchFun ξ
    left_inv := switchFun_involutive ξ
    right_inv := switchFun_involutive ξ }

/-- `(x₁,…,x_d) ↦ (x₂,…,x_d,x₁)`. -/
def rotate (d : ℕ) : Equiv.Perm (Card d) where
  toFun x i := x (finRotate d i)
  invFun x i := x ((finRotate d).symm i)
  left_inv x := by funext i; simp only [Equiv.apply_symm_apply]
  right_inv x := by funext i; simp only [Equiv.symm_apply_apply]

/-- One physical shuffle: rotate after independently switching each pair. -/
def step : (d : ℕ) → Coins d → Equiv.Perm (Card d)
  | 0, _ => 1
  | d + 1, ξ => rotate (d + 1) * pairSwitch ξ

/-- The time-t permutation, with the latest physical shuffle multiplying on the left. -/
def run (d : ℕ) : (t : ℕ) → (Fin t → Coins d) → Equiv.Perm (Card d)
  | 0, _ => 1
  | t + 1, ω => step d (ω (Fin.last t)) * run d t (fun i => ω i.castSucc)

/-- The push-forward of the uniform law on all independent fair coin tapes. -/
noncomputable def law (d t : ℕ) (g : Equiv.Perm (Card d)) : ℝ :=
  (Fintype.card {ω : Fin t → Coins d // run d t ω = g} : ℝ) /
    (Fintype.card (Fin t → Coins d) : ℝ)

/-- Full-permutation total variation, with the source's factor one half. -/
noncomputable def distance (d t : ℕ) : ℝ :=
  (1 / 2 : ℝ) * ∑ g : Equiv.Perm (Card d),
    |law d t g - 1 / (Nat.factorial (2 ^ d) : ℝ)|

/-- First physical time with TV at most 1/4. The main conclusion proves this
set nonempty for every sufficiently large d. -/
noncomputable def mixingTime (d : ℕ) : ℕ :=
  sInf {t : ℕ | distance d t ≤ (1 / 4 : ℝ)}

/-- The exact integer lower bound, using log base two. -/
noncomputable def supportTimeBound (d : ℕ) : ℤ :=
  ⌈(2 / (2 : ℝ) ^ d) *
    (Real.log ((3 / 4 : ℝ) * (Nat.factorial (2 ^ d) : ℝ)) / Real.log 2)⌉

/-- Every clause of the literal optimal-order endpoint. The single absolute C
is in PHYSICAL time; convergence is to zero, not merely below a fixed cutoff. -/
def OptimalOrder : Prop :=
  ∃ C : ℕ, 0 < C ∧
    Tendsto (fun d : ℕ => distance d (C * d)) atTop (nhds 0) ∧
    (∀ d t : ℕ, 1 - (2 : ℝ) ^ ((t : ℝ) * (2 : ℝ) ^ d / 2) /
      (Nat.factorial (2 ^ d) : ℝ) ≤ distance d t) ∧
    (∀ᶠ d : ℕ in atTop,
      supportTimeBound d ≤ (mixingTime d : ℤ) ∧ mixingTime d ≤ C * d) ∧
    (∃ K : ℝ, ∀ᶠ d : ℕ in atTop, 2 * (d : ℝ) - K ≤ (mixingTime d : ℝ)) ∧
    Asymptotics.IsTheta atTop (fun d : ℕ => (mixingTime d : ℝ)) (fun d : ℕ => (d : ℝ))




/-- A finite uniform experiment pushed forward by an arbitrary map. -/
noncomputable def finiteLaw {α β : Type*} [Fintype α] (f : α → β) (b : β) : ℝ := by
  classical
  exact (Fintype.card {a : α // f a = b} : ℝ) / (Fintype.card α : ℝ)

lemma sum_card_fibers {α β : Type*} [Fintype α] [Fintype β] [DecidableEq β] (f : α → β) :
    ∑ b, Fintype.card {a : α // f a = b} = Fintype.card α := by
  classical
  rw [← Fintype.card_sigma]
  exact Fintype.card_congr (Equiv.sigmaFiberEquiv f)

lemma finiteLaw_nonneg {α β : Type*} [Fintype α] (f : α → β) (b : β) :
    0 ≤ finiteLaw f b := by
  exact div_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _)

lemma finiteLaw_sum {α β : Type*} [Fintype α] [Nonempty α] [Fintype β] (f : α → β) :
    ∑ b, finiteLaw f b = 1 := by
  classical
  simp only [finiteLaw, ← Finset.sum_div]
  have hc : (∑ b, (Fintype.card {a : α // f a = b} : ℝ)) = (Fintype.card α : ℝ) := by
    exact_mod_cast sum_card_fibers f
  rw [hc]
  exact div_self (Nat.cast_ne_zero.mpr Fintype.card_ne_zero)

lemma finiteLaw_eq_zero_of_not_mem {α β : Type*} [Fintype α] [DecidableEq β]
    (f : α → β) {b : β} (hb : b ∉ Finset.univ.image f) : finiteLaw f b = 0 := by
  classical
  have : IsEmpty {a : α // f a = b} := ⟨fun a => hb (Finset.mem_image.mpr
    ⟨a.val, Finset.mem_univ _, a.property⟩)⟩
  simp [finiteLaw]

/-- An event discrepancy is bounded by one-half L1, with no missing factor of two. -/
lemma event_le_totalVariation {β : Type*} [Fintype β] [DecidableEq β]
    (p q : β → ℝ) (hpq : ∑ b, (p b - q b) = 0) (s : Finset β) :
    (∑ b ∈ s, p b) - (∑ b ∈ s, q b) ≤ (1 / 2 : ℝ) * ∑ b, |p b - q b| := by
  have h₁ : (∑ b ∈ s, (p b - q b)) ≤ ∑ b ∈ s, |p b - q b| :=
    Finset.sum_le_sum (fun b _ => le_abs_self (p b - q b))
  have h₂ : -(∑ b ∈ sᶜ, (p b - q b)) ≤ ∑ b ∈ sᶜ, |p b - q b| := by
    rw [← Finset.sum_neg_distrib]
    exact Finset.sum_le_sum (fun b _ => neg_le_abs (p b - q b))
  have hz := Finset.sum_add_sum_compl s (fun b => p b - q b)
  have ha := Finset.sum_add_sum_compl s (fun b => |p b - q b|)
  rw [hpq] at hz
  rw [← Finset.sum_sub_distrib]
  linarith

/-- Information-theoretic support obstruction for a finite uniform experiment. -/
lemma finiteLaw_support_bound {α β : Type*} [Fintype α] [Nonempty α]
    [Fintype β] [Nonempty β] (f : α → β) :
    1 - (Fintype.card α : ℝ) / (Fintype.card β : ℝ) ≤
      (1 / 2 : ℝ) * ∑ b, |finiteLaw f b - 1 / (Fintype.card β : ℝ)| := by
  classical
  let s := Finset.univ.image f
  have hs : ∑ b ∈ s, finiteLaw f b = 1 := by
    have h := Finset.sum_subset (Finset.subset_univ s)
      (fun b _ hb => finiteLaw_eq_zero_of_not_mem f hb)
    simpa only [finiteLaw_sum] using h
  have hβ : (Fintype.card β : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr Fintype.card_ne_zero
  have hq : (∑ _b : β, 1 / (Fintype.card β : ℝ)) = 1 := by simp [hβ]
  have hd : (∑ b, (finiteLaw f b - 1 / (Fintype.card β : ℝ))) = 0 := by
    rw [Finset.sum_sub_distrib, finiteLaw_sum, hq, sub_self]
  have he := event_le_totalVariation (finiteLaw f) (fun _ => 1 / (Fintype.card β : ℝ)) hd s
  rw [hs] at he
  have hsq : (∑ _b ∈ s, 1 / (Fintype.card β : ℝ)) = (s.card : ℝ) / Fintype.card β := by
    simp [div_eq_mul_inv]
  rw [hsq] at he
  have hcard : (s.card : ℝ) ≤ Fintype.card α := by
    exact_mod_cast (Finset.card_image_le (s := (Finset.univ : Finset α)) (f := f))
  have hdiv := div_le_div_of_nonneg_right hcard (Nat.cast_nonneg (Fintype.card β) : (0 : ℝ) ≤ _)
  linarith

lemma card_positions (d : ℕ) : Fintype.card (Card d) = 2 ^ d := by
  simp [Card]

lemma card_permutations (d : ℕ) : Fintype.card (Equiv.Perm (Card d)) = Nat.factorial (2 ^ d) := by
  rw [Fintype.card_perm, card_positions]

lemma card_coins_succ (d : ℕ) : Fintype.card (Coins (d + 1)) = 2 ^ (2 ^ d) := by
  simp [Coins]

lemma card_tapes_succ (d t : ℕ) : Fintype.card (Fin t → Coins (d + 1)) = 2 ^ (t * 2 ^ d) := by
  rw [Fintype.card_fun, card_coins_succ, Fintype.card_fin, ← pow_mul, Nat.mul_comm]

lemma law_eq_finiteLaw (d t : ℕ) (g : Equiv.Perm (Card d)) :
    law d t g = finiteLaw (run d t) g := by
  unfold law finiteLaw
  apply congrArg (fun n : ℕ => (n : ℝ) / (Fintype.card (Fin t → Coins d) : ℝ))
  exact congrArg (@Fintype.card _) (Subsingleton.elim _ _)

lemma law_nonneg (d t : ℕ) (g : Equiv.Perm (Card d)) : 0 ≤ law d t g := by
  rw [law_eq_finiteLaw]
  exact finiteLaw_nonneg (run d t) g

lemma law_sum (d t : ℕ) : ∑ g, law d t g = 1 := by
  simp only [law_eq_finiteLaw]
  exact finiteLaw_sum (run d t)

lemma physical_support_bound_succ (d t : ℕ) :
    1 - (2 : ℝ) ^ (t * 2 ^ d) / (Nat.factorial (2 ^ (d + 1)) : ℝ) ≤ distance (d + 1) t := by
  have : Nonempty (Equiv.Perm (Card (d + 1))) := ⟨1⟩
  have h := finiteLaw_support_bound (run (d + 1) t)
  rw [card_tapes_succ, card_permutations] at h
  simpa only [Nat.cast_pow, Nat.cast_ofNat, distance, law_eq_finiteLaw] using h


/-- The coordinate formula in the manuscript, before any sweep conversion. -/
lemma step_succ_formula (d : ℕ) (ξ : Coins (d + 1)) (x : Card (d + 1)) :
    step (d + 1) ξ x = Fin.snoc (Fin.tail x) (Bool.xor (x 0) (ξ (Fin.tail x))) := by
  change (fun i => switchFun ξ x (finRotate (d + 1) i)) = _
  rw [Fin.snoc_eq_cons_rotate]
  rfl

lemma distance_nonneg (d t : ℕ) : 0 ≤ distance d t := by
  unfold distance
  exact mul_nonneg (by norm_num) (Finset.sum_nonneg (fun _ _ => abs_nonneg _))

/-- The exact support clause, uniform over every physical time and deck dimension. -/
lemma physical_support_bound (d t : ℕ) :
    1 - (2 : ℝ) ^ ((t : ℝ) * (2 : ℝ) ^ d / 2) /
      (Nat.factorial (2 ^ d) : ℝ) ≤ distance d t := by
  cases d with
  | zero =>
    have h : 1 ≤ (2 : ℝ) ^ ((t : ℝ) / 2) := Real.one_le_rpow (by norm_num) (by positivity)
    simpa only [pow_zero, Nat.factorial_one, Nat.cast_one, div_one, mul_one] using
      le_trans (sub_nonpos.mpr h) (distance_nonneg 0 t)
  | succ d =>
    have he : (t : ℝ) * (2 : ℝ) ^ (d + 1) / 2 = (t * 2 ^ d : ℕ) := by
      push_cast
      rw [pow_succ]
      ring
    rw [he, Real.rpow_natCast]
    exact physical_support_bound_succ d t

/-- Every time that attains the prescribed TV tolerance obeys the integer lower bound. -/
lemma supportTimeBound_le_of_distance_le (d t : ℕ) (ht : distance d t ≤ (1 / 4 : ℝ)) :
    supportTimeBound d ≤ (t : ℤ) := by
  have hF : (0 : ℝ) < Nat.factorial (2 ^ d) := by positivity
  have hN : (0 : ℝ) < (2 : ℝ) ^ d := by positivity
  have hL : (0 : ℝ) < Real.log 2 := Real.log_pos (by norm_num)
  have hb := physical_support_bound d t
  have hp : (3 / 4 : ℝ) ≤
      (2 : ℝ) ^ ((t : ℝ) * (2 : ℝ) ^ d / 2) / (Nat.factorial (2 ^ d) : ℝ) := by
    linarith
  have hr := (le_div_iff₀ hF).mp hp
  have hlog := Real.log_le_log (show (0 : ℝ) < (3 / 4 : ℝ) * Nat.factorial (2 ^ d) by positivity) hr
  rw [Real.log_rpow (by norm_num : (0 : ℝ) < 2)] at hlog
  unfold supportTimeBound
  apply Int.ceil_le.mpr
  simp only [Int.cast_natCast]
  calc
    2 / (2 : ℝ) ^ d * (Real.log ((3 / 4 : ℝ) * Nat.factorial (2 ^ d)) / Real.log 2) =
        Real.log ((3 / 4 : ℝ) * Nat.factorial (2 ^ d)) / ((2 : ℝ) ^ d / 2 * Real.log 2) := by
      field_simp
    _ ≤ (t : ℝ) := (div_le_iff₀ (mul_pos (div_pos hN (by norm_num)) hL)).mpr (by
      nlinarith [hlog])

/-- Once the defining set is nonempty, its minimum inherits the exact obstruction. -/
lemma supportTimeBound_le_mixingTime {d : ℕ}
    (h : ({t : ℕ | distance d t ≤ (1 / 4 : ℝ)} : Set ℕ).Nonempty) :
    supportTimeBound d ≤ (mixingTime d : ℤ) := by
  exact supportTimeBound_le_of_distance_le d (mixingTime d) (Nat.sInf_mem h)


lemma log_factorial_lower {n : ℕ} (hn : 1 ≤ n) :
    (n : ℝ) * Real.log n - n ≤ Real.log (Nat.factorial n) := by
  have h := Stirling.le_log_factorial_stirling (show n ≠ 0 by omega)
  have hln : 0 ≤ Real.log (n : ℝ) := Real.log_nonneg (by exact_mod_cast hn)
  have hlp : 0 ≤ Real.log (2 * Real.pi) := Real.log_nonneg (by
    have := Real.pi_gt_three
    linarith)
  linarith

lemma log_three_quarters_lower : -(1 : ℝ) ≤ Real.log (3 / 4 : ℝ) := by
  have h := Real.log_le_sub_one_of_pos (show (0 : ℝ) < 4 / 3 by norm_num)
  have he : Real.log (4 / 3 : ℝ) = - Real.log (3 / 4 : ℝ) := by
    rw [← Real.log_inv]
    congr 1
    norm_num
  rw [he] at h
  linarith

/-- An explicit version of the source's `2d - O(1)` support lower bound. -/
lemma linear_le_supportTimeBound (d : ℕ) :
    2 * (d : ℝ) - 4 / Real.log 2 ≤ (supportTimeBound d : ℝ) := by
  have hN : 1 ≤ (2 : ℝ) ^ d := one_le_pow₀ (by norm_num)
  have hNp : 0 < (2 : ℝ) ^ d := by positivity
  have hL : 0 < Real.log 2 := Real.log_pos (by norm_num)
  have hf := log_factorial_lower (show 1 ≤ 2 ^ d by exact one_le_pow₀ (by norm_num))
  have hlog : (2 : ℝ) ^ d * ((d : ℝ) * Real.log 2) - (2 : ℝ) ^ d - 1 ≤
      Real.log ((3 / 4 : ℝ) * (Nat.factorial (2 ^ d) : ℝ)) := by
    rw [Real.log_mul (by norm_num) (by positivity)]
    push_cast at hf
    rw [Real.log_pow] at hf
    linarith [log_three_quarters_lower]
  apply le_trans _ (Int.le_ceil _)
  have hmul : (2 * (d : ℝ) - 4 / Real.log 2) *
      ((2 : ℝ) ^ d / 2 * Real.log 2) ≤
      Real.log ((3 / 4 : ℝ) * (Nat.factorial (2 ^ d) : ℝ)) := by
    have hcancel : (2 * (d : ℝ) - 4 / Real.log 2) *
        ((2 : ℝ) ^ d / 2 * Real.log 2) =
        (2 : ℝ) ^ d * ((d : ℝ) * Real.log 2) - 2 * (2 : ℝ) ^ d := by
      field_simp
      ring
    rw [hcancel]
    linarith
  convert (le_div_iff₀ (mul_pos (div_pos hNp (by norm_num)) hL)).mpr hmul using 1
  field_simp


lemma linear_le_time_of_distance_le (d t : ℕ)
    (ht : distance d t ≤ (1 / 4 : ℝ)) :
    2 * (d : ℝ) - 4 / Real.log 2 ≤ (t : ℝ) := by
  have h := supportTimeBound_le_of_distance_le d t ht
  have hr : (supportTimeBound d : ℝ) ≤ (t : ℝ) := by exact_mod_cast h
  exact (linear_le_supportTimeBound d).trans hr


lemma entropy_chord (p : ℝ) (hp : 0 ≤ p) (hq : p ≤ 1 / 2) :
    2 * p * Real.log 2 ≤ Real.binEntropy p := by
  have hc := Real.strictConcave_binEntropy.concaveOn.2
    (show (0 : ℝ) ∈ Set.Icc (0 : ℝ) 1 by norm_num)
    (show (2 : ℝ)⁻¹ ∈ Set.Icc (0 : ℝ) 1 by norm_num)
    (show 0 ≤ 1 - 2 * p by linarith)
    (show 0 ≤ 2 * p by positivity)
    (show (1 - 2 * p) + 2 * p = 1 by ring)
  simpa only [Real.binEntropy_zero, Real.binEntropy_two_inv,
    smul_eq_mul, mul_zero, zero_add, show 2 * p * (2 : ℝ)⁻¹ = p by ring] using hc

lemma split_entropy_lower (a b : ℝ) (ha : 0 ≤ a) (hb : 0 ≤ b) :
    2 * min a b * Real.log 2 ≤
      (a + b) * Real.log (a + b) - a * Real.log a - b * Real.log b := by
  wlog hab : a ≤ b generalizing a b
  · have hba := this b a hb ha (le_of_not_ge hab)
    simpa only [min_comm, add_comm b a] using hba.trans_eq (show (b + a) * Real.log (b + a) - b * Real.log b - a * Real.log a =
      (a + b) * Real.log (a + b) - a * Real.log a - b * Real.log b by rw [add_comm b a]; ring)
  rw [min_eq_left hab]
  by_cases hz : a = 0
  · subst a
    simp
  have hap : 0 < a := lt_of_le_of_ne ha (Ne.symm hz)
  have hbp : 0 < b := hap.trans_le hab
  have hs : 0 < a + b := add_pos hap hbp
  have hp : 0 ≤ a / (a + b) := div_nonneg ha hs.le
  have hq : a / (a + b) ≤ 1 / 2 := (div_le_iff₀ hs).mpr (by linarith)
  have hc := mul_le_mul_of_nonneg_left (entropy_chord (a / (a + b)) hp hq) hs.le
  have he : (a + b) * Real.binEntropy (a / (a + b)) =
      (a + b) * Real.log (a + b) - a * Real.log a - b * Real.log b := by
    unfold Real.binEntropy
    rw [show 1 - a / (a + b) = b / (a + b) by field_simp; ring]
    simp only [Real.log_inv]
    rw [Real.log_div (ne_of_gt hap) (ne_of_gt hs),
      Real.log_div (ne_of_gt hbp) (ne_of_gt hs)]
    field_simp
    ring
  rw [he] at hc
  calc
    2 * a * Real.log 2 = (a + b) * (2 * (a / (a + b)) * Real.log 2) := by
      field_simp
    _ ≤ _ := hc


/-- Two independently routed half-sized butterflies, followed by the final
layer of first-coordinate pair switches. Coordinates are named in the reverse
of their editing order, as in the manuscript's recursive proof. -/
def Butterfly : ℕ → Type
  | 0 => Unit
  | d + 1 => (Card d → Bool) × (Bool → Butterfly d)

def childLift {d : ℕ} (p : Bool → Equiv.Perm (Card d)) : Equiv.Perm (Card (d + 1)) where
  toFun x := Fin.cons (x 0) (p (x 0) (Fin.tail x))
  invFun x := Fin.cons (x 0) ((p (x 0)).symm (Fin.tail x))
  left_inv x := by simp only [Fin.cons_zero, Fin.tail_cons, Equiv.symm_apply_apply, Fin.cons_self_tail]
  right_inv x := by simp only [Fin.cons_zero, Fin.tail_cons, Equiv.apply_symm_apply, Fin.cons_self_tail]

def butterflyPerm : (d : ℕ) → Butterfly d → Equiv.Perm (Card d)
  | 0, _ => 1
  | d + 1, b => pairSwitch b.1 * childLift (fun ε => butterflyPerm d (b.2 ε))

/-- The marked input paths assigned to one of the two recursive children. -/
noncomputable def childMarks {d : ℕ} (s : Finset (Card (d + 1))) (ε : Bool) :
    Finset (Card d) := (s.filter (fun x => x 0 = ε)).image Fin.tail

lemma card_childMarks {d : ℕ} (s : Finset (Card (d + 1))) (ε : Bool) :
    (childMarks s ε).card = (s.filter (fun x => x 0 = ε)).card := by
  classical
  unfold childMarks
  apply Finset.card_image_iff.mpr
  intro x hx y hy hxy
  have hx0 := (Finset.mem_filter.mp hx).2
  have hy0 := (Finset.mem_filter.mp hy).2
  rw [← Fin.cons_self_tail x, ← Fin.cons_self_tail y, hx0, hy0, hxy]

lemma card_childMarks_add {d : ℕ} (s : Finset (Card (d + 1))) :
    (childMarks s false).card + (childMarks s true).card = s.card := by
  classical
  rw [card_childMarks, card_childMarks]
  simpa only [Bool.not_eq_false] using
    (Finset.card_filter_add_card_filter_not (s := s) (fun x => x 0 = false))

/-- The switches in the final layer used by two marked paths. A switch is
indexed by the common tail at the end of the two child butterflies. -/
noncomputable def topMeetings {d : ℕ} (b : Butterfly (d + 1))
    (s : Finset (Card (d + 1))) : Finset (Card d) :=
  ((childMarks s false).image (butterflyPerm d (b.2 false))) ∩
    ((childMarks s true).image (butterflyPerm d (b.2 true)))

lemma card_topMeetings_le {d : ℕ} (b : Butterfly (d + 1)) (s : Finset (Card (d + 1))) :
    (topMeetings b s).card ≤ min (childMarks s false).card (childMarks s true).card := by
  classical
  apply le_min
  · exact (Finset.card_le_card Finset.inter_subset_left).trans_eq
      (Finset.card_image_of_injective _ (butterflyPerm d (b.2 false)).injective)
  · exact (Finset.card_le_card Finset.inter_subset_right).trans_eq
      (Finset.card_image_of_injective _ (butterflyPerm d (b.2 true)).injective)

/-- Total number of shared switches along the distinct marked routes. -/
noncomputable def encounters : (d : ℕ) → Butterfly d → Finset (Card d) → ℕ
  | 0, _, _ => 0
  | d + 1, b, s => encounters d (b.2 false) (childMarks s false) +
      encounters d (b.2 true) (childMarks s true) + (topMeetings b s).card

/-- Butterfly encounter estimate (`net:encounters`): no random hypotheses are
needed, and each switch contains at most two paths because each child routes
by a bijection. -/
lemma butterfly_encounters (d : ℕ) (b : Butterfly d) (s : Finset (Card d)) :
    (encounters d b s : ℝ) ≤ (s.card : ℝ) * Real.log s.card / (2 * Real.log 2) := by
  induction d with
  | zero =>
    simp only [encounters, Nat.cast_zero]
    have hs : s.card ≤ 1 := by
      simpa [Card] using Finset.card_le_univ s
    interval_cases s.card <;> simp
  | succ d ih =>
    have h₀ := ih (b.2 false) (childMarks s false)
    have h₁ := ih (b.2 true) (childMarks s true)
    have ht : ((topMeetings b s).card : ℝ) ≤
        min ((childMarks s false).card : ℝ) ((childMarks s true).card : ℝ) := by
      exact_mod_cast card_topMeetings_le b s
    have he := split_entropy_lower ((childMarks s false).card : ℝ)
      ((childMarks s true).card : ℝ) (by positivity) (by positivity)
    have hs : ((childMarks s false).card : ℝ) + (childMarks s true).card = s.card := by
      exact_mod_cast card_childMarks_add s
    rw [hs] at he
    have hL : 0 < 2 * Real.log 2 := by positivity
    rw [le_div_iff₀ hL] at h₀ h₁ ⊢
    simp only [encounters, Nat.cast_add]
    nlinarith [mul_le_mul_of_nonneg_right ht hL.le]



lemma prod_split_at {α : Type*} [DecidableEq α] (s : Finset α) (f : α → ℝ) (a : α) :
    ∏ i ∈ s, f i = (if a ∈ s then f a else 1) * ∏ i ∈ s.erase a, f i := by
  by_cases ha : a ∈ s
  · rw [ite_eq_left ha]
    exact (Finset.mul_prod_erase s f ha).symm
  · simp [ha]

lemma prod_split_two {α : Type*} [DecidableEq α] (s : Finset α) (f : α → ℝ)
    (a b : α) (hab : a ≠ b) :
    ∏ i ∈ s, f i = (if a ∈ s then f a else 1) * (if b ∈ s then f b else 1) *
      ∏ i ∈ (s.erase a).erase b, f i := by
  calc
    ∏ i ∈ s, f i = (if a ∈ s then f a else 1) * ∏ i ∈ s.erase a, f i :=
      prod_split_at s f a
    _ = _ := by
      rw [prod_split_at (s.erase a) f b]
      have hm : (b ∈ s.erase a) ↔ b ∈ s :=
        ⟨fun h => (Finset.mem_erase.mp h).2, fun h => Finset.mem_erase.mpr ⟨Ne.symm hab, h⟩⟩
      simp only [hm, mul_assoc]

/-- A fair transposition preserves the upper product bound on every inclusion
moment; this is the elementary input used in the factorial-moment route,
`11-palindrome.tex:94–97`. -/
lemma swap_average_product {α : Type*} [DecidableEq α] (s : Finset α) (p : α → ℝ)
    (hp : ∀ i, 0 ≤ p i) (a b : α) :
    ((∏ i ∈ s, p i) + ∏ i ∈ s, p (Equiv.swap a b i)) / 2 ≤
      ∏ i ∈ s, (p i + p (Equiv.swap a b i)) / 2 := by
  by_cases hab : a = b
  · subst b
    simp only [Equiv.swap_self, Equiv.refl_apply]
    have h : (fun i => (p i + p i) / 2) = p := by funext i; ring
    rw [h]
    linarith
  let t := (s.erase a).erase b
  have hfix : ∀ i ∈ t, Equiv.swap a b i = i := by
    intro i hi
    exact Equiv.swap_apply_of_ne_of_ne (Finset.mem_erase.mp (Finset.mem_erase.mp hi).2).1
      (Finset.mem_erase.mp hi).1
  have hprod : (∏ i ∈ t, p (Equiv.swap a b i)) = ∏ i ∈ t, p i :=
    Finset.prod_congr rfl (fun i hi => by rw [hfix i hi])
  have havg : (∏ i ∈ t, (p i + p (Equiv.swap a b i)) / 2) = ∏ i ∈ t, p i :=
    Finset.prod_congr rfl (fun i hi => by rw [hfix i hi]; ring)
  rw [prod_split_two s p a b hab,
    prod_split_two s (fun i => p (Equiv.swap a b i)) a b hab,
    prod_split_two s (fun i => (p i + p (Equiv.swap a b i)) / 2) a b hab]
  change ((if a ∈ s then p a else 1) * (if b ∈ s then p b else 1) * (∏ i ∈ t, p i) +
    (if a ∈ s then p (Equiv.swap a b a) else 1) *
      (if b ∈ s then p (Equiv.swap a b b) else 1) * (∏ i ∈ t, p (Equiv.swap a b i))) / 2 ≤ _
  rw [hprod]
  change _ ≤ (if a ∈ s then (p a + p (Equiv.swap a b a)) / 2 else 1) *
    (if b ∈ s then (p b + p (Equiv.swap a b b)) / 2 else 1) *
      (∏ i ∈ t, (p i + p (Equiv.swap a b i)) / 2)
  rw [havg, Equiv.swap_apply_left, Equiv.swap_apply_right]
  have ht : 0 ≤ ∏ i ∈ t, p i := Finset.prod_nonneg (fun i _ => hp i)
  by_cases ha : a ∈ s <;> by_cases hb : b ∈ s <;> simp only [ha, hb, ↓reduceIte]
  · have hsq := mul_nonneg (sq_nonneg (p a - p b)) ht
    nlinarith
  all_goals ring_nf; rfl

/-- Abstract inclusion moments `m(S)` and their coordinate marginal majorant.
This definition does not postulate independence. -/
def CylinderBound {α : Type*} (m : Finset α → ℝ) (p : α → ℝ) : Prop :=
  ∀ s, m s ≤ ∏ i ∈ s, p i

lemma CylinderBound.fair_swap {α : Type*} [DecidableEq α]
    {m : Finset α → ℝ} {p : α → ℝ} (h : CylinderBound m p)
    (hp : ∀ i, 0 ≤ p i) (a b : α) :
    CylinderBound (fun s => (m s + m (s.image (Equiv.swap a b))) / 2)
      (fun i => (p i + p (Equiv.swap a b i)) / 2) := by
  intro s
  have h₀ := h s
  have h₁ := h (s.image (Equiv.swap a b))
  rw [Finset.prod_image (Equiv.swap a b).injective.injOn] at h₁
  exact (show (m s + m (s.image (Equiv.swap a b))) / 2 ≤
      ((∏ i ∈ s, p i) + ∏ i ∈ s, p (Equiv.swap a b i)) / 2 by linarith).trans
    (swap_average_product s p hp a b)


/-- Uniform expectation in a finite experiment, kept in the real numbers. -/
noncomputable def finiteMean {Ω : Type*} [Fintype Ω] (f : Ω → ℝ) : ℝ :=
  (∑ ω, f ω) / Fintype.card Ω

/-- The inclusion moment of the random marked set `F`. -/
noncomputable def inclusionMoment {α Ω : Type*} [Fintype Ω]
    (F : Ω → Finset α) (s : Finset α) : ℝ := by
  classical
  exact finiteMean (fun ω => if s ⊆ F ω then 1 else 0)

lemma inclusionMoment_nonneg {α Ω : Type*} [Fintype Ω]
    (F : Ω → Finset α) (s : Finset α) : 0 ≤ inclusionMoment F s := by
  classical
  unfold inclusionMoment finiteMean
  positivity

lemma indicator_subset_prod {α : Type*} [DecidableEq α] (A s : Finset α) :
    (if s ⊆ A then (1 : ℝ) else 0) = ∏ i ∈ s, (if i ∈ A then 1 else 0) := by
  by_cases h : s ⊆ A
  · rw [ite_eq_left h]
    exact (Finset.prod_eq_one (fun i hi => ite_eq_left (h hi))).symm
  · rw [ite_eq_right h]
    obtain ⟨i, hi, hiA⟩ := Finset.not_subset.mp h
    exact (Finset.prod_eq_zero hi (ite_eq_right hiA)).symm

lemma inclusionMoment_const {α Ω : Type*} [DecidableEq α] [Fintype Ω] [Nonempty Ω]
    (A s : Finset α) : inclusionMoment (fun _ : Ω => A) s =
      if s ⊆ A then 1 else 0 := by
  classical
  have hn : (Fintype.card Ω : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr Fintype.card_ne_zero
  by_cases h : s ⊆ A <;> simp [inclusionMoment, finiteMean, h, hn]

lemma cylinder_const {α Ω : Type*} [Fintype Ω] [Nonempty Ω] (A : Finset α) :
    CylinderBound (inclusionMoment (fun _ : Ω => A))
      (fun i => inclusionMoment (fun _ : Ω => A) {i}) := by
  classical
  intro s
  simp only [inclusionMoment_const, Finset.singleton_subset_iff]
  exact (indicator_subset_prod A s).le

/-- Add an independent fair coin which chooses whether to transpose `a` and `b`. -/
noncomputable def fairSetSwap {α Ω : Type*} [DecidableEq α]
    (F : Ω → Finset α) (a b : α) : Ω × Bool → Finset α :=
  fun ω => if ω.2 then (F ω.1).image (Equiv.swap a b) else F ω.1

lemma subset_swap_image_iff {α : Type*} [DecidableEq α]
    (A s : Finset α) (a b : α) :
    s ⊆ A.image (Equiv.swap a b) ↔ s.image (Equiv.swap a b) ⊆ A := by
  constructor
  · intro h
    have h' := Finset.image_subset_image h (f := Equiv.swap a b)
    simpa only [Finset.image_image, Function.comp_def, Equiv.swap_apply_self, Finset.image_id'] using h'
  · intro h
    have h' := Finset.image_subset_image h (f := Equiv.swap a b)
    simpa only [Finset.image_image, Function.comp_def, Equiv.swap_apply_self, Finset.image_id'] using h'

lemma inclusionMoment_fairSetSwap {α Ω : Type*} [DecidableEq α] [Fintype Ω]
    (F : Ω → Finset α) (a b : α) (s : Finset α) :
    inclusionMoment (fairSetSwap F a b) s =
      (inclusionMoment F s + inclusionMoment F (s.image (Equiv.swap a b))) / 2 := by
  classical
  simp only [inclusionMoment, finiteMean, Fintype.sum_prod_type, Fintype.sum_bool,
    fairSetSwap, Bool.false_eq_true, ↓reduceIte, Fintype.card_prod, Fintype.card_bool,
    Nat.cast_mul, Nat.cast_ofNat, subset_swap_image_iff, Finset.sum_add_distrib]
  rw [div_mul_eq_div_div, add_div]
  ring_nf

lemma cylinder_fairSetSwap {α Ω : Type*} [DecidableEq α] [Fintype Ω]
    (F : Ω → Finset α) (a b : α)
    (h : CylinderBound (inclusionMoment F) (fun i => inclusionMoment F {i})) :
    CylinderBound (inclusionMoment (fairSetSwap F a b))
      (fun i => inclusionMoment (fairSetSwap F a b) {i}) := by
  classical
  have h' := h.fair_swap (fun i => inclusionMoment_nonneg F {i}) a b
  intro s
  simpa only [inclusionMoment_fairSetSwap, Finset.image_singleton] using h' s

/-- An explicit product of independent fair coins, of a recursively specified length. -/
def SwitchSamples : ℕ → Type
  | 0 => Unit
  | n + 1 => SwitchSamples n × Bool

instance (n : ℕ) : Fintype (SwitchSamples n) := by
  induction n with
  | zero => exact inferInstanceAs (Fintype Unit)
  | succ n ih => exact inferInstanceAs (Fintype (SwitchSamples n × Bool))

instance (n : ℕ) : Nonempty (SwitchSamples n) := by
  induction n with
  | zero => exact inferInstanceAs (Nonempty Unit)
  | succ n ih => exact inferInstanceAs (Nonempty (SwitchSamples n × Bool))

/-- Successive independent fair transpositions, listed in reverse time order. -/
noncomputable def switchedSet {α : Type*} [DecidableEq α] (A : Finset α) :
    (L : List (α × α)) → SwitchSamples L.length → Finset α
  | [], _ => A
  | (a,b) :: L, ω => fairSetSwap (switchedSet A L) a b ω

/-- Actual inclusion moments after any deterministic sequence of independent
fair switches satisfy the upper product-of-marginals bound. -/
lemma switchedSet_cylinder {α : Type*} [DecidableEq α] (A : Finset α)
    (L : List (α × α)) :
    CylinderBound (inclusionMoment (switchedSet A L))
      (fun i => inclusionMoment (switchedSet A L) {i}) := by
  induction L with
  | nil => exact cylinder_const A
  | cons e L ih => exact cylinder_fairSetSwap (switchedSet A L) e.1 e.2 ih

lemma finiteMean_congr {Ω : Type*} [Fintype Ω] {f g : Ω → ℝ}
    (h : ∀ ω, f ω = g ω) : finiteMean f = finiteMean g := by
  unfold finiteMean
  congr 1
  exact Finset.sum_congr rfl (fun ω _ => h ω)

lemma finiteMean_add {Ω : Type*} [Fintype Ω] (f g : Ω → ℝ) :
    finiteMean (fun ω => f ω + g ω) = finiteMean f + finiteMean g := by
  simp only [finiteMean,Finset.sum_add_distrib,add_div]

lemma finiteMean_mul_const {Ω : Type*} [Fintype Ω] (f : Ω → ℝ) (c : ℝ) :
    finiteMean (fun ω => f ω * c) = finiteMean f * c := by
  unfold finiteMean
  rw [← Finset.sum_mul]
  ring

lemma finiteMean_sum {Ω α : Type*} [Fintype Ω] (s : Finset α) (f : α → Ω → ℝ) :
    finiteMean (fun ω => ∑ i ∈ s, f i ω) = ∑ i ∈ s, finiteMean (f i) := by
  simp only [finiteMean,Finset.sum_div]
  exact Finset.sum_comm

lemma finiteMean_mono {Ω : Type*} [Fintype Ω] {f g : Ω → ℝ}
    (h : ∀ ω, f ω ≤ g ω) : finiteMean f ≤ finiteMean g := by
  exact div_le_div_of_nonneg_right (Finset.sum_le_sum (fun ω _ => h ω)) (Nat.cast_nonneg _)

lemma finiteMean_equiv {Ω Ω' : Type*} [Fintype Ω] [Fintype Ω']
    (e : Ω ≃ Ω') (f : Ω → ℝ) :
    finiteMean f = finiteMean (fun ω => f (e.symm ω)) := by
  unfold finiteMean
  rw [Fintype.card_congr e]
  congr 1
  exact Fintype.sum_equiv e _ _ (fun ω => by simp)

lemma finiteMean_prod_left {Ω Ω' : Type*} [Fintype Ω] [Fintype Ω'] [Nonempty Ω']
    (f : Ω → ℝ) : finiteMean (fun ω : Ω × Ω' => f ω.1) = finiteMean f := by
  simp only [finiteMean,Fintype.sum_prod_type,Finset.sum_const,nsmul_eq_mul,
    ← Finset.mul_sum,Fintype.card_prod,Nat.cast_mul,Finset.card_univ]
  have hn : (Fintype.card Ω' : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr Fintype.card_ne_zero
  field_simp

lemma finiteMean_pi_eval {C : Type*} [Fintype C] [DecidableEq C]
    {A : C → Type*} [∀ c, Fintype (A c)] [∀ c, Nonempty (A c)]
    (c : C) (g : A c → ℝ) :
    finiteMean (fun z : ∀ c, A c => g (z c)) = finiteMean g := by
  rw [finiteMean_equiv (Equiv.piSplitAt c A)]
  have he : (fun z : A c × ((j : {j // j ≠ c}) → A j) =>
      g ((Equiv.piSplitAt c A).symm z c)) = (fun z => g z.1) := by
    funext z
    simp [Equiv.piSplitAt]
  rw [he,finiteMean_prod_left]

lemma finiteMean_eq_indicator {Ω : Type*} [Fintype Ω] [DecidableEq Ω] (a : Ω) :
    finiteMean (fun ω : Ω => if ω = a then (1:ℝ) else 0) = 1 / Fintype.card Ω := by
  simp [finiteMean]

lemma exp_finiteMean_le {Ω : Type*} [Fintype Ω] [Nonempty Ω] (f : Ω → ℝ) :
    Real.exp (finiteMean f) ≤ finiteMean (fun ω => Real.exp (f ω)) := by
  have hn : (Fintype.card Ω : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr Fintype.card_ne_zero
  have hw : ∑ ω : Ω, (1 / (Fintype.card Ω : ℝ)) = 1 := by simp [hn]
  have hj := convexOn_exp.map_sum_le (t := Finset.univ)
    (w := fun _ : Ω => 1 / (Fintype.card Ω : ℝ)) (p := f)
    (fun _ _ => by positivity) hw (fun _ _ => Set.mem_univ _)
  simp only [smul_eq_mul, ← Finset.mul_sum] at hj
  simpa only [finiteMean, div_eq_mul_inv, one_div, mul_comm, mul_one, one_mul] using hj

end CubeShuffle

end OAI