import Mathlib

namespace OAI

/-! Exterior forms, differentials, Koszul operators and residue pairings. -/

noncomputable section
open scoped BigOperators

namespace PD4Tensor.Forms
noncomputable section
open scoped TensorProduct BigOperators

variable (K A σ : Type*) [Field K] [CommRing A] [Algebra K A]
  [Fintype σ] [DecidableEq σ]

abbrev E := ExteriorAlgebra K (σ → K)
abbrev Ω := A ⊗[K] E K σ

def dx (i : σ) : E K σ := ExteriorAlgebra.ι K (Pi.single i 1)
def scalar (a : A) : Ω K A σ := a ⊗ₜ[K] (1 : E K σ)
def parity : Ω K A σ →ₐ[K] Ω K A σ :=
  Algebra.TensorProduct.map (AlgHom.id K A) CliffordAlgebra.involute

def oneForm (v : σ → A) : Ω K A σ := ∑ i, v i ⊗ₜ[K] dx K σ i

variable {K A σ}

omit [Fintype σ] [DecidableEq σ] in
@[simp] theorem parity_tmul (a : A) (e : E K σ) :
    parity K A σ (a ⊗ₜ[K] e) = a ⊗ₜ[K] CliffordAlgebra.involute e := rfl

omit [Fintype σ] in
@[simp] theorem parity_dx (i : σ) :
    CliffordAlgebra.involute (dx K σ i) = -dx K σ i := by
  exact CliffordAlgebra.involute_ι _

omit [Fintype σ] [DecidableEq σ] in
@[simp] theorem parity_parity (ω : Ω K A σ) :
    parity K A σ (parity K A σ ω) = ω := by
  induction ω using TensorProduct.inductionOn with
  | tmul a e => simp
  | add a b ha hb => simp [ha, hb]

omit [Fintype σ] [DecidableEq σ] in
theorem exterior_anticommute (v : σ → K) (e : E K σ) :
    ExteriorAlgebra.ι K v * e = CliffordAlgebra.involute e * ExteriorAlgebra.ι K v := by
  induction e using ExteriorAlgebra.induction with
  | algebraMap r => simp [Algebra.commutes]
  | ι w =>
    rw [CliffordAlgebra.involute_ι, neg_mul]
    exact eq_neg_of_add_eq_zero_left (ExteriorAlgebra.ι_add_mul_swap v w)
  | mul a b ha hb =>
    rw [map_mul, ← mul_assoc, ha, mul_assoc, hb, ← mul_assoc]
  | add a b ha hb => simp [mul_add, add_mul, ha, hb]

theorem oneForm_anticommute (v : σ → A) (ω : Ω K A σ) :
    oneForm K A σ v * ω = parity K A σ ω * oneForm K A σ v := by
  induction ω using TensorProduct.inductionOn with
  | tmul a e =>
    simp only [oneForm, Finset.sum_mul, Finset.mul_sum, parity_tmul,
      Algebra.TensorProduct.tmul_mul_tmul]
    apply Finset.sum_congr rfl
    intro i _
    rw [mul_comm (v i) a, dx, exterior_anticommute]
  | add a b ha hb => simp [mul_add, add_mul, ha, hb]

@[simp] theorem parity_oneForm (v : σ → A) :
    parity K A σ (oneForm K A σ v) = -oneForm K A σ v := by
  simp only [oneForm, map_sum, parity_tmul, parity_dx, TensorProduct.tmul_neg,
    Finset.sum_neg_distrib]

theorem oneForm_sq_zero [Invertible (2 : K)] (v : σ → A) :
    oneForm K A σ v * oneForm K A σ v = 0 := by
  have h := oneForm_anticommute v (oneForm K A σ v)
  rw [parity_oneForm, neg_mul] at h
  have h2 : (2 : K) • (oneForm K A σ v * oneForm K A σ v) = 0 := by
    rw [two_smul K]
    exact eq_neg_iff_add_eq_zero.mp h
  exact (isUnit_of_invertible (2 : K)).smul_eq_zero.mp h2

variable (K A σ)
 
def differential (der : σ → A →ₗ[K] A) : Ω K A σ →ₗ[K] Ω K A σ :=
  ∑ i, TensorProduct.map (der i) (LinearMap.mulLeft K (dx K σ i))

variable {K A σ}
@[simp] theorem differential_tmul (der : σ → A →ₗ[K] A) (a : A) (e : E K σ) :
    differential K A σ der (a ⊗ₜ[K] e) = ∑ i, der i a ⊗ₜ[K] (dx K σ i * e) := by
  simp [differential]

@[simp] theorem differential_scalar (der : σ → A →ₗ[K] A) (a : A) :
    differential K A σ der (scalar K A σ a) = oneForm K A σ (fun i => der i a) := by
  simp [scalar, oneForm]

omit [Fintype σ] [DecidableEq σ] in
@[simp] theorem parity_scalar (a : A) : parity K A σ (scalar K A σ a) = scalar K A σ a := by
  simp [scalar]

theorem differential_mul (der : σ → A →ₗ[K] A)
    (hder : ∀ i a b, der i (a*b) = der i a * b + a * der i b)
    (ω η : Ω K A σ) :
    differential K A σ der (ω*η) = differential K A σ der ω * η +
      parity K A σ ω * differential K A σ der η := by
  induction ω using TensorProduct.inductionOn with
  | add a b ha hb => simp only [add_mul, map_add, ha, hb]; abel
  | tmul a e =>
    induction η using TensorProduct.inductionOn with
    | add b c hb hc => simp only [mul_add, map_add, hb, hc]; abel
    | tmul b f =>
      simp only [Algebra.TensorProduct.tmul_mul_tmul, differential_tmul,
        Finset.sum_mul, Finset.mul_sum, parity_tmul, hder, TensorProduct.add_tmul]
      rw [← Finset.sum_add_distrib]
      apply Finset.sum_congr rfl
      intro i _
      simp only [dx, ← mul_assoc, exterior_anticommute (Pi.single i 1) e]

theorem differential_parity (der : σ → A →ₗ[K] A) (ω : Ω K A σ) :
    differential K A σ der (parity K A σ ω) = -parity K A σ (differential K A σ der ω) := by
  induction ω using TensorProduct.inductionOn with
  | add a b ha hb => simp only [map_add, ha, hb]; abel
  | tmul a e =>
    simp only [parity_tmul, differential_tmul, map_sum, map_mul, parity_dx,
      neg_mul, TensorProduct.tmul_neg, Finset.sum_neg_distrib, neg_neg]

theorem differential_sq_zero [Invertible (2 : K)] (der : σ → A →ₗ[K] A)
    (hder : ∀ i j a, der i (der j a) = der j (der i a)) (ω : Ω K A σ) :
    differential K A σ der (differential K A σ der ω) = 0 := by
  induction ω using TensorProduct.inductionOn with
  | add a b ha hb => simp [ha, hb]
  | tmul a e =>
    have hanti : ∀ i j, dx K σ i * dx K σ j = -(dx K σ j * dx K σ i) := by
      intro i j
      exact eq_neg_of_add_eq_zero_left (ExteriorAlgebra.ι_add_mul_swap _ _)
    have heq : differential K A σ der (differential K A σ der (a ⊗ₜ[K] e)) =
        -differential K A σ der (differential K A σ der (a ⊗ₜ[K] e)) := by
      simp only [differential_tmul, map_sum]
      conv_rhs => rw [Finset.sum_comm]
      simp only [← Finset.sum_neg_distrib]
      apply Finset.sum_congr rfl
      intro i _
      apply Finset.sum_congr rfl
      intro j _
      rw [hder j i a, ← mul_assoc, hanti j i, neg_mul, TensorProduct.tmul_neg, mul_assoc]
    exact (isUnit_of_invertible (2 : K)).smul_eq_zero.mp (by
      rw [two_smul K]
      exact eq_neg_iff_add_eq_zero.mp heq)

omit [Fintype σ] [DecidableEq σ] in
@[simp] theorem scalar_mul (a b : A) : scalar K A σ (a*b) = scalar K A σ a * scalar K A σ b := by
  simp [scalar, Algebra.TensorProduct.tmul_mul_tmul]

omit [Fintype σ] [DecidableEq σ] in
@[simp] theorem scalar_add (a b : A) : scalar K A σ (a+b) = scalar K A σ a + scalar K A σ b := by
  simp [scalar, TensorProduct.add_tmul]

omit [Fintype σ] [DecidableEq σ] in
@[simp] theorem scalar_zero : scalar K A σ 0 = 0 := by simp [scalar]
omit [Fintype σ] [DecidableEq σ] in
@[simp] theorem scalar_one : scalar K A σ 1 = 1 := by
  exact Algebra.TensorProduct.one_def.symm

omit [Fintype σ] [DecidableEq σ] in
theorem scalar_commute (a : A) (ω : Ω K A σ) : scalar K A σ a * ω = ω * scalar K A σ a := by
  induction ω using TensorProduct.inductionOn with
  | add b c hb hc => simp [mul_add, add_mul, hb, hc]
  | tmul b e => simp [scalar, Algebra.TensorProduct.tmul_mul_tmul, mul_comm a b]

variable (K A σ)
 
def contraction (i : σ) : Ω K A σ →ₗ[K] Ω K A σ :=
  TensorProduct.map LinearMap.id (CliffordAlgebra.contractLeft (LinearMap.proj i))

variable {K A σ}
omit [Fintype σ] [DecidableEq σ] in
@[simp] theorem contraction_tmul (i : σ) (a : A) (e : E K σ) :
    contraction K A σ i (a ⊗ₜ[K] e) =
      a ⊗ₜ[K] CliffordAlgebra.contractLeft (LinearMap.proj i) e := rfl

theorem contraction_oneForm_mul (i : σ) (v : σ → A) (ω : Ω K A σ) :
    contraction K A σ i (oneForm K A σ v * ω) =
      scalar K A σ (v i) * ω - oneForm K A σ v * contraction K A σ i ω := by
  induction ω using TensorProduct.inductionOn with
  | add a b ha hb => simp only [mul_add, map_add, ha, hb]; abel
  | tmul a e =>
    simp only [oneForm, Finset.sum_mul, map_sum, Algebra.TensorProduct.tmul_mul_tmul,
      contraction_tmul, dx, CliffordAlgebra.contractLeft_ι_mul, LinearMap.proj_apply,
      TensorProduct.tmul_sub, TensorProduct.tmul_smul, Finset.sum_sub_distrib]
    congr 1
    simp [Pi.single_apply, scalar, Algebra.TensorProduct.tmul_mul_tmul]

theorem gradient_multiple_boundary (v : σ → A) (ω : Ω K A σ)
    (hω : oneForm K A σ v * ω = 0) (a : σ → A) :
    scalar K A σ (∑ i, a i * v i) * ω ∈ LinearMap.range (LinearMap.mulLeft K (oneForm K A σ v)) := by
  refine ⟨∑ i, scalar K A σ (a i) * contraction K A σ i ω, ?_⟩
  simp only [LinearMap.mulLeft_apply, Finset.mul_sum]
  have hi : ∀ i, oneForm K A σ v * contraction K A σ i ω = scalar K A σ (v i) * ω := by
    intro i
    have h := contraction_oneForm_mul i v ω
    rw [hω, map_zero] at h
    exact (sub_eq_zero.mp h.symm).symm
  have hsc : scalar K A σ (∑ i, a i*v i) = ∑ i, scalar K A σ (a i*v i) := by
    simp [scalar, TensorProduct.sum_tmul]
  rw [hsc, Finset.sum_mul]
  apply Finset.sum_congr rfl
  intro i _
  rw [← mul_assoc, ← scalar_commute, mul_assoc, hi, ← mul_assoc, ← scalar_mul]

variable (K A σ)
 
def normalFactor (der : σ → A →ₗ[K] A) (p : ℕ) (c : A) : Ω K A σ :=
  scalar K A σ (c^(p-1)) * differential K A σ der (scalar K A σ c)

def normalCycle (der : σ → A →ₗ[K] A) (p : ℕ) (cs : List A) : Ω K A σ :=
  (cs.map (normalFactor K A σ der p)).prod

variable {K A σ}
variable [Invertible (2 : K)]
variable (der : σ → A →ₗ[K] A)
  (hleib : ∀ i a b, der i (a*b) = der i a*b + a*der i b)
  (hcomm : ∀ i j a, der i (der j a) = der j (der i a))

omit [Fintype σ] [DecidableEq σ] [Invertible (2 : K)] in
include hleib in
private theorem deriv_one_eq_zero (i : σ) : der i 1 = 0 := by
  have h := hleib i 1 1
  simp only [mul_one, one_mul] at h
  exact add_left_cancel (show der i 1 + der i 1 = der i 1 + 0 by simpa using h.symm)

omit [Invertible (2 : K)] in
include hleib in
@[simp] theorem differential_one : differential K A σ der 1 = 0 := by
  rw [← scalar_one, differential_scalar]
  simp [oneForm, deriv_one_eq_zero der hleib]

include hleib in
theorem differential_power_mul_self (c : A) (r : ℕ) :
    differential K A σ der (scalar K A σ (c^r)) *
      differential K A σ der (scalar K A σ c) = 0 := by
  have hs : differential K A σ der (scalar K A σ c) *
      differential K A σ der (scalar K A σ c) = 0 := by
    rw [differential_scalar]
    exact oneForm_sq_zero _
  induction r with
  | zero => simp [differential_one der hleib]
  | succ r ih =>
    rw [pow_succ, scalar_mul, differential_mul der hleib, parity_scalar, add_mul,
      ← scalar_commute c, mul_assoc, ih, mul_zero, zero_add,
      mul_assoc, hs, mul_zero]

include hleib hcomm in
theorem normalFactor_closed (p : ℕ) (c : A) :
    differential K A σ der (normalFactor K A σ der p c) = 0 := by
  rw [normalFactor, differential_mul der hleib, differential_sq_zero der hcomm,
    mul_zero, add_zero]
  exact differential_power_mul_self der hleib c _

include hleib hcomm in
theorem normalCycle_closed (p : ℕ) (cs : List A) :
    differential K A σ der (normalCycle K A σ der p cs) = 0 := by
  induction cs with
  | nil => simp [normalCycle, differential_one der hleib]
  | cons c cs ih =>
    change differential K A σ der (normalFactor K A σ der p c * normalCycle K A σ der p cs) = 0
    rw [differential_mul der hleib, normalFactor_closed der hleib hcomm, ih]
    simp

 
omit [Invertible (2 : K)] in
theorem normalFactor_scalar_ann (p : ℕ) (hp : 0<p) (c : A) (hc : c^p=0) :
    scalar K A σ c * normalFactor K A σ der p c = 0 := by
  rw [normalFactor, ← mul_assoc, ← scalar_mul, ← pow_succ', Nat.sub_add_cancel hp,
    hc, scalar_zero, zero_mul]

theorem normalFactor_dscalar_ann (p : ℕ) (c : A) :
    differential K A σ der (scalar K A σ c) * normalFactor K A σ der p c = 0 := by
  rw [normalFactor, ← mul_assoc, ← scalar_commute, mul_assoc, differential_scalar,
    oneForm_sq_zero, mul_zero]

omit [Invertible (2 : K)] in
theorem normalCycle_scalar_ann (p : ℕ) (hp : 0<p) (cs : List A)
    (hnil : ∀ c∈cs, c^p=0) (c : A) (hc : c∈cs) :
    scalar K A σ c * normalCycle K A σ der p cs = 0 := by
  induction cs with
  | nil => simp at hc
  | cons a cs ih =>
    change scalar K A σ c * (normalFactor K A σ der p a * normalCycle K A σ der p cs) = 0
    rcases List.mem_cons.mp hc with rfl | hc
    · rw [← mul_assoc, normalFactor_scalar_ann der p hp c (hnil c (by simp)), zero_mul]
    · rw [← mul_assoc, scalar_commute, mul_assoc, ih (fun b hb => hnil b (by simp [hb])) hc,
        mul_zero]

theorem normalCycle_dscalar_ann (p : ℕ) (cs : List A) (c : A) (hc : c∈cs) :
    differential K A σ der (scalar K A σ c) * normalCycle K A σ der p cs = 0 := by
  induction cs with
  | nil => simp at hc
  | cons a cs ih =>
    change differential K A σ der (scalar K A σ c) *
      (normalFactor K A σ der p a * normalCycle K A σ der p cs) = 0
    rcases List.mem_cons.mp hc with rfl | hc
    · rw [← mul_assoc, normalFactor_dscalar_ann, zero_mul]
    · rw [← mul_assoc, differential_scalar, oneForm_anticommute, mul_assoc,
        ← differential_scalar, ih hc, mul_zero]

include hleib in
 

theorem normalCycle_ideal_ann (p : ℕ) (hp : 0<p) (cs : List A)
    (hnil : ∀ c∈cs, c^p=0) (S : A) (hS : S ∈ Ideal.span {c | c∈cs}) :
    scalar K A σ S * normalCycle K A σ der p cs = 0 ∧
      differential K A σ der (scalar K A σ S) * normalCycle K A σ der p cs = 0 := by
  induction hS using Submodule.span_induction with
  | mem c hc => exact ⟨normalCycle_scalar_ann der p hp cs hnil c hc,
      normalCycle_dscalar_ann der p cs c hc⟩
  | zero => simp
  | add a b ha hb iha ihb =>
    simp only [scalar_add, map_add, add_mul, iha.1, ihb.1, iha.2, ihb.2, zero_add]
    trivial
  | smul a b hb ih =>
    change scalar K A σ (a*b) * _ = 0 ∧ differential K A σ der (scalar K A σ (a*b)) * _ = 0
    rw [scalar_mul, mul_assoc, ih.1, mul_zero]
    constructor
    · rfl
    · rw [differential_mul der hleib, add_mul, mul_assoc, ih.1, mul_zero,
        mul_assoc, ih.2, mul_zero, zero_add]

 
omit [Invertible (2 : K)] in
theorem gradient_ideal_boundary (v : σ → A) (ω : Ω K A σ)
    (hω : oneForm K A σ v * ω = 0) (a : A) (ha : a ∈ Ideal.span (Set.range v)) :
    scalar K A σ a * ω ∈ LinearMap.range (LinearMap.mulLeft K (oneForm K A σ v)) := by
  obtain ⟨b, hb⟩ := Ideal.mem_span_range_iff_exists_fun.mp ha
  rw [← hb]
  exact gradient_multiple_boundary v ω hω b

 
omit [Invertible (2 : K)] in
theorem oneForm_mul_zero_iff (v : σ → A) (ω : Ω K A σ) :
    oneForm K A σ v * ω = 0 ↔ ω * oneForm K A σ v = 0 := by
  constructor
  · intro h
    have he := congrArg (parity K A σ) h
    simp only [map_mul, parity_oneForm, map_zero, neg_mul, neg_eq_zero] at he
    rw [oneForm_anticommute, parity_parity] at he
    exact he
  · intro h
    rw [oneForm_anticommute]
    have he := congrArg (parity K A σ) h
    simpa only [map_mul, parity_oneForm, map_zero, mul_neg, neg_eq_zero] using he

 
omit [Invertible (2 : K)] in
theorem boundary_mul_cycle_zero (v : σ → A) (ω η : Ω K A σ)
    (hω : ω ∈ LinearMap.range (LinearMap.mulLeft K (oneForm K A σ v)))
    (hη : oneForm K A σ v * η = 0) : ω * η = 0 := by
  obtain ⟨β, rfl⟩ := hω
  change (oneForm K A σ v * β) * η = 0
  rw [oneForm_anticommute, mul_assoc, hη, mul_zero]

end
end PD4Tensor.Forms
end

end OAI