import Mathlib
import OAI.Algebra.FrobeniusObstruction.FormTensor

namespace OAI

noncomputable section
open scoped BigOperators TensorProduct

namespace BoundaryOnly.FormalObstruction
namespace SignedTensor

variable {k ι : Type*} [Field k] [Fintype ι] [LinearOrder ι]
variable (V : ι → Type*) [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)]

abbrev EndFamily := ∀ i, Module.End k (V i)
abbrev TensorEnd := Module.End k (⨂[k] i, V i)

def dSlot (P D : EndFamily (k := k) V) (i : ι) : EndFamily (k := k) V :=
  fun j => if j < i then P j else if j = i then D j else 1

def hSlot (P r h : EndFamily (k := k) V) (i : ι) : EndFamily (k := k) V :=
  fun j => if j < i then r j * P j else if j = i then h j else 1

def diagSlot (r : EndFamily (k := k) V) (i : ι) : EndFamily (k := k) V :=
  fun j => if j < i then r j else if j = i then 1 - r j else 1

def differential (P D : EndFamily (k := k) V) : TensorEnd (k := k) V :=
  ∑ i, PiTensorProduct.map (dSlot V P D i)

def homotopy (P r h : EndFamily (k := k) V) : TensorEnd (k := k) V :=
  ∑ i, PiTensorProduct.map (hSlot V P r h i)

omit [Fintype ι] in
private theorem tensor_neg_at (f g : EndFamily (k := k) V) (i : ι)
    (hii : f i = -g i) (hij : ∀ j, j ≠ i → f j = g j) :
    PiTensorProduct.map f = -PiTensorProduct.map g := by
  have heq : f = Function.update g i (-g i) := by
    funext j
    by_cases h : j = i
    · subst j; simpa using hii
    · simp only [Function.update_of_ne h, hij j h]
  rw [heq]
  exact (PiTensorProduct.mapMultilinear k V V).map_update_neg g i (g i) |>.trans
    (by rw [Function.update_eq_self]; rfl)

omit [Fintype ι] in
private theorem tensor_add_at (f g b : EndFamily (k := k) V) (i : ι)
    (hf : ∀ j, j ≠ i → f j = b j) (hg : ∀ j, j ≠ i → g j = b j) :
    PiTensorProduct.map f + PiTensorProduct.map g =
      PiTensorProduct.map (Function.update b i (f i + g i)) := by
  have hh (a : EndFamily (k := k) V) (ha : ∀ j, j ≠ i → a j = b j) :
      a = Function.update b i (a i) := by
    funext j
    by_cases h : j = i
    · subst j; simp
    · simp only [Function.update_of_ne h, ha j h]
  conv_lhs => rw [hh f hf, hh g hg]
  exact ((PiTensorProduct.mapMultilinear k V V).map_update_add b i (f i) (g i)).symm

variable {V}

                                                    
omit [Fintype ι] in
theorem mixed_cancel (P D r h : EndFamily (k := k) V)
    (hDP : ∀ i, D i * P i = -(P i * D i))
    (hDr : ∀ i, D i * r i = r i * D i)
    (hPr : ∀ i, P i * r i = r i * P i)
    (hPh : ∀ i, P i * h i = -(h i * P i))
    (i j : ι) (hij : i ≠ j) :
    PiTensorProduct.map (dSlot V P D i) * PiTensorProduct.map (hSlot V P r h j) +
      PiTensorProduct.map (hSlot V P r h j) * PiTensorProduct.map (dSlot V P D i) = 0 := by
  rw [← PiTensorProduct.map_mul, ← PiTensorProduct.map_mul]
  suffices hh : PiTensorProduct.map (dSlot V P D i * hSlot V P r h j) =
      -PiTensorProduct.map (hSlot V P r h j * dSlot V P D i) by exact add_eq_zero_iff_eq_neg.mpr hh
  rcases lt_or_gt_of_ne hij with hij | hji
  · apply tensor_neg_at V _ _ i
    · simp only [Pi.mul_apply, dSlot, hSlot, lt_irrefl, ite_false, ite_true, hij]
      rw [← mul_assoc, hDr, mul_assoc, hDP, mul_neg, ← mul_assoc]
    · intro a hai
      by_cases haj : a = j
      · subst a
        simp [dSlot, hSlot, hai, not_lt_of_gt hij]
      · by_cases hal : a < i
        · have hajl : a < j := hal.trans hij
          simp only [Pi.mul_apply, dSlot, hSlot, hal, hajl, ite_true]
          rw [← mul_assoc, hPr, mul_assoc]
        · by_cases hajl : a < j
          · simp [dSlot, hSlot, hal, hajl, hai]
          · simp [dSlot, hSlot, hal, hajl, hai, haj]
  · apply tensor_neg_at V _ _ j
    · simp only [Pi.mul_apply, dSlot, hSlot, lt_irrefl, ite_false, ite_true, hji]
      exact hPh j
    · intro a haj
      by_cases hai : a = i
      · subst a
        simp [dSlot, hSlot, haj, not_lt_of_gt hji]
      · by_cases hal : a < j
        · have hail : a < i := hal.trans hji
          simp only [Pi.mul_apply, dSlot, hSlot, hal, hail, ite_true]
          rw [← mul_assoc, hPr, mul_assoc]
        · by_cases hail : a < i
          · simp [dSlot, hSlot, hal, hail, haj]
          · simp [dSlot, hSlot, hal, hail, hai, haj]

                                                                
omit [Fintype ι] in
theorem diagonal_term (P D r h : EndFamily (k := k) V)
    (hP2 : ∀ i, P i * P i = 1)
    (hPr : ∀ i, P i * r i = r i * P i)
    (hDh : ∀ i, D i * h i + h i * D i = 1 - r i)
    (i : ι) :
    PiTensorProduct.map (dSlot V P D i) * PiTensorProduct.map (hSlot V P r h i) +
      PiTensorProduct.map (hSlot V P r h i) * PiTensorProduct.map (dSlot V P D i) =
        PiTensorProduct.map (diagSlot V r i) := by
  rw [← PiTensorProduct.map_mul, ← PiTensorProduct.map_mul]
  have hbefore (a : ι) : P a * (r a * P a) = r a := by
    rw [← mul_assoc, hPr, mul_assoc, hP2, mul_one]
  rw [tensor_add_at V _ _ (diagSlot V r i) i]
  · congr 1
    funext a
    by_cases hai : a = i
    · subst a
      simp only [Function.update_self, dSlot, hSlot, diagSlot,
        lt_irrefl, ite_false, ite_true, hDh]
    · rw [Function.update_of_ne hai]
  · intro a hai
    by_cases hal : a < i
    · simp [dSlot, hSlot, diagSlot, hal, hbefore]
    · simp [dSlot, hSlot, diagSlot, hal, hai]
  · intro a hai
    by_cases hal : a < i
    · simp only [dSlot, hSlot, diagSlot, hal, ite_true]
      rw [mul_assoc, hP2, mul_one]
    · simp [dSlot, hSlot, diagSlot, hal, hai]

                                                                      
theorem diagonal_sum (r : EndFamily (k := k) V) :
    ∑ i, PiTensorProduct.map (diagSlot V r i) = 1 - PiTensorProduct.map r := by
  let m := PiTensorProduct.mapMultilinear k V V
  have H := m.map_piecewise_sub_map_piecewise r (1 : EndFamily (k := k) V) (1 : EndFamily (k := k) V) Finset.univ
  simp only [Finset.piecewise_univ, Finset.mem_univ, ↓reduceIte] at H
  have hn (i : ι) : m (fun j => if j < i then r j else if j = i then r j - 1 else 1) =
      -PiTensorProduct.map (diagSlot V r i) := by
    apply tensor_neg_at V _ _ i
    · simp [diagSlot]
    · intro j hji
      simp [diagSlot, hji]
  change m r - m (1 : EndFamily (k := k) V) =
    ∑ i, m (fun j => if j < i then r j else if j = i then r j - 1 else 1) at H
  simp_rw [hn] at H
  change PiTensorProduct.map r - PiTensorProduct.map (1 : EndFamily (k := k) V) = _ at H
  have hone : PiTensorProduct.map (1 : EndFamily (k := k) V) = 1 := PiTensorProduct.map_one
  rw [hone, Finset.sum_neg_distrib] at H
  apply neg_injective
  rw [← H]
  abel

                                                                                       
theorem tensor_homotopy (P D r h : EndFamily (k := k) V)
    (hP2 : ∀ i, P i * P i = 1)
    (hDP : ∀ i, D i * P i = -(P i * D i))
    (hDr : ∀ i, D i * r i = r i * D i)
    (hPr : ∀ i, P i * r i = r i * P i)
    (hPh : ∀ i, P i * h i = -(h i * P i))
    (hDh : ∀ i, D i * h i + h i * D i = 1 - r i) :
    differential V P D * homotopy V P r h + homotopy V P r h * differential V P D =
      1 - PiTensorProduct.map r := by
  simp only [differential, homotopy, Finset.sum_mul, Finset.mul_sum]
  rw [Finset.sum_comm (f := fun i j =>
    PiTensorProduct.map (dSlot V P D j) * PiTensorProduct.map (hSlot V P r h i)),
    ← Finset.sum_add_distrib]
  simp_rw [← Finset.sum_add_distrib]
  have hsum (i : ι) : ∑ j,
      (PiTensorProduct.map (dSlot V P D i) * PiTensorProduct.map (hSlot V P r h j) +
        PiTensorProduct.map (hSlot V P r h j) * PiTensorProduct.map (dSlot V P D i)) =
      PiTensorProduct.map (diagSlot V r i) := by
    rw [Finset.sum_eq_single i]
    · exact diagonal_term P D r h hP2 hPr hDh i
    · intro j _ hji
      exact mixed_cancel P D r h hDP hDr hPr hPh i j hji.symm
    · simp
  simp_rw [hsum]
  exact diagonal_sum r

end SignedTensor
end BoundaryOnly.FormalObstruction

namespace BoundaryOnly.FormalObstruction.SignedTensor
open GlobalForms
open scoped TensorProduct BigOperators
variable {k : Type*} [Field k] {n : ℕ}
variable (V : Fin (n + 1) → Type*) [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)]

                                                                          
                                              
theorem differential_cons_tprod (P D : EndFamily (k := k) V) (v : ∀ i, V i) :
    tensorCons V (differential V P D (PiTensorProduct.tprod k v)) =
      D 0 (v 0) ⊗ₜ[k] PiTensorProduct.tprod k (fun i : Fin n => v i.succ) +
        P 0 (v 0) ⊗ₜ[k] differential (fun i : Fin n => V i.succ)
          (fun i => P i.succ) (fun i => D i.succ)
          (PiTensorProduct.tprod k (fun i : Fin n => v i.succ)) := by
  simp only [differential, LinearMap.sum_apply, PiTensorProduct.map_tprod, map_sum,
    tensorCons_tprod]
  rw [Fin.sum_univ_succ, TensorProduct.tmul_sum]
  simp only [dSlot, Fin.lt_def, Fin.ext_iff, Fin.val_zero, Fin.val_succ,
    Nat.not_lt_zero, Nat.succ_ne_zero, Nat.zero_lt_succ, Nat.add_lt_add_iff_right,
    Nat.add_right_cancel_iff, ite_false, ite_true, Module.End.one_apply]

@[simp] theorem parity_cons_tprod (P : EndFamily (k := k) V) (v : ∀ i, V i) :
    tensorCons V (PiTensorProduct.map P (PiTensorProduct.tprod k v)) =
      P 0 (v 0) ⊗ₜ[k] PiTensorProduct.map (fun i : Fin n => P i.succ)
        (PiTensorProduct.tprod k (fun i : Fin n => v i.succ)) := by
  simp only [PiTensorProduct.map_tprod, tensorCons_tprod]

end BoundaryOnly.FormalObstruction.SignedTensor

end

end OAI