lean/OAI/Algebra/Finitistic/Bar/MultibarDecomposition.lean

import OAI.Algebra.Finitistic.Bar.MultibarIndex

namespace OAI
open scoped TensorProduct DirectSum
open TensorProduct TrivSqZeroExt
noncomputable section

namespace DerivedBar.Multibar.Indexed
universe u

/-- A D/X pattern with length and X-count in its type, avoiding any degree casts. -/
inductive Shape : ℕ → ℕ → Type
  | nil : Shape 0 0
  | base {n r : ℕ} : Shape n r → Shape (n+1) r
  | ideal {n r : ℕ} : Shape n r → Shape (n+1) (r+1)

local instance (n r : ℕ) : DecidableEq (Shape n r) := Classical.decEq _

def toList : {n r : ℕ} → Shape n r → List Bool
  | _, _, .nil => []
  | _, _, .base p => false :: toList p
  | _, _, .ideal p => true :: toList p

@[simp] theorem length_toList {n r : ℕ} (p : Shape n r) : (toList p).length = n := by
  induction p <;> simp_all [toList]

@[simp] theorem count_toList {n r : ℕ} (p : Shape n r) : count (toList p) = r := by
  induction p <;> simp_all [toList, count]

variable (k D X N : Type u) [Field k] [Ring D] [Algebra k D]
  [AddCommGroup X] [Module k X] [Module D X] [Module Dᵐᵒᵖ X]
  [SMulCommClass D Dᵐᵒᵖ X] [IsScalarTower k D X] [IsScalarTower k Dᵐᵒᵖ X]
  [AddCommGroup N] [Module k N]

@[reducible] def tensor : {n r : ℕ} → Shape n r → ModuleCat k
  | _, _, .nil => ModuleCat.of k N
  | _, _, .base p => ModuleCat.of k (D ⊗[k] tensor p)
  | _, _, .ideal p => ModuleCat.of k (X ⊗[k] tensor p)

def inclusion : {n r : ℕ} → (p : Shape n r) →
    tensor k D X N p →ₗ[k] DerivedBar.term k (TrivSqZeroExt D X) N n
  | _, _, .nil => LinearMap.id
  | _, _, .base p => TensorProduct.map (inlAlgHom k D X).toLinearMap (inclusion p)
  | _, _, .ideal p => TensorProduct.map ((inrHom D X).restrictScalars k) (inclusion p)

def retraction : {n r : ℕ} → (p : Shape n r) →
    DerivedBar.term k (TrivSqZeroExt D X) N n →ₗ[k] tensor k D X N p
  | _, _, .nil => LinearMap.id
  | _, _, .base p => TensorProduct.map (fstHom k D X).toLinearMap (retraction p)
  | _, _, .ideal p => TensorProduct.map ((sndHom D X).restrictScalars k) (retraction p)

theorem retraction_inclusion {n r : ℕ} (p : Shape n r) (v : tensor k D X N p) :
    retraction k D X N p (inclusion k D X N p v) = v := by
  induction p with
  | nil => rfl
  | base p ih =>
    induction v using TensorProduct.inductionOn with
    | tmul d v =>
      change d ⊗ₜ[k] retraction k D X N p (inclusion k D X N p v) = _
      rw [ih]
    | add v w hv hw => simp only [map_add, hv, hw]
  | ideal p ih =>
    induction v using TensorProduct.inductionOn with
    | tmul x v =>
      change x ⊗ₜ[k] retraction k D X N p (inclusion k D X N p v) = _
      rw [ih]
    | add v w hv hw => simp only [map_add, hv, hw]

/-- Distinct patterns are separated by slotwise projections, including non-flat bimodules. -/
theorem retraction_other {n r : ℕ} (p q : Shape n r) (hpq : p ≠ q)
    (v : tensor k D X N q) : retraction k D X N p (inclusion k D X N q v) = 0 := by
  induction p with
  | nil => cases q; exact (hpq rfl).elim
  | base p ih =>
    cases q with
    | base q =>
      have h : p ≠ q := fun h => hpq (congrArg Shape.base h)
      induction v using TensorProduct.inductionOn with
      | tmul d v =>
        change d ⊗ₜ[k] retraction k D X N p (inclusion k D X N q v) = 0
        rw [ih q h, TensorProduct.tmul_zero]
      | add v w hv hw => simp only [map_add, hv, hw, add_zero]
    | ideal q =>
      induction v using TensorProduct.inductionOn with
      | tmul x v => exact TensorProduct.zero_tmul _ _
      | add v w hv hw => simp only [map_add, hv, hw, add_zero]
  | ideal p ih =>
    cases q with
    | base q =>
      induction v using TensorProduct.inductionOn with
      | tmul d v => exact TensorProduct.zero_tmul _ _
      | add v w hv hw => simp only [map_add, hv, hw, add_zero]
    | ideal q =>
      have h : p ≠ q := fun h => hpq (congrArg Shape.ideal h)
      induction v using TensorProduct.inductionOn with
      | tmul x v =>
        change x ⊗ₜ[k] retraction k D X N p (inclusion k D X N q v) = 0
        rw [ih q h, TensorProduct.tmul_zero]
      | add v w hv hw => simp only [map_add, hv, hw, add_zero]

theorem inclusion_mem {n r : ℕ} (p : Shape n r) (v : tensor k D X N p) :
    inclusion k D X N p v ∈ SquareZero.weight k D X N n r := by
  induction p with
  | nil => exact Submodule.subset_span (SquareZero.Word.nil v)
  | base p ih =>
    induction v using TensorProduct.inductionOn with
    | tmul d v => exact SquareZero.base_tmul_mem d (ih v)
    | add v w hv hw => simpa only [map_add] using Submodule.add_mem _ hv hw
  | ideal p ih =>
    induction v using TensorProduct.inductionOn with
    | tmul x v => exact SquareZero.ideal_tmul_mem x (ih v)
    | add v w hv hw => simpa only [map_add] using Submodule.add_mem _ hv hw

/-- Every homogeneous word is an actual tensor in one of the prescribed blocks. -/
theorem word_inclusion {n r : ℕ} {z : DerivedBar.term k (TrivSqZeroExt D X) N n}
    (hz : SquareZero.Word k D X N n r z) :
    ∃ (p : Shape n r) (v : tensor k D X N p), inclusion k D X N p v = z := by
  induction hz with
  | nil v => exact ⟨.nil, v, rfl⟩
  | base d h ih =>
    obtain ⟨p, v, hv⟩ := ih
    exact ⟨.base p, d ⊗ₜ[k] v, by change (inl d : TrivSqZeroExt D X) ⊗ₜ[k] _ = _; rw [hv]⟩
  | ideal x h ih =>
    obtain ⟨p, v, hv⟩ := ih
    exact ⟨.ideal p, x ⊗ₜ[k] v, by change (inr x : TrivSqZeroExt D X) ⊗ₜ[k] _ = _; rw [hv]⟩

abbrev outerTensor {n r : ℕ} (p : Shape n r) := D ⊗[k] tensor k D X N p

def outerInclusion {n r : ℕ} (p : Shape n r) : outerTensor k D X N p →ₗ[D]
    D ⊗[k] DerivedBar.term k (TrivSqZeroExt D X) N n :=
  AlgebraTensorModule.lTensor D D (inclusion k D X N p)

def outerRetraction {n r : ℕ} (p : Shape n r) :
    D ⊗[k] DerivedBar.term k (TrivSqZeroExt D X) N n →ₗ[D] outerTensor k D X N p :=
  AlgebraTensorModule.lTensor D D (retraction k D X N p)

theorem outerRetraction_inclusion {n r : ℕ} (p : Shape n r) (v : outerTensor k D X N p) :
    outerRetraction k D X N p (outerInclusion k D X N p v) = v := by
  induction v using TensorProduct.inductionOn with
  | tmul d v =>
    change d ⊗ₜ[k] retraction k D X N p (inclusion k D X N p v) = _
    rw [retraction_inclusion]
  | add v w hv hw => simp only [map_add, hv, hw]

theorem outerRetraction_other {n r : ℕ} (p q : Shape n r) (hpq : p ≠ q)
    (v : outerTensor k D X N q) :
    outerRetraction k D X N p (outerInclusion k D X N q v) = 0 := by
  induction v using TensorProduct.inductionOn with
  | tmul d v =>
    change d ⊗ₜ[k] retraction k D X N p (inclusion k D X N q v) = 0
    rw [retraction_other k D X N p q hpq, TensorProduct.tmul_zero]
  | add v w hv hw => simp only [map_add, hv, hw, add_zero]

theorem outerInclusion_mem {n r : ℕ} (p : Shape n r) (v : outerTensor k D X N p) :
    outerInclusion k D X N p v ∈ SquareZero.twoSidedWeight k D X N n r := by
  induction v using TensorProduct.inductionOn with
  | tmul d v => exact SquareZero.tensor_weight_mem d (inclusion_mem k D X N p v)
  | add v w hv hw => simpa only [map_add] using Submodule.add_mem _ hv hw

/-- The actual sum of all tensor-block inclusions in count r and degree n. -/
def assemble (n r : ℕ) : (⨁ p : Shape n r, outerTensor k D X N p) →ₗ[D]
    SquareZero.twoSidedWeight k D X N n r :=
  DirectSum.toModule D (Shape n r) _ (fun p =>
    (outerInclusion k D X N p).codRestrict _ (outerInclusion_mem k D X N p))

/-- Surjectivity is proved from the original homogeneous-word spanning definition. -/
theorem assemble_surjective (n r : ℕ) : Function.Surjective (assemble k D X N n r) := by
  let S := LinearMap.range (assemble k D X N n r)
  have hle : SquareZero.twoSidedWeight k D X N n r ≤
      S.map (SquareZero.twoSidedWeight k D X N n r).subtype := by
    apply Submodule.span_le.mpr
    rintro z ⟨d, v, hv, rfl⟩
    obtain ⟨p, w, hw⟩ := word_inclusion k D X N hv
    refine ⟨assemble k D X N n r (DirectSum.lof D _ _ p (d ⊗ₜ[k] w)), ⟨_, rfl⟩, ?_⟩
    simp only [assemble, DirectSum.toModule_lof, LinearMap.codRestrict_apply,
      Submodule.subtype_apply]
    change d ⊗ₜ[k] inclusion k D X N p w = d ⊗ₜ[k] v
    rw [hw]
  intro v
  obtain ⟨w, ⟨z, hz⟩, hw⟩ := hle v.property
  refine ⟨z, ?_⟩
  apply Subtype.ext
  rw [hz]
  exact hw

/-- Projection onto an actual block after summation recovers the direct-sum component. -/
theorem outerRetraction_assemble (n r : ℕ) (p : Shape n r)
    (z : ⨁ p : Shape n r, outerTensor k D X N p) :
    outerRetraction k D X N p (assemble k D X N n r z) = z p := by
  have h : (outerRetraction k D X N p).comp
      ((SquareZero.twoSidedWeight k D X N n r).subtype.comp (assemble k D X N n r)) =
      DirectSum.component D (Shape n r) (outerTensor k D X N) p := by
    apply DirectSum.linearMap_ext
    intro q
    apply LinearMap.ext
    intro v
    by_cases hpq : p = q
    · subst q
      simpa only [LinearMap.comp_apply, assemble, DirectSum.toModule_lof,
        LinearMap.codRestrict_apply, Submodule.subtype_apply,
        DirectSum.component.lof_self] using
          outerRetraction_inclusion k D X N p v
    · simpa only [LinearMap.comp_apply, assemble, DirectSum.toModule_lof,
        LinearMap.codRestrict_apply, Submodule.subtype_apply,
        DirectSum.component.of, Ne.symm hpq, dite_eq_right, dite_false] using
          outerRetraction_other k D X N p q hpq v
  exact LinearMap.congr_fun h z

/-- The block direct sum is linearly isomorphic to the entire actual count submodule. -/
def decomposition (n r : ℕ) : (⨁ p : Shape n r, outerTensor k D X N p) ≃ₗ[D]
    SquareZero.twoSidedWeight k D X N n r :=
  LinearEquiv.ofBijective (assemble k D X N n r)
    ⟨by
      intro z w h
      apply DFinsupp.ext
      intro p
      rw [← outerRetraction_assemble k D X N n r p z,
        ← outerRetraction_assemble k D X N n r p w, h],
     assemble_surjective k D X N n r⟩
end DerivedBar.Multibar.Indexed

end

end OAI