lean/OAI/Geometry/PeriodicTiling/FiniteMasks.lean

import OAI.Geometry.PeriodicTiling.TilingBasic
import Mathlib.Algebra.MonoidAlgebra.Basic
import Mathlib.Algebra.BigOperators.Ring.Finset
import Mathlib.Basic.Real.Basic
import Mathlib.Tactic.Abel

namespace OAI

universe uG uR uι

noncomputable section

open scoped BigOperators Classical

namespace PeriodicTilingThree

variable {G : Type uG}

def tileIndicator (R : Type uR) [Zero R] [One R] (A : Set G) (x : G) : R :=
  if x ∈ A then 1 else 0

theorem tileIndicator_nonneg (A : Set G) (x : G) :
    0 ≤ tileIndicator ℝ A x := by
  classical
  unfold tileIndicator
  split_ifs <;> simp

theorem tileIndicator_le_one (A : Set G) (x : G) :
    tileIndicator ℝ A x ≤ 1 := by
  classical
  unfold tileIndicator
  split_ifs <;> simp

theorem tileIndicator_nat_le_one (A : Set G) (x : G) :
    tileIndicator ℕ A x ≤ 1 := by
  classical
  unfold tileIndicator
  split_ifs <;> simp

theorem sum_tileIndicator_cast (R : Type uR) [AddCommMonoidWithOne R]
    {ι : Type uι} (s : Finset ι) (A : Set G) (v : ι → G) :
    ((∑ i ∈ s, tileIndicator ℕ A (v i) : ℕ) : R) =
      ∑ i ∈ s, tileIndicator R A (v i) := by
  classical
  simp only [Nat.cast_sum]
  apply Finset.sum_congr rfl
  intro i hi
  by_cases h : v i ∈ A <;> simp [tileIndicator, h]

section Counts

variable [AddCommGroup G]

def tileCount (F : Finset G) (A : Set G) (x : G) : ℕ :=
  ∑ f ∈ F, tileIndicator ℕ A (x - f)

theorem tileCount_eq_card_filter (F : Finset G) (A : Set G) (x : G) :
    tileCount F A x = (F.filter fun f => x - f ∈ A).card := by
  classical
  simp [tileCount, tileIndicator]

theorem tileCount_le_card (F : Finset G) (A : Set G) (x : G) :
    tileCount F A x ≤ F.card := by
  classical
  rw [tileCount_eq_card_filter]
  exact Finset.card_filter_le _ _

theorem tileCount_cast (R : Type uR) [AddCommMonoidWithOne R]
    (F : Finset G) (A : Set G) (x : G) :
    (tileCount F A x : R) = ∑ f ∈ F, tileIndicator R A (x - f) :=
  sum_tileIndicator_cast R F A (fun f => x - f)

theorem tiles_iff_tileCount_eq_one {F : Finset G} {A : Set G} :
    Tiles F A ↔ ∀ x : G, tileCount F A x = 1 := by
  classical
  rw [tiles_iff_unique_tile]
  constructor
  · intro h x
    obtain ⟨f, hf, hu⟩ := h x
    have he : (F.filter fun g => x - g ∈ A) = {f.val} := by
      ext g
      simp only [Finset.mem_filter, Finset.mem_singleton]
      constructor
      · rintro ⟨hg, hga⟩
        exact congrArg Subtype.val (hu ⟨g, hg⟩ hga)
      · intro hg
        subst g
        exact ⟨f.property, hf⟩
    rw [tileCount_eq_card_filter, he, Finset.card_singleton]
  · intro h x
    obtain ⟨f, hf⟩ := Finset.card_eq_one.mp ((tileCount_eq_card_filter F A x).symm.trans (h x))
    have hm : f ∈ F ∧ x - f ∈ A := by
      apply Finset.mem_filter.mp
      rw [hf]
      exact Finset.mem_singleton_self f
    refine ⟨⟨f, hm.1⟩, hm.2, ?_⟩
    intro g hg
    apply Subtype.ext
    have hg' : g.val ∈ F.filter fun f => x - f ∈ A :=
      Finset.mem_filter.mpr ⟨g.property, hg⟩
    simpa only [hf, Finset.mem_singleton] using hg'

theorem Tiles.tileCount_eq_one {F : Finset G} {A : Set G}
    (h : Tiles F A) (x : G) : tileCount F A x = 1 :=
  tiles_iff_tileCount_eq_one.mp h x

theorem Tiles.sum_tileIndicator_eq_one {F : Finset G} {A : Set G}
    (h : Tiles F A) (R : Type uR) [AddCommMonoidWithOne R] (x : G) :
    (∑ f ∈ F, tileIndicator R A (x - f)) = 1 := by
  rw [← tileCount_cast, h.tileCount_eq_one x, Nat.cast_one]

end Counts

section MaskAction

variable {R : Type uR} [Semiring R] [AddCommGroup G]

def maskAction (m : AddMonoidAlgebra R G) (a : G → R) (x : G) : R :=
  m.coeff.sum fun y c => c * a (x - y)

@[simp] theorem maskAction_zero (a : G → R) (x : G) :
    maskAction (0 : AddMonoidAlgebra R G) a x = 0 := by
  simp [maskAction]

@[simp] theorem maskAction_single (y : G) (c : R) (a : G → R) (x : G) :
    maskAction (AddMonoidAlgebra.single y c) a x = c * a (x - y) := by
  simp [maskAction]

theorem maskAction_add (m n : AddMonoidAlgebra R G) (a : G → R) (x : G) :
    maskAction (m + n) a x = maskAction m a x + maskAction n a x := by
  simpa only [maskAction, AddMonoidAlgebra.coeff_add] using
    (Finsupp.sum_add_index' (f := m.coeff) (g := n.coeff)
      (h := fun y c => c * a (x - y))
      (fun _ => zero_mul _) (fun _ _ _ => add_mul _ _ _))

theorem maskAction_sum {ι : Type uι} (s : Finset ι)
    (m : ι → AddMonoidAlgebra R G) (a : G → R) (x : G) :
    maskAction (∑ i ∈ s, m i) a x = ∑ i ∈ s, maskAction (m i) a x := by
  simpa only [maskAction, AddMonoidAlgebra.coeff_sum] using
    (Finsupp.sum_finsetSum_index (s := s) (g := fun i => (m i).coeff)
      (h := fun y c => c * a (x - y))
      (fun _ => zero_mul _) (fun _ _ _ => add_mul _ _ _)).symm

private theorem maskAction_single_mul (y : G) (c : R)
    (m : AddMonoidAlgebra R G) (a : G → R) (x : G) :
    maskAction (AddMonoidAlgebra.single y c * m) a x =
      c * maskAction m a (x - y) := by
  induction m using AddMonoidAlgebra.induction with
  | zero => simp
  | single_add z d m hz hd ih =>
    rw [mul_add, maskAction_add, maskAction_add, mul_add, ih]
    rw [AddMonoidAlgebra.single_mul_single, maskAction_single, maskAction_single]
    rw [mul_assoc, sub_sub]

theorem maskAction_mul (m n : AddMonoidAlgebra R G) (a : G → R) (x : G) :
    maskAction (m * n) a x = maskAction m (fun y => maskAction n a y) x := by
  induction m using AddMonoidAlgebra.induction with
  | zero => simp
  | single_add y c m hy hc ih =>
    rw [add_mul, maskAction_add, maskAction_add, ih]
    rw [maskAction_single_mul, maskAction_single]

@[simp] theorem maskAction_one (a : G → R) (x : G) :
    maskAction (1 : AddMonoidAlgebra R G) a x = a x := by
  rw [AddMonoidAlgebra.one_def, maskAction_single]
  simp

theorem maskAction_translate (m : AddMonoidAlgebra R G) (a : G → R) (x v : G) :
    maskAction m (fun y => a (y + v)) x = maskAction m a (x + v) := by
  unfold maskAction
  apply Finsupp.sum_congr
  intro y hy
  congr 2
  abel_nf

def familyMask (R : Type uR) [Semiring R] {ι : Type uι} (s : Finset ι) (v : ι → G) :
    AddMonoidAlgebra R G :=
  ∑ i ∈ s, AddMonoidAlgebra.single (v i) 1

def tileMask (R : Type uR) [Semiring R] (F : Finset G) : AddMonoidAlgebra R G :=
  familyMask R F id

theorem maskAction_familyMask {ι : Type uι} (s : Finset ι) (v : ι → G)
    (a : G → R) (x : G) :
    maskAction (familyMask R s v) a x = ∑ i ∈ s, a (x - v i) := by
  simp only [familyMask, maskAction_sum, maskAction_single, one_mul]

theorem maskAction_tileMask (F : Finset G) (a : G → R) (x : G) :
    maskAction (tileMask R F) a x = ∑ f ∈ F, a (x - f) :=
  maskAction_familyMask F id a x

theorem maskAction_familyMask_const {ι : Type uι} (s : Finset ι) (v : ι → G)
    (c : R) (x : G) :
    maskAction (familyMask R s v) (fun _ => c) x = (s.card : R) * c := by
  simp [maskAction_familyMask, nsmul_eq_mul]

theorem maskAction_familyMask_pow_const {ι : Type uι} (s : Finset ι) (v : ι → G)
    (n : ℕ) (c : R) (x : G) :
    maskAction (familyMask R s v ^ n) (fun _ => c) x = (s.card : R) ^ n * c := by
  induction n generalizing x with
  | zero => simp
  | succ n ih =>
    rw [pow_succ', maskAction_mul]
    simp_rw [ih]
    rw [maskAction_familyMask_const, pow_succ', mul_assoc]

theorem maskAction_familyMask_pow_succ {ι : Type uι} (s : Finset ι) (v : ι → G)
    (a : G → R) (h : ∀ x, (∑ i ∈ s, a (x - v i)) = 1) (n : ℕ) (x : G) :
    maskAction (familyMask R s v ^ (n + 1)) a x = (s.card : R) ^ n := by
  rw [pow_succ, maskAction_mul]
  simp_rw [maskAction_familyMask, h]
  rw [maskAction_familyMask_pow_const, mul_one]

end MaskAction

end PeriodicTilingThree

end

end OAI