import Mathlib
import OAI.RingTheory.Multiplicity.CarrierOperators
import OAI.RingTheory.Multiplicity.CechNormalizationRows

namespace OAI

noncomputable section
namespace Lech.CechNormalization
open Set FiniteCoverCech CarrierOperators
universe u
variable {R : Type u} [CommRing R] {ι : Type} [Fintype ι] [LinearOrder ι]

abbrev fullCarrier (p : ℕ) : Carrier ι := ⟨Fin p → ι,intersection⟩
abbrev sortedCarrier (p : ℕ) : Carrier ι := ⟨powersetCard ι p,Subtype.val⟩

def deltaOp (p : ℕ) : Op (R:=R) (fullCarrier (ι:=ι) p) (fullCarrier (p+1)) where
  app M := delta R M p
  natural l f := delta_natural R _ l p f
  locality M S f g h := delta_agree R M S p f g h

def normalizeOp (p : ℕ) : Op (R:=R) (fullCarrier (ι:=ι) p) (fullCarrier p) where
  app M := normalize R M p
  natural l f := normalize_natural R _ l p f
  locality M S f g h := normalize_agree R M S p f g h

def contractionOp (p : ℕ) : Op (R:=R) (fullCarrier (ι:=ι) (p+1)) (fullCarrier p) where
  app M := contraction R M p
  natural l f := contraction_natural R _ l p f
  locality M S f g h := contraction_agree R M S p f g h

def sortOp (p : ℕ) : Op (R:=R) (fullCarrier (ι:=ι) p) (sortedCarrier p) where
  app M := sortedRestriction R M p
  natural _ _ := rfl
  locality M S f g h s hs := by
    apply h
    change intersection (s.val.orderEmbOfFin s.property)⊆S
    intro index hindex
    obtain ⟨position,_,rfl⟩ := Finset.mem_image.mp hindex
    exact hs (s.val.orderEmbOfFin_mem s.property position)

variable (R) (M : Type u) [AddCommGroup M] [Module R M]

def expansion (p : ℕ) : (powersetCard ι p → M) →ₗ[R] Row M (ι:=ι) p :=
  (AlternatingCech.evaluation R M p).comp (AlternatingCech.sortedCoordinates R M p).symm.toLinearMap

lemma expansion_sorted (p : ℕ) (f : powersetCard ι p → M) (s : powersetCard ι p) :
    expansion R M p f (s.val.orderEmbOfFin s.property)=f s := by
  change AlternatingCech.evaluation R M p ((AlternatingCech.sortedCoordinates R M p).symm f)
    (s.val.orderEmbOfFin s.property)=_
  rw [←AlternatingCech.sortedCoordinates_eq_evaluation,LinearEquiv.apply_symm_apply]

lemma expansion_perm (p : ℕ) (f : powersetCard ι p → M) (a : Fin p → ι) (σ : Equiv.Perm (Fin p)) :
    expansion R M p f (a ∘ σ)=(Equiv.Perm.sign σ:ℤ) • expansion R M p f a := by
  change ((AlternatingCech.sortedCoordinates R M p).symm f)
    ((fun i => AlternatingCech.basis R (a i)) ∘ σ)=_
  exact ((AlternatingCech.sortedCoordinates R M p).symm f).map_perm _ σ

lemma expansion_degenerate (p : ℕ) (f : powersetCard ι p → M) (a : Fin p → ι)
    (ha : ¬Function.Injective a) : expansion R M p f a=0 := by
  apply ((AlternatingCech.sortedCoordinates R M p).symm f).map_eq_zero_of_not_injective
  intro h
  apply ha
  intro i j hij
  exact h (congrArg (AlternatingCech.basis R) hij)

lemma expansion_natural {N : Type u} [AddCommGroup N] [Module R N]
    (l : M →ₗ[R] N) (p : ℕ) (f : powersetCard ι p → M) :
    expansion R N p (l ∘ f)=l ∘ expansion R M p f := by
  ext a
  by_cases h : Function.Injective a
  · obtain ⟨s,σ,hs,hσ⟩ := AlternatingCech.tuple_sort a h
    rw [hσ,expansion_perm,expansion_sorted]
    change _=l (expansion R M p f (s.val.orderEmbOfFin s.property ∘ σ))
    rw [expansion_perm,expansion_sorted,map_zsmul]
    rfl
  · rw [expansion_degenerate R N p _ a h]
    change _=l (expansion R M p f a)
    rw [expansion_degenerate R M p f a h,map_zero]

lemma expansion_agree (S : Finset ι) (p : ℕ) (f g : powersetCard ι p → M)
    (hf : Agree (sortedCarrier p) M S f g) :
    Agree (fullCarrier p) M S (expansion R M p f) (expansion R M p g) := by
  intro a ha
  by_cases h : Function.Injective a
  · obtain ⟨s,σ,hs,hσ⟩ := AlternatingCech.tuple_sort a h
    rw [hσ,expansion_perm,expansion_perm,expansion_sorted,expansion_sorted]
    congr 1
    apply hf
    change s.val⊆S
    rw [←hs]
    intro index hindex
    obtain ⟨position,_,hposition⟩ :=
      (@Finset.mem_image (Fin p) ι
        (fun left right => Classical.propDecidable (left=right)) a Finset.univ index).mp hindex
    exact ha (Finset.mem_image.mpr ⟨position,Finset.mem_univ _,hposition⟩)
  · rw [expansion_degenerate R M p f a h,expansion_degenerate R M p g a h]

variable {R M}
def expandOp (p : ℕ) : Op (R:=R) (sortedCarrier (ι:=ι) p) (fullCarrier p) where
  app M := expansion R M p
  natural l f := expansion_natural R _ l p f
  locality M S f g h := expansion_agree R M S p f g h

def sortedDeltaOp (p : ℕ) : Op (R:=R) (sortedCarrier (ι:=ι) p) (sortedCarrier (p+1)) where
  app M := AlternatingCech.rawDelta R M p
  natural l f := by
    ext s
    change (∑ i : Fin (p+1),(-1:ℤ)^i.val • l (f (AlternatingCech.delete s i))) =
      l (∑ i : Fin (p+1),(-1:ℤ)^i.val • f (AlternatingCech.delete s i))
    rw [map_sum]
    simp only [map_zsmul]
  locality M S f g h s hs := by
    change (∑ i : Fin (p+1),(-1:ℤ)^i.val • f (AlternatingCech.delete s i)) =
      ∑ i : Fin (p+1),(-1:ℤ)^i.val • g (AlternatingCech.delete s i)
    apply Finset.sum_congr rfl
    intro i hi
    congr 1
    exact h _ ((AlternatingCech.delete_subset s i).trans hs)

omit [Fintype ι] in
lemma sort_delta (M : ModuleCat.{u} R) (p : ℕ) :
    ((sortOp (R:=R) (ι:=ι) (p+1)).app M).comp ((deltaOp p).app M) =
      ((sortedDeltaOp p).app M).comp ((sortOp p).app M) := by
  apply LinearMap.ext
  intro f
  funext s
  change (∑ i : Fin (p+1),(-1:R)^i.val • f (s.val.orderEmbOfFin s.property ∘ i.succAbove)) =
    ∑ i : Fin (p+1),(-1:ℤ)^i.val • f ((AlternatingCech.delete s i).val.orderEmbOfFin (AlternatingCech.delete s i).property)
  apply Finset.sum_congr rfl
  intro i hi
  rw [←Int.cast_smul_eq_zsmul R]
  simp only [Int.cast_pow,Int.cast_neg,Int.cast_one]
  congr 1
  change f (powersetCard.ofFinEmbEquiv.symm s ∘ i.succAbove)=
    f (powersetCard.ofFinEmbEquiv.symm (AlternatingCech.delete s i))
  rw [AlternatingCech.delete_sorted]
  rfl

lemma sort_expand (M : ModuleCat.{u} R) (p : ℕ) :
    ((sortOp (R:=R) (ι:=ι) p).app M).comp ((expandOp p).app M)=LinearMap.id := by
  apply LinearMap.ext
  intro f
  funext s
  exact expansion_sorted R M p f s

lemma expand_sort (M : ModuleCat.{u} R) (p : ℕ) :
    ((expandOp (R:=R) (ι:=ι) p).app M).comp ((sortOp p).app M)=(normalizeOp p).app M := rfl

lemma expand_delta (M : ModuleCat.{u} R) (p : ℕ) :
    ((expandOp (R:=R) (ι:=ι) (p+1)).app M).comp ((sortedDeltaOp p).app M) =
      ((deltaOp p).app M).comp ((expandOp p).app M) := by
  apply LinearMap.ext
  intro f
  have hr : sortedRestriction R M p (expansion R M p f)=f := by
    ext s
    exact expansion_sorted R M p f s
  have hs := DFunLike.congr_fun (sort_delta (R:=R) (ι:=ι) M p) (expansion R M p f)
  change sortedRestriction R M (p+1) (delta R M p (expansion R M p f))=
    AlternatingCech.rawDelta R M p (sortedRestriction R M p (expansion R M p f)) at hs
  rw [hr] at hs
  change expansion R M (p+1) (AlternatingCech.rawDelta R M p f)=delta R M p (expansion R M p f)
  rw [←hs]
  change normalize R M (p+1) (delta R M p (expansion R M p f))=_
  rw [normalize_delta]
  change delta R M p (expansion R M p (sortedRestriction R M p (expansion R M p f)))=_
  rw [hr]
end Lech.CechNormalization

end

end OAI