lean/OAI/Computability/DirectedFeedback/RankGraph/PrefixBit.lean

import Mathlib
import OAI.Computability.DirectedFeedback.RankGraph.RoundBoolean

namespace OAI

section
noncomputable section
open scoped BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical
noncomputable section
open scoped Classical
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped BigOperators
noncomputable section
open scoped BigOperators
open DirectedFeedback.SourceProbability
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
noncomputable section
open scoped Classical BigOperators
namespace DirectedFeedback.Construction
open DirectedFeedback.SourceProbability FiniteDistribution
open RankGraph Prefix PrefixExperiment Games
variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E]
  [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y]
variable {M T N : ℕ} [NeZero M] [NeZero T]
omit [Fintype U] [Fintype X] [NeZero M] [NeZero T] [Nonempty X] in
theorem vertices_takePrefix {t : ℕ} (ht : t ≤ T) (a : PrefixData U X M T) :
    vertices (takePrefix ht a) = takePrefix ht (vertices a) := rfl

variable (G : Game U V E X Y) (ψLaw : FiniteDistribution (Emb (rankLength X T) N))
variable (hYX : Fintype.card Y ≤ Fintype.card X) (fiber : E → X ≃ Y × Bool)
variable (deleted : OutputVertex (M := M) G ψLaw → Bool)
variable (ord : OutputVertex (M := M) G ψLaw → ℕ)
variable (hord : ∀ {a b}, deleted a = false → deleted b = false →
  OutputArc G ψLaw hYX fiber a b → ord a < ord b)
variable (hrank : ∀ r, deleted (.inl r) = false)

def prefixBit (d : Full U X M T N) (t : ℕ) : Set (Fin t → X) → Bool :=
  if h : t ≤ T then referenceBit (rankOrder G ψLaw ord) d.1.val rankLength_ge
    (.inl ⟨⟨t,by omega⟩,takePrefix h (vertices d.2)⟩) else fun _ => false

include hord hrank in
theorem prefixBit_properties (d : Full U X M T N) {t : ℕ} (ht : t ≤ T) :
    prefixBit G ψLaw ord d t ∅ = false ∧ prefixBit G ψLaw ord d t Set.univ = true := by
  simp only [prefixBit, dite_eq_left ht]
  exact ⟨reference_empty rankLength_ge d.1.property
    (rankOrder_arc G ψLaw hYX fiber deleted ord hord hrank) _,
    reference_univ rankLength_ge d.1.property
    (rankOrder_arc G ψLaw hYX fiber deleted ord hord hrank) _⟩

def prefixTransition (d : Full U X M T N) (t : ℕ) : Fin (cellCount t) :=
  if h : t ≤ T then transition (prefixBit G ψLaw ord d t) (prefixCell t (sets d.2))
    (prefixBit_properties G ψLaw hYX fiber deleted ord hord hrank d h).1
    (prefixBit_properties G ψLaw hYX fiber deleted ord hord hrank d h).2
  else 0

theorem prefixBit_lift (d : Full U X M T N) (t : ℕ) (ht : t < T)
    (A : Set (Fin t → X)) :
    prefixBit G ψLaw ord d (t+1) (Fin.init ⁻¹' A) = prefixBit G ψLaw ord d t A := by
  simp only [prefixBit, dite_eq_left (show t+1 ≤ T by omega), dite_eq_left (show t ≤ T by omega), referenceBit]
  exact (compare_prefix_big (ord := rankOrder G ψLaw ord) (ψ := d.1.val)
    t ht (takePrefix (by omega) (vertices d.2)) A _ _ _).symm

theorem full_membership (fallback : X) (d : Full U X M T N)
    (hgood : Good (rankOrder G ψLaw ord) d.1.val rankLength_ge (fullWildcard (V := V) (Y := Y) d).tuple)
    (a : Fin T → X)
    (ha : cell d.2 a = prefixTransition G ψLaw hYX fiber deleted ord hord hrank d T)
    (j : Fin T) :
    (d.2 j).2.2 (a j) = bigFunction G ψLaw hYX fiber deleted ord hord hrank fallback
      (d.1, ⟨j,takePrefix (Nat.le_of_lt j.isLt) d.2⟩) (d.2 j).1 (d.2 j).2.2 := by
  let g := prefixBit G ψLaw ord d
  let r := prefixTransition G ψLaw hYX fiber deleted ord hord hrank d
  have hg (t : ℕ) (ht : t ≤ T) : Monotone (g t) := by
    simp only [g, prefixBit, dite_eq_left ht]
    exact good_monotone rankLength_ge d.1.property
      (rankOrder_arc G ψLaw hYX fiber deleted ord hord hrank) _
      (good_take_prefix _ _ rankLength_ge T le_rfl (vertices d.2) hgood t ht)
  have hr (t : ℕ) (ht : t ≤ T) : Transition (g t) (prefixCell t (sets d.2)) (r t) := by
    simp only [r, prefixTransition, dite_eq_left ht]
    exact transition_spec _ _ _ _
  have hh := full_transition_membership g (sets d.2) r T hg
    (prefixBit_lift G ψLaw ord d) hr a ha j
  have hgood' : Good (rankOrder G ψLaw ord) d.1.val rankLength_ge
      (.inl ⟨⟨j.val+1,by have := j.isLt; omega⟩,
        Fin.snoc (vertices (takePrefix (Nat.le_of_lt j.isLt) d.2)) (d.2 j).1⟩) := by
    convert good_take_prefix (rankOrder G ψLaw ord) d.1.val rankLength_ge T le_rfl
      (vertices d.2) hgood (j.val+1) (by have := j.isLt; omega) using 1
    congr 2
    funext i
    refine Fin.lastCases ?_ (fun k => ?_) i
    · simp [vertices, takePrefix]
    · simp [vertices, takePrefix]
  have hvertices : takePrefix (by have := j.isLt; omega : j.val+1 ≤ T) (vertices d.2) =
      Fin.snoc (vertices (takePrefix (Nat.le_of_lt j.isLt) d.2)) (d.2 j).1 := by
    funext i
    refine Fin.lastCases ?_ (fun k => ?_) i
    · simp [vertices, takePrefix]
    · simp [vertices, takePrefix]
  simp only [vertices_takePrefix] at hvertices
  have hgood'' := hgood'
  simp only [vertices_takePrefix] at hgood''
  have hb (b : Bool) : decide (b = true) = b := by cases b <;> rfl
  simp only [g, r, conditionedValue, stepFunction, prefixBit,
    dite_eq_left (Nat.le_of_lt j.isLt), dite_eq_left (show j.val+1 ≤ T by have := j.isLt; omega),
    prefixTransition, sets, dite_eq_left j.isLt, Set.mem_ofPred_eq,
    hb, bigFunction, conditionedBig, normalizedCondition, ↓reduceIte,
    bigStepBit, cell_takePrefix, vertices_takePrefix, hgood''] at hh ⊢
  rw [hvertices] at hh
  exact hh

end DirectedFeedback.Construction

noncomputable section
open scoped Classical BigOperators
namespace DirectedFeedback.Construction
open DirectedFeedback.SourceProbability FiniteDistribution
open RankGraph Prefix PrefixExperiment Games
variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E]
  [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y]
variable {M T N : ℕ} [NeZero M] [NeZero T]
variable (G : Game U V E X Y) (ψLaw : FiniteDistribution (Emb (rankLength X T) N))
variable (hYX : Fintype.card Y ≤ Fintype.card X) (fiber : E → X ≃ Y × Bool)
variable (deleted : OutputVertex (M := M) G ψLaw → Bool)
variable (ord : OutputVertex (M := M) G ψLaw → ℕ)
variable (hord : ∀ {a b}, deleted a = false → deleted b = false →
  OutputArc G ψLaw hYX fiber a b → ord a < ord b)
variable (hrank : ∀ r, deleted (.inl r) = false)

def favorable (d : Full U X M T N) : Bool := decide (
  0 < (fullLaw G ψLaw).weight d ∧ fullDeleted G ψLaw deleted d = false ∧
  Good (rankOrder G ψLaw ord) d.1.val rankLength_ge (fullWildcard (V := V) (Y := Y) d).tuple)

def prefixValue (fallback : X) (ψ : Emb (rankLength X T) N) (t : ℕ)
    (a : PrefixData U X M t) (u : U) (b : X → Bool) : ℝ :=
  if ht : t < T then
    if bigFunction G ψLaw hYX fiber deleted ord hord hrank fallback (ψ,⟨⟨t,ht⟩,a⟩) u b
    then 1 else 0
  else 0

theorem favorable_count (fallback : X) (d : Full U X M T N)
    (hd : favorable G ψLaw deleted ord d = true) (i : Fin M) :
    bias i * T / (2*M) ≤ count i (prefixValue G ψLaw hYX fiber deleted ord hord hrank fallback)
      d.1 d.2 := by
  obtain ⟨hpos,hkeep,hgood⟩ := of_decide_eq_true hd
  have hk : deleted (.inr (.inl (.inl ⟨d,hpos⟩))) = false := by
    simpa only [fullDeleted, extend, dite_eq_left hpos] using hkeep
  obtain ⟨x,hx,hstar⟩ := full_unstarred G ψLaw hYX fiber deleted ord hord hrank ⟨d,hpos⟩ hk hgood
  have hm (j : Fin T) := full_membership G ψLaw hYX fiber deleted ord hord hrank fallback d hgood x
    (by simpa only [prefixTransition, prefixBit, dite_eq_left le_rfl, takePrefix_self, fullWildcard, cell] using hx) j
  have he : count i (prefixValue G ψLaw hYX fiber deleted ord hord hrank fallback) d.1 d.2 =
      (fullCount d.2 i x : ℝ) := by
    simp only [count, fullCount, Finset.card_filter, Nat.cast_sum, Nat.cast_ite,
      Nat.cast_one, Nat.cast_zero, prefixValue]
    apply Finset.sum_congr rfl
    intro j _
    simp only [dite_eq_left j.isLt]
    rw [← hm j]
    by_cases hi : (d.2 j).2.1 = i <;> cases (d.2 j).2.2 (x j) <;> simp [hi]
  rw [he]
  exact not_lt.mp (fun h => hstar ⟨i,h⟩)

theorem favorable_probability (D H ρ : ℝ) (hH : 0 < H)
    (hcost : H * (fullLaw G ψLaw).probability (fullDeleted G ψLaw deleted) ≤ D)
    (hbad : (fullLaw (M := M) G ψLaw).probability (fun d => decide (¬
      Good (rankOrder G ψLaw ord) d.1.val rankLength_ge
        (fullWildcard (V := V) (Y := Y) d).tuple)) ≤ ρ)
    (hnum : ρ + D/H ≤ 1/2) :
    1/2 ≤ (fullLaw G ψLaw).probability (favorable G ψLaw deleted ord) := by
  have he := expectation_mono_support (fullLaw (M := M) G ψLaw)
    (f := fun _ => (1:ℝ))
    (g := fun d => (if favorable G ψLaw deleted ord d then 1 else 0) +
      (if fullDeleted G ψLaw deleted d then 1 else 0) +
      (if decide (¬Good (rankOrder G ψLaw ord) d.1.val rankLength_ge
        (fullWildcard (V := V) (Y := Y) d).tuple) then 1 else 0)) (by
      intro d hp
      by_cases hg : Good (rankOrder G ψLaw ord) d.1.val rankLength_ge
        (fullWildcard (V := V) (Y := Y) d).tuple
      <;> cases hk : fullDeleted G ψLaw deleted d <;> simp [favorable,hp,hg,hk])
  simp only [expectation_add, ← probability_eq_expect, expectation_const] at he
  have hc : (fullLaw G ψLaw).probability (fullDeleted G ψLaw deleted) ≤ D/H :=
    (le_div_iff₀ hH).mpr (by simpa [mul_comm] using hcost)
  linarith

theorem full_acceptance (fallback : X)
    (hprob : 1/2 ≤ (fullLaw G ψLaw).probability (favorable G ψLaw deleted ord)) (i : Fin M) :
    bias i / 4 ≤ (common (M := M) G ψLaw).expectation (fun d =>
      (bigMarginal G).expectation (fun u => (subsetLaw i).probability
        (bigFunction G ψLaw hYX fiber deleted ord hord hrank fallback d u))) := by
  have hh := acceptance_lower_bound ψLaw (bigMarginal G) subsetLaw i T
    (prefixValue G ψLaw hYX fiber deleted ord hord hrank fallback) (bias i) (bias_pos i).le
    (favorable G ψLaw deleted ord)
    (by intro ψ t a u b; unfold prefixValue; split_ifs <;> norm_num)
    hprob (fun d hd => by
      simpa only [Fintype.card_fin] using
        (favorable_count G ψLaw hYX fiber deleted ord hord hrank fallback d hd i))
  apply hh.trans_eq
  apply expectation_congr
  intro d
  change (bigMarginal G).expectation (fun u =>
    (subsetLaw i).expectation (prefixValue G ψLaw hYX fiber deleted ord hord hrank fallback
      d.1 d.2.1.val d.2.2 u)) = _
  apply expectation_congr
  intro u
  rw [probability_eq_expect]
  apply expectation_congr
  intro b
  simp only [prefixValue, dite_eq_left d.2.1.isLt]

end DirectedFeedback.Construction

noncomputable section
open scoped BigOperators
namespace DirectedFeedback.Ranks

def Homogeneous {C : Type*} (r : ℕ) (color : Finset ℕ → C) (s : Finset ℕ) : Prop :=
  ∃ c, ∀ t ⊆ s, t.card = r → color t = c

theorem end_homogeneous {C : Type*} [Fintype C] [Nonempty C] (r : ℕ)
    (R : ℕ → ℕ) (hR : ∀ k, ∀ (s : Finset ℕ), R k ≤ s.card →
      ∀ color : Finset ℕ → C, ∃ h ⊆ s, h.card = k ∧ Homogeneous r color h) :
    ∀ k, ∃ N, ∀ (s : Finset ℕ), N ≤ s.card → ∀ color : Finset ℕ → C,
      ∃ h ⊆ s, h.card = k ∧ ∃ tag : ℕ → C,
        ∀ t ⊆ h, t.card = r + 1 → ∀ a ∈ t,
          (∀ b ∈ t, a ≤ b) → color t = tag a := by
  classical
  intro k
  induction k with
  | zero =>
    refine ⟨0, ?_⟩
    intro s _ color
    refine ⟨∅, Finset.empty_subset _, rfl, (fun _ => color ∅), ?_⟩
    intro t ht hcard a ha _
    have : t = ∅ := Finset.subset_empty.mp ht
    simp [this] at ha
  | succ k ih =>
    obtain ⟨N, hN⟩ := ih
    refine ⟨R N + 1, ?_⟩
    intro s hs color
    have hsne : s.Nonempty := Finset.card_pos.mp (by omega)
    let v := s.min' hsne
    have hv : v ∈ s := Finset.min'_mem _ _
    have hrest : R N ≤ (s.erase v).card := by
      rw [Finset.card_erase_of_mem hv]
      omega
    obtain ⟨B, hBs, hBcard, c, hc⟩ := hR N (s.erase v) hrest (fun t => color (insert v t))
    obtain ⟨H, hHB, hHcard, tag, htag⟩ := hN B hBcard.ge color
    have hvH : v ∉ H := fun h => (Finset.mem_erase.mp (hBs (hHB h))).1 rfl
    have hvmin : ∀ a ∈ B, v < a := by
      intro a ha
      have hsa := Finset.mem_erase.mp (hBs ha)
      exact lt_of_le_of_ne (Finset.min'_le _ _ hsa.2) hsa.1.symm
    refine ⟨insert v H, Finset.insert_subset hv (hHB.trans (hBs.trans (Finset.erase_subset _ _))),
      by simp [hvH, hHcard], (fun a => if a = v then c else tag a), ?_⟩
    intro t ht hcard a ha hamin
    by_cases hvt : v ∈ t
    · have hat : a = v := by
        apply Nat.le_antisymm (hamin v hvt)
        rcases Finset.mem_insert.mp (ht ha) with hav | haH
        · exact hav ▸ le_rfl
        · exact (hvmin a (hHB haH)).le
      subst a
      have het : t.erase v ⊆ B := by
        intro a ha
        rcases Finset.mem_insert.mp (ht (Finset.mem_erase.mp ha).2) with hav | haH
        · exact False.elim ((Finset.mem_erase.mp ha).1 hav)
        · exact hHB haH
      have hecard : (t.erase v).card = r := by
        rw [Finset.card_erase_of_mem hvt, hcard]
        omega
      have h := hc (t.erase v) het hecard
      simpa [Finset.insert_erase hvt] using h
    · have htH : t ⊆ H := by
        intro b hb
        rcases Finset.mem_insert.mp (ht hb) with hbv | hbH
        · exact False.elim (hvt (hbv ▸ hb))
        · exact hbH
      have hav : a ≠ v := fun he => hvt (he ▸ ha)
      simp only [ite_eq_right hav]
      exact htag t htH hcard a ha hamin

theorem finite_ramsey {C : Type*} [Fintype C] [Nonempty C] :
    ∀ r k : ℕ, ∃ N ≥ k, ∀ (s : Finset ℕ), N ≤ s.card →
      ∀ color : Finset ℕ → C, ∃ h ⊆ s, h.card = k ∧ Homogeneous r color h := by
  classical
  intro r
  induction r with
  | zero =>
    intro k
    refine ⟨k, le_rfl, ?_⟩
    intro s hs color
    obtain ⟨h, hhs, hh⟩ := Finset.exists_subset_card_eq hs
    refine ⟨h, hhs, hh, color ∅, ?_⟩
    intro t _ ht
    rw [Finset.card_eq_zero.mp ht]
  | succ r ih =>
    choose R hRk hR using ih
    intro k
    obtain ⟨N, hN⟩ := end_homogeneous r R hR (Fintype.card C * k)
    refine ⟨max N k, le_max_right _ _, ?_⟩
    intro s hs color
    obtain ⟨H, hHs, hHcard, tag, htag⟩ := hN s ((le_max_left _ _).trans hs) color
    obtain ⟨c, _, hc⟩ := Finset.exists_le_card_fiber_of_mul_le_card_of_maps_to
      (s := H) (t := (Finset.univ : Finset C)) (f := tag)
      (fun _ _ => Finset.mem_univ _) Finset.univ_nonempty
      (by simpa using hHcard.ge : Fintype.card C * k ≤ H.card)
    obtain ⟨h, hsub, hcard⟩ := Finset.exists_subset_card_eq hc
    refine ⟨h, hsub.trans (Finset.filter_subset _ _ |>.trans hHs), hcard, c, ?_⟩
    intro t ht htcard
    have htne : t.Nonempty := Finset.card_pos.mp (by omega)
    let a := t.min' htne
    have ha : a ∈ t := Finset.min'_mem _ _
    have ha' := Finset.mem_filter.mp (hsub (ht ha))
    rw [htag t (ht.trans (hsub.trans (Finset.filter_subset _ _))) htcard a ha
      (fun b hb => Finset.min'_le _ _ hb), ha'.2]

end DirectedFeedback.Ranks

noncomputable section
open scoped BigOperators
namespace DirectedFeedback.Ranks

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

def payoff (a : I → J → ℝ) (x : I → ℝ) (y : J → ℝ) : ℝ :=
  ∑ i, ∑ j, x i * y j * a i j

theorem payoff_left (a : I → J → ℝ) (x x' : I → ℝ) (y : J → ℝ) (r s : ℝ) :
    payoff a (r • x + s • x') y = r * payoff a x y + s * payoff a x' y := by
  simp only [payoff, Pi.add_apply, Pi.smul_apply, smul_eq_mul, add_mul,
    Finset.sum_add_distrib, Finset.mul_sum, mul_assoc]

theorem payoff_right (a : I → J → ℝ) (x : I → ℝ) (y y' : J → ℝ) (r s : ℝ) :
    payoff a x (r • y + s • y') = r * payoff a x y + s * payoff a x y' := by
  simp only [payoff, Pi.add_apply, Pi.smul_apply, smul_eq_mul, mul_add, add_mul,
    Finset.sum_add_distrib, Finset.mul_sum]
  congr 1 <;> apply Finset.sum_congr rfl <;> intro i _ <;>
    apply Finset.sum_congr rfl <;> intro j _ <;> ring

def probabilitySimplex (Index : Type*) [Fintype Index] : Set (Index → ℝ) :=
  {weights | (∀ index, 0 ≤ weights index) ∧ ∑ index, weights index = 1}

theorem single_mem_probabilitySimplex {Index : Type*} [Fintype Index] [DecidableEq Index]
    (index : Index) : Pi.single index 1 ∈ probabilitySimplex Index :=
  ⟨le_update_iff.2 ⟨zero_le_one, fun _ _ => le_rfl⟩, by simp⟩

theorem convex_probabilitySimplex (Index : Type*) [Fintype Index] :
    Convex ℝ (probabilitySimplex Index) := by
  intro left hleft right hright weightLeft weightRight hweightLeft hweightRight hsum
  refine ⟨fun index => ?_, ?_⟩
  · exact add_nonneg (mul_nonneg hweightLeft (hleft.1 index))
      (mul_nonneg hweightRight (hright.1 index))
  · simp_rw [Pi.add_apply, Pi.smul_apply]
    rwa [Finset.sum_add_distrib, ← Finset.smul_sum, ← Finset.smul_sum,
      hleft.2, hright.2, smul_eq_mul, smul_eq_mul, mul_one, mul_one]

theorem isCompact_probabilitySimplex (Index : Type*) [Fintype Index] :
    IsCompact (probabilitySimplex Index) := by
  have hform : probabilitySimplex Index =
      (⋂ index : Index, {weights : Index → ℝ | 0 ≤ weights index}) ∩
        {weights | ∑ index, weights index = 1} := by
    ext weights
    simp only [probabilitySimplex, Set.mem_inter_iff, Set.mem_iInter, Set.mem_ofPred_eq]
  apply IsCompact.of_isClosed_subset (s := Set.Icc (0 : Index → ℝ) 1) isCompact_Icc
  · rw [hform]
    exact (isClosed_iInter fun index =>
      isClosed_le continuous_const (continuous_apply index)).inter
      (isClosed_eq (by fun_prop) continuous_const)
  · intro weights hweights
    refine ⟨hweights.1, fun index => ?_⟩
    change weights index ≤ 1
    rw [← hweights.2]
    exact Finset.single_le_sum (fun other _ => hweights.1 other) (Finset.mem_univ index)

theorem finite_minimax [Nonempty I] [Nonempty J] (a : I → J → ℝ) (δ : ℝ)
    (hresponse : ∀ y ∈ probabilitySimplex J, ∃ i, (∑ j, y j * a i j) ≤ δ) :
    ∃ x ∈ probabilitySimplex I, ∀ j, (∑ i, x i * a i j) ≤ δ := by
  classical
  have hI : (probabilitySimplex I).Nonempty := ⟨Pi.single (Classical.arbitrary I) 1,
    single_mem_probabilitySimplex _⟩
  have hJ : (probabilitySimplex J).Nonempty := ⟨Pi.single (Classical.arbitrary J) 1,
    single_mem_probabilitySimplex _⟩
  have hleft (y : J → ℝ) : Continuous (fun x : I → ℝ => payoff a x y) := by
    unfold payoff
    fun_prop
  have hright (x : I → ℝ) : Continuous (fun y : J → ℝ => payoff a x y) := by
    unfold payoff
    fun_prop
  have hcLeft (y : J → ℝ) : ConvexOn ℝ (probabilitySimplex I) (fun x => payoff a x y) := by
    refine ⟨convex_probabilitySimplex _, ?_⟩
    intro x _ x' _ r s _ _ _
    exact (payoff_left a x x' y r s).le
  have hcRight (x : I → ℝ) : ConcaveOn ℝ (probabilitySimplex J) (fun y => payoff a x y) := by
    refine ⟨convex_probabilitySimplex _, ?_⟩
    intro y _ y' _ r s _ _ _
    exact (payoff_right a x y y' r s).ge
  obtain ⟨x, hx, y, hy, hxy⟩ := Sion.exists_isSaddlePointOn hI (convex_probabilitySimplex _)
    (isCompact_probabilitySimplex _) (fun y _ => (hleft y).continuousOn.lowerSemicontinuousOn)
    (fun y _ => (hcLeft y).quasiconvexOn) (convex_probabilitySimplex _) hJ
    (isCompact_probabilitySimplex _) (fun x _ => (hright x).continuousOn.upperSemicontinuousOn)
    (fun x _ => (hcRight x).quasiconcaveOn)
  obtain ⟨i, hi⟩ := hresponse y hy
  refine ⟨x, hx, ?_⟩
  intro j
  have hsaddle := hxy (Pi.single i 1) (single_mem_probabilitySimplex _)
    (Pi.single j 1) (single_mem_probabilitySimplex _)
  have hpureLeft : payoff a (Pi.single i 1) y = ∑ j, y j * a i j := by
    simp [payoff, Pi.single_apply, ite_mul]
  have hpureRight : payoff a x (Pi.single j 1) = ∑ i, x i * a i j := by
    simp [payoff, Pi.single_apply, mul_ite, ite_mul]
  rw [hpureLeft, hpureRight] at hsaddle
  exact hsaddle.trans hi

theorem rational_simplex_approximation [Nonempty I] (x : I → ℝ)
    (hx : x ∈ probabilitySimplex I) (ε : ℝ) (hε : 0 < ε) :
    ∃ q : I → ℚ, (∀ i, 0 ≤ q i) ∧ (∑ i, q i = 1) ∧
      (∑ i, |(q i : ℝ) - x i|) < ε := by
  classical
  let n : ℝ := Fintype.card I
  have hn : 0 < n := by
    change 0 < (Fintype.card I : ℝ)
    exact_mod_cast (Fintype.card_pos : 0 < Fintype.card I)
  let d := ε / (2 * n)
  have hd : 0 < d := by dsimp [d]; positivity
  have hex (i : I) : ∃ q : ℚ, 0 ≤ q ∧ (q : ℝ) ≤ x i ∧ x i - q < d := by
    by_cases hxi : x i = 0
    · exact ⟨0, le_rfl, by simp [hxi], by simpa [hxi] using hd⟩
    have hp : 0 < x i := lt_of_le_of_ne (hx.1 i) (Ne.symm hxi)
    obtain ⟨q, hq1, hq2⟩ := exists_rat_btwn (show max 0 (x i - d) < x i by
      exact max_lt hp (by linarith))
    refine ⟨q, ?_, hq2.le, ?_⟩
    · exact_mod_cast (le_max_left _ _).trans hq1.le
    · have hh := (le_max_right _ _).trans_lt hq1
      linarith
  choose q hqnonneg hqle hqerr using hex
  let deficit : ℚ := 1 - ∑ i, q i
  have hdef : 0 ≤ deficit := by
    have hsum : (∑ i, (q i : ℝ)) ≤ 1 := by
      rw [← hx.2]
      exact Finset.sum_le_sum (fun i _ => hqle i)
    dsimp [deficit]
    exact_mod_cast (sub_nonneg.mpr hsum)
  have herr : (deficit : ℝ) < ε / 2 := by
    have hh := Finset.sum_lt_sum_of_nonempty Finset.univ_nonempty (fun i _ => hqerr i)
    have hdid : (∑ _i : I, d) = ε / 2 := by
      simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul]
      change n * (ε / (2 * n)) = ε / 2
      field_simp
    rw [Finset.sum_sub_distrib, hx.2, hdid] at hh
    simpa [deficit] using hh
  let i₀ : I := Classical.arbitrary I
  let q' : I → ℚ := fun i => q i + if i = i₀ then deficit else 0
  refine ⟨q', (fun i => add_nonneg (hqnonneg i) (by split_ifs <;> positivity)), ?_, ?_⟩
  · simp [q', Finset.sum_add_distrib, deficit]
  · calc
      (∑ i, |(q' i : ℝ) - x i|) ≤
          ∑ i, ((x i - (q i : ℝ)) + if i = i₀ then (deficit : ℝ) else 0) := by
        apply Finset.sum_le_sum
        intro i _
        dsimp [q']
        push_cast
        split_ifs with hi
        · have ht := abs_add_le ((q i : ℝ) - x i) (deficit : ℝ)
          rw [abs_of_nonpos (sub_nonpos.mpr (hqle i)),
            abs_of_nonneg (show (0 : ℝ) ≤ (deficit : ℝ) by exact_mod_cast hdef)] at ht
          calc
            |(q i : ℝ) + (deficit : ℝ) - x i| =
                |((q i : ℝ) - x i) + (deficit : ℝ)| := by congr 1; ring
            _ ≤ -((q i : ℝ) - x i) + (deficit : ℝ) := ht
            _ = _ := by ring
        · rw [Rat.cast_zero, add_zero, add_zero, abs_of_nonpos (sub_nonpos.mpr (hqle i))]
          linarith
      _ = 2 * deficit := by
        rw [Finset.sum_add_distrib, Finset.sum_sub_distrib, hx.2]
        simp [deficit]
        ring
      _ < ε := by linarith

end DirectedFeedback.Ranks

noncomputable section
open scoped BigOperators
namespace DirectedFeedback.Ranks

abbrev Triple (n : ℕ) := {s : Finset (Fin n) // s.card = 3}
abbrev Increasing (L N : ℕ) := {f : Fin L → Fin N // StrictMono f}

theorem triple_nonempty {L : ℕ} (hL : 3 ≤ L) : Nonempty (Triple L) := by
  classical
  refine ⟨⟨Finset.univ.image (Fin.castLE hL), ?_⟩⟩
  rw [Finset.card_image_of_injective _ (Fin.castLE_injective hL)]
  simp

def toFinite (N : ℕ) (s : Finset ℕ) : Finset (Fin N) :=
  s.preimage Fin.val Fin.val_injective.injOn

@[simp] theorem toFinite_image {N : ℕ} (s : Finset (Fin N)) :
    toFinite N (s.image Fin.val) = s := by
  classical
  ext x
  simp [toFinite, Fin.val_inj]

abbrev RankTest (L N : ℕ) := (Triple L × Triple L) × Finset (Finset (Fin N))

def rankPayoff {L N : ℕ} (ψ : Increasing L N) (t : RankTest L N) : ℝ :=
  (if t.1.1.val.image ψ.val ∈ t.2 then 1 else 0) -
  (if t.1.2.val.image ψ.val ∈ t.2 then 1 else 0)

theorem rankPayoff_abs {L N : ℕ} (ψ : Increasing L N) (t : RankTest L N) :
    |rankPayoff ψ t| ≤ 1 := by
  unfold rankPayoff
  split_ifs <;> norm_num

theorem bucket_close (b : ℕ) (hb : 0 < b) (x y : ℝ) (_hx : 0 ≤ x) (hy : 0 ≤ y)
    (h : ⌊(b : ℝ) * x⌋₊ = ⌊(b : ℝ) * y⌋₊) : x - y ≤ 1 / b := by
  have hb' : (0 : ℝ) < b := by exact_mod_cast hb
  have h1 := Nat.lt_floor_add_one ((b : ℝ) * x)
  have h2 := Nat.floor_le (mul_nonneg hb'.le hy)
  rw [h] at h1
  apply (le_div_iff₀ hb').mpr
  nlinarith

theorem rank_spreading (L : ℕ) (hL : 3 ≤ L) (η : ℝ) (hη : 0 < η) :
    ∃ N ≥ L, ∃ μ : Increasing L N → ℚ,
      (∀ ψ, 0 ≤ μ ψ) ∧ (∑ ψ, μ ψ = 1) ∧
      ∀ I I' : Triple L, ∀ A : Finset (Finset (Fin N)),
        |(∑ ψ, (μ ψ : ℝ) * if I.val.image ψ.val ∈ A then 1 else 0) -
          (∑ ψ, (μ ψ : ℝ) * if I'.val.image ψ.val ∈ A then 1 else 0)| ≤ η := by
  classical
  let : Nonempty (Triple L) := triple_nonempty hL
  let P := Triple L × Triple L
  let c : ℝ := Fintype.card P
  have hc : 0 < c := by
    dsimp [c]
    exact_mod_cast (Fintype.card_pos : 0 < Fintype.card P)
  obtain ⟨b₀, hb₀⟩ := exists_nat_one_div_lt (show 0 < η / (4 * c) by positivity)
  let b := b₀ + 1
  have hb : 0 < b := Nat.succ_pos _
  have hb' : (0 : ℝ) < b := by exact_mod_cast hb
  have hcb : c * (1 / (b : ℝ)) < η / 4 := by
    have hh := mul_lt_mul_of_pos_left hb₀ hc
    have heq : c * (η / (4 * c)) = η / 4 := by field_simp
    simpa [b, heq] using hh
  obtain ⟨N, hNL, hN⟩ := finite_ramsey (C := P → Fin (b + 1)) 3 L
  let : Nonempty (Increasing L N) := ⟨⟨Fin.castLE hNL, fun _ _ h => h⟩⟩
  have hresponse : ∀ τ ∈ probabilitySimplex (RankTest L N), ∃ ψ : Increasing L N,
      (∑ t, τ t * rankPayoff ψ t) ≤ η / 4 := by
    intro τ hτ
    let q (p : P) (Z : Finset (Fin N)) : ℝ :=
      ∑ A : Finset (Finset (Fin N)), τ (p, A) * if Z ∈ A then 1 else 0
    have hq0 (p : P) (Z : Finset (Fin N)) : 0 ≤ q p Z := by
      apply Finset.sum_nonneg
      intro A _
      split_ifs <;> simp [hτ.1 (p, A)]
    have hq1 (p : P) (Z : Finset (Fin N)) : q p Z ≤ 1 := by
      calc
        q p Z ≤ ∑ A : Finset (Finset (Fin N)), τ (p, A) := by
          apply Finset.sum_le_sum
          intro A _
          split_ifs <;> simp [hτ.1 (p, A)]
        _ ≤ ∑ p' : P, ∑ A : Finset (Finset (Fin N)), τ (p', A) := by
          exact Finset.single_le_sum (fun p' _ => Finset.sum_nonneg (fun A _ => hτ.1 (p', A)))
            (Finset.mem_univ p)
        _ = 1 := by
          have hh := hτ.2
          rw [Fintype.sum_prod_type] at hh
          exact hh
    let color (s : Finset ℕ) (p : P) : Fin (b + 1) :=
      ⟨⌊(b : ℝ) * q p (toFinite N s)⌋₊, by
        have hh := Nat.floor_mono (mul_le_mul_of_nonneg_left (hq1 p (toFinite N s)) hb'.le)
        simp only [mul_one, Nat.floor_natCast] at hh
        omega⟩
    obtain ⟨H, hHN, hHcard, tag, htag⟩ := hN (Finset.range N) (by simp) color
    let ψ₀ : Fin L → Fin N := fun i =>
      ⟨H.orderEmbOfFin hHcard i, Finset.mem_range.mp (hHN (H.orderEmbOfFin_mem hHcard i))⟩
    have hψ : StrictMono ψ₀ := fun i j hij => (H.orderEmbOfFin hHcard).strictMono hij
    let ψ : Increasing L N := ⟨ψ₀, hψ⟩
    have hmono (I : Triple L) : color ((I.val.image ψ.val).image Fin.val) = tag := by
      apply htag
      · intro a ha
        obtain ⟨v, hv, rfl⟩ := Finset.mem_image.mp ha
        obtain ⟨i, _, rfl⟩ := Finset.mem_image.mp hv
        exact H.orderEmbOfFin_mem hHcard i
      · rw [Finset.card_image_of_injective _ Fin.val_injective,
          Finset.card_image_of_injective _ hψ.injective]
        exact I.property
    have hclose (p : P) : q p (p.1.val.image ψ.val) - q p (p.2.val.image ψ.val) ≤ 1 / b := by
      apply bucket_close b hb _ _ (hq0 _ _) (hq0 _ _)
      have heq := congrArg (fun f => (f p).val) ((hmono p.1).trans (hmono p.2).symm)
      simpa only [color, toFinite_image] using heq
    refine ⟨ψ, ?_⟩
    calc
      (∑ t, τ t * rankPayoff ψ t) =
          ∑ p : P, (q p (p.1.val.image ψ.val) - q p (p.2.val.image ψ.val)) := by
        rw [Fintype.sum_prod_type]
        simp only [rankPayoff, mul_sub, Finset.sum_sub_distrib, q]
        rfl
      _ ≤ ∑ _p : P, (1 / (b : ℝ)) := Finset.sum_le_sum (fun p _ => hclose p)
      _ = c * (1 / (b : ℝ)) := by simp [c]
      _ ≤ η / 4 := hcb.le
  obtain ⟨x, hx, hxbound⟩ := finite_minimax rankPayoff (η / 4) hresponse
  obtain ⟨μ, hμ0, hμ1, hμerr⟩ := rational_simplex_approximation x hx (η / 2) (by positivity)
  have hμbound (t : RankTest L N) : (∑ ψ, (μ ψ : ℝ) * rankPayoff ψ t) < η := by
    have hle : (∑ ψ, (μ ψ : ℝ) * rankPayoff ψ t) ≤
        (∑ ψ, x ψ * rankPayoff ψ t) + ∑ ψ, |(μ ψ : ℝ) - x ψ| := by
      rw [← Finset.sum_add_distrib]
      apply Finset.sum_le_sum
      intro ψ _
      have hh : ((μ ψ : ℝ) - x ψ) * rankPayoff ψ t ≤ |(μ ψ : ℝ) - x ψ| := by
        calc
          _ ≤ |((μ ψ : ℝ) - x ψ) * rankPayoff ψ t| := le_abs_self _
          _ = |(μ ψ : ℝ) - x ψ| * |rankPayoff ψ t| := abs_mul _ _
          _ ≤ |(μ ψ : ℝ) - x ψ| * 1 :=
            mul_le_mul_of_nonneg_left (rankPayoff_abs ψ t) (abs_nonneg _)
          _ = _ := mul_one _
      linarith
    have hh := hxbound t
    linarith
  refine ⟨N, hNL, μ, hμ0, hμ1, ?_⟩
  intro I I' A
  have h1 := hμbound ((I, I'), A)
  have h2 := hμbound ((I', I), A)
  simp only [rankPayoff, mul_sub, Finset.sum_sub_distrib] at h1 h2
  exact abs_le.mpr ⟨by linarith, h1.le⟩

end DirectedFeedback.Ranks
open scoped Classical
namespace DirectedFeedback.Ranks
open DirectedFeedback.SourceProbability
open DirectedFeedback.SourceProbability.FiniteDistribution

def Spreads {L N : ℕ} (μ : FiniteDistribution (Increasing L N)) (η : ℝ) : Prop :=
  ∀ I I' : Triple L, ∀ A : Finset (Finset (Fin N)),
    |μ.probability (fun ψ => decide (I.val.image ψ.val ∈ A)) -
      μ.probability (fun ψ => decide (I'.val.image ψ.val ∈ A))| ≤ η

theorem exists_spreading_law (L : ℕ) (hL : 3 ≤ L) (η : ℝ) (hη : 0 < η) :
    ∃ N ≥ L, ∃ μ : FiniteDistribution (Increasing L N), Spreads μ η ∧
      ∀ ψ, ∃ q : ℚ, μ.weight ψ = q := by
  obtain ⟨N, hNL, q, hq0, hq1, hq⟩ := rank_spreading L hL η hη
  let μ : FiniteDistribution (Increasing L N) :=
    ⟨fun ψ => q ψ, fun ψ => by exact_mod_cast hq0 ψ, by exact_mod_cast hq1⟩
  refine ⟨N, hNL, μ, ?_, fun ψ => ⟨q ψ, rfl⟩⟩
  intro I I' A
  convert hq I I' A using 1
  simp only [probability, μ, decide_eq_true_eq, mul_ite, mul_one, mul_zero]

theorem triple_data_processing {L N : ℕ} {η : ℝ}
    (μ : FiniteDistribution (Increasing L N)) (hs : Spreads μ η)
    (f g : Fin 3 → Fin L) (hf : StrictMono f) (hg : StrictMono g)
    (K : (Fin 3 → Fin N) → Bool) :
    |μ.probability (fun ψ => K (ψ.val ∘ f)) -
      μ.probability (fun ψ => K (ψ.val ∘ g))| ≤ η := by
  classical
  let I (f : Fin 3 → Fin L) (hf : StrictMono f) : Triple L :=
    ⟨Finset.univ.image f, by rw [Finset.card_image_of_injective _ hf.injective]; simp⟩
  let event (s : Finset (Fin N)) : Bool :=
    if h : s.card = 3 then K (s.orderEmbOfFin h) else false
  let A : Finset (Finset (Fin N)) := Finset.univ.filter (fun s => event s = true)
  have hevent (f : Fin 3 → Fin L) (hf : StrictMono f) (ψ : Increasing L N) :
      decide ((I f hf).val.image ψ.val ∈ A) = K (ψ.val ∘ f) := by
    have hmono := ψ.property.comp hf
    have hc : ((I f hf).val.image ψ.val).card = 3 := by
      rw [Finset.card_image_of_injective _ ψ.property.injective]
      exact (I f hf).property
    have heq := Finset.orderEmbOfFin_unique hc (f := ψ.val ∘ f)
      (fun j => by simp [I]) hmono
    simp only [A, Finset.mem_filter, Finset.mem_univ, true_and]
    have hh : event ((I f hf).val.image ψ.val) = K (ψ.val ∘ f) := by
      dsimp [event]
      rw [dite_eq_left hc, ← heq]
    simp [hh]
  simpa only [hevent] using hs (I f hf) (I g hg) A

def tripleVector {L : ℕ} (a c h : Fin L) : Fin 3 → Fin L := ![a, c, h]

theorem tripleVector_strict {L : ℕ} {a c h : Fin L} (hac : a < c) (hch : c < h) :
    StrictMono (tripleVector a c h) := by
  intro i j hij
  fin_cases i <;> fin_cases j <;> simp_all [tripleVector]
  exact hac.trans hch

end DirectedFeedback.Ranks

namespace DirectedFeedback.RankGraph
open DirectedFeedback.SourceProbability
open DirectedFeedback.SourceProbability.FiniteDistribution
open DirectedFeedback.Ranks
variable {U V X Y : Type} {T N L : ℕ}

theorem comparison_expectations {η : ℝ}
    (μ : FiniteDistribution (Increasing L N)) (hs : Spreads μ η)
    (ord : Rank U V X Y T N → ℕ) (d : Tuple U V T)
    (E : Set (Domain U V X Y T d)) (a c h a' c' h' : Fin L)
    (hac : a < c) (hch : c < h) (hac' : a' < c') (hch' : c' < h') :
    |μ.probability (fun ψ => compareBit ord ψ.val d E a c h) -
      μ.probability (fun ψ => compareBit ord ψ.val d E a' c' h')| ≤ η := by
  classical
  exact triple_data_processing μ hs _ _ (tripleVector_strict hac hch)
    (tripleVector_strict hac' hch')
    (fun r => decide (ord (vertex d (fun lambda => if lambda ∈ E then r 0 else r 2)) <
      ord (marker (r 1))))

theorem ordered_disagreement {I : Type*} [Fintype I]
    (μ : FiniteDistribution I) (p q : I → Bool)
    (hpq : (∀ i, p i ≤ q i) ∨ (∀ i, q i ≤ p i)) {η : ℝ}
    (hc : |μ.probability p - μ.probability q| ≤ η) :
    μ.probability (fun i => decide (p i ≠ q i)) ≤ η := by
  rcases hpq with h | h
  · rw [indicator_difference μ p q (fun i => (Bool.le_iff_imp.mp (h i)))]
    exact (le_abs_self _).trans (by rwa [abs_sub_comm])
  · have he := indicator_difference μ q p (fun i => (Bool.le_iff_imp.mp (h i)))
    have hh : (fun i => decide (p i ≠ q i)) = (fun i => decide (q i ≠ p i)) := by
      funext i; simp [ne_comm]
    rw [hh, he]
    exact (le_abs_self _).trans hc

theorem compare_marker_mono (ord : Rank U V X Y T N → ℕ)
    (hord : ∀ {a b}, Arc a b → ord a < ord b)
    (ψ : Increasing L N) (d : Tuple U V T) (E : Set (Domain U V X Y T d))
    (a h : Fin L) {c c' : Fin L} (hc : c ≤ c') :
    compareBit ord ψ.val d E a c h ≤ compareBit ord ψ.val d E a c' h := by
  rcases hc.eq_or_lt with rfl | hc
  · exact le_rfl
  rw [Bool.le_iff_imp]
  simp only [compareBit, decide_eq_true_eq]
  exact fun hh => hh.trans (hord (marker_arc (ψ.property hc)))

theorem comparison_disagreement (hL : 30 ≤ L) {η : ℝ}
    (μ : FiniteDistribution (Increasing L N)) (hs : Spreads μ η)
    (ord : Rank U V X Y T N → ℕ)
    (hord : ∀ {a b}, Arc a b → ord a < ord b)
    (d : Tuple U V T) (E : Set (Domain U V X Y T d))
    (a c h : Fin L) (hu : usable a c h) :
    μ.probability (fun ψ => decide (compareBit ord ψ.val d E a c h ≠
      referenceBit ord ψ.val hL d E)) ≤ 3 * η := by
  have hua := hu.1
  have hac := hu.2.1
  have huc := hu.2.2.1
  have hucL := hu.2.2.2.1
  have huh := hu.2.2.2.2
  let z : Fin L := ⟨0, by omega⟩
  let lo : Fin L := ⟨1, by omega⟩
  let ref : Fin L := ⟨14, by omega⟩
  let hi : Fin L := ⟨L - 2, by omega⟩
  let cp : Fin L := ⟨c.val + 1, by omega⟩
  let A0 (ψ : Increasing L N) := compareBit ord ψ.val d E lo ref hi
  let A1 (ψ : Increasing L N) := compareBit ord ψ.val d E lo c hi
  let A2 (ψ : Increasing L N) := compareBit ord ψ.val d E z c cp
  let A3 (ψ : Increasing L N) := compareBit ord ψ.val d E a c h
  have h01 : μ.probability (fun ψ => decide (A0 ψ ≠ A1 ψ)) ≤ η := by
    apply ordered_disagreement
    · rcases le_total ref c with hc | hc
      · exact Or.inl (fun ψ => compare_marker_mono ord hord ψ d E lo hi hc)
      · exact Or.inr (fun ψ => compare_marker_mono ord hord ψ d E lo hi hc)
    · exact comparison_expectations μ hs ord d E lo ref hi lo c hi
        (by simp [Fin.lt_def, lo, ref]) (by simp [Fin.lt_def, ref, hi]; omega)
        (by simp [Fin.lt_def, lo]; omega) (by simp [Fin.lt_def, hi]; omega)
  have h12 : μ.probability (fun ψ => decide (A1 ψ ≠ A2 ψ)) ≤ η := by
    apply ordered_disagreement
    · apply Or.inl
      intro ψ
      apply compareBit_mono_of_arc hord
      exact twoLevel_arc ψ.property d (Set.Subset.refl _) (by simp [Fin.lt_def, z, lo])
        (by simp [Fin.lt_def, z, hi]; omega) (by simp [Fin.lt_def, cp, hi]; omega)
    · exact comparison_expectations μ hs ord d E lo c hi z c cp
        (by simp [Fin.lt_def, lo]; omega) (by simp [Fin.lt_def, hi]; omega)
        (by simp [Fin.lt_def, z]; omega) (by simp [Fin.lt_def, cp])
  have h23 : μ.probability (fun ψ => decide (A2 ψ ≠ A3 ψ)) ≤ η := by
    apply ordered_disagreement
    · apply Or.inr
      intro ψ
      apply compareBit_mono_of_arc hord
      exact twoLevel_arc ψ.property d (Set.Subset.refl _) (by simp [Fin.lt_def, z]; omega)
        (by simp [Fin.lt_def, z]; omega) (by simp [Fin.lt_def, cp]; omega)
    · exact comparison_expectations μ hs ord d E z c cp a c h
        (by simp [Fin.lt_def, z]; omega) (by simp [Fin.lt_def, cp]) hac (by omega)
  have hh := probability_disagree_triangle μ A0 A1 A3
  have hh' := probability_disagree_triangle μ A1 A2 A3
  have he : μ.probability (fun ψ => decide (A0 ψ ≠ A3 ψ)) ≤ 3 * η := by linarith
  calc
    _ = μ.probability (fun ψ => decide (A0 ψ ≠ A3 ψ)) := by
      apply congrArg (μ.probability)
      funext ψ
      change decide (A3 ψ ≠ A0 ψ) = decide (A0 ψ ≠ A3 ψ)
      apply Bool.eq_iff_iff.mpr
      simp only [decide_eq_true_eq]
      exact ne_comm
    _ ≤ _ := he

theorem goodness_probability [Fintype X] [Fintype Y]
    (hL : 30 ≤ L) {η : ℝ} (hη : 0 ≤ η)
    (μ : FiniteDistribution (Increasing L N)) (hs : Spreads μ η)
    (ord : Rank U V X Y T N → ℕ)
    (hord : ∀ {a b}, Arc a b → ord a < ord b) (d : Tuple U V T) :
    μ.probability (fun ψ => decide (¬Good ord ψ.val hL d)) ≤
      3 * η * (L : ℝ)^3 * 2^(Fintype.card (Domain U V X Y T d)) := by
  classical
  let J := Set (Domain U V X Y T d) × Fin L × Fin L × Fin L
  let bad (j : J) (ψ : Increasing L N) : Bool :=
    decide (usable j.2.1 j.2.2.1 j.2.2.2 ∧
      compareBit ord ψ.val d j.1 j.2.1 j.2.2.1 j.2.2.2 ≠ referenceBit ord ψ.val hL d j.1)
  have hb (j : J) : μ.probability (bad j) ≤ 3 * η := by
    by_cases hu : usable j.2.1 j.2.2.1 j.2.2.2
    · simpa only [bad, hu, true_and] using comparison_disagreement hL μ hs ord hord d j.1
        j.2.1 j.2.2.1 j.2.2.2 hu
    · simp only [bad, hu, false_and, decide_false, probability_false]
      positivity
  calc
    _ ≤ μ.probability (fun ψ => decide (∃ j : J, bad j ψ = true)) := by
      apply probability_mono
      intro ψ hp
      have hn : ¬Good ord ψ.val hL d := of_decide_eq_true hp
      unfold Good at hn
      push Not at hn
      obtain ⟨E, a, c, h, hu, he⟩ := hn
      apply decide_eq_true
      refine ⟨(E, a, c, h), ?_⟩
      simpa only [bad, decide_eq_true_eq] using And.intro hu he
    _ ≤ ∑ j : J, μ.probability (bad j) := probability_exists_le_sum μ bad
    _ ≤ ∑ _j : J, 3 * η := Finset.sum_le_sum (fun j _ => hb j)
    _ = _ := by simp [J, Fintype.card_set, Nat.cast_mul, Nat.cast_pow]; ring

end DirectedFeedback.RankGraph

noncomputable section
open scoped Classical BigOperators
namespace DirectedFeedback.RankGraph
open DirectedFeedback.SourceProbability FiniteDistribution
open Ranks
variable {U V X Y : Type} [Fintype X] [Fintype Y] [Nonempty X]
variable {T N L : ℕ}

theorem domain_card_bound (hYX : Fintype.card Y ≤ Fintype.card X) (d : Tuple U V T) :
    Fintype.card (Domain U V X Y T d) ≤ (Fintype.card X)^T := by
  have hm : 1 ≤ Fintype.card X := Fintype.card_pos
  rcases d with ⟨t,s⟩ | ⟨t,s,v⟩
  · change Fintype.card (Fin t.val → X) ≤ _
    rw [Fintype.card_fun, Fintype.card_fin]
    exact Nat.pow_le_pow_right hm (by have := t.isLt; omega)
  · change Fintype.card ((Fin t.val → X) × Y) ≤ _
    rw [Fintype.card_prod, Fintype.card_fun, Fintype.card_fin]
    calc
      _ ≤ (Fintype.card X)^t.val * Fintype.card X := Nat.mul_le_mul_left _ hYX
      _ = (Fintype.card X)^(t.val+1) := (pow_succ _ _).symm
      _ ≤ _ := Nat.pow_le_pow_right hm t.isLt

theorem goodness_bound (hYX : Fintype.card Y ≤ Fintype.card X)
    (hL : 30 ≤ L) {η ρ : ℝ} (hη : 0 ≤ η)
    (haccuracy : 3*η*(L:ℝ)^3*2^((Fintype.card X)^T) ≤ ρ)
    (μ : FiniteDistribution (Increasing L N)) (hs : Spreads μ η)
    (ord : Rank U V X Y T N → ℕ)
    (hord : ∀ {a b}, Arc a b → ord a < ord b) (d : Tuple U V T) :
    μ.probability (fun ψ => decide (¬Good ord ψ.val hL d)) ≤ ρ := by
  apply (goodness_probability hL hη μ hs ord hord d).trans
  apply le_trans _ haccuracy
  apply mul_le_mul_of_nonneg_left _ (by positivity)
  exact pow_le_pow_right₀ (by norm_num : (1:ℝ) ≤ 2) (domain_card_bound hYX d)

theorem sampled_goodness {Ω : Type*} [Fintype Ω]
    (hYX : Fintype.card Y ≤ Fintype.card X) (hL : 30 ≤ L) {η ρ : ℝ} (hη : 0 ≤ η)
    (haccuracy : 3*η*(L:ℝ)^3*2^((Fintype.card X)^T) ≤ ρ)
    (μ : FiniteDistribution (Increasing L N)) (hs : Spreads μ η)
    (ν : FiniteDistribution Ω) (tuple : Ω → Tuple U V T)
    (ord : Rank U V X Y T N → ℕ)
    (hord : ∀ {a b}, Arc a b → ord a < ord b) :
    (μ.product ν).probability (fun a => decide (¬Good ord a.1.val hL (tuple a.2))) ≤ ρ := by
  rw [probability_eq_expect, expectation_product, expectation_comm]
  simp_rw [← probability_eq_expect]
  calc
    _ ≤ ν.expectation (fun _ => ρ) := expectation_mono _ (fun a =>
      goodness_bound hYX hL hη haccuracy μ hs ord hord (tuple a))
    _ = _ := expectation_const _ _

end DirectedFeedback.RankGraph

noncomputable section
open scoped Classical BigOperators
namespace DirectedFeedback.Construction
open DirectedFeedback.SourceProbability FiniteDistribution
open RankGraph Prefix PrefixExperiment Games Ranks
variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E]
  [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y]
variable {M T N : ℕ} [NeZero M] [NeZero T]
variable (G : Game U V E X Y) (ψLaw : FiniteDistribution (Emb (rankLength X T) N))
variable (hYX : Fintype.card Y ≤ Fintype.card X) (fiber : E → X ≃ Y × Bool)
variable (deleted : OutputVertex (M := M) G ψLaw → Bool)
variable (ord : OutputVertex (M := M) G ψLaw → ℕ)
variable (hord : ∀ {a b}, deleted a = false → deleted b = false →
  OutputArc G ψLaw hYX fiber a b → ord a < ord b)
variable (hrank : ∀ r, deleted (.inl r) = false)
variable {η ρ : ℝ} (hη : 0 ≤ η)
variable (haccuracy : 3*η*(rankLength X T : ℝ)^3*2^((Fintype.card X)^T) ≤ ρ)
variable (hs : Spreads ψLaw η)

include hord hrank hη haccuracy hs in
theorem full_badness :
    (fullLaw (M := M) G ψLaw).probability (fun d => decide (¬
      Good (rankOrder G ψLaw ord) d.1.val rankLength_ge
        (fullWildcard (V := V) (Y := Y) d).tuple)) ≤ ρ := by
  exact sampled_goodness hYX rankLength_ge hη haccuracy ψLaw hs
    ((atomLaw (bigMarginal G) subsetLaw).iid T)
    (fun a => Sum.inl ⟨⟨T,by omega⟩,vertices a⟩)
    (rankOrder G ψLaw ord) (rankOrder_arc G ψLaw hYX fiber deleted ord hord hrank)

end DirectedFeedback.Construction
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end

end OAI