import Mathlib
import OAI.Algebra.FrobeniusObstruction.TensorKernels

namespace OAI

noncomputable section
open scoped BigOperators TensorProduct

namespace BoundaryOnly.FormalObstruction.BlockCohomology
open SquareZero MixedForms
variable {k A ι : Type*} [Field k] [CommRing A] [Algebra k A]
  [Fintype ι] [DecidableEq ι]
variable (pd : ι → Derivation k A A) (q : A)

                                                                       
                                                                                
structure Contraction where
  j : H pd q →ₗ[k] Forms (k := k) (A := A) (ι := ι)
  p : Forms (k := k) (A := A) (ι := ι) →ₗ[k] H pd q
  h : Module.End k (Forms (k := k) (A := A) (ι := ι))
  cycle_j : ∀ x, delta pd q (j x) = 0
  p_boundary : ∀ x, p (delta pd q x) = 0
  p_j : ∀ x, p (j x) = x
  p_cycle : ∀ z : Cycles (delta pd q), p z = classMap _ (delta_sq pd q) z
  j_parity : ∀ x, j (P pd q x) = parity (j x)
  p_parity : ∀ x, p (parity x) = P pd q (p x)
  h_parity : ∀ x, h (parity x) = -parity (h x)
  homotopy : ∀ x, x - j (p x) = delta pd q (h x) + h (delta pd q x)

 theorem contraction_exists (htwo : (2 : k) ≠ 0) : Nonempty (Contraction pd q) := by
  obtain ⟨j,p,h,hj,hp,hpj,hpc,hjP,hpP,hhP,hh⟩ := parity_cohomology_contraction
    htwo (delta pd q) parity.toLinearMap (delta_sq pd q) parity_sq (delta_parity pd q)
  exact ⟨⟨j,p,h,hj,hp,hpj,hpc,hjP,hpP,hhP,hh⟩⟩

def contraction (htwo : (2 : k) ≠ 0) : Contraction pd q :=
  Classical.choice (contraction_exists pd q htwo)

namespace Contraction
variable {pd q} (c : Contraction pd q)

 theorem class_j (x : H pd q) :
    classMap _ (delta_sq pd q) ⟨c.j x, c.cycle_j x⟩ = x :=
  (c.p_cycle ⟨c.j x, c.cycle_j x⟩).symm.trans (c.p_j x)

 theorem project_odd (f : Module.End k (Forms (k := k) (A := A) (ι := ι)))
    (hf : ∀ x, delta pd q (f x) = -f (delta pd q x)) (x : H pd q) :
    c.p (f (c.j x)) = oddInduced _ (delta_sq pd q) f hf x := by
  conv_rhs => rw [← c.class_j x, oddInduced_class, ← c.p_cycle]
  rfl

 theorem project_even (f : Module.End k (Forms (k := k) (A := A) (ι := ι)))
    (hf : ∀ x, delta pd q (f x) = f (delta pd q x)) (x : H pd q) :
    c.p (f (c.j x)) = evenInduced _ (delta_sq pd q) f hf x := by
  conv_rhs => rw [← c.class_j x, evenInduced_class, ← c.p_cycle]
  rfl

 theorem project_d (hc : ∀ i j a, pd i (pd j a) = pd j (pd i a)) (x : H pd q) :
    c.p (d pd (c.j x)) = D pd q hc x :=
  c.project_odd (d pd) (delta_d pd q hc) x

 theorem project_coefficient (s : A) (x : H pd q) :
    c.p (coefficient s (c.j x)) = S pd q s x :=
  c.project_even (coefficient s) (delta_coefficient pd q s) x

end Contraction
end BoundaryOnly.FormalObstruction.BlockCohomology

namespace BoundaryOnly.FormalObstruction.SignedTensor
variable {k ι : Type*} [Field k] [Fintype ι] [LinearOrder ι]
variable {V W : ι → Type*} [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)]
  [∀ i, AddCommGroup (W i)] [∀ i, Module k (W i)]

theorem differential_map (P D : EndFamily (k := k) V) (Q E : EndFamily (k := k) W)
    (f : ∀ i, V i →ₗ[k] W i)
    (hP : ∀ i, (f i).comp (P i) = (Q i).comp (f i))
    (hD : ∀ i, (f i).comp (D i) = (E i).comp (f i)) :
    (PiTensorProduct.map f).comp (differential V P D) =
      (differential W Q E).comp (PiTensorProduct.map f) := by
  apply PiTensorProduct.ext
  ext v
  simp only [LinearMap.compMultilinearMap_apply, LinearMap.comp_apply,
    differential, LinearMap.sum_apply, PiTensorProduct.map_tprod, map_sum]
  apply Finset.sum_congr rfl
  intro i _
  congr 1
  funext a
  by_cases ha : a < i
  · simp only [dSlot, ite_eq_left ha]
    exact LinearMap.congr_fun (hP a) (v a)
  · by_cases he : a = i
    · simp only [dSlot, ite_eq_right ha, ite_eq_left he]
      exact LinearMap.congr_fun (hD a) (v a)
    · simp only [dSlot, ite_eq_right ha, ite_eq_right he, Module.End.one_apply]

end BoundaryOnly.FormalObstruction.SignedTensor

namespace BoundaryOnly.FormalObstruction.BlockTensor
open MixedForms SquareZero SignedTensor
variable {k t : Type*} [Field k] [Fintype t] [LinearOrder t]
variable (A K : t → Type*) [∀ i, CommRing (A i)] [∀ i, Algebra k (A i)]
  [∀ i, Fintype (K i)] [∀ i, DecidableEq (K i)]
abbrev V (i : t) := Forms (k := k) (A := A i) (ι := K i)
variable {A K}
variable (pd : ∀ i, K i → Derivation k (A i) (A i)) (q : ∀ i, A i)
abbrev H (i : t) := BlockCohomology.H (pd i) (q i)
def P : EndFamily (k := k) (V (k := k) A K) := fun _ => parity.toLinearMap
local notation "PV" => (P (k := k) (A := A) (K := K))
def D : EndFamily (k := k) (V (k := k) A K) := fun i => d (pd i)
def delta : EndFamily (k := k) (V (k := k) A K) := fun i => MixedForms.delta (pd i) (q i)
def S (s : ∀ i, A i) : EndFamily (k := k) (V (k := k) A K) :=
  fun i => BlockCohomology.coefficient (s i)
def HP : EndFamily (k := k) (H pd q) := fun i => BlockCohomology.P (pd i) (q i)
def HD (hc : ∀ a i j x, pd a i (pd a j x) = pd a j (pd a i x)) :
    EndFamily (k := k) (H pd q) := fun i => BlockCohomology.D (pd i) (q i) (hc i)
def HS (s : ∀ i, A i) : EndFamily (k := k) (H pd q) :=
  fun i => BlockCohomology.S (pd i) (q i) (s i)
variable (c : ∀ i, BlockCohomology.Contraction (pd i) (q i))
def j : (⨂[k] i, H pd q i) →ₗ[k] (⨂[k] i, V (k := k) A K i) :=
  PiTensorProduct.map (fun i => (c i).j)
def p : (⨂[k] i, V (k := k) A K i) →ₗ[k] (⨂[k] i, H pd q i) :=
  PiTensorProduct.map (fun i => (c i).p)

theorem projection_boundary (x : ⨂[k] i, V (k := k) A K i) :
    p pd q c (differential (V (k := k) A K) PV (delta pd q) x) = 0 := by
  exact LinearMap.congr_fun (projection_boundaries PV (delta pd q)
    (fun i => (c i).p) (fun i => by apply LinearMap.ext; intro z; exact (c i).p_boundary z)) x

theorem representatives_cycle (x : ⨂[k] i, H pd q i) :
    differential (V (k := k) A K) PV (delta pd q) (j pd q c x) = 0 := by
  exact LinearMap.congr_fun (representatives_cycles PV (delta pd q)
    (fun i => (c i).j) (fun i => by apply LinearMap.ext; intro z; exact (c i).cycle_j z)) x

theorem cycle_decomposition (z : ⨂[k] i, V (k := k) A K i)
    (hz : differential (V (k := k) A K) PV (delta pd q) z = 0) :
    ∃ y, z - j pd q c (p pd q c z) = differential (V (k := k) A K) PV (delta pd q) y := by
  apply tensor_cycle_decomposition PV (delta pd q)
    (fun i => (c i).j) (fun i => (c i).p) (fun i => (c i).h) _ _ _ _ _ _ _ z hz
  · intro i; apply LinearMap.ext; intro x; exact parity_sq x
  · intro i; apply LinearMap.ext; intro x; exact BlockCohomology.delta_parity (pd i) (q i) x
  · intro i; apply LinearMap.ext; intro x; exact (c i).cycle_j x
  · intro i; apply LinearMap.ext; intro x; exact (c i).p_boundary x
  · intro i; apply LinearMap.ext; intro x
    change parity ((c i).j ((c i).p x)) = (c i).j ((c i).p (parity x))
    rw [(c i).p_parity, (c i).j_parity]
  · intro i; apply LinearMap.ext; intro x
    change parity ((c i).h x) = -(c i).h (parity x)
    rw [(c i).h_parity, neg_neg]
  · intro i; apply LinearMap.ext; intro x
    exact ((c i).homotopy x).symm

omit [Fintype t] [LinearOrder t] in
theorem project_parity (i : t) :
    (c i).p.comp ((PV i).comp (c i).j) = HP pd q i := by
  apply LinearMap.ext; intro x
  change (c i).p (parity ((c i).j x)) = BlockCohomology.P (pd i) (q i) x
  rw [(c i).p_parity, (c i).p_j]

theorem project_D (hc : ∀ a i j x, pd a i (pd a j x) = pd a j (pd a i x)) :
    (p pd q c).comp ((differential (V (k := k) A K) PV (D pd)).comp (j pd q c)) =
      differential (H pd q) (HP pd q) (HD pd q hc) := by
  apply project_differential
  · intro i; apply LinearMap.ext; intro x; exact (c i).p_j x
  · exact project_parity pd q c
  · intro i; apply LinearMap.ext; intro x; exact (c i).project_d (hc i) x

omit [Fintype t] in
theorem project_S (s : ∀ i, A i) (I : Finset t) :
    (p pd q c).comp ((tensorAction (V (k := k) A K) (S s) I).comp (j pd q c)) =
      tensorAction (H pd q) (HS pd q s) I := by
  apply project_tensor_map
  intro i
  by_cases hi : i ∈ I
  · apply LinearMap.ext; intro x
    simpa only [tensorAction, ite_eq_left hi, LinearMap.comp_apply, S, HS]
      using (c i).project_coefficient (s i) x
  · apply LinearMap.ext; intro x
    simpa only [tensorAction, ite_eq_right hi, LinearMap.comp_apply, LinearMap.id_apply]
      using (c i).p_j x

end BoundaryOnly.FormalObstruction.BlockTensor

namespace BoundaryOnly.FormalObstruction.SignedTensor
variable {k t : Type*} [Field k] [Fintype t] [LinearOrder t]
variable (V : t → Type*) [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)]

theorem differential_anticomm (P D E : EndFamily (k := k) V)
    (hP : ∀ i, P i * P i = 1)
    (hD : ∀ i, D i * P i = -(P i * D i))
    (hE : ∀ i, P i * E i = -(E i * P i))
    (hDE : ∀ i, D i * E i + E i * D i = 0) :
    differential V P D * differential V P E +
      differential V P E * differential V P D = 0 := by
  have hh : homotopy V P (fun _ => 1) E = differential V P E := by
    unfold homotopy differential
    apply Finset.sum_congr rfl
    intro i _
    congr 1
  have h := tensor_homotopy P D (fun _ => 1) E hP hD
    (fun i => by simp only [mul_one, one_mul])
    (fun i => by simp only [mul_one, one_mul]) hE
    (fun i => by rw [sub_self]; exact hDE i)
  rw [hh] at h
  have hi : PiTensorProduct.map (fun i : t => (1 : Module.End k (V i))) = 1 :=
    PiTensorProduct.map_id
  rwa [hi, sub_self] at h

end BoundaryOnly.FormalObstruction.SignedTensor

namespace BoundaryOnly.FormalObstruction.BlockTensor
open MixedForms SquareZero SignedTensor
variable {k t : Type*} [Field k] [Fintype t] [LinearOrder t]
variable {A K : t → Type*} [∀ i, CommRing (A i)] [∀ i, Algebra k (A i)]
  [∀ i, Fintype (K i)] [∀ i, DecidableEq (K i)]
variable (pd : ∀ i, K i → Derivation k (A i) (A i)) (q : ∀ i, A i)
local notation "PV" => (P (k := k) (A := A) (K := K))

theorem D_delta_anticomm (hc : ∀ a i j x, pd a i (pd a j x) = pd a j (pd a i x))
    (x : ⨂[k] i, V (k := k) A K i) :
    differential (V (k := k) A K) PV (D pd)
      (differential (V (k := k) A K) PV (delta pd q) x) =
    -differential (V (k := k) A K) PV (delta pd q)
      (differential (V (k := k) A K) PV (D pd) x) := by
  have h := differential_anticomm (V (k := k) A K) PV (D pd) (delta pd q)
    (fun i => by apply LinearMap.ext; intro y; exact parity_sq y)
    (fun i => by apply LinearMap.ext; intro y; exact d_parity (pd i) y)
    (fun i => by
      apply LinearMap.ext; intro y
      change parity (MixedForms.delta (pd i) (q i) y) =
        -MixedForms.delta (pd i) (q i) (parity y)
      rw [BlockCohomology.delta_parity, neg_neg])
    (fun i => by
      apply LinearMap.ext; intro y
      change d (pd i) (MixedForms.delta (pd i) (q i) y) +
        MixedForms.delta (pd i) (q i) (d (pd i) y) = 0
      exact d_delta (pd i) (hc i) (q i) y)
  exact eq_neg_of_add_eq_zero_left (LinearMap.congr_fun h x)

theorem S_delta_comm (s : ∀ i, A i) (I : Finset t)
    (x : ⨂[k] i, V (k := k) A K i) :
    tensorAction (V (k := k) A K) (S s) I
      (differential (V (k := k) A K) PV (delta pd q) x) =
    differential (V (k := k) A K) PV (delta pd q)
      (tensorAction (V (k := k) A K) (S s) I x) := by
  apply LinearMap.congr_fun (differential_map PV (delta pd q) PV (delta pd q)
    (fun i => if i ∈ I then S s i else LinearMap.id) ?_ ?_) x
  · intro i
    by_cases hi : i ∈ I
    · simp only [ite_eq_left hi]
      apply LinearMap.ext; intro y
      change coeff (s i) * parity y = parity (coeff (s i) * y)
      rw [map_mul, parity_coeff]
    · simp only [ite_eq_right hi, LinearMap.id_comp, LinearMap.comp_id]
  · intro i
    by_cases hi : i ∈ I
    · simp only [ite_eq_left hi]
      apply LinearMap.ext; intro y
      exact (BlockCohomology.delta_coefficient (pd i) (q i) (s i) y).symm
    · simp only [ite_eq_right hi, LinearMap.id_comp, LinearMap.comp_id]

end BoundaryOnly.FormalObstruction.BlockTensor

namespace BoundaryOnly.FormalObstruction.BlockTensor
open MixedForms SquareZero SignedTensor
variable {k t : Type*} [Field k] [Fintype t] [LinearOrder t]
variable {A K : t → Type*} [∀ i, CommRing (A i)] [∀ i, Algebra k (A i)]
  [∀ i, Fintype (K i)] [∀ i, DecidableEq (K i)]
variable (pd : ∀ i, K i → Derivation k (A i) (A i)) (q : ∀ i, A i)
local notation "PV" => (P (k := k) (A := A) (K := K))
local notation "Ω" => (V (k := k) A K)
local notation "δt" => (differential Ω PV (delta pd q))
local notation "Dt" => (differential Ω PV (D pd))

theorem project_D_cycle
    (hc : ∀ a i j x, pd a i (pd a j x) = pd a j (pd a i x))
    (c : ∀ i, BlockCohomology.Contraction (pd i) (q i))
    (z : ⨂[k] i, Ω i) (hz : δt z = 0) :
    differential (H pd q) (HP pd q) (HD pd q hc) (p pd q c z) = p pd q c (Dt z) := by
  refine CycleTransfer.operator (H := ⨂[k] i, H pd q i) δt (j pd q c) (p pd q c)
    (projection_boundary pd q c) (cycle_decomposition pd q c) Dt (-Dt)
    (differential (H pd q) (HP pd q) (HD pd q hc)) ?_ ?_ z hz
  · intro x
    simpa only [LinearMap.neg_apply, map_neg] using D_delta_anticomm pd q hc x
  · intro x
    exact (LinearMap.congr_fun (project_D pd q c hc) x).symm

theorem pairing_project_D
    (hc : ∀ a i j x, pd a i (pd a j x) = pd a j (pd a i x))
    (c : ∀ i, BlockCohomology.Contraction (pd i) (q i))
    (Φ : (⨂[k] i, Ω i) →ₗ[k] k)
    (hΦδ : ∀ x, Φ (δt x) = 0) (hΦD : ∀ x, Φ (Dt x) = 0)
    (x : ⨂[k] i, H pd q i) :
    Φ (j pd q c (differential (H pd q) (HP pd q) (HD pd q hc) x)) = 0 := by
  refine CycleTransfer.pairing_operator (H := ⨂[k] i, H pd q i) δt (j pd q c) (p pd q c)
    (cycle_decomposition pd q c) Dt (-Dt)
    (differential (H pd q) (HP pd q) (HD pd q hc)) ?_ ?_ ?_ Φ hΦδ hΦD x
  · intro z
    change _ = -(Dt (δt z))
    rw [D_delta_anticomm pd q hc z, neg_neg]
  · exact representatives_cycle pd q c
  · intro z
    exact (LinearMap.congr_fun (project_D pd q c hc) z).symm

theorem project_S_cycle
    (c : ∀ i, BlockCohomology.Contraction (pd i) (q i))
    (s : ∀ i, A i) (I : Finset t)
    (z : ⨂[k] i, Ω i) (hz : δt z = 0) :
    tensorAction (H pd q) (HS pd q s) I (p pd q c z) =
      p pd q c (tensorAction Ω (S s) I z) := by
  refine CycleTransfer.operator (H := ⨂[k] i, H pd q i) δt (j pd q c) (p pd q c)
    (projection_boundary pd q c) (cycle_decomposition pd q c)
    (tensorAction Ω (S s) I) (tensorAction Ω (S s) I)
    (tensorAction (H pd q) (HS pd q s) I) ?_ ?_ z hz
  · exact S_delta_comm pd q s I
  · intro x
    exact (LinearMap.congr_fun (project_S pd q c s I) x).symm

                                                                               
                                                                             
theorem selected_classes (htwo : (2 : k) ≠ 0)
    (hc : ∀ a i j x, pd a i (pd a j x) = pd a j (pd a i x))
    (s : ∀ i, A i) (active : Finset t) (hcard : 5 ≤ active.card)
    (c : ∀ i, BlockCohomology.Contraction (pd i) (q i))
    (Φ : (⨂[k] i, Ω i) →ₗ[k] k)
    (hΦδ : ∀ x, Φ (δt x) = 0) (hΦD : ∀ x, Φ (Dt x) = 0)
    (z : ⨂[k] i, Ω i) (hz : δt z = 0) (hDz : Dt z = 0) (hΦz : Φ z ≠ 0)
    (htriple : ∀ I : Finset t, I ⊆ active → I.card = 3 →
      ∃ y, tensorAction Ω (S s) I z = δt y) :
    ∃ (J : Finset t) (m : ∀ i, H pd q i),
      J ⊆ active ∧ 3 ≤ J.card ∧
      (∀ i ∈ J, HS pd q s i (m i) = 0 ∧
        HS pd q s i (HD pd q hc i (m i)) = 0) ∧
      Φ (j pd q c (PiTensorProduct.tprod k m)) ≠ 0 := by
  let φ := Φ.comp (j pd q c)
  have hHD : differential (H pd q) (HP pd q) (HD pd q hc) (p pd q c z) = 0 := by
    rw [project_D_cycle pd q hc c z hz, hDz, map_zero]
  have hφD (x : ⨂[k] i, H pd q i) :
      φ (differential (H pd q) (HP pd q) (HD pd q hc) x) = 0 :=
    pairing_project_D pd q hc c Φ hΦδ hΦD x
  have hφz : φ (p pd q c z) ≠ 0 := by
    change Φ (j pd q c (p pd q c z)) ≠ 0
    rw [CycleTransfer.pairing (H := ⨂[k] i, H pd q i) δt (j pd q c) (p pd q c) (cycle_decomposition pd q c) Φ hΦδ z hz]
    exact hΦz
  have hSz (I : Finset t) (hi : I ⊆ active) (hI : I.card = 3) :
      tensorAction (H pd q) (HS pd q s) I (p pd q c z) = 0 := by
    rw [project_S_cycle pd q c s I z hz]
    obtain ⟨y,hy⟩ := htriple I hi hI
    rw [hy, projection_boundary]
  choose r h hrD hrP hhP hDh hNr using
    (fun i => BlockCohomology.retraction (pd i) (q i) (hc i) htwo (s i))
  apply select_special_fiber_tensor (HS pd q s) (HP pd q) (HD pd q hc) r h
    active hcard _ _ _ _ _ _ _ φ hφD (p pd q c z) hHD hφz hSz
  · intro i; apply LinearMap.ext; intro x; exact BlockCohomology.P_sq (pd i) (q i) x
  · intro i; apply LinearMap.ext; intro x; exact BlockCohomology.D_P (pd i) (q i) (hc i) x
  · intro i; apply LinearMap.ext; intro x; exact hrD i x
  · intro i; apply LinearMap.ext; intro x; exact hrP i x
  · intro i; apply LinearMap.ext; intro x; exact hhP i x
  · intro i; apply LinearMap.ext; intro x; exact (hDh i x).symm
  · intro i _ x hx; exact hNr i x hx

                                                                           
                                                                    
theorem selected_cycles (htwo : (2 : k) ≠ 0)
    (hc : ∀ a i j x, pd a i (pd a j x) = pd a j (pd a i x))
    (s : ∀ i, A i) (active : Finset t) (hcard : 5 ≤ active.card)
    (Φ : (⨂[k] i, Ω i) →ₗ[k] k)
    (hΦδ : ∀ x, Φ (δt x) = 0) (hΦD : ∀ x, Φ (Dt x) = 0)
    (z : ⨂[k] i, Ω i) (hz : δt z = 0) (hDz : Dt z = 0) (hΦz : Φ z ≠ 0)
    (htriple : ∀ I : Finset t, I ⊆ active → I.card = 3 →
      ∃ y, tensorAction Ω (S s) I z = δt y) :
    ∃ (J : Finset t) (x : ∀ i, Ω i),
      J ⊆ active ∧ 3 ≤ J.card ∧ (∀ i, delta pd q i (x i) = 0) ∧
      (∀ i ∈ J, ∃ y : Ω i, delta pd q i y = -MixedForms.delta (pd i) (s i) (x i)) ∧
      Φ (PiTensorProduct.tprod k x) ≠ 0 := by
  let c := fun i => BlockCohomology.contraction (pd i) (q i) htwo
  obtain ⟨J,m,hJ,hcardJ,hm,hpair⟩ := selected_classes pd q htwo hc s active hcard c
    Φ hΦδ hΦD z hz hDz hΦz htriple
  refine ⟨J,fun i => (c i).j (m i),hJ,hcardJ,?_,?_,?_⟩
  · intro i; exact (c i).cycle_j (m i)
  · intro i hi
    apply BlockCohomology.correction (pd i) (q i) (hc i) (s i)
      ⟨(c i).j (m i), (c i).cycle_j (m i)⟩
    · rw [(c i).class_j]; exact (hm i hi).1
    · rw [(c i).class_j]; exact (hm i hi).2
  · simpa only [j, PiTensorProduct.map_tprod] using hpair

end BoundaryOnly.FormalObstruction.BlockTensor

end

end OAI