lean/OAI/Computability/PerfectCompleteness/Decoding/LeftDecoder.lean

import OAI.Computability.PerfectCompleteness.Decoding.RepresentativeBucketCollisionLemmas
import OAI.Computability.PerfectCompleteness.Foundations.PartitionsLemmas
import OAI.Computability.PerfectCompleteness.Sampling.FiniteListSampling
import OAI.Computability.UniqueGames.Foundations.SamplingLemmas

namespace OAI


namespace PerfectCompleteness.LeftDecoder

open scoped BigOperators Classical
open UniqueGamesTheorem.Foundations.Games
open ClauseSupport MixedSupport

abbrev F2 := ZMod 2

noncomputable section

section Affine

variable {V : Type*} [AddCommGroup V] [Module F2 V] [FiniteDimensional F2 V]

local instance dualFintype : Fintype (Module.Dual F2 V) :=
  Fintype.ofEquiv (Fin (Module.finrank F2 (Module.Dual F2 V)) → F2)
    (Module.finBasis F2 (Module.Dual F2 V)).equivFun.toEquiv.symm

def affineLaw (W : Submodule F2 V)
    (C : Submodule F2 (Module.Dual F2 (V ⧸ W))) (center : Module.Dual F2 V) :
    FiniteDistribution (Module.Dual F2 V) :=
  (FiniteDistribution.uniform (PulledColumnSpace.Candidates W C center)).pushforward Subtype.val

theorem affineLaw_probability (W : Submodule F2 V)
    (C : Submodule F2 (Module.Dual F2 (V ⧸ W))) (center : Module.Dual F2 V)
    (event : Module.Dual F2 V → Bool) :
    (affineLaw W C center).probability event =
      (FiniteDistribution.uniform (PulledColumnSpace.Candidates W C center)).probability
        (fun q => event q.val) :=
  FiniteDistribution.probability_pushforward _ _ _

theorem affineLaw_probability_eq_one (W : Submodule F2 V)
    (C : Submodule F2 (Module.Dual F2 (V ⧸ W))) (center : Module.Dual F2 V)
    (event : Module.Dual F2 V → Bool)
    (hevent : ∀ q : PulledColumnSpace.Candidates W C center, event q.val = true) :
    (affineLaw W C center).probability event = 1 := by
  rw [affineLaw_probability]
  have heq : (fun q : PulledColumnSpace.Candidates W C center => event q.val) =
      fun _ => true := funext hevent
  rw [heq, FiniteDistribution.probability_true]

theorem affineLaw_weight (W : Submodule F2 V)
    (C : Submodule F2 (Module.Dual F2 (V ⧸ W))) (center q : Module.Dual F2 V) :
    (affineLaw W C center).weight q =
      if q - center ∈ PulledColumnSpace.pulled W C then
        1 / (2 : ℝ) ^ Module.finrank F2 C else 0 := by
  have hweight : (affineLaw W C center).weight q =
      if q - center ∈ PulledColumnSpace.pulled W C then
        1 / (Fintype.card (PulledColumnSpace.Candidates W C center) : ℝ) else 0 := by
    let : Fintype {p : Module.Dual F2 V // p - center ∈ PulledColumnSpace.pulled W C} :=
      PulledColumnSpace.candidatesFintype W C center
    change (∑ p : {p : Module.Dual F2 V // p - center ∈ PulledColumnSpace.pulled W C},
      if p.val = q then
        1 / (Fintype.card (PulledColumnSpace.Candidates W C center) : ℝ) else 0) = _
    by_cases hq : q - center ∈ PulledColumnSpace.pulled W C
    · rw [ite_eq_left hq, Finset.sum_eq_single
        (⟨q, hq⟩ : {p : Module.Dual F2 V // p - center ∈ PulledColumnSpace.pulled W C})]
      · simp
      · intro p _ hp
        have hne : p.val ≠ q := fun heq => hp (Subtype.ext heq)
        simp [hne]
      · simp
    · rw [ite_eq_right hq]
      apply Finset.sum_eq_zero
      intro p _
      have hne : p.val ≠ q := fun heq => hq (heq ▸ p.property)
      simp [hne]
  simpa only [PulledColumnSpace.fintype_card_candidates, Nat.cast_pow, Nat.cast_ofNat]
    using hweight

theorem affineLaw_support (W : Submodule F2 V)
    (C : Submodule F2 (Module.Dual F2 (V ⧸ W))) (center : Module.Dual F2 V) :
    (affineLaw W C center).probability
      (fun q => decide (q - center ∈ PulledColumnSpace.pulled W C)) = 1 := by
  rw [affineLaw_probability]
  have hevent : (fun q : PulledColumnSpace.Candidates W C center =>
      decide (q.val - center ∈ PulledColumnSpace.pulled W C)) = fun _ => true := by
    funext q
    exact decide_eq_true q.property
  rw [hevent, FiniteDistribution.probability_true]

theorem affineLaw_success_lower (W : Submodule F2 V)
    (C : Submodule F2 (Module.Dual F2 (V ⧸ W))) (center : Module.Dual F2 V)
    {r : Nat} (hC : Module.finrank F2 C ≤ r) (event : Module.Dual F2 V → Bool)
    (witness : ∃ q : PulledColumnSpace.Candidates W C center, event q.val = true) :
    1 / (2 : ℝ) ^ r ≤ (affineLaw W C center).probability event := by
  obtain ⟨q, hq⟩ := witness
  have hweight := FiniteListSampling.probability_ge_weight
    (affineLaw W C center) event q.val hq
  rw [affineLaw_weight, ite_eq_left q.property] at hweight
  exact (one_div_le_one_div_of_le (pow_pos (by norm_num : (0 : ℝ) < 2) _)
    (pow_le_pow_right₀ (by norm_num : (1 : ℝ) ≤ 2) hC)).trans hweight

end Affine


attribute [local instance] UniqueGamesTheorem.Appendix.RankLevelFilter.linearMapFintype

variable {n : Nat} {K Z : Type*} [AddCommGroup K] [Module F2 K]
  (slots : Fin n → Slot) (H : Submodule F2 (Assignment slots → F2))
  (other : Assignment slots → Z) (labeling : KeyStrategy.Strategy n)
  (W : Submodule F2 H) (s : (H ⧸ W) →ₗ[F2] H)
  (hs : W.mkQ.comp s = LinearMap.id)
  [FiniteDimensional F2 H] [FiniteDimensional F2 K]
  [Fintype H] [Fintype K] [Fintype Z]
  (useful : (Module.Dual F2 (H ⧸ W) →ₗ[F2] K) → Prop)
  {r : Nat} {ρ : ℝ} {A : ManyGoodRows.RowMap K r}
  {U : Module.Dual F2 (H ⧸ W) →ₗ[F2] (Fin r → F2)}

local instance representativeDualFintype : Fintype (Module.Dual F2 H) :=
  dualFintype (V := H)

def center (w : DenseWitnessRealization.RepresentativeWitness
    slots H other labeling W s useful (r := r) (ρ := ρ) (A := A) (U := U)) :
    Module.Dual F2 H :=
  RepresentativeMatrixTable.correctionFunctional slots H other W s hs w.value.2

def law (w : DenseWitnessRealization.RepresentativeWitness
    slots H other labeling W s useful (r := r) (ρ := ρ) (A := A) (U := U)) :
    FiniteDistribution (Module.Dual F2 H) :=
  affineLaw W w.columnSpace (center slots H other labeling W s hs useful w)

omit [FiniteDimensional F2 K] [Fintype Z]

theorem law_weight (w : DenseWitnessRealization.RepresentativeWitness
    slots H other labeling W s useful (r := r) (ρ := ρ) (A := A) (U := U))
    (q : Module.Dual F2 H) :
    (law slots H other labeling W s hs useful w).weight q =
      if q - center slots H other labeling W s hs useful w ∈
          PulledColumnSpace.pulled W w.columnSpace then
        1 / (2 : ℝ) ^ Module.finrank F2 w.columnSpace else 0 :=
  affineLaw_weight W w.columnSpace _ q

theorem law_support (w : DenseWitnessRealization.RepresentativeWitness
    slots H other labeling W s useful (r := r) (ρ := ρ) (A := A) (U := U)) :
    (law slots H other labeling W s hs useful w).probability
      (fun q => decide (q - center slots H other labeling W s hs useful w ∈
        PulledColumnSpace.pulled W w.columnSpace)) = 1 :=
  affineLaw_support W w.columnSpace _

omit [FiniteDimensional F2 H] in
theorem exists_candidate_realizer
    (hW : RepresentativeMatrixTable.Determined slots H other W)
    (w : DenseWitnessRealization.RepresentativeWitness
      slots H other labeling W s useful (r := r) (ρ := ρ) (A := A) (U := U))
    (hρ : 0 < ρ) :
    ∃ x : Assignment slots, other x = w.value.2 ∧
      ∀ q : PulledColumnSpace.Candidates W w.columnSpace
        (center slots H other labeling W s hs useful w),
      ∀ b : W, q.val (b : H) = b.val.val x := by
  obtain ⟨X, _, x, hx, hknown⟩ := DenseWitnessRealization.exists_coset_realizer
    slots H other labeling W s useful hs hW w hρ
    (PulledColumnSpace.pulled W w.columnSpace)
    (PulledColumnSpace.pulled_le_annihilator W w.columnSpace)
  refine ⟨x, congrArg Prod.snd hx, ?_⟩
  intro q b
  rw [PulledColumnSpace.candidate_apply_known]
  simpa only [center, Submodule.coe_zero, add_zero] using hknown 0 b

omit [FiniteDimensional F2 H] in
theorem candidate_one (hW : RepresentativeMatrixTable.Determined slots H other W)
    (w : DenseWitnessRealization.RepresentativeWitness
      slots H other labeling W s useful (r := r) (ρ := ρ) (A := A) (U := U))
    (hρ : 0 < ρ) (b : W) (hb : b.val.val = (1 : Assignment slots → F2))
    (q : PulledColumnSpace.Candidates W w.columnSpace
      (center slots H other labeling W s hs useful w)) : q.val (b : H) = 1 := by
  obtain ⟨x, _, hknown⟩ :=
    exists_candidate_realizer slots H other labeling W s hs useful hW w hρ
  rw [hknown q b, hb]
  rfl

theorem law_normalized_on_one
    (hW : RepresentativeMatrixTable.Determined slots H other W)
    (w : DenseWitnessRealization.RepresentativeWitness
      slots H other labeling W s useful (r := r) (ρ := ρ) (A := A) (U := U))
    (hρ : 0 < ρ) (b : W) (hb : b.val.val = (1 : Assignment slots → F2)) :
    (law slots H other labeling W s hs useful w).probability
      (fun q => decide (q (b : H) = 1)) = 1 := by
  rw [law, affineLaw_probability]
  have hevent : (fun q : PulledColumnSpace.Candidates W w.columnSpace
      (center slots H other labeling W s hs useful w) => decide (q.val (b : H) = 1)) =
      fun _ => true := by
    funext q
    exact decide_eq_true (candidate_one slots H other labeling W s hs useful hW w hρ b hb q)
  rw [hevent, FiniteDistribution.probability_true]

theorem success_lower (w : DenseWitnessRealization.RepresentativeWitness
    slots H other labeling W s useful (r := r) (ρ := ρ) (A := A) (U := U))
    (event : Module.Dual F2 H → Bool)
    (witness : ∃ q : PulledColumnSpace.Candidates W w.columnSpace
      (center slots H other labeling W s hs useful w), event q.val = true) :
    1 / (2 : ℝ) ^ r ≤
      (law slots H other labeling W s hs useful w).probability event :=
  affineLaw_success_lower W w.columnSpace _ w.column_count event witness

def adviceLaw (r : Nat) (ρ : ℝ) (A : ManyGoodRows.RowMap K r)
    (U : Module.Dual F2 (H ⧸ W) →ₗ[F2] (Fin r → F2)) :
    FiniteDistribution (Module.Dual F2 H) :=
  if hgood : ManyGoodRows.GoodRow
      (RepresentativeMatrixTable.partialTable slots H other labeling W s useful) r ρ A U then
    law slots H other labeling W s hs useful
      (ManyGoodRows.selectWitness
        (RepresentativeMatrixTable.partialTable slots H other labeling W s useful) r ρ A U hgood)
  else
    affineLaw W ⊥ (RepresentativeMatrixTable.correctionFunctional slots H other W s hs
      (CanonicalMatrixTable.response slots H other labeling (0 : CanonicalMatrixTable.Matrix
        (K := K) slots H)).2)

theorem adviceLaw_of_good (r : Nat) (ρ : ℝ) (A : ManyGoodRows.RowMap K r)
    (U : Module.Dual F2 (H ⧸ W) →ₗ[F2] (Fin r → F2))
    (hgood : ManyGoodRows.GoodRow
      (RepresentativeMatrixTable.partialTable slots H other labeling W s useful) r ρ A U) :
    adviceLaw slots H other labeling W s hs useful r ρ A U =
      law slots H other labeling W s hs useful
        (ManyGoodRows.selectWitness
          (RepresentativeMatrixTable.partialTable slots H other labeling W s useful)
          r ρ A U hgood) := by
  simp only [adviceLaw, dite_eq_left hgood]

theorem adviceLaw_normalized_on_one
    (hW : RepresentativeMatrixTable.Determined slots H other W)
    (r : Nat) (ρ : ℝ) (hρ : 0 < ρ) (A : ManyGoodRows.RowMap K r)
    (U : Module.Dual F2 (H ⧸ W) →ₗ[F2] (Fin r → F2))
    (b : W) (hb : b.val.val = (1 : Assignment slots → F2)) :
    (adviceLaw slots H other labeling W s hs useful r ρ A U).probability
      (fun q => decide (q (b : H) = 1)) = 1 := by
  by_cases hgood : ManyGoodRows.GoodRow
      (RepresentativeMatrixTable.partialTable slots H other labeling W s useful) r ρ A U
  · rw [adviceLaw_of_good slots H other labeling W s hs useful r ρ A U hgood]
    exact law_normalized_on_one slots H other labeling W s hs useful hW _ hρ b hb
  · simp only [adviceLaw, dite_eq_right hgood]
    apply affineLaw_probability_eq_one
    intro q
    apply decide_eq_true
    rw [PulledColumnSpace.candidate_apply_known]
    obtain ⟨x, _, hx⟩ := CanonicalMatrixTable.response_realized slots H other labeling
      (0 : CanonicalMatrixTable.Matrix (K := K) slots H)
    rw [← hx]
    simpa only [add_zero] using RepresentativeDecoder.coset_one_at_image
      slots H other W s hs hW x 0 W.dualAnnihilator.zero_mem b hb


end

end PerfectCompleteness.LeftDecoder

end OAI