lean/OAI/Computability/PerfectCompleteness/Sampling/RestrictionRowsLaw.lean

import Mathlib.LinearAlgebra.Basis.Defs
import OAI.Computability.PerfectCompleteness.Algebra.UniformLinearImage
import OAI.Computability.PerfectCompleteness.Sampling.RationalFiniteLawLemmas
import OAI.Computability.UniqueGames.Analysis.MatrixRestrictions
import OAI.Computability.UniqueGames.Foundations.SamplingLemmas

namespace OAI


namespace PerfectCompleteness.RestrictionRowsLaw

noncomputable section

open UniqueGamesTheorem.Integration.BinaryLinear
open UniqueGamesTheorem.Fourier.MatrixRestrictions
open UniqueGamesTheorem.Foundations.Games
open scoped Classical

variable {E C I : Type*} [AddCommGroup E] [Module F2 E]
  [AddCommGroup C] [Module F2 C] [Fintype I]
  (W : Submodule F2 E) (C' : Submodule F2 C) (b : Module.Basis I F2 C')

def rowsLinear : Parameter W C' →ₗ[F2] (I → Module.Dual F2 (E ⧸ W)) where
  toFun A i := (b.coord i).comp A
  map_add' A B := by
    funext i
    apply LinearMap.ext
    intro x
    exact map_add (b.coord i) (A x) (B x)
  map_smul' a A := by
    funext i
    apply LinearMap.ext
    intro x
    exact map_smul (b.coord i) a (A x)

omit [Fintype I] in
@[simp] theorem rowsLinear_apply (A : Parameter W C') (i : I) :
    rowsLinear W C' b A i = (b.coord i).comp A := rfl

def fromRows (rows : I → Module.Dual F2 (E ⧸ W)) : Parameter W C' :=
  b.equivFun.symm.toLinearMap.comp (LinearMap.pi rows)

@[simp] theorem rowsLinear_fromRows (rows : I → Module.Dual F2 (E ⧸ W)) :
    rowsLinear W C' b (fromRows W C' b rows) = rows := by
  funext i
  apply LinearMap.ext
  intro x
  exact b.coord_equivFun_symm i (fun j => rows j x)

theorem rowsLinear_surjective : Function.Surjective (rowsLinear W C' b) :=
  fun rows => ⟨fromRows W C' b rows, rowsLinear_fromRows W C' b rows⟩

omit [Fintype I] in
theorem rowsLinear_injective : Function.Injective (rowsLinear W C' b) := by
  intro A B h
  apply LinearMap.ext
  intro x
  apply b.repr.injective
  ext i
  exact congrArg (fun rows : I → Module.Dual F2 (E ⧸ W) => rows i x) h

def rowsEquiv : Parameter W C' ≃ₗ[F2] (I → Module.Dual F2 (E ⧸ W)) :=
  LinearEquiv.ofBijective (rowsLinear W C' b)
    ⟨rowsLinear_injective W C' b, rowsLinear_surjective W C' b⟩

section Selection

variable {J : Type*} (sel : J → I)

def selectLinear : (I → Module.Dual F2 (E ⧸ W)) →ₗ[F2]
    (J → Module.Dual F2 (E ⧸ W)) :=
  LinearMap.pi (fun j => LinearMap.proj (sel j))

omit [Fintype I] in
theorem selectLinear_surjective (hsel : Function.Injective sel) :
    Function.Surjective (selectLinear W sel) :=
  hsel.surjective_comp_right

def selectedRowsLinear : Parameter W C' →ₗ[F2] (J → Module.Dual F2 (E ⧸ W)) :=
  (selectLinear W sel).comp (rowsLinear W C' b)

omit [Fintype I] in
@[simp] theorem selectedRowsLinear_apply (A : Parameter W C') (j : J) :
    selectedRowsLinear W C' b sel A j = (b.coord (sel j)).comp A := rfl

theorem selectedRowsLinear_surjective (hsel : Function.Injective sel) :
    Function.Surjective (selectedRowsLinear W C' b sel) :=
  (selectLinear_surjective W sel hsel).comp (rowsLinear_surjective W C' b)

end Selection

section Uniform

variable [Fintype (Parameter W C')] [Fintype (Module.Dual F2 (E ⧸ W))]

theorem uniform_rowsLinear :
    (FiniteDistribution.uniform (Parameter W C')).pushforward (rowsLinear W C' b) =
      FiniteDistribution.uniform (I → Module.Dual F2 (E ⧸ W)) :=
  UniformLinearImage.uniform_pushforward_linearMap
    (rowsLinear W C' b) (rowsLinear_surjective W C' b)

theorem uniform_rows_law [DecidableEq I] :
    (FiniteDistribution.uniform (Parameter W C')).pushforward (rowsLinear W C' b) =
      FiniteProduct.law (fun _ : I => FiniteDistribution.uniform
        (Module.Dual F2 (E ⧸ W))) := by
  rw [UniformLinearImage.law_uniform]
  exact UniformLinearImage.uniform_pushforward_linearMap
    (rowsLinear W C' b) (rowsLinear_surjective W C' b)

private theorem uniform_add_left {V : Type*} [AddGroup V] [Fintype V] (offset : V) :
    (FiniteDistribution.uniform V).pushforward (fun x => offset + x) =
      FiniteDistribution.uniform V := by
  change (FiniteDistribution.uniform V).pushforward (Equiv.addLeft offset) = _
  rw [FiniteDistribution.pushforward_equiv]
  apply FiniteDistribution.eq_of_weight_eq
  intro x
  rfl

theorem uniform_translated_rows (offsets : I → Module.Dual F2 (E ⧸ W)) :
    (FiniteDistribution.uniform (Parameter W C')).pushforward
        (fun A => offsets + rowsLinear W C' b A) =
      FiniteDistribution.uniform (I → Module.Dual F2 (E ⧸ W)) := by
  rw [← FiniteDistribution.pushforward_comp
    (FiniteDistribution.uniform (Parameter W C')) (rowsLinear W C' b)
    (fun rows => offsets + rows), uniform_rowsLinear]
  exact uniform_add_left offsets

variable {J : Type*} [Fintype J] (sel : J → I)

theorem uniform_selectedRowsLinear (hsel : Function.Injective sel) :
    (FiniteDistribution.uniform (Parameter W C')).pushforward
        (selectedRowsLinear W C' b sel) =
      FiniteDistribution.uniform (J → Module.Dual F2 (E ⧸ W)) :=
  UniformLinearImage.uniform_pushforward_linearMap
    (selectedRowsLinear W C' b sel) (selectedRowsLinear_surjective W C' b sel hsel)

theorem uniform_selected_rows_law [DecidableEq J] (hsel : Function.Injective sel) :
    (FiniteDistribution.uniform (Parameter W C')).pushforward
        (selectedRowsLinear W C' b sel) =
      FiniteProduct.law (fun _ : J => FiniteDistribution.uniform
        (Module.Dual F2 (E ⧸ W))) := by
  rw [UniformLinearImage.law_uniform]
  exact UniformLinearImage.uniform_pushforward_linearMap
    (selectedRowsLinear W C' b sel) (selectedRowsLinear_surjective W C' b sel hsel)

end Uniform

def affineRow (offset : Module.Dual F2 E) (row : Module.Dual F2 (E ⧸ W)) :
    Module.Dual F2 E := offset + row.comp W.mkQ

omit [Fintype I] in
theorem coordinate_translate (coordinates : I → Module.Dual F2 C)
    (hcoordinates : ∀ i, (coordinates i).comp C'.subtype = b.coord i)
    (X : E →ₗ[F2] C) (A : Parameter W C') (i : I) :
    (coordinates i).comp (translate W C' X A) =
      affineRow W ((coordinates i).comp X) (rowsLinear W C' b A i) := by
  apply LinearMap.ext
  intro x
  change coordinates i (X x + (A (W.mkQ x) : C)) =
    coordinates i (X x) + b.coord i (A (W.mkQ x))
  rw [map_add]
  congr 1
  exact congrArg (fun f : C' →ₗ[F2] F2 => f (A (W.mkQ x))) (hcoordinates i)


variable [Fintype (Parameter W C')] [Fintype (Module.Dual F2 (E ⧸ W))]
  [Fintype (Module.Dual F2 E)]

def affineRowLaw (offset : Module.Dual F2 E) : FiniteDistribution (Module.Dual F2 E) :=
  (FiniteDistribution.uniform (Module.Dual F2 (E ⧸ W))).pushforward (affineRow W offset)

theorem uniform_affine_rows_law [DecidableEq I] (offsets : I → Module.Dual F2 E) :
    (FiniteDistribution.uniform (Parameter W C')).pushforward
        (fun A i => affineRow W (offsets i) (rowsLinear W C' b A i)) =
      FiniteProduct.law (fun i => affineRowLaw W (offsets i)) := by
  rw [← FiniteDistribution.pushforward_comp
    (FiniteDistribution.uniform (Parameter W C')) (rowsLinear W C' b)
    (fun rows i => affineRow W (offsets i) (rows i)), uniform_rows_law]
  exact FiniteProduct.pushforward_map _ (fun i => affineRow W (offsets i))

theorem uniform_coordinate_translate_law [DecidableEq I]
    (coordinates : I → Module.Dual F2 C)
    (hcoordinates : ∀ i, (coordinates i).comp C'.subtype = b.coord i)
    (X : E →ₗ[F2] C) :
    (FiniteDistribution.uniform (Parameter W C')).pushforward
        (fun A i => (coordinates i).comp (translate W C' X A)) =
      FiniteProduct.law (fun i => affineRowLaw W ((coordinates i).comp X)) := by
  have hrows : (fun A i => (coordinates i).comp (translate W C' X A)) =
      (fun A i => affineRow W ((coordinates i).comp X) (rowsLinear W C' b A i)) := by
    funext A i
    exact coordinate_translate W C' b coordinates hcoordinates X A i
  rw [hrows]
  exact uniform_affine_rows_law W C' b (fun i => (coordinates i).comp X)

variable {J : Type*} [Fintype J] [DecidableEq J]

theorem uniform_selected_affine_rows_law (sel : J → I)
    (hsel : Function.Injective sel) (offsets : J → Module.Dual F2 E) :
    (FiniteDistribution.uniform (Parameter W C')).pushforward
        (fun A j => affineRow W (offsets j) (selectedRowsLinear W C' b sel A j)) =
      FiniteProduct.law (fun j => affineRowLaw W (offsets j)) := by
  rw [← FiniteDistribution.pushforward_comp
    (FiniteDistribution.uniform (Parameter W C')) (selectedRowsLinear W C' b sel)
    (fun rows j => affineRow W (offsets j) (rows j)),
    uniform_selected_rows_law W C' b sel hsel]
  exact FiniteProduct.pushforward_map _ (fun j => affineRow W (offsets j))

end
end PerfectCompleteness.RestrictionRowsLaw

end OAI