lean/OAI/LinearAlgebra/MatrixMultiplication/Recovery/InheritedMasks.lean

import OAI.LinearAlgebra.MatrixMultiplication.Separation.ComplexTypeCounting
import OAI.LinearAlgebra.MatrixMultiplication.Tensor.ComplexTensor
import Mathlib.Analysis.SpecialFunctions.Log.Basic
import Mathlib.Tactic.Linarith

namespace OAI

/-! Finite orbit symmetries, masks and exact recovery operations. -/

namespace MatrixMultiplication.InheritedMasks

open MatrixMultiplication.Foundation
open scoped BigOperators

section ClassWords

variable {C : Type*} (P A : C → Type*)
  [∀ c, Fintype (P c)]
  [∀ c, Fintype (A c)] [∀ c, DecidableEq (A c)]

abbrev ClassWords := ∀ c, P c → A c

def SameClassOrbit (w v : ClassWords P A) : Prop :=
  ∃ e : ∀ c, Equiv.Perm (P c), ∀ c, w c ∘ e c = v c

omit [∀ label, Fintype (A label)] in
theorem sameClassOrbit_iff (w v : ClassWords P A) :
    SameClassOrbit P A w v ↔
      ∀ c a, wordPopulation (v c) a = wordPopulation (w c) a := by
  constructor
  · rintro ⟨e, he⟩ c a
    rw [← he c]
    exact wordPopulation_reindex (w c) (e c) a
  · intro h
    have he : ∀ c, ∃ e : Equiv.Perm (P c), w c ∘ e = v c :=
      fun c => (samePopulation_iff_permutation (w c) (v c)).mp (h c)
    choose e he using he
    exact ⟨e, he⟩

abbrev Profile := ∀ c, A c → Fin (Fintype.card (P c) + 1)

noncomputable def profile (w : ClassWords P A) : Profile P A :=
  fun c a => ⟨wordPopulation (w c) a,
    Nat.lt_succ_of_le (Fintype.card_subtype_le _)⟩

omit [∀ label, Fintype (A label)] in
theorem profile_eq_iff (w v : ClassWords P A) :
    profile P A w = profile P A v ↔ SameClassOrbit P A w v := by
  rw [sameClassOrbit_iff]
  constructor
  · intro h c a
    have hh := congrArg (fun f : Profile P A => (f c a).val) h
    exact hh.symm
  · intro h
    funext c a
    apply Fin.ext
    exact (h c a).symm

theorem card_profile [Fintype C] [DecidableEq C] :
    Fintype.card (Profile P A) =
      ∏ c, (Fintype.card (P c) + 1) ^ Fintype.card (A c) := by
  simp [Profile, Fintype.card_pi]

end ClassWords

section TensorAction

variable {F C : Type*} [CommSemiring F] [Fintype C]
  {P X Y Z : C → Type*} [∀ c, Fintype (P c)]

def classProduct (T : ∀ c, Tensor F (X c) (Y c) (Z c)) :
    Tensor F (∀ c, P c → X c) (∀ c, P c → Y c) (∀ c, P c → Z c) :=
  fun x y z => ∏ c, ∏ i, T c (x c i) (y c i) (z c i)

theorem classProduct_permutation
    (T : ∀ c, Tensor F (X c) (Y c) (Z c))
    (e : ∀ c, Equiv.Perm (P c))
    (x : ∀ c, P c → X c) (y : ∀ c, P c → Y c) (z : ∀ c, P c → Z c) :
    classProduct T (fun c => x c ∘ e c) (fun c => y c ∘ e c)
      (fun c => z c ∘ e c) = classProduct T x y z := by
  apply Finset.prod_congr rfl
  intro c _
  exact Equiv.prod_comp (e c) (fun i => T c (x c i) (y c i) (z c i))

end TensorAction

theorem statisticPopulation_permutation {P A B : Type*}
    [Fintype P] [DecidableEq P] [Fintype B] [DecidableEq B]
    (w : P → A) (statistic : A → B) (e : Equiv.Perm P) (b : B) :
    wordPopulation (statistic ∘ w ∘ e) b = wordPopulation (statistic ∘ w) b :=
  wordPopulation_reindex (statistic ∘ w) e b

section EmpiricalWindows

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

noncomputable def empiricalLaw (w : P → A) (a : A) : ℝ :=
  (wordPopulation w a : ℝ) / Fintype.card P

def typeWindow (ν : A → ℝ) (η : ℝ) (w : P → A) : Prop :=
  ∀ a, |empiricalLaw w a - ν a| ≤ η

theorem typeWindow_permutation (ν : A → ℝ) (η : ℝ) (w : P → A)
    (e : Equiv.Perm P) : typeWindow ν η (w ∘ e) ↔ typeWindow ν η w := by
  simp [typeWindow, empiricalLaw, wordPopulation_reindex]

theorem wordPopulation_equiv (w : P → A) (e : A ≃ B) (a : A) :
    wordPopulation (e ∘ w) (e a) = wordPopulation w a := by
  apply Fintype.card_congr
  exact Equiv.subtypeEquivRight fun i => e.injective.eq_iff

theorem typeWindow_equiv (ν : A → ℝ) (η : ℝ) (w : P → A) (e : A ≃ B) :
    typeWindow (ν ∘ e.symm) η (e ∘ w) ↔ typeWindow ν η w := by
  constructor
  · intro h a
    have hh := h (e a)
    simpa [empiricalLaw, wordPopulation_equiv] using hh
  · intro h b
    obtain ⟨a, rfl⟩ := e.surjective b
    simpa [empiricalLaw, wordPopulation_equiv] using h a

end EmpiricalWindows

section Windows

variable {I : Type*} [Fintype I]

theorem weighted_window (w x : I → ℝ) (μ η : ℝ)
    (hw : ∀ i, 0 ≤ w i) (hsum : ∑ i, w i = 1)
    (hx : ∀ i, |x i - μ| ≤ η) :
    |(∑ i, w i * x i) - μ| ≤ η := by
  have heq : (∑ i, w i * x i) - μ = ∑ i, w i * (x i - μ) := by
    simp only [mul_sub, Finset.sum_sub_distrib, ← Finset.sum_mul, hsum, one_mul]
  rw [heq]
  calc
    |∑ i, w i * (x i - μ)| ≤ ∑ i, |w i * (x i - μ)| :=
      Finset.abs_sum_le_sum_abs _ _
    _ = ∑ i, w i * |x i - μ| := by
      apply Finset.sum_congr rfl
      intro i _
      rw [abs_mul, abs_of_nonneg (hw i)]
    _ ≤ ∑ i, w i * η := Finset.sum_le_sum fun i _ => mul_le_mul_of_nonneg_left (hx i) (hw i)
    _ = η := by rw [← Finset.sum_mul, hsum, one_mul]

theorem product_coordinate_error {a b a' b' τ : ℝ}
    (ha : 0 ≤ a) (ha1 : a ≤ 1) (hb' : 0 ≤ b') (hb1' : b' ≤ 1)
    (hea : |a - a'| ≤ τ) (heb : |b - b'| ≤ τ) :
    |a * b - a' * b'| ≤ 2 * τ := by
  have ht : 0 ≤ τ := le_trans (abs_nonneg _) hea
  have heq : a * b - a' * b' = a * (b - b') + (a - a') * b' := by ring
  rw [heq]
  calc
    |a * (b - b') + (a - a') * b'| ≤ |a * (b - b')| + |(a - a') * b'| := abs_add_le _ _
    _ = a * |b - b'| + |a - a'| * b' := by rw [abs_mul, abs_mul, abs_of_nonneg ha, abs_of_nonneg hb']
    _ ≤ a * τ + τ * b' := add_le_add
      (mul_le_mul_of_nonneg_left heb ha) (mul_le_mul_of_nonneg_right hea hb')
    _ ≤ 2 * τ := by nlinarith

theorem inherited_margin {actual expected prescribed η τ α : ℝ}
    (hchild : |expected - prescribed| ≤ 2 * τ)
    (happrox : |actual - expected| ≤ α)
    (hτ : τ ≤ η / 8) (hα : α ≤ η / 4) :
    |actual - prescribed| ≤ η / 2 := by
  calc
    |actual - prescribed| = |(actual - expected) + (expected - prescribed)| := by ring_nf
    _ ≤ |actual - expected| + |expected - prescribed| := abs_add_le _ _
    _ ≤ α + 2 * τ := add_le_add happrox hchild
    _ ≤ η / 2 := by linarith

end Windows

end MatrixMultiplication.InheritedMasks

end OAI