lean/OAI/Computability/PerfectCompleteness/Sampling/CutSamplerReplayTransportLemmas.lean

import OAI.Computability.PerfectCompleteness.Construction.LocalReconstruction
import OAI.Computability.PerfectCompleteness.Foundations.RecursiveSpaceEquivLemmas
import OAI.Computability.PerfectCompleteness.Sampling.CutSamplerKeyLocalityLemmas
import OAI.Computability.PerfectCompleteness.Sampling.RecordSeedSamplingLemmas
import OAI.Computability.UniqueGames.Foundations.Conditioning
import OAI.Computability.UniqueGames.Foundations.SamplingLemmas

namespace OAI


namespace PerfectCompleteness.CutSamplerReplayTransport

open PointwiseSpaces RecursiveSpaces DescendantSpaces RecursiveSampler
open CutSamplerKeyLocality
open scoped BigOperators Classical

noncomputable section

universe u v w

variable {branch : Nat → Nat} {n m : Nat}
  (𝕜 : Type w) [Field 𝕜] (repeats : Nat → Nat)

theorem squareEquiv_symm_apply
    {A : Slots branch n → Type u} {B : Slots branch n → Type v}
    (e : ∀ s, A s ≃ B s) (f : squareSpace (space 𝕜 branch n A))
    (y : Assignment B) :
    ((RecursiveSpaceEquiv.squareEquiv (𝕜 := 𝕜) e).symm f).val y =
      f.val (project (fun s => (e s).symm) y) := rfl

theorem squareEquiv_symm_eval_of_agree
    {A : Slots branch n → Type u} {B : Slots branch n → Type v}
    (e : ∀ s, A s ≃ B s) (f : squareSpace (space 𝕜 branch n A))
    (x : Assignment A) (y : Assignment B)
    (hagree : ∀ s, e s (x s) = y s) :
    ((RecursiveSpaceEquiv.squareEquiv (𝕜 := 𝕜) e).symm f).val y = f.val x := by
  rw [squareEquiv_symm_apply]
  apply congrArg f.val
  funext s
  exact (congrArg (e s).symm (hagree s)).symm.trans ((e s).symm_apply_apply (x s))

def transport (𝕜 : Type w) [Field 𝕜] (repeats : Nat → Nat) :
    {n m : Nat} → (p : Path branch n (m + 1)) →
    (A : Slots branch n → Type u) → (B : Slots branch n → Type v) →
    (clean : Fin (branch m) → Prop) →
    (∀ s, keptLeaf p clean s → A s ≃ B s) →
    CutSamplerReplay.Tape 𝕜 repeats p A clean →
      CutSamplerReplay.Tape 𝕜 repeats p B clean
  | _, _, .refl _, _, _, _, e, tape =>
      fun i => (RecursiveSpaceEquiv.squareEquiv (𝕜 := 𝕜)
        (fun s => e (i.val, s) i.property)).symm (tape i)
  | _, _, .step i p, A, B, clean, e, tape =>
      (fun j => (RecursiveSpaceEquiv.squareEquiv (𝕜 := 𝕜)
        (fun s => e (j.val, s) (Or.inl j.property))).symm (tape.1 j),
        fun call => transport 𝕜 repeats p (childFamily A i) (childFamily B i) clean
          (fun s hs => e (i, s) (Or.inr hs)) (tape.2 call))

theorem evaluate_transport (p : Path branch n (m + 1)) :
    ∀ (A : Slots branch n → Type u) (B : Slots branch n → Type v)
      (clean : Fin (branch m) → Prop)
      (e : ∀ s, keptLeaf p clean s → A s ≃ B s)
      (tape : CutSamplerReplay.Tape 𝕜 repeats p A clean)
      (x : Assignment A) (y : Assignment B),
      (∀ s hs, e s hs (x s) = y s) →
      CutSamplerReplay.evaluate 𝕜 repeats p B clean
          (transport 𝕜 repeats p A B clean e tape) y =
        CutSamplerReplay.evaluate 𝕜 repeats p A clean tape x := by
  induction n generalizing m with
  | zero =>
      have h := p.height_le
      omega
  | succ n ih =>
      cases p with
      | refl =>
          intro A B clean e tape x y hagree
          simp only [CutSamplerReplay.evaluate_refl]
          apply Finset.sum_congr rfl
          intro i _
          exact squareEquiv_symm_eval_of_agree 𝕜
            (fun s => e (i.val, s) i.property) (tape i)
            (childRestriction A i.val x) (childRestriction B i.val y)
            (fun s => hagree (i.val, s) i.property)
      | step i p =>
          intro A B clean e tape x y hagree
          simp only [CutSamplerReplay.evaluate_step]
          apply congrArg₂ (fun a b : 𝕜 => a + b)
          · apply Finset.sum_congr rfl
            intro j _
            exact squareEquiv_symm_eval_of_agree 𝕜
              (fun s => e (j.val, s) (Or.inl j.property)) (tape.1 j)
              (childRestriction A j.val x) (childRestriction B j.val y)
              (fun s => hagree (j.val, s) (Or.inl j.property))
          · apply Finset.sum_congr rfl
            intro h _
            apply congrArg₂ (fun a b : 𝕜 => a * b)
            · exact ih p (childFamily A i) (childFamily B i) clean
                (fun s hs => e (i, s) (Or.inr hs)) (tape.2 (h, false))
                (childRestriction A i x) (childRestriction B i y)
                (fun s hs => hagree (i, s) (Or.inr hs))
            · exact ih p (childFamily A i) (childFamily B i) clean
                (fun s hs => e (i, s) (Or.inr hs)) (tape.2 (h, true))
                (childRestriction A i x) (childRestriction B i y)
                (fun s hs => hagree (i, s) (Or.inr hs))

end
end PerfectCompleteness.CutSamplerReplayTransport


section

namespace PerfectCompleteness.LocalReconstruction.Recipe

open scoped BigOperators

variable {𝕜 Atom Atom' X J : Type*} [Field 𝕜]

def map (f : Atom → Atom') : Recipe 𝕜 Atom → Recipe 𝕜 Atom'
  | .constant c => .constant c
  | .atom a => .atom (f a)
  | .add r s => .add (map f r) (map f s)
  | .mul r s => .mul (map f r) (map f s)

theorem evaluate_map (f : Atom → Atom') (atoms : Atom' → X → 𝕜)
    (r : Recipe 𝕜 Atom) :
    (r.map f).evaluate atoms = r.evaluate (fun a => atoms (f a)) := by
  induction r with
  | constant c => rfl
  | atom a => rfl
  | add r s hr hs => simp only [map, evaluate, hr, hs]
  | mul r s hr hs => simp only [map, evaluate, hr, hs]

def sumList (f : J → Recipe 𝕜 Atom) : List J → Recipe 𝕜 Atom
  | [] => .constant 0
  | j :: js => .add (f j) (sumList f js)

theorem evaluate_sumList (f : J → Recipe 𝕜 Atom) (js : List J)
    (atoms : Atom → X → 𝕜) :
    (sumList f js).evaluate atoms = (js.map fun j => (f j).evaluate atoms).sum := by
  induction js with
  | nil => rfl
  | cons j js ih => simp only [sumList, evaluate, List.map_cons, List.sum_cons, ih]

noncomputable def sumIndexed [Fintype J] (f : J → Recipe 𝕜 Atom) : Recipe 𝕜 Atom :=
  sumList f Finset.univ.toList

theorem evaluate_sumIndexed [Fintype J] (f : J → Recipe 𝕜 Atom)
    (atoms : Atom → X → 𝕜) :
    (sumIndexed f).evaluate atoms = ∑ j, (f j).evaluate atoms := by
  rw [sumIndexed, evaluate_sumList, Finset.sum_map_toList]

end PerfectCompleteness.LocalReconstruction.Recipe

namespace PerfectCompleteness.StoppedSamplerRecipe

open scoped BigOperators
open PointwiseSpaces RecursiveSpaces DescendantSpaces RecursiveSampler
open LocalReconstruction

noncomputable section

universe u w

variable {branch : Nat → Nat} {n m : Nat}

def ordinaryTag (repeats : Nat → Nat) (i : Fin (branch n)) (p : Path branch n m)
    (j : OffPath i) : DrawIndex repeats (.step i p) := Sum.inl j

def factorTag (repeats : Nat → Nat) (i : Fin (branch n)) (p : Path branch n m)
    (h : Fin (repeats (n + 1))) (b : Bool) (j : DrawIndex repeats p) :
    DrawIndex repeats (.step i p) := Sum.inr ((h, b), j)

def recipe (𝕜 : Type w) [Field 𝕜] (repeats : Nat → Nat) :
    {n m : Nat} → (p : Path branch n m) → Recipe 𝕜 (DrawIndex repeats p)
  | _, _, .refl _ => .atom ()
  | n + 1, _, .step i p =>
      .add
        (Recipe.sumIndexed (fun j : OffPath i => .atom (ordinaryTag repeats i p j)))
        (Recipe.sumIndexed (fun h : Fin (repeats (n + 1)) =>
          .mul
            ((recipe 𝕜 repeats p).map (factorTag repeats i p h false))
            ((recipe 𝕜 repeats p).map (factorTag repeats i p h true))))

def atoms (𝕜 : Type w) [Field 𝕜] (repeats : Nat → Nat) :
    {n m : Nat} → (p : Path branch n m) → (A : Slots branch n → Type u) →
      Tape 𝕜 repeats p A → DrawIndex repeats p → Assignment A → 𝕜
  | _, _, .refl _, _, t, j => (t j).val
  | _, _, .step i p, A, t, j =>
      match j with
      | Sum.inl j => pullback 𝕜 (childRestriction A j.val) (t (Sum.inl j)).val
      | Sum.inr j =>
          pullback 𝕜 (childRestriction A i)
            (atoms 𝕜 repeats p (childFamily A i)
              (subTape 𝕜 repeats i p A t j.1.1 j.1.2) j.2)

variable (𝕜 : Type w) [Field 𝕜]

theorem evaluate_recipe (repeats : Nat → Nat) (p : Path branch n m) :
    ∀ (A : Slots branch n → Type u) (t : Tape 𝕜 repeats p A),
      (recipe 𝕜 repeats p).evaluate (atoms 𝕜 repeats p A t) =
        (RecursiveSampler.evaluate 𝕜 repeats p A t).val := by
  induction p with
  | refl n =>
      intro A t
      rfl
  | @step n m i p ih =>
      intro A t
      have child (h : Fin (repeats (n + 1))) (b : Bool) :
          ((recipe 𝕜 repeats p).map (factorTag repeats i p h b)).evaluate
              (atoms 𝕜 repeats (.step i p) A t) =
            (RecursiveSampler.evaluate 𝕜 repeats p (childFamily A i)
              (subTape 𝕜 repeats i p A t h b)).val ∘ childRestriction A i := by
        rw [Recipe.evaluate_map]
        change (recipe 𝕜 repeats p).evaluate (fun j =>
          atoms 𝕜 repeats p (childFamily A i) (subTape 𝕜 repeats i p A t h b) j ∘
            childRestriction A i) = _
        rw [Recipe.evaluate_pullback, ih]
      simp only [recipe, Recipe.evaluate, Recipe.evaluate_sumIndexed, child]
      funext x
      simp only [RecursiveSampler.evaluate, combine, combineFunction,
        Finset.sum_apply, Pi.add_apply, Pi.mul_apply, Function.comp_apply,
        atoms, ordinaryTag, PointwiseSpaces.pullback_apply]

theorem evaluate_factors {Z : Type*} (repeats : Nat → Nat) (p : Path branch n m)
    (A : Slots branch n → Type u) (t : Tape 𝕜 repeats p A) (other : Assignment A → Z)
    (known : ∀ j, atoms 𝕜 repeats p A t j ∈ FactoredFunctions.factoringSpace other) :
    (RecursiveSampler.evaluate 𝕜 repeats p A t).val ∈
      FactoredFunctions.factoringSpace other := by
  rw [← evaluate_recipe 𝕜 repeats p A t]
  exact Recipe.evaluate_factors other (atoms 𝕜 repeats p A t) known (recipe 𝕜 repeats p)

end
end PerfectCompleteness.StoppedSamplerRecipe

end


namespace PerfectCompleteness.UniformConditioning

noncomputable section

open scoped BigOperators Classical
open UniqueGamesTheorem.Foundations.Games

variable {Ω Γ : Type*} [Fintype Ω] [Fintype Γ] [Nonempty Ω] [Nonempty Γ]

theorem uniform_transport (e : Ω ≃ Γ) :
    (FiniteDistribution.uniform Ω).transport e = FiniteDistribution.uniform Γ := by
  apply FiniteDistribution.eq_of_weight_eq
  intro y
  change 1 / (Fintype.card Ω : ℝ) = 1 / (Fintype.card Γ : ℝ)
  rw [Fintype.card_congr e]

theorem uniform_probability_equiv (e : Ω ≃ Γ) (event : Γ → Bool) :
    (FiniteDistribution.uniform Ω).probability (fun x => event (e x)) =
      (FiniteDistribution.uniform Γ).probability event := by
  rw [← uniform_transport e, FiniteDistribution.probability_transport]

theorem uniform_probability (T : Ω → Prop) :
    (FiniteDistribution.uniform Ω).probability (fun x => decide (T x)) =
      (Fintype.card {x : Ω // T x} : ℝ) / (Fintype.card Ω : ℝ) := by
  calc
    _ = (∑ x : Ω, if T x then (1 : ℝ) else 0) / (Fintype.card Ω : ℝ) := by
      change (∑ x : Ω, if decide (T x) then 1 / (Fintype.card Ω : ℝ) else 0) = _
      simp only [div_eq_mul_inv, Finset.sum_mul]
      apply Finset.sum_congr rfl
      intro x _
      by_cases hx : T x <;> simp [hx]
    _ = _ := by simp only [Fintype.card_subtype, Finset.sum_boole]

theorem uniform_probability_pos (T : Ω → Prop) [Nonempty {x : Ω // T x}] :
    0 < (FiniteDistribution.uniform Ω).probability (fun x => decide (T x)) := by
  rw [uniform_probability]
  exact div_pos (Nat.cast_pos.mpr Fintype.card_pos) (Nat.cast_pos.mpr Fintype.card_pos)

omit [Nonempty Ω] in
theorem uniform_subtype_pushforward_weight (T : Ω → Prop)
    [Nonempty {x : Ω // T x}] (x : Ω) :
    ((FiniteDistribution.uniform {x : Ω // T x}).pushforward Subtype.val).weight x =
      if T x then 1 / (Fintype.card {x : Ω // T x} : ℝ) else 0 := by
  change (∑ y : {x : Ω // T x},
    if y.val = x then 1 / (Fintype.card {x : Ω // T x} : ℝ) else 0) = _
  by_cases hx : T x
  · rw [ite_eq_left hx]
    rw [Finset.sum_eq_single (⟨x, hx⟩ : {x : Ω // T x})]
    · simp
    · intro y _ hy
      have hne : y.val ≠ x := fun heq => hy (Subtype.ext heq)
      simp [hne]
    · simp
  · rw [ite_eq_right hx]
    apply Finset.sum_eq_zero
    intro y _
    have hne : y.val ≠ x := fun heq => hx (heq ▸ y.property)
    simp [hne]

theorem condition_uniform (T : Ω → Prop) [Nonempty {x : Ω // T x}]
    (positive : 0 < (FiniteDistribution.uniform Ω).probability (fun x => decide (T x))) :
    (FiniteDistribution.uniform Ω).condition (fun x => decide (T x)) positive =
      (FiniteDistribution.uniform {x : Ω // T x}).pushforward Subtype.val := by
  apply FiniteDistribution.eq_of_weight_eq
  intro x
  rw [uniform_subtype_pushforward_weight]
  change (if decide (T x) then
    (1 / (Fintype.card Ω : ℝ)) /
      (FiniteDistribution.uniform Ω).probability (fun x => decide (T x)) else 0) = _
  rw [uniform_probability]
  have hcard : (Fintype.card Ω : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr Fintype.card_ne_zero
  by_cases hx : T x
  · simpa [hx] using
      div_div_div_cancel_right₀ hcard (1 : ℝ) (Fintype.card {x : Ω // T x} : ℝ)
  · simp [hx]

theorem probability_condition_uniform (T : Ω → Prop) [Nonempty {x : Ω // T x}]
    (positive : 0 < (FiniteDistribution.uniform Ω).probability (fun x => decide (T x)))
    (event : Ω → Bool) :
    ((FiniteDistribution.uniform Ω).condition (fun x => decide (T x)) positive).probability
        event =
      (FiniteDistribution.uniform {x : Ω // T x}).probability (fun x => event x.val) := by
  rw [condition_uniform, FiniteDistribution.probability_pushforward]

end
end PerfectCompleteness.UniformConditioning

end OAI