lean/OAI/Probability/CoordinateSweeps/Grid.lean

import Mathlib

namespace OAI

noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators ComplexConjugate Matrix.Norms.L2Operator
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators ComplexOrder MatrixOrder
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators ENNReal
open MeasureTheory
noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
noncomputable section
open scoped BigOperators
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
attribute [local instance] Classical.propDecidable
namespace CoordinateSweeps

/- A probability law on a finite sample space, with real-valued masses. -/
structure FiniteLaw (Ω : Type*) where
  mass : Ω → ℝ
  nonneg : ∀ x, 0 ≤ mass x
  total : ∑ᶠ x, mass x = 1

namespace FiniteLaw

variable {Ω X Y : Type*}

instance : CoeFun (FiniteLaw Ω) (fun _ => Ω → ℝ) := ⟨FiniteLaw.mass⟩

@[ext] theorem ext {μ ν : FiniteLaw Ω} (h : ∀ x, μ x = ν x) : μ = ν := by
  cases μ
  cases ν
  congr
  exact funext h

variable [Fintype Ω] [Fintype X] [Fintype Y]

@[simp] theorem sum_mass (μ : FiniteLaw Ω) : ∑ x, μ x = 1 := by
  simpa only [finsum_eq_sum_of_fintype] using μ.total

/- Uniform probability, not counting measure. -/
def uniform (Ω : Type*) [Fintype Ω] [Nonempty Ω] : FiniteLaw Ω where
  mass _ := (Fintype.card Ω : ℝ)⁻¹
  nonneg _ := inv_nonneg.mpr (Nat.cast_nonneg _)
  total := by
    rw [finsum_eq_sum_of_fintype]
    simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul]
    exact mul_inv_cancel₀ (by exact_mod_cast Fintype.card_ne_zero)

/- Push forward a law; the sample space need not map injectively. -/
def map (μ : FiniteLaw Ω) (f : Ω → X) : FiniteLaw X where
  mass y := ∑ x, if f x = y then μ x else 0
  nonneg y := Finset.sum_nonneg (fun x _ => by split_ifs; exact μ.nonneg x; exact le_rfl)
  total := by
    rw [finsum_eq_sum_of_fintype]
    classical
    rw [Finset.sum_comm]
    simp [μ.sum_mass]

@[simp] theorem uniform_apply [Nonempty Ω] (x : Ω) : uniform Ω x =
    (Fintype.card Ω : ℝ)⁻¹ := rfl

@[simp] theorem map_apply (μ : FiniteLaw Ω) (f : Ω → X) (y : X) :
    μ.map f y = ∑ x, if f x = y then μ x else 0 := rfl

/- Mixture of two laws, with the real probability range explicit. -/
def mix (μ ν : FiniteLaw Ω) (z : ℝ) (hz : 0 ≤ z) (hz' : z ≤ 1) : FiniteLaw Ω where
  mass x := (1 - z) * μ x + z * ν x
  nonneg x := add_nonneg (mul_nonneg (sub_nonneg.mpr hz') (μ.nonneg x))
    (mul_nonneg hz (ν.nonneg x))
  total := by
    rw [finsum_eq_sum_of_fintype]
    simp only [Finset.sum_add_distrib, ← Finset.mul_sum, μ.sum_mass, ν.sum_mass]
    ring

/- Independent laws on finitely many (possibly different) finite spaces. -/
def independent {ι : Type*} [Fintype ι] {A : ι → Type*} [∀ i, Fintype (A i)]
    (μ : ∀ i, FiniteLaw (A i)) : FiniteLaw (∀ i, A i) where
  mass x := ∏ i, μ i (x i)
  nonneg x := Finset.prod_nonneg (fun i _ => (μ i).nonneg (x i))
  total := by
    rw [finsum_eq_sum_of_fintype]
    rw [← Fintype.prod_sum]
    simp only [FiniteLaw.sum_mass, Finset.prod_const_one]

/- The finite total-variation convention of the source: half the l1 distance. -/
def tv (μ ν : FiniteLaw Ω) : ℝ := (1 / 2 : ℝ) * ∑ x, |μ x - ν x|

/- Probability of an event. -/
def event (μ : FiniteLaw Ω) (s : Finset Ω) : ℝ := ∑ x ∈ s, μ x

end FiniteLaw

def lineCost (m u : ℕ) : ℝ :=
  Real.log ((m : ℝ)^u / (m.descFactorial u : ℝ))

theorem monotone_prefix_average (f : ℕ → ℝ) {u m : ℕ} (hu : u ≤ m)
    (hf : ∀ i < m, ∀ j < m, i ≤ j → f i ≤ f j) :
    (m : ℝ) * (∑ i ∈ Finset.range u, f i) ≤
      (u : ℝ) * (∑ i ∈ Finset.range m, f i) := by
  have h : (∑ i ∈ Finset.range u, ∑ j ∈ Finset.Ico u m, f i) ≤
      ∑ i ∈ Finset.range u, ∑ j ∈ Finset.Ico u m, f j := by
    apply Finset.sum_le_sum
    intro i hi
    apply Finset.sum_le_sum
    intro j hj
    have hi' := Finset.mem_range.mp hi
    have hj' := Finset.mem_Ico.mp hj
    exact hf i (lt_of_lt_of_le hi' hu) j hj'.2 (le_trans (le_of_lt hi') hj'.1)
  simp only [Finset.sum_const, Nat.card_Ico, Finset.card_range, nsmul_eq_mul,
    ← Finset.mul_sum, Nat.cast_sub hu] at h
  have hs := Finset.sum_range_add_sum_Ico f hu
  nlinarith

theorem sum_corrections (m u : ℕ) (hu : u ≤ m) :
    (∑ j ∈ Finset.range u, (Real.log m - Real.log (m-j : ℕ))) =
       (u : ℝ) * Real.log m - Real.log (m.descFactorial u : ℝ) := by
  induction u with
  | zero => simp
  | succ u ih =>
    have hum : u ≤ m := by omega
    rw [Finset.sum_range_succ, ih hum, Nat.descFactorial_succ, Nat.cast_mul,
      Real.log_mul (by exact_mod_cast (show m-u ≠ 0 by omega))
        (by exact_mod_cast (Nat.descFactorial_pos.mpr hum).ne')]
    push_cast
    ring

theorem lineCost_eq (m u : ℕ) (hm : 0 < m) (hu : u ≤ m) :
    lineCost m u = ∑ j ∈ Finset.range u, (Real.log m - Real.log (m-j : ℕ)) := by
  rw [lineCost, Real.log_div (by positivity)
    (by exact_mod_cast (Nat.descFactorial_pos.mpr hu).ne'), Real.log_pow,
    sum_corrections m u hu]

theorem lineCost_nonneg (m u : ℕ) (hm : 0 < m) (hu : u ≤ m) :
    0 ≤ lineCost m u := by
  rw [lineCost_eq m u hm hu]
  apply Finset.sum_nonneg
  intro j hj
  have hj' : j < m := (Finset.mem_range.mp hj).trans_le hu
  apply sub_nonneg.mpr
  apply Real.log_le_log
  · exact_mod_cast (show 0 < m-j by omega)
  · exact_mod_cast (Nat.sub_le m j)

theorem full_lineCost_le (m : ℕ) (hm : 0 < m) : lineCost m m ≤ m := by
  have hs := Stirling.le_log_factorial_stirling (Nat.ne_of_gt hm)
  have hm1 : (1 : ℝ) ≤ m := by exact_mod_cast hm
  have hp : 0 ≤ Real.log (2 * Real.pi) := Real.log_nonneg (by linarith [Real.pi_gt_three])
  have hl : 0 ≤ Real.log (m : ℝ) := Real.log_nonneg hm1
  rw [lineCost_eq m m hm le_rfl, sum_corrections m m le_rfl, Nat.descFactorial_self]
  linarith

theorem lineCost_le (m u : ℕ) (hm : 0 < m) (hu : u ≤ m) : lineCost m u ≤ u := by
  have hs := monotone_prefix_average (fun j => Real.log m - Real.log (m-j : ℕ)) hu
    (by
      intro i hi j hj hij
      have hlog : Real.log (m-j : ℕ) ≤ Real.log (m-i : ℕ) :=
        Real.log_le_log (by exact_mod_cast (show 0 < m-j by omega))
          (by exact_mod_cast (Nat.sub_le_sub_left hij m))
      linarith)
  rw [← lineCost_eq m u hm hu, ← lineCost_eq m m hm le_rfl] at hs
  have hall := full_lineCost_le m hm
  have hu0 : (0 : ℝ) ≤ u := Nat.cast_nonneg u
  have hm0 : (0 : ℝ) < m := Nat.cast_pos.mpr hm
  nlinarith

/- Binary positions with their actual bit-coordinate labels. -/
abbrev Cube (d : ℕ) := Fin d → Bool

/- Switches on a family of disjoint two-point fibers. -/
def pairSwitch {L : Type*} (bits : L → Bool) : Equiv.Perm (Bool × L) where
  toFun x := (Bool.xor x.1 (bits x.2), x.2)
  invFun x := (Bool.xor x.1 (bits x.2), x.2)
  left_inv x := by
    rcases x with ⟨b, l⟩
    change ((b ^^ bits l) ^^ bits l, l) = (b, l)
    cases b <;> cases bits l <;> simp
  right_inv x := by
    rcases x with ⟨b, l⟩
    change ((b ^^ bits l) ^^ bits l, l) = (b, l)
    cases b <;> cases bits l <;> simp

/- The parallel-edge switch layer in one specified bit direction. -/
def binaryLayer {d : ℕ} (j : Fin d) (bits : ({k : Fin d // k ≠ j} → Bool) → Bool) :
    Equiv.Perm (Cube d) :=
  (Equiv.funSplitAt j Bool).trans ((pairSwitch bits).trans (Equiv.funSplitAt j Bool).symm)

/- Ordered composition: coordinate 0 is visited first. -/
def orderedProduct {G : Type*} [Monoid G] {d : ℕ} (g : Fin d → G) : G :=
  (List.ofFn g).reverse.prod

/- Exactly one independent fair bit for every stage-edge. -/
abbrev BinaryChoices (d : ℕ) := ∀ j : Fin d, ({k : Fin d // k ≠ j} → Bool) → Bool

instance (d : ℕ) : Nonempty (BinaryChoices d) := ⟨fun _ _ => false⟩

/- One binary coordinate sweep, with all individual switches specified. -/
def binarySweep (d : ℕ) (bits : BinaryChoices d) : Equiv.Perm (Cube d) :=
  orderedProduct (fun j => binaryLayer j (bits j))

/- The source's B_(2^d), as the pushforward of the independent fair switches. -/
def binaryLaw (d : ℕ) : FiniteLaw (Equiv.Perm (Cube d)) :=
  (FiniteLaw.uniform (BinaryChoices d)).map (binarySweep d)

/- The line law L_m(z)=(1-z)U_m+zB_m, with m=2^d. -/
def lineLaw (d : ℕ) (z : ℝ) (hz : 0 ≤ z) (hz' : z ≤ 1) :
    FiniteLaw (Equiv.Perm (Cube d)) :=
  (FiniteLaw.uniform _).mix (binaryLaw d) z hz hz'

/- An ordered power-of-two grid. Its coordinate bounds are kept in the theorem,
not hidden in a change to the definition of the process. -/
structure Grid where
  b : ℕ
  positive : 0 < b
  bits : Fin b → ℕ

namespace Grid

def size (G : Grid) : ℕ := ∏ j, 2 ^ G.bits j

abbrev Slot (G : Grid) := ∀ j, Cube (G.bits j)

abbrev Line (G : Grid) (j : Fin G.b) := ∀ k : {k : Fin G.b // k ≠ j}, Cube (G.bits k)

abbrev Choices (G : Grid) := ∀ j, G.Line j → Equiv.Perm (Cube (G.bits j))

/- Simultaneous permutations on disjoint coordinate lines. -/
def fiberPerm {A B : Type*} (p : B → Equiv.Perm A) : Equiv.Perm (A × B) where
  toFun x := (p x.2 x.1, x.2)
  invFun x := ((p x.2).symm x.1, x.2)
  left_inv x := by simp
  right_inv x := by simp

def stage (G : Grid) (ω : G.Choices) (j : Fin G.b) : Equiv.Perm G.Slot :=
  (Equiv.piSplitAt j (fun k => Cube (G.bits k))).trans
    ((fiberPerm (ω j)).trans (Equiv.piSplitAt j (fun k => Cube (G.bits k))).symm)

/- The partial sweep at a stage boundary, including boundaries 0 and b. -/
def boundary (G : Grid) (ω : G.Choices) (t : ℕ) : Equiv.Perm G.Slot :=
  ((List.ofFn (G.stage ω)).take t).reverse.prod

def sweep (G : Grid) (ω : G.Choices) : Equiv.Perm G.Slot := G.boundary ω G.b

/- Independent line choices for a single coordinate stage. -/
def stageLaw (G : Grid) (j : Fin G.b) (z : ℝ) (hz : 0 ≤ z) (hz' : z ≤ 1) :
    FiniteLaw (G.Line j → Equiv.Perm (Cube (G.bits j))) :=
  FiniteLaw.independent (fun _ : G.Line j => lineLaw (G.bits j) z hz hz')

/- All stage-lines randomize independently, exactly as in 03-paths:5-17. -/
def choiceLaw (G : Grid) (z : ℝ) (hz : 0 ≤ z) (hz' : z ≤ 1) : FiniteLaw G.Choices :=
  FiniteLaw.independent (fun j => G.stageLaw j z hz hz')

/- Allowed grid, with R=2^r. This is precisely m_j ∈ [R,R²] in bit coordinates. -/
def Allowed (G : Grid) (r : ℕ) : Prop := ∀ j, r ≤ G.bits j ∧ G.bits j ≤ 2 * r

/- Prescribed disjoint trajectories; disjointness is required at every boundary. -/
structure Holes (G : Grid) (h : ℕ) where
  path : Fin h → Fin (G.b + 1) → G.Slot
  disjoint : ∀ t, Function.Injective (fun i => path i t)
  coordinate_step : ∀ i (j : Fin G.b) (k : Fin G.b), k ≠ j →
    path i j.succ k = path i j.castSucc k

namespace Holes

variable {G : Grid} {h : ℕ}

def Compatible (H : G.Holes h) (ω : G.Choices) : Prop :=
  ∀ i (t : Fin (G.b + 1)), G.boundary ω t (H.path i 0) = H.path i t

def Feasible (H : G.Holes h) : Prop := ∃ ω, H.Compatible ω

/- Holes using a particular stage-line, counted before that stage. -/
def lineCount (H : G.Holes h) (j : Fin G.b) (L : G.Line j) : ℕ :=
  (Finset.univ.filter (fun i : Fin h =>
    (fun k : {k : Fin G.b // k ≠ j} => H.path i j.castSucc k) = L)).card

/- The exact falling-factorial potential C(H), with (m)_0=1. -/
def cost (H : G.Holes h) : ℝ :=
  ∑ j, ∑ L : G.Line j,
    Real.log (((2 ^ G.bits j : ℕ) : ℝ) ^ H.lineCount j L /
      ((2 ^ G.bits j).descFactorial (H.lineCount j L) : ℝ))

theorem lineCount_le (H : G.Holes h) (j : Fin G.b) (L : G.Line j) :
    H.lineCount j L ≤ 2 ^ G.bits j := by
  have hb : H.lineCount j L ≤ Fintype.card (Cube (G.bits j)) := by
    apply Finset.card_le_card_of_injOn (fun i => H.path i j.castSucc j)
    · intro _ _
      exact Finset.mem_univ _
    · intro i hi i' hi' he
      apply H.disjoint j.castSucc
      funext k
      by_cases hk : k = j
      · subst k
        exact he
      · have h1 := (Finset.mem_filter.mp hi).2
        have h2 := (Finset.mem_filter.mp hi').2
        exact (congrFun h1 ⟨k, hk⟩).trans (congrFun h2 ⟨k, hk⟩).symm
  simpa [Cube] using hb

theorem sum_lineCount (H : G.Holes h) (j : Fin G.b) :
    ∑ L : G.Line j, H.lineCount j L = h := by
  unfold lineCount
  simp only [Finset.card_eq_sum_ones, Finset.sum_filter]
  rw [Finset.sum_comm]
  simp

theorem cost_nonneg (H : G.Holes h) : 0 ≤ H.cost := by
  apply Finset.sum_nonneg
  intro j _
  apply Finset.sum_nonneg
  intro L _
  exact lineCost_nonneg _ _ (by positivity) (H.lineCount_le j L)

theorem cost_le (H : G.Holes h) : H.cost ≤ (G.b : ℝ) * h := by
  calc
    H.cost ≤ ∑ j, ∑ L : G.Line j, (H.lineCount j L : ℝ) := by
      apply Finset.sum_le_sum
      intro j _
      apply Finset.sum_le_sum
      intro L _
      exact lineCost_le _ _ (by positivity) (H.lineCount_le j L)
    _ = (G.b : ℝ) * h := by
      simp only [← Nat.cast_sum, H.sum_lineCount]
      simp

/- Permutations of the free input sites, presented as permutations fixing the
prescribed inputs. This is the symmetric group on exactly s-h sites. -/
def stabilizer (H : G.Holes h) : Subgroup (Equiv.Perm G.Slot) where
  carrier g := ∀ i, g (H.path i 0) = H.path i 0
  one_mem' _ := rfl
  mul_mem' := by
    intro g g' hg hg' i
    change g (g' (H.path i 0)) = H.path i 0
    rw [hg' i, hg i]
  inv_mem' hg i := (Equiv.symm_apply_eq _).mpr (hg i).symm

/- One feasible reference bijection is a permitted choice of identifications
of the remaining input and output sites (02-preliminaries:5). -/
def reference (H : G.Holes h) (hf : H.Feasible) : G.Choices := hf.choose

theorem reference_compatible (H : G.Holes h) (hf : H.Feasible) :
    H.Compatible (H.reference hf) := hf.choose_spec

/- The remaining permutation relative to those identifications. -/
def residual (H : G.Holes h) (hf : H.Feasible) (ω : {ω : G.Choices // H.Compatible ω}) :
    H.stabilizer :=
  ⟨(G.sweep (H.reference hf))⁻¹ * G.sweep ω.val, by
    intro i
    change (G.sweep (H.reference hf)).symm (G.sweep ω.val (H.path i 0)) = H.path i 0
    apply (Equiv.symm_apply_eq _).mpr
    exact (ω.property i (Fin.last _)).trans ((H.reference_compatible hf i (Fin.last _)).symm)⟩

end Holes

/- Joint mass of all independent stage-line choices. -/
def choiceWeight (G : Grid) (z : ℝ) (ω : G.Choices) : ℝ :=
  ∏ j, ∏ L : G.Line j,
    ((1-z) * (Fintype.card (Equiv.Perm (Cube (G.bits j))) : ℝ)⁻¹ +
      z * binaryLaw (G.bits j) (ω j L))

@[simp] theorem choiceWeight_eq (G : Grid) (z : ℝ) (hz : 0 ≤ z) (hz' : z ≤ 1)
    (ω : G.Choices) : G.choiceWeight z ω = G.choiceLaw z hz hz' ω := rfl

theorem choiceWeight_pos (G : Grid) {z : ℝ} (hz : 0 ≤ z) (hz' : z < 1)
    (ω : G.Choices) : 0 < G.choiceWeight z ω := by
  apply Finset.prod_pos
  intro j _
  apply Finset.prod_pos
  intro L _
  apply add_pos_of_pos_of_nonneg
  · apply mul_pos (sub_pos.mpr hz')
    exact inv_pos.mpr (Nat.cast_pos.mpr Fintype.card_pos)
  · exact mul_nonneg hz ((binaryLaw (G.bits j)).nonneg (ω j L))

end Grid

namespace Grid

variable (G : Grid)

@[simp] theorem boundary_zero (ω : G.Choices) : G.boundary ω 0 = 1 := by
  simp [boundary]

theorem boundary_succ (ω : G.Choices) {t : ℕ} (ht : t < G.b) :
    G.boundary ω (t+1) = G.stage ω ⟨t,ht⟩ * G.boundary ω t := by
  unfold boundary
  rw [List.take_succ_eq_append_getElem (by simpa using ht)]
  simp [List.reverse_append]

@[simp] theorem stage_apply_same (ω : G.Choices) (j : Fin G.b) (x : G.Slot) :
    G.stage ω j x j = ω j (fun k => x k) (x j) := by
  simp [stage, fiberPerm, Equiv.piSplitAt_apply, Equiv.piSplitAt_symm_apply]

theorem stage_apply_ne (ω : G.Choices) (j k : Fin G.b) (hk : k ≠ j) (x : G.Slot) :
    G.stage ω j x k = x k := by
  simp [stage, fiberPerm, Equiv.piSplitAt_apply, Equiv.piSplitAt_symm_apply, hk]

namespace Holes
variable {G} {h : ℕ}

def StepCompatible (H : G.Holes h) (ω : G.Choices) : Prop :=
  ∀ i (j : Fin G.b), G.stage ω j (H.path i j.castSucc) = H.path i j.succ

theorem compatible_iff_step (H : G.Holes h) (ω : G.Choices) :
    H.Compatible ω ↔ H.StepCompatible ω := by
  constructor
  · intro hω i j
    have hs := congrArg (fun g : Equiv.Perm G.Slot => g (H.path i 0))
      (G.boundary_succ ω j.isLt)
    change G.boundary ω (j.val+1) (H.path i 0) =
      G.stage ω j (G.boundary ω j.val (H.path i 0)) at hs
    have h1 := hω i j.succ
    have h0 := hω i j.castSucc
    simp only [Fin.val_succ, Fin.val_castSucc] at h1 h0
    rw [h1, h0] at hs
    exact hs.symm
  · intro hω i t
    have hb : ∀ n (hn : n ≤ G.b), G.boundary ω n (H.path i 0) =
        H.path i ⟨n, by omega⟩ := by
      intro n
      induction n with
      | zero => intro hn; simp
      | succ n ih =>
        intro hn
        have hnb : n < G.b := by omega
        rw [G.boundary_succ ω hnb]
        change G.stage ω ⟨n,hnb⟩ (G.boundary ω n (H.path i 0)) = _
        rw [ih (by omega)]
        exact hω i ⟨n,hnb⟩
    exact hb t.val (by omega)

/- Compatibility is a product of independent line assignment events. -/
theorem step_iff_coordinate (H : G.Holes h) (ω : G.Choices) :
    H.StepCompatible ω ↔ ∀ i (j : Fin G.b),
      ω j (fun k => H.path i j.castSucc k) (H.path i j.castSucc j) = H.path i j.succ j := by
  constructor
  · intro hω i j
    have hh := congrFun (hω i j) j
    simpa using hh
  · intro hω i j
    funext k
    by_cases hk : k = j
    · subst k
      exact (G.stage_apply_same ω j _).trans (hω i j)
    · exact (G.stage_apply_ne ω j k hk _).trans (H.coordinate_step i j k hk).symm

def OnLine (H : G.Holes h) (j : Fin G.b) (L : G.Line j) (i : Fin h) : Prop :=
  (fun k : {k : Fin G.b // k ≠ j} => H.path i j.castSucc k) = L

theorem line_input_injective (H : G.Holes h) (j : Fin G.b) (L : G.Line j) :
    Function.Injective (fun i : {i : Fin h // H.OnLine j L i} => H.path i j.castSucc j) := by
  intro i i' he
  apply Subtype.ext
  apply H.disjoint j.castSucc
  funext k
  by_cases hk : k = j
  · subst k; exact he
  · exact (congrFun i.property ⟨k,hk⟩).trans (congrFun i'.property ⟨k,hk⟩).symm

theorem line_output_injective (H : G.Holes h) (j : Fin G.b) (L : G.Line j) :
    Function.Injective (fun i : {i : Fin h // H.OnLine j L i} => H.path i j.succ j) := by
  intro i i' he
  apply Subtype.ext
  apply H.disjoint j.succ
  funext k
  by_cases hk : k = j
  · subst k; exact he
  · change H.path i.val j.succ k = H.path i'.val j.succ k
    rw [H.coordinate_step _ _ _ hk, H.coordinate_step _ _ _ hk]
    exact (congrFun i.property ⟨k,hk⟩).trans (congrFun i'.property ⟨k,hk⟩).symm

/- Disjoint source trajectories really are feasible; no probability event
is postulated to be nonempty. The main target still retains its explicit
feasibility hypothesis. -/
theorem feasible_of_disjoint (H : G.Holes h) : H.Feasible := by
  have hex : ∀ (j : Fin G.b) (L : G.Line j), ∃ σ : Equiv.Perm (Cube (G.bits j)),
      ∀ i : {i : Fin h // H.OnLine j L i}, σ (H.path i j.castSucc j) = H.path i j.succ j := by
    intro j L
    exact Equiv.Perm.exists_extending_pair _ _ (H.line_input_injective j L)
      (H.line_output_injective j L)
  choose ω hω using hex
  refine ⟨ω, (H.compatible_iff_step ω).mpr ((H.step_iff_coordinate ω).mpr ?_)⟩
  intro i j
  exact hω j (fun k => H.path i j.castSucc k) ⟨i, rfl⟩

end Holes
end Grid

namespace FiniteLaw

variable {Ω : Type*} [Fintype Ω]

theorem mass_le_one (μ : FiniteLaw Ω) (x : Ω) : μ x ≤ 1 := by
  rw [← μ.sum_mass]
  exact Finset.single_le_sum (fun y _ => μ.nonneg y) (Finset.mem_univ x)

/- A uniform, finite-alphabet perturbation interval, depending on the line
size only. This proves the source's half-to-two measure comparison. -/
theorem mix_uniform_between [Nonempty Ω] (ν : FiniteLaw Ω) {z : ℝ}
    (hz : 0 ≤ z) (hzhalf : z ≤ 1/2) (hzcard : z ≤ (Fintype.card Ω : ℝ)⁻¹)
    (x : Ω) :
    (1/2 : ℝ) * uniform Ω x ≤ (uniform Ω).mix ν z hz (by linarith) x ∧
      (uniform Ω).mix ν z hz (by linarith) x ≤ 2 * uniform Ω x := by
  have hn := ν.nonneg x
  have hle := ν.mass_le_one x
  have hU : 0 ≤ uniform Ω x := (uniform Ω).nonneg x
  change (1/2 : ℝ) * uniform Ω x ≤ (1-z) * uniform Ω x + z * ν x ∧
    (1-z) * uniform Ω x + z * ν x ≤ 2 * uniform Ω x
  constructor
  · nlinarith [mul_nonneg hz hn, mul_nonneg (sub_nonneg.mpr hzhalf) hU]
  · change z ≤ uniform Ω x at hzcard
    nlinarith [mul_nonneg hz hU, mul_le_mul_of_nonneg_left hle hz]

variable [DecidableEq Ω]

def assignments {h : ℕ} (μ : FiniteLaw (Equiv.Perm Ω))
    (x y : Fin h ↪ Ω) : ℝ :=
  ∑ g : Equiv.Perm Ω, if x.trans g.toEmbedding = y then μ g else 0

theorem assignments_nonneg {h : ℕ} (μ : FiniteLaw (Equiv.Perm Ω))
    (x y : Fin h ↪ Ω) : 0 ≤ μ.assignments x y := by
  apply Finset.sum_nonneg
  intro g _
  split_ifs
  · exact μ.nonneg g
  · rfl

theorem sum_assignments {h : ℕ} (μ : FiniteLaw (Equiv.Perm Ω))
    (x : Fin h ↪ Ω) : ∑ y, μ.assignments x y = 1 := by
  unfold assignments
  rw [Finset.sum_comm]
  simp

theorem uniform_assignments_same {h : ℕ} (x y z : Fin h ↪ Ω) :
    (uniform (Equiv.Perm Ω)).assignments x y =
      (uniform (Equiv.Perm Ω)).assignments x z := by
  obtain ⟨σ, hσ⟩ := Equiv.Perm.exists_extending_pair y z y.injective z.injective
  have hz : y.trans σ.toEmbedding = z := by
    ext i
    exact hσ i
  unfold assignments
  rw [← Equiv.sum_comp (Equiv.mulLeft σ)
    (fun g : Equiv.Perm Ω => if x.trans g.toEmbedding = z then
      uniform (Equiv.Perm Ω) g else 0)]
  apply Finset.sum_congr rfl
  intro g _
  have he : x.trans (σ * g).toEmbedding = z ↔ x.trans g.toEmbedding = y := by
    rw [← hz]
    constructor
    · intro he
      ext i
      exact σ.injective (congrArg (fun f : Fin h ↪ Ω => f i) he)
    · intro he
      ext i
      change σ (g (x i)) = σ (y i)
      exact congrArg σ (congrArg (fun f : Fin h ↪ Ω => f i) he)
  simp only [Equiv.coe_mulLeft, he, uniform_apply]

theorem uniform_assignments {h : ℕ} (x y : Fin h ↪ Ω) :
    (uniform (Equiv.Perm Ω)).assignments x y =
      ((Fintype.card Ω).descFactorial h : ℝ)⁻¹ := by
  let : Nonempty (Fin h ↪ Ω) := ⟨y⟩
  have hh : (∑ z : Fin h ↪ Ω, (uniform (Equiv.Perm Ω)).assignments x y) = 1 := by
    convert sum_assignments (uniform (Equiv.Perm Ω)) x using 1
    apply Finset.sum_congr rfl
    intro z _
    exact uniform_assignments_same x y z
  simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul,
    Fintype.card_embedding_eq, Fintype.card_fin] at hh
  have hm : ((Fintype.card Ω).descFactorial h : ℝ) ≠ 0 := by
    intro hm
    rw [hm, zero_mul] at hh
    norm_num at hh
  exact ((mul_eq_one_iff_inv_eq₀ hm).mp hh).symm

theorem uniform_assignments_pos {h : ℕ} (x y : Fin h ↪ Ω) :
    0 < (uniform (Equiv.Perm Ω)).assignments x y := by
  rw [uniform_assignments]
  apply inv_pos.mpr
  exact_mod_cast Nat.descFactorial_pos.mpr (by simpa using Fintype.card_le_of_embedding x)

theorem assignments_le {h : ℕ} (μ ν : FiniteLaw (Equiv.Perm Ω)) (C : ℝ)
    (hb : ∀ g, μ g ≤ C * ν g) (x y : Fin h ↪ Ω) :
    μ.assignments x y ≤ C * ν.assignments x y := by
  unfold assignments
  rw [Finset.mul_sum]
  apply Finset.sum_le_sum
  intro g _
  split_ifs
  · exact hb g
  · simp

theorem le_assignments {h : ℕ} (μ ν : FiniteLaw (Equiv.Perm Ω)) (C : ℝ)
    (hb : ∀ g, C * ν g ≤ μ g) (x y : Fin h ↪ Ω) :
    C * ν.assignments x y ≤ μ.assignments x y := by
  unfold assignments
  rw [Finset.mul_sum]
  apply Finset.sum_le_sum
  intro g _
  split_ifs
  · exact hb g
  · simp

/- The exact factor four in the line-conditioning argument, with all
line assignments represented by actual injections, not abstract events. -/
theorem assignments_ratio_le_four {h v : ℕ} (μ : FiniteLaw (Equiv.Perm Ω))
    (hμlo : ∀ g, (1/2 : ℝ) * uniform (Equiv.Perm Ω) g ≤ μ g)
    (hμhi : ∀ g, μ g ≤ 2 * uniform (Equiv.Perm Ω) g)
    (x y : Fin h ↪ Ω) (x' y' : Fin (h+v) ↪ Ω) :
    μ.assignments x' y' / μ.assignments x y ≤
      4 * (((Fintype.card Ω - h).descFactorial v : ℝ)⁻¹) := by
  have hlo := le_assignments μ (uniform _) (1/2) hμlo x y
  have hhi := assignments_le μ (uniform _) 2 hμhi x' y'
  have hp := uniform_assignments_pos x y
  have hmp : 0 < μ.assignments x y := lt_of_lt_of_le (by positivity) hlo
  have hcard : h+v ≤ Fintype.card Ω := by simpa using Fintype.card_le_of_embedding x'
  have hprod : (Fintype.card Ω).descFactorial (h+v) =
      (Fintype.card Ω).descFactorial h * (Fintype.card Ω-h).descFactorial v := by
    simpa only [Nat.add_sub_cancel_left, mul_comm] using
      (Nat.descFactorial_mul_descFactorial (n := Fintype.card Ω) (k := h) (m := h+v) (by omega)).symm
  have hh : ((Fintype.card Ω).descFactorial h : ℝ) ≠ 0 := by
    exact_mod_cast (Nat.descFactorial_pos.mpr (by omega)).ne'
  have hv : ((Fintype.card Ω-h).descFactorial v : ℝ) ≠ 0 := by
    exact_mod_cast (Nat.descFactorial_pos.mpr (by omega)).ne'
  calc
    _ ≤ (2 * (uniform (Equiv.Perm Ω)).assignments x' y') /
          ((1/2) * (uniform (Equiv.Perm Ω)).assignments x y) := by
      exact div_le_div₀ (mul_nonneg (by norm_num) ((uniform _).assignments_nonneg x' y')) hhi (by positivity) hlo
    _ = _ := by
      rw [uniform_assignments, uniform_assignments, hprod, Nat.cast_mul]
      field_simp
      ring

end FiniteLaw

namespace Grid.Holes
variable {G : Grid} {h : ℕ}

def LineCompatible (H : G.Holes h) (j : Fin G.b) (L : G.Line j)
    (σ : Equiv.Perm (Cube (G.bits j))) : Prop :=
  ∀ i : {i : Fin h // H.OnLine j L i}, σ (H.path i j.castSucc j) = H.path i j.succ j

theorem compatible_iff_lines (H : G.Holes h) (ω : G.Choices) :
    H.Compatible ω ↔ ∀ j L, H.LineCompatible j L (ω j L) := by
  rw [H.compatible_iff_step, H.step_iff_coordinate]
  constructor
  · intro hω j L i
    have hh := hω i.val j
    rw [i.property] at hh
    exact hh
  · intro hω i j
    exact hω j (fun k => H.path i j.castSucc k) ⟨i,rfl⟩

def compatibleEquiv (H : G.Holes h) :
    {ω : G.Choices // H.Compatible ω} ≃
      (∀ j L, {σ : Equiv.Perm (Cube (G.bits j)) // H.LineCompatible j L σ}) where
  toFun ω j L := ⟨ω.val j L, (H.compatible_iff_lines ω.val).mp ω.property j L⟩
  invFun σ := ⟨(fun j L => (σ j L).val),
    (H.compatible_iff_lines _).mpr (fun j L => (σ j L).property)⟩
  left_inv _ := rfl
  right_inv _ := rfl

/- Probability of the prescribed trajectory event, with the root definition. -/
def probability (H : G.Holes h) (z : ℝ) : ℝ :=
  ∑ ω : {ω : G.Choices // H.Compatible ω}, G.choiceWeight z ω.val

/- Exact path probability factors into its independent constrained lines. -/
theorem probability_prod (H : G.Holes h) {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ 1) :
    H.probability z = ∏ j, ∏ L, ∑ σ : {σ // H.LineCompatible j L σ},
      lineLaw (G.bits j) z hz hz' σ.val := by
  unfold probability
  rw [← Equiv.sum_comp H.compatibleEquiv.symm]
  change (∑ σ : (∀ j L, {σ // H.LineCompatible j L σ}),
    ∏ j, ∏ L, lineLaw (G.bits j) z hz hz' (σ j L).val) = _
  rw [← Fintype.prod_sum (fun j : Fin G.b =>
    fun σ : (∀ L, {σ // H.LineCompatible j L σ}) =>
      ∏ L, lineLaw (G.bits j) z hz hz' (σ L).val)]
  apply Finset.prod_congr rfl
  intro j _
  exact (Fintype.prod_sum (fun L => fun σ : {σ // H.LineCompatible j L σ} =>
    lineLaw (G.bits j) z hz hz' σ.val)).symm

theorem card_onLine (H : G.Holes h) (j : Fin G.b) (L : G.Line j) :
    Fintype.card {i : Fin h // H.OnLine j L i} = H.lineCount j L := by
  have hh := Fintype.card_subtype (H.OnLine j L)
  unfold lineCount
  convert hh using 1
  congr 2

def lineCards (H : G.Holes h) (j : Fin G.b) (L : G.Line j) :
    Fin (H.lineCount j L) ≃ {i : Fin h // H.OnLine j L i} :=
  (Fintype.equivFinOfCardEq (H.card_onLine j L)).symm

def lineInput (H : G.Holes h) (j : Fin G.b) (L : G.Line j) :
    Fin (H.lineCount j L) ↪ Cube (G.bits j) :=
  H.lineCards j L |>.toEmbedding |>.trans ⟨_, H.line_input_injective j L⟩

def lineOutput (H : G.Holes h) (j : Fin G.b) (L : G.Line j) :
    Fin (H.lineCount j L) ↪ Cube (G.bits j) :=
  H.lineCards j L |>.toEmbedding |>.trans ⟨_, H.line_output_injective j L⟩

theorem lineCompatible_iff_assignments (H : G.Holes h) (j : Fin G.b) (L : G.Line j)
    (σ : Equiv.Perm (Cube (G.bits j))) :
    H.LineCompatible j L σ ↔ (H.lineInput j L).trans σ.toEmbedding = H.lineOutput j L := by
  constructor
  · intro hs
    apply Function.Embedding.ext
    intro i
    exact hs (H.lineCards j L i)
  · intro hs i
    obtain ⟨k,rfl⟩ := (H.lineCards j L).surjective i
    exact congrArg (fun f : Fin (H.lineCount j L) ↪ Cube (G.bits j) => f k) hs

theorem sum_subtype_eq_sum_ite_of_iff {Ω : Type*} [Fintype Ω]
    {p q : Ω → Prop} [Fintype {a // p a}] [DecidablePred q]
    (h : ∀ a, p a ↔ q a) (f : Ω → ℝ) :
    (∑ a : {a // p a}, f a.val) = ∑ a, if q a then f a else 0 := by
  classical
  rw [← Finset.sum_subtype (Finset.univ.filter p) (by simp)]
  rw [Finset.sum_filter]
  apply Finset.sum_congr rfl
  intro a _
  simp only [h a]

theorem lineProbability_eq (H : G.Holes h) (j : Fin G.b) (L : G.Line j)
    (μ : FiniteLaw (Equiv.Perm (Cube (G.bits j)))) :
    (∑ σ : {σ // H.LineCompatible j L σ}, μ σ.val) =
      μ.assignments (H.lineInput j L) (H.lineOutput j L) := by
  exact sum_subtype_eq_sum_ite_of_iff (H.lineCompatible_iff_assignments j L) μ.mass

theorem probability_eq_assignments (H : G.Holes h) {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ 1) :
    H.probability z = ∏ j, ∏ L,
      (lineLaw (G.bits j) z hz hz').assignments (H.lineInput j L) (H.lineOutput j L) := by
  rw [H.probability_prod hz hz']
  apply Finset.prod_congr rfl
  intro j _
  apply Finset.prod_congr rfl
  intro L _
  exact H.lineProbability_eq j L (lineLaw (G.bits j) z hz hz')

/- Under uniform line randomization each prescribed injection pays exactly
one falling-factorial denominator. -/
theorem probability_zero (H : G.Holes h) :
    H.probability 0 = ∏ j, ∏ L,
      (((2 ^ G.bits j).descFactorial (H.lineCount j L) : ℝ)⁻¹) := by
  rw [H.probability_eq_assignments (le_refl 0) zero_le_one]
  apply Finset.prod_congr rfl
  intro j _
  apply Finset.prod_congr rfl
  intro L _
  have he : lineLaw (G.bits j) 0 (le_refl 0) zero_le_one = FiniteLaw.uniform _ := by
    ext σ
    simp [lineLaw, FiniteLaw.mix]
  rw [he]
  have hu := FiniteLaw.uniform_assignments (H.lineInput j L) (H.lineOutput j L)
  have hc : Fintype.card (Cube (G.bits j)) = 2 ^ G.bits j := by simp [Cube]
  rw [hc] at hu
  exact hu

end Grid.Holes
end CoordinateSweeps

end
end
end
end
end
end
end
open scoped Matrix.Norms.L2Operator

end OAI