lean/OAI/Computability/UniqueGames/Reduction/CloneTable.lean

import Mathlib.Data.List.Basic
import OAI.Computability.UniqueGames.Reduction.CanonicalBodyTemplateLemmas
import OAI.Computability.UniqueGames.Reduction.SourceIncidenceLemmas

namespace OAI

section

namespace UniqueGamesTheorem.Reduction.CloneTable

open CloneGap ActualSource

variable {n : Nat}

/-- A total bounded-name helper. Every index used by the table is below 48,
    and `cloneName_value` removes the remainder operation on those indices. -/
def cloneName (v : Fin n) (i : Nat) : Fin (n * 48) :=
  ⟨i % 48 + 48 * v.val, by
    have hi := Nat.mod_lt i (show 0 < 48 by decide)
    have hv := v.isLt
    omega⟩

theorem cloneName_value (v : Fin n) (i : Nat) (hi : i < 48) :
    (cloneName v i).val = i + 48 * v.val := by
  simp only [cloneName, Nat.mod_eq_of_lt hi]

def cloneEquation (e : Equation (Fin n)) (t : Nat × Nat × Nat) :
    Equation (Fin (n * 48)) :=
  ⟨cloneName e.first t.1, cloneName e.second t.2.1,
    cloneName e.third t.2.2, e.rhs⟩

def clonedEquations (es : List (Equation (Fin n))) : List (Equation (Fin (n * 48))) :=
  es.flatMap fun e => distinctTriples.map (cloneEquation e)

private theorem length_flatMap_map {α β γ : Type*}
    (xs : List α) (ys : List β) (f : α → β → γ) :
    (xs.flatMap fun x => ys.map (f x)).length = xs.length * ys.length := by
  induction xs with
  | nil => simp
  | cons x xs ih =>
      simp only [List.flatMap_cons, List.length_append, List.length_map, List.length_cons]
      rw [ih]
      simp [Nat.add_mul, Nat.add_comm]

theorem clonedEquations_length (es : List (Equation (Fin n))) :
    (clonedEquations es).length = es.length * distinctTriples.length := by
  exact length_flatMap_map es distinctTriples cloneEquation

theorem clonedEquations_nonempty (es : List (Equation (Fin n))) (hne : es ≠ []) :
    clonedEquations es ≠ [] := by
  apply List.length_pos_iff.mp
  rw [clonedEquations_length]
  exact Nat.mul_pos (List.length_pos_iff.mpr hne) FiniteSource.distinctTriples_nonempty

/-- Exact equality of typed ordered lists, not just permutation or equal counts. -/
theorem cloned_sourceList (S : Source) :
    (FiniteSource.cloned S).sourceList = clonedEquations S.sourceList := by
  let encode : Equation (Fin S.variables × Nat) → Equation (Fin (S.variables * 48)) :=
    fun e => FiniteSource.mapEquation (fun z => cloneName z.1 z.2) e
  have hmap : (FiniteSource.cloned S).sourceList = (cloneList S.sourceList).map encode := by
    have hm := congrArg (List.map encode)
      (List.ofFn_getElem (xs := cloneList S.sourceList))
    change List.ofFn (fun i : Fin (cloneList S.sourceList).length =>
      encode (cloneList S.sourceList)[i.val]) = _
    simpa only [List.map_ofFn, Function.comp_def] using hm
  rw [hmap]
  simp only [cloneList, clonedEquations, List.map_flatMap, List.map_map, Function.comp_def]
  rfl

theorem cloned_ofList_sourceList (es : List (Equation (Fin n))) (hne : es ≠ []) :
    (FiniteSource.cloned (Source.ofList es hne)).sourceList = clonedEquations es := by
  rw [cloned_sourceList, Source.sourceList_ofList]
  rfl

theorem source_reconstructed (S : Source) :
    Source.ofList S.sourceList S.sourceList_nonempty = S := by
  cases S with
  | mk n m hm eqn =>
      simp only [Source.ofList, Source.sourceList]
      erw [Source.mk.injEq]
      refine ⟨rfl, List.length_ofFn, ?_⟩
      apply (Fin.heq_fun_iff List.length_ofFn).mpr
      intro i
      simp only [List.get_eq_getElem, List.getElem_ofFn]

private theorem ofList_congr {es fs : List (Equation (Fin n))}
    (he : es = fs) (hne : es ≠ []) (hnf : fs ≠ []) :
    Source.ofList es hne = Source.ofList fs hnf := by
  cases he
  rfl

def eraseEquation (e : Equation (Fin n)) : Equation Nat :=
  ⟨e.first.val, e.second.val, e.third.val, e.rhs⟩

/-- Numeric machine target: no remainder, bounded-name proofs, or function
    lookup is needed in the three generated variable names. -/
def natCloneEquation (e : Equation Nat) (t : Nat × Nat × Nat) : Equation Nat :=
  ⟨t.1 + 48 * e.first, t.2.1 + 48 * e.second, t.2.2 + 48 * e.third, e.rhs⟩

def natClonedEquations (es : List (Equation Nat)) : List (Equation Nat) :=
  es.flatMap fun e => distinctTriples.map (natCloneEquation e)

theorem erase_cloneEquation (e : Equation (Fin n)) (t : Nat × Nat × Nat)
    (ht : t ∈ distinctTriples) :
    eraseEquation (cloneEquation e t) = natCloneEquation (eraseEquation e) t := by
  obtain ⟨h₁, h₂, h₃⟩ := FiniteSource.distinctTriple_bounds ht
  simp only [eraseEquation, cloneEquation, natCloneEquation, cloneName,
    Nat.mod_eq_of_lt h₁, Nat.mod_eq_of_lt h₂, Nat.mod_eq_of_lt h₃]

theorem erase_clonedEquations (es : List (Equation (Fin n))) :
    (clonedEquations es).map eraseEquation = natClonedEquations (es.map eraseEquation) := by
  simp only [clonedEquations, natClonedEquations, List.map_flatMap, List.map_map,
    List.flatMap_map, Function.comp_def]
  apply List.flatMap_congr
  intro e _
  apply List.map_congr_left
  intro t ht
  exact erase_cloneEquation e t ht

def cloneEquationWords (e : Equation (Fin n)) (t : Nat × Nat × Nat) : List Nat :=
  [t.1 + 48 * e.first.val, t.2.1 + 48 * e.second.val,
    t.2.2 + 48 * e.third.val, if e.rhs then 1 else 0]

def clonedBodyWords (es : List (Equation (Fin n))) : List Nat :=
  es.flatMap fun e => distinctTriples.flatMap (cloneEquationWords e)

theorem cloneEquation_words (e : Equation (Fin n)) (t : Nat × Nat × Nat)
    (ht : t ∈ distinctTriples) :
    SourceEncoding.equationWords (cloneEquation e t) = cloneEquationWords e t := by
  obtain ⟨h₁, h₂, h₃⟩ := FiniteSource.distinctTriple_bounds ht
  simp only [SourceEncoding.equationWords, cloneEquationWords, cloneEquation, cloneName,
    Nat.mod_eq_of_lt h₁, Nat.mod_eq_of_lt h₂, Nat.mod_eq_of_lt h₃]

theorem clonedEquations_words (es : List (Equation (Fin n))) :
    (clonedEquations es).flatMap SourceEncoding.equationWords = clonedBodyWords es := by
  simp only [clonedEquations, clonedBodyWords, List.flatMap_assoc, List.flatMap_map]
  apply List.flatMap_congr
  intro e _
  apply List.flatMap_congr
  intro t ht
  exact cloneEquation_words e t ht

def clonedInput (input : SourceEncoding.Input) : SourceEncoding.Input where
  «variables» := input.variables * 48
  equations := clonedEquations input.equations
  nonempty := clonedEquations_nonempty input.equations input.nonempty

def clonedInputWords (input : SourceEncoding.Input) : List Nat :=
  [input.variables * 48, input.equations.length * distinctTriples.length] ++
    clonedBodyWords input.equations

theorem clonedInput_equations (input : SourceEncoding.Input) :
    (clonedInput input).equations =
      (FiniteSource.cloned (Source.ofList input.equations input.nonempty)).sourceList := by
  exact (cloned_ofList_sourceList input.equations input.nonempty).symm

theorem clonedInput_source (input : SourceEncoding.Input) :
    Source.ofList (clonedInput input).equations (clonedInput input).nonempty =
      FiniteSource.cloned (Source.ofList input.equations input.nonempty) := by
  have hs := source_reconstructed
    (FiniteSource.cloned (Source.ofList input.equations input.nonempty))
  have he := clonedInput_equations input
  exact (ofList_congr he _ _).trans hs

theorem clonedInput_words (input : SourceEncoding.Input) :
    SourceEncoding.inputWords (clonedInput input) = clonedInputWords input := by
  simp only [SourceEncoding.inputWords, clonedInput, clonedInputWords,
    clonedEquations_length, clonedEquations_words]

theorem clonedInput_decodes (input : SourceEncoding.Input) :
    SourceEncoding.decodeInputWords (clonedInputWords input) = some (clonedInput input) := by
  rw [← clonedInput_words]
  exact SourceEncoding.decodeInputWords_encoded _

/-- A size bound for the actual serialized intermediate table. This is not
    a machine-time bound. -/
theorem clonedInput_bits_length_le (input : SourceEncoding.Input) :
    (SourceEncoding.inputBits (clonedInput input)).length ≤
      48 * input.variables + distinctTriples.length * input.equations.length + 2 +
        distinctTriples.length * input.equations.length * (144 * input.variables + 2) := by
  calc
    _ ≤ (clonedInput input).variables + (clonedInput input).equations.length + 2 +
        (clonedInput input).equations.length * (3 * (clonedInput input).variables + 2) :=
      SourceEncoding.inputBits_length_le _
    _ = _ := by
      simp only [clonedInput, clonedEquations_length]
      ring

end UniqueGamesTheorem.Reduction.CloneTable

end

end OAI