lean/OAI/Computability/PerfectCompleteness/Construction/MixedSourceLocalOddLists.lean

import OAI.Computability.PerfectCompleteness.Construction.SourceLocalOddLists

namespace OAI

section

namespace PerfectCompleteness.MixedSourceLocalOddLists

open scoped BigOperators Classical
open PointwiseSpaces TreeSourceSpaces SourceAnswerEquiv
open UniqueGamesTheorem.Foundations.Games

abbrev F2 := ZMod 2

noncomputable section

section Composition

variable {A B C : Type*} [Fintype A] [Fintype B] [Fintype C]
  [DecidableEq A] [DecidableEq B] [DecidableEq C]

private theorem parity_comp (π : A → B) (ρ : B → C) (L : Finset A) :
    OddLists.parityPushforward ρ (OddLists.parityPushforward π L) =
      OddLists.parityPushforward (ρ ∘ π) L := by
  let f : A → F2 := fun a => if a ∈ L then 1 else 0
  have hf : OddLists.support f = L := by
    ext a
    by_cases ha : a ∈ L <;> simp [OddLists.mem_support, f, ha]
  rw [← hf, OddLists.parityPushforward_support, OddLists.parityPushforward_support,
    OddLists.parityPushforward_support]
  congr 1
  funext c
  calc
    (∑ b, if ρ b = c then ∑ a, if π a = b then f a else 0 else 0) =
        ∑ b, ∑ a, if ρ b = c then (if π a = b then f a else 0) else 0 := by
      apply Finset.sum_congr rfl
      intro b _
      by_cases hb : ρ b = c <;> simp only [hb, ite_true, ite_false, Finset.sum_const_zero]
    _ = ∑ a, ∑ b, if ρ b = c then (if π a = b then f a else 0) else 0 :=
      Finset.sum_comm
    _ = ∑ a, if (ρ ∘ π) a = c then f a else 0 := by
      apply Finset.sum_congr rfl
      intro a _
      rw [Finset.sum_eq_single (π a)]
      · simp only [Function.comp_apply, ite_true]
      · intro b _ hb
        simp only [ite_eq_right (Ne.symm hb), ite_self]
      · intro h
        exact (h (Finset.mem_univ _)).elim

private theorem oddList_map_comp {s : Nat} (π : A → B) (ρ : B → C)
    (L : OddLists.OddList s A) :
    OddLists.OddList.map ρ (OddLists.OddList.map π L) =
      OddLists.OddList.map (ρ ∘ π) L := by
  apply Subtype.ext
  exact parity_comp π ρ L.val

end Composition

private theorem map_eq_of_map_eq {A B : Type*} {s : Nat}
    {f₁ f₂ : Fintype B} {d₁ d₂ : DecidableEq B}
    (π : A → B) (L : OddLists.OddList s A) (R : OddLists.OddList s B)
    (accepted : @OddLists.OddList.map A B s f₁ d₁ π L = R) :
    @OddLists.OddList.map A B s f₂ d₂ π L = R := by
  have hf : f₁ = f₂ := Subsingleton.elim _ _
  cases hf
  have hd : d₁ = d₂ := Subsingleton.elim _ _
  cases hd
  exact accepted

variable {branch : Nat → Nat} {h t v m s : Nat}
  (clauses : Fin m → SourceClause.NormalizedClause v)

private theorem encoded_accepts {B : Type*} [Fintype B] [DecidableEq B]
    (e : SourceOddLists.Occurrences m t)
    (π : LeftDomain clauses (SourceOddLists.left e) → B)
    (ρ : B → SourceOddLists.RightLabels t)
    (hcomm : ρ ∘ π = (actualProjection clauses e :
      LeftDomain clauses (SourceOddLists.left e) → SourceOddLists.RightLabels t))
    (L : OddLists.OddList s (LeftDomain clauses (SourceOddLists.left e)))
    (R : OddLists.OddList s B) (hnative : OddLists.OddList.map π L = R) :
    OddLists.OddList.map (SourceOddLists.projection clauses e)
      (encodeOddList clauses (SourceOddLists.left e) L) = OddLists.OddList.map ρ R := by
  let actual : LeftDomain clauses (SourceOddLists.left e) → SourceOddLists.RightLabels t :=
    actualProjection clauses e
  have henc0 := encodeOddList_projection clauses e L
  have henc : OddLists.OddList.map actual L =
      OddLists.OddList.map (SourceOddLists.projection clauses e)
        (encodeOddList clauses (SourceOddLists.left e) L) :=
    map_eq_of_map_eq (B := SourceOddLists.RightLabels t) actual L _ henc0.symm
  calc
    _ = OddLists.OddList.map actual L := henc.symm
    _ = OddLists.OddList.map (ρ ∘ π) L :=
      congrArg (fun f : LeftDomain clauses (SourceOddLists.left e) → SourceOddLists.RightLabels t =>
        OddLists.OddList.map f L) hcomm.symm
    _ = OddLists.OddList.map ρ (OddLists.OddList.map π L) := (oddList_map_comp π ρ L).symm
    _ = OddLists.OddList.map ρ R := congrArg (OddLists.OddList.map ρ) hnative

abbrev Endpoints := RecursiveSpaces.Slots branch h → Fin t → SourceKeys.Endpoint v m

def slotsOf (q : Endpoints (branch := branch) (h := h) (t := t) (v := v) (m := m)) :
    RecursiveSpaces.Slots branch h → Fin t → MixedSupport.Slot :=
  fun leaf k => SourceKeys.slot clauses (q leaf k)

abbrev RightForms :=
  (q : Endpoints (branch := branch) (h := h) (t := t) (v := v) (m := m)) →
    SourceLocalOddLists.Form (slotsOf clauses q)

def defaultValue : (q : SourceKeys.Endpoint v m) → (SourceKeys.slot clauses q).Domain
  | .clause c => (clauseAnswerEquiv (clauses c).signs).symm 0
  | .variable _ => false

def readBit : (q : SourceKeys.Endpoint v m) → (SourceKeys.slot clauses q).Domain → Bool
  | .clause _, _ => false
  | .variable _, b => b

def leafToBits (q : Fin t → SourceKeys.Endpoint v m)
    (a : MixedSupport.Assignment (fun k => SourceKeys.slot clauses (q k))) :
    SourceOddLists.RightLabels t :=
  fun k => readBit clauses (q k) (a k)

def rightResponse (positive : 0 < s) (forms : RightForms (branch := branch) (h := h) (t := t) clauses)
    (q : Endpoints (branch := branch) (h := h) (t := t) (v := v) (m := m))
    (leaf : RecursiveSpaces.Slots branch h) : OddLists.OddList s (SourceOddLists.RightLabels t) :=
  OddLists.OddList.map (leafToBits clauses (q leaf))
    (SourceLocalOddLists.extract positive (slotsOf clauses q) (forms q) leaf
      (fun k => defaultValue clauses (q leaf k)))

def target : Bool → SourceClause.Occurrence m → SourceKeys.Endpoint v m
  | false, e => .clause e.1
  | true, e => .variable ((clauses e.1).variable e.2)

def step : (projected : Bool) → (e : SourceClause.Occurrence m) →
    SourceKeys.Step clauses (.clause e.1) (target clauses projected e)
  | false, e => .keep (.clause e.1)
  | true, e => .select e.1 e.2

def rightEndpoints (projected : RecursiveSpaces.Slots branch h → Bool)
    (e : SourceLocalOddLists.Occurrences (branch := branch) (h := h) (m := m) (t := t)) :
    Endpoints (branch := branch) (h := h) (t := t) (v := v) (m := m) :=
  fun leaf k => target clauses (projected leaf) (e leaf k)

def treeProjection (projected : RecursiveSpaces.Slots branch h → Bool)
    (e : SourceLocalOddLists.Occurrences (branch := branch) (h := h) (m := m) (t := t)) :
    ∀ leaf k, MixedSupport.Projection
      (leftTreeSlots clauses (fun j => SourceOddLists.left (e j)) leaf k)
      (slotsOf clauses (rightEndpoints clauses projected e) leaf k) :=
  fun leaf k => (step clauses (projected leaf) (e leaf k)).projection

theorem clean_leaf_projection (projected : RecursiveSpaces.Slots branch h → Bool)
    (e : SourceLocalOddLists.Occurrences (branch := branch) (h := h) (m := m) (t := t))
    (leaf : RecursiveSpaces.Slots branch h) (hp : projected leaf = true) :
    leafToBits clauses (rightEndpoints clauses projected e leaf) ∘
        MixedSupport.projectionMap (treeProjection clauses projected e leaf) =
      actualProjection clauses (e leaf) := by
  funext a k
  change readBit clauses (target clauses (projected leaf) (e leaf k))
      ((step clauses (projected leaf) (e leaf k)).projection.map (a k)) =
    (a k).val.at (e leaf k).2
  rw [hp]
  rfl

section Clean

open SourceLocalOddLists (CleanLeaves fill)

variable (clean : RecursiveSpaces.Slots branch h → Prop)
  (projected : RecursiveSpaces.Slots branch h → Bool)
  (background : SourceLocalOddLists.Occurrences (branch := branch) (h := h) (m := m) (t := t))

def strategy (positive : 0 < s)
    (leftForms : SourceLocalOddLists.LeftForms (branch := branch) (h := h) (t := t) clauses) (rightForms : RightForms (branch := branch) (h := h) (t := t) clauses) :
    Strategy (CleanLeaves clean → Fin t → Fin m) (CleanLeaves clean → Fin t → Fin v)
      (CleanLeaves clean → OddLists.OddList s (SourceOddLists.LeftLabels t))
      (CleanLeaves clean → OddLists.OddList s (SourceOddLists.RightLabels t)) :=
  (fun q leaf => SourceLocalOddLists.leftResponse clauses positive leftForms
      (fill clean (fun j => SourceOddLists.left (background j)) q) leaf.val,
   fun q leaf => rightResponse clauses positive rightForms
      (fill clean (rightEndpoints clauses projected background)
        (fun i k => SourceKeys.Endpoint.variable (q i k))) leaf.val)

theorem fill_rightEndpoints (hclean : ∀ leaf, clean leaf → projected leaf = true)
    (e : CleanLeaves clean → SourceOddLists.Occurrences m t) :
    fill clean (rightEndpoints clauses projected background)
        (fun i k => SourceKeys.Endpoint.variable (SourceOddLists.right clauses (e i) k)) =
      rightEndpoints clauses projected (fill clean background e) := by
  funext leaf k
  by_cases hc : clean leaf
  · simp only [SourceLocalOddLists.fill, dite_eq_left hc, rightEndpoints, hclean leaf hc, target]
    rfl
  · simp only [SourceLocalOddLists.fill, dite_eq_right hc, rightEndpoints]

theorem strategy_wins [NeZero m] (positive : 0 < s)
    (leftForms : SourceLocalOddLists.LeftForms (branch := branch) (h := h) (t := t) clauses) (rightForms : RightForms (branch := branch) (h := h) (t := t) clauses)
    (hclean : ∀ leaf, clean leaf → projected leaf = true)
    (e : CleanLeaves clean → SourceOddLists.Occurrences m t)
    (z : Module.Dual F2 (squareSpace
      (H (leftTreeSlots clauses (fun j => SourceOddLists.left (fill clean background e j))))))
    (hform : leftForms (fun j => SourceOddLists.left (fill clean background e j)) =
      OddListExtraction.multiplicationForm
        (H (leftTreeSlots clauses (fun j => SourceOddLists.left (fill clean background e j)))) z)
    (hone :
      (1 : Domain (leftTreeSlots clauses (fun j => SourceOddLists.left (fill clean background e j))) → F2) ∈
      squareSpace (H (leftTreeSlots clauses (fun j => SourceOddLists.left (fill clean background e j)))))
    (hnorm : z ⟨1, hone⟩ = 1)
    (hrank : OddListExtraction.formRank
      (H (leftTreeSlots clauses (fun j => SourceOddLists.left (fill clean background e j))))
      (leftForms (fun j => SourceOddLists.left (fill clean background e j))) ≤ s)
    (hagree : ∀ f g,
      rightForms (rightEndpoints clauses projected (fill clean background e)) f g =
      OddListExtraction.multiplicationForm
        (H (leftTreeSlots clauses (fun j => SourceOddLists.left (fill clean background e j)))) z
        (HPullback (treeProjection clauses projected (fill clean background e)) f)
        (HPullback (treeProjection clauses projected (fill clean background e)) g)) :
    (IndexedRepetition.game (SourceOddLists.game s clauses t) (CleanLeaves clean)).wins
      (strategy clauses clean projected background positive leftForms rightForms) e = true := by
  simp only [OccurrenceGame.wins, IndexedRepetition.game, SourceOddLists.game,
    OddListGame.game, OccurrenceGame.ofProjection, strategy, decide_eq_true_eq]
  intro leaf
  rw [SourceLocalOddLists.fill_comp clean background e SourceOddLists.left,
    fill_rightEndpoints clauses clean projected background hclean e]
  let full : SourceLocalOddLists.Occurrences (branch := branch) (h := h) (m := m) (t := t) :=
    fill clean background e
  let qL : SourceLocalOddLists.LeftQuestions (branch := branch) (h := h) (t := t) (m := m) :=
    fun j => SourceOddLists.left (full j)
  let qR : Endpoints (branch := branch) (h := h) (t := t) (v := v) (m := m) :=
    rightEndpoints clauses projected full
  let slotsL : RecursiveSpaces.Slots branch h → Fin t → MixedSupport.Slot :=
    leftTreeSlots (branch := branch) (n := h) clauses qL
  let slotsR : RecursiveSpaces.Slots branch h → Fin t → MixedSupport.Slot :=
    slotsOf (branch := branch) (h := h) (t := t) clauses qR
  let L : OddLists.OddList s (LeftDomain clauses (SourceOddLists.left (full leaf.val))) :=
    SourceLocalOddLists.extract (branch := branch) (h := h) (t := t)
      positive slotsL (leftForms qL) leaf.val
      ((leftEquiv clauses (SourceOddLists.left (full leaf.val))).symm (fun _ => 0))
  let R : OddLists.OddList s (LeafDomain slotsR leaf.val) :=
    SourceLocalOddLists.extract (branch := branch) (h := h) (t := t)
      positive slotsR (rightForms qR) leaf.val
      (fun k => defaultValue clauses (qR leaf.val k))
  let π : LeftDomain clauses (SourceOddLists.left (full leaf.val)) → LeafDomain slotsR leaf.val :=
    MixedSupport.projectionMap
      (treeProjection (branch := branch) (h := h) (t := t) clauses projected full leaf.val)
  let ρ : LeafDomain slotsR leaf.val → SourceOddLists.RightLabels t :=
    leafToBits clauses (qR leaf.val)
  have hraw := SourceLocalOddLists.extract_accepts (branch := branch) (h := h) (t := t)
      (slots := slotsL) (projected := slotsR) positive
      (treeProjection (branch := branch) (h := h) (t := t) clauses projected full)
      leaf.val (leftForms qL) (rightForms qR) z hform hone hnorm hrank hagree
      ((leftEquiv clauses (SourceOddLists.left (full leaf.val))).symm (fun _ => 0))
      (fun k => defaultValue clauses (qR leaf.val k))
  have hnative : OddLists.OddList.map π L = R := map_eq_of_map_eq π L R hraw
  have hcomm : ρ ∘ π =
      (actualProjection clauses (full leaf.val) :
        LeftDomain clauses (SourceOddLists.left (full leaf.val)) → SourceOddLists.RightLabels t) :=
    clean_leaf_projection clauses projected full leaf.val (hclean leaf.val leaf.property)
  have haccept := encoded_accepts clauses (full leaf.val) π ρ hcomm L R hnative
  rw [← SourceLocalOddLists.fill_clean clean background e leaf]
  change OddLists.OddList.map (SourceOddLists.projection clauses (full leaf.val))
      (encodeOddList clauses (SourceOddLists.left (full leaf.val)) L) = OddLists.OddList.map ρ R
  exact haccept

end Clean

end
end PerfectCompleteness.MixedSourceLocalOddLists

end

end OAI