import OAI.Computability.UniqueGames.Reduction.ExplicitLemmas
import OAI.Computability.UniqueGames.Reduction.OutputTranslationsLemmas

namespace OAI

section

namespace UniqueGamesTheorem.Reduction.FixedOutcomes

open Integration.BinaryLinear ActualHomogeneous ActualSource
open ActualEnumeration UniqueGamesTheorem.Reduction.Explicit

variable {N : Type*}

abbrev Parameter (k s d : Nat) (N : Type*) :=
  (E k →ₗ[F2] ActualEnumeration.Ambient s d) × (N × (E k →ₗ[F2] F2))

def occurrenceTuples (m k : Nat) : List (Fin k → Fin m) :=
  functions (List.finRange m) k

/-- Ambient linear map, noise occurrence index, scalar linear functional,
in exactly the original nested enumeration order. -/
def fixedParams (k s d : Nat) (indices : List N) : List (Parameter k s d N) :=
  pairs (allLinearMaps k _ (ambientVectors s d))
    (pairs indices (allLinearMaps k F2 [0, 1]))

def assemble {m k s d : Nat} (U : Fin k → Fin m) (p : Parameter k s d N) :
    Query m k s d × (N × (E k →ₗ[F2] F2)) :=
  ((U, p.1), p.2)

/-- The reassociation changes only parentheses, not enumeration order. -/
def outcomeEquiv (m k s d : Nat) (N : Type*) :
    (Query m k s d × (N × (E k →ₗ[F2] F2))) ≃
      ((Fin k → Fin m) × Parameter k s d N) :=
  Equiv.prodAssoc _ _ _

private theorem pairs_associate {Left Middle Right : Type*}
    (xs : List Left) (ys : List Middle) (zs : List Right) :
    pairs (pairs xs ys) zs =
      xs.flatMap (fun x => (pairs ys zs).map (fun p => ((x, p.1), p.2))) := by
  simp only [pairs, List.flatMap_assoc, List.flatMap_map, List.map_flatMap,
    List.map_map, Function.comp_def]

theorem indexedOutcomes_factor (m k s d : Nat) (indices : List N) :
    ActualEnumeration.indexedOutcomes m k s d indices =
      (occurrenceTuples m k).flatMap (fun U => (fixedParams k s d indices).map (assemble U)) := by
  exact pairs_associate (functions (List.finRange m) k)
    (allLinearMaps k _ (ambientVectors s d))
    (pairs indices (allLinearMaps k F2 [0, 1]))

theorem indexedOutcomes_reassociate (m k s d : Nat) (indices : List N) :
    (ActualEnumeration.indexedOutcomes m k s d indices).map (outcomeEquiv m k s d N) =
      pairs (occurrenceTuples m k) (fixedParams k s d indices) := by
  rw [indexedOutcomes_factor]
  simp only [pairs, List.map_flatMap, List.map_map, Function.comp_def,
    assemble, outcomeEquiv, Equiv.prodAssoc_apply]

theorem occurrenceTuples_length (m k : Nat) : (occurrenceTuples m k).length = m^k := by
  simp only [occurrenceTuples, length_functions, List.length_finRange]

theorem fixedParams_length (k s d : Nat) (indices : List N) :
    (fixedParams k s d indices).length = 2^((2*k+1)*(s+d+1)) * indices.length := by
  simp only [fixedParams, length_pairs, length_allLinearMaps, length_ambientVectors,
    List.length_cons, List.length_nil, ← pow_mul]
  change 2^((s+d)*(2*k+1)) * (indices.length * 2^(2*k+1)) =
    2^((2*k+1)*(s+d+1)) * indices.length
  rw [show (2*k+1)*(s+d+1) = (s+d)*(2*k+1)+(2*k+1) by ring, pow_add]
  ring

theorem fixedParams_nonempty (k s d : Nat) {indices : List N} (hne : indices ≠ []) :
    fixedParams k s d indices ≠ [] := by
  apply List.length_pos_iff.mp
  rw [fixedParams_length]
  exact Nat.mul_pos (Nat.two_pow_pos _) (List.length_pos_iff.mpr hne)

/-- A coefficient-only representation of each fixed linear-map parameter. -/
abbrev CoefficientParameter (k s d : Nat) (N : Type*) :=
  Coefficients k (ActualEnumeration.Ambient s d) × (N × Coefficients k F2)

def coefficientValues {Value : Type*} (k : Nat) (values : List Value) :
    List (Coefficients k Value) :=
  pairs values (functions (pairs values values) k)

def fixedCoefficientParams (k s d : Nat) (indices : List N) :
    List (CoefficientParameter k s d N) :=
  pairs (coefficientValues k (ambientVectors s d))
    (pairs indices (coefficientValues k ([0, 1] : List F2)))

def fromCoefficientParameter {k s d : Nat} (p : CoefficientParameter k s d N) :
    Parameter k s d N :=
  (coefficientEquiv k _ p.1, (p.2.1, coefficientEquiv k F2 p.2.2))

/-- The concrete coefficient enumeration produces precisely the fixed parameter
list. No choice of maps or representatives is made by this constructor. -/
theorem fixedCoefficientParams_map (k s d : Nat) (indices : List N) :
    (fixedCoefficientParams k s d indices).map fromCoefficientParameter =
      fixedParams k s d indices := by
  simp only [fixedCoefficientParams, fixedParams, coefficientValues, allLinearMaps,
    pairs, List.map_flatMap, List.flatMap_assoc, List.flatMap_map, List.map_map, Function.comp_def,
    fromCoefficientParameter]

theorem fixedCoefficientParams_length (k s d : Nat) (indices : List N) :
    (fixedCoefficientParams k s d indices).length =
      2^((2*k+1)*(s+d+1)) * indices.length := by
  rw [← fixedParams_length k s d indices, ← fixedCoefficientParams_map, List.length_map]

def tableParams (k : Nat) {s d : Nat} (T : Integration.NoiseTables.Table s d) :
    List (Parameter k s d (Fin T.vectors.length)) :=
  fixedParams k s d (List.finRange T.vectors.length)

theorem tableParams_length (k : Nat) {s d : Nat} (T : Integration.NoiseTables.Table s d) :
    (tableParams k T).length = 2^((2*k+1)*(s+d+1)) * T.vectors.length := by
  simp only [tableParams, fixedParams_length, List.length_finRange]

theorem outputInstance_constraints (S : Source) (k : Nat) {s d : Nat}
    (g : SplitGadget s d) (en : NoiseEnumeration g) :
    (AddressGame.outputInstance S k g en).constraints =
      (occurrenceTuples S.occurrences k).flatMap (fun U =>
        (fixedParams k s d en.indices).map (fun p =>
          AddressGame.addressEdge S k g (assemble U p))) := by
  change (ActualEnumeration.indexedOutcomes S.occurrences k s d en.indices).map
    (AddressGame.addressEdge S k g) = _
  rw [indexedOutcomes_factor]
  simp only [List.map_flatMap, List.map_map, Function.comp_def]

theorem tableOutput_constraints (S : Source) (k : Nat) {s d : Nat}
    (T : Integration.NoiseTables.Table s d) :
    (AddressGame.tableOutput S k T).constraints =
      (occurrenceTuples S.occurrences k).flatMap (fun U =>
        (tableParams k T).map (fun p => AddressGame.addressEdge S k
          (Integration.TableReduction.tableSkeleton T) (assemble U p))) :=
  outputInstance_constraints S k (Integration.TableReduction.tableSkeleton T)
    (Integration.TableReduction.tableEnumeration T Prod.fst (fun _ _ => rfl))

end UniqueGamesTheorem.Reduction.FixedOutcomes

end

end OAI