Add lean source and binary files (part 6)

lean/OAI/Algebra/AuslanderReiten/Fibers/ConcreteFiberEvaluation.lean

@@ -0,0 +1,86 @@
+import OAI.Algebra.AuslanderReiten.Fibers.FiberEvaluationMap
+import OAI.Algebra.AuslanderReiten.Evaluation.TensorTwistEvaluation
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.T
+open CategoryTheory CategoryTheory.Pretriangulated
+open scoped TensorProduct
+universe u
+variable {k : Type u} [Field k] [CharP k 2] (q : k) (H₁ H₂ : kˣ)
+local notation "R" => A k q
+local notation "X" => A.simpleFiniteModule q
+local notation "U₁" => twistedFiniteModule (sourceTwist q H₁)
+local notation "U₂" => twistedFiniteModule (sourceTwist q H₂)
+local notation "Y" => fiberTarget q
+
+abbrev evaluatedFiber := FiniteLeftModule.evaluated X (finiteFiber q H₁ H₂)
+
+abbrev evaluatedMiddle := FiniteLeftModule.evaluated X (FiniteLeftModule.fiberSource U₁ U₂ Y)
+
+def evaluatedTwistPairEquiv :
+    ((FiniteLeftModule.evaluated X U₁).carrier × (FiniteLeftModule.evaluated X U₂).carrier) ≃ₗ[R]
+      ((X).carrier × (X).carrier) :=
+  LinearEquiv.prodCongr (evaluatedTwistEquiv q H₁) (evaluatedTwistEquiv q H₂)
+
+def middleToSimplePair : (evaluatedMiddle q H₁ H₂).carrier →ₗ[R] ((X).carrier × (X).carrier) :=
+  (evaluatedTwistPairEquiv q H₁ H₂).toLinearMap.comp
+    (FiniteLeftModule.middlePairMap X U₁ U₂ Y)
+
+def middleSimpleStableIso : StableIsomorphism R (evaluatedMiddle q H₁ H₂).carrier
+    ((X).carrier × (X).carrier) :=
+  (FiniteLeftModule.evaluatedMiddleStableIso X U₁ U₂ Y).trans
+    (StableIsomorphism.ofLinearEquiv (evaluatedTwistPairEquiv q H₁ H₂))
+
+@[simp] theorem middleSimpleStableIso_hom : (middleSimpleStableIso q H₁ H₂).hom =
+    StableHom.classOf R _ _ (middleToSimplePair q H₁ H₂) := by
+  change StableHom.comp (StableHom.classOf R _ _ (evaluatedTwistPairEquiv q H₁ H₂).toLinearMap)
+    (FiniteLeftModule.evaluatedMiddleStableIso X U₁ U₂ Y).hom = _
+  rw [FiniteLeftModule.evaluatedMiddleStableIso_hom, StableHom.comp_classOf]
+  rfl
+
+def evaluatedRho₁ : (evaluatedFiber q H₁ H₂).carrier →ₗ[R] (X).carrier :=
+  (evaluatedTwistEquiv q H₁).toLinearMap.comp
+    (FiniteLeftModule.evaluationMap X (rho₁ q H₁ H₂).hom)
+
+def evaluatedRho₂ : (evaluatedFiber q H₁ H₂).carrier →ₗ[R] (X).carrier :=
+  (evaluatedTwistEquiv q H₂).toLinearMap.comp
+    (FiniteLeftModule.evaluationMap X (rho₂ q H₁ H₂).hom)
+
+def evaluatedFiberInclusion : (evaluatedFiber q H₁ H₂).carrier →ₗ[R]
+    (evaluatedMiddle q H₁ H₂).carrier :=
+  FiniteLeftModule.fiberEvaluationInclusion X U₁ U₂ Y
+    (normalizedLift q H₁) (normalizedLift q H₂)
+
+theorem middleToSimplePair_fiberInclusion :
+    (middleToSimplePair q H₁ H₂).comp (evaluatedFiberInclusion q H₁ H₂) =
+    (evaluatedRho₁ q H₁ H₂).prod (evaluatedRho₂ q H₁ H₂) := by
+  apply BalancedTensor.leftHom_ext (k := k)
+  intro m x
+  rfl
+
+theorem fiberTarget_right_projective : Module.Projective Rᵐᵒᵖ
+    (EnvelopingBimodule k R (fiberTarget q).carrier) := by
+  let := firstTailModule_right_finite q
+  let := firstTailModule_right_projective q
+  let := (BimoduleFiber.target_right (firstTailModule q) (AEnvelopingFrobeniusTrace k q)).2
+  infer_instance
+
+def fiberEvaluationTriangle :
+    Triangle (HomotopyCategory (ModuleCat.{u} R) (ComplexShape.up ℤ)) := by
+  letI := fiberTarget_right_projective q
+  exact FiniteLeftModule.evaluatedFiberTriangle X U₁ U₂ Y
+    (normalizedLift q H₁) (normalizedLift q H₂) (AFrobeniusTrace k q)
+
+ theorem fiberEvaluationTriangle_distinguished : fiberEvaluationTriangle q H₁ H₂ ∈
+    distTriang (HomotopyCategory (ModuleCat.{u} R) (ComplexShape.up ℤ)) := by
+  let := fiberTarget_right_projective q
+  exact FiniteLeftModule.evaluatedFiberTriangle_distinguished X U₁ U₂ Y
+    (normalizedLift q H₁) (normalizedLift q H₂) (AFrobeniusTrace k q)
+
+end ArExplicit.T
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/ConcreteFiberHomCoordinates.lean

@@ -0,0 +1,65 @@
+import OAI.Algebra.AuslanderReiten.Fibers.ConcreteFiberHomotopy
+import OAI.Algebra.AuslanderReiten.Coordinates.MappedBiproductHom
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.T
+open CategoryTheory CategoryTheory.Limits
+open scoped TensorProduct ModuleCat.Algebra
+universe u
+variable {k : Type u} [Field k] [CharP k 2] (q : k) (H₁ H₂ : kˣ)
+local notation "R" => A k q
+local notation "X" => A.simpleFiniteModule q
+local notation "τ" => AFrobeniusTrace k q
+local notation "HC" => HomotopyCategory (ModuleCat R) (ComplexShape.up ℤ)
+local notation "Q" => HomotopyCategory.quotient (ModuleCat R) (ComplexShape.up ℤ)
+abbrev simpleHomotopyObject := (Q).obj ((X).completeCochain τ)
+local notation "SX" => simpleHomotopyObject q
+
+abbrev SimpleHom (n : ℤ) := SX ⟶ (SX)⟦n⟧
+abbrev FiberHom (n : ℤ) := SX ⟶ ((Q).obj ((evaluatedFiber q H₁ H₂).completeCochain τ))⟦n⟧
+abbrev MiddleHom (n : ℤ) := SX ⟶ ((Q).obj ((evaluatedMiddle q H₁ H₂).completeCochain τ))⟦n⟧
+
+def middleHomEquiv (n : ℤ) : MiddleHom q H₁ H₂ n ≃ₗ[k]
+    (SimpleHom q n × SimpleHom q n) :=
+  (Linear.homCongr k (Iso.refl _) ((CategoryTheory.shiftFunctor HC n).mapIso
+    (middleProductResolutionIso q H₁ H₂))).trans
+      (mappedBiproductHomEquiv k (CategoryTheory.shiftFunctor HC n) SX SX SX)
+
+def fiberHomInclusion (n : ℤ) : FiberHom q H₁ H₂ n →ₗ[k] MiddleHom q H₁ H₂ n :=
+  Linear.rightComp k SX ((CategoryTheory.shiftFunctor HC n).map
+    ((Q).map (FiniteLeftModule.resolutionMap (M := evaluatedFiber q H₁ H₂)
+      (N := evaluatedMiddle q H₁ H₂) τ (evaluatedFiberInclusion q H₁ H₂))))
+
+def fiberHomRhoPair (n : ℤ) : FiberHom q H₁ H₂ n →ₗ[k]
+    (SimpleHom q n × SimpleHom q n) :=
+  (Linear.rightComp k SX ((CategoryTheory.shiftFunctor HC n).map
+    ((Q).map (FiniteLeftModule.resolutionMap (M := evaluatedFiber q H₁ H₂)
+      (N := X) τ (evaluatedRho₁ q H₁ H₂))))).prod
+    (Linear.rightComp k SX ((CategoryTheory.shiftFunctor HC n).map
+      ((Q).map (FiniteLeftModule.resolutionMap (M := evaluatedFiber q H₁ H₂)
+        (N := X) τ (evaluatedRho₂ q H₁ H₂)))))
+
+theorem middleHomEquiv_inclusion (n : ℤ) (f : FiberHom q H₁ H₂ n) :
+    middleHomEquiv q H₁ H₂ n (fiberHomInclusion q H₁ H₂ n f) =
+      fiberHomRhoPair q H₁ H₂ n f := by
+  apply Prod.ext
+  · simp only [middleHomEquiv, LinearEquiv.trans_apply, mappedBiproductHomEquiv_fst,
+      Linear.homCongr_apply, Iso.refl_inv, Category.id_comp, Functor.mapIso_hom,
+      fiberHomInclusion, Linear.rightComp_apply, fiberHomRhoPair, LinearMap.prod_apply]
+    simp only [Category.assoc, ← Functor.map_comp]
+    rw [fiberInclusion_product_fst q H₁ H₂]
+    rfl
+  · simp only [middleHomEquiv, LinearEquiv.trans_apply, mappedBiproductHomEquiv_snd,
+      Linear.homCongr_apply, Iso.refl_inv, Category.id_comp, Functor.mapIso_hom,
+      fiberHomInclusion, Linear.rightComp_apply, fiberHomRhoPair, LinearMap.prod_apply]
+    simp only [Category.assoc, ← Functor.map_comp]
+    rw [fiberInclusion_product_snd q H₁ H₂]
+    rfl
+
+end ArExplicit.T
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/ConcreteFiberHomotopy.lean

@@ -0,0 +1,77 @@
+import OAI.Algebra.AuslanderReiten.Fibers.ConcreteFiberEvaluation
+import OAI.Algebra.AuslanderReiten.Resolutions.FiniteResolutionProduct
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.T
+open CategoryTheory CategoryTheory.Limits
+open scoped TensorProduct
+universe u
+variable {k : Type u} [Field k] [CharP k 2] (q : k) (H₁ H₂ : kˣ)
+local notation "R" => A k q
+local notation "X" => A.simpleFiniteModule q
+local notation "τ" => AFrobeniusTrace k q
+local notation "Q" => HomotopyCategory.quotient (ModuleCat R) (ComplexShape.up ℤ)
+
+def middlePairResolutionIso :
+    (Q).obj ((evaluatedMiddle q H₁ H₂).completeCochain τ) ≅
+      (Q).obj ((FiniteLeftModule.pairModule X X).completeCochain τ) :=
+  FiniteLeftModule.stableResolutionIso (M := evaluatedMiddle q H₁ H₂)
+    (N := FiniteLeftModule.pairModule X X) τ (middleSimpleStableIso q H₁ H₂)
+
+@[simp] theorem middlePairResolutionIso_hom : (middlePairResolutionIso q H₁ H₂).hom =
+    (Q).map (FiniteLeftModule.resolutionMap (M := evaluatedMiddle q H₁ H₂)
+      (N := FiniteLeftModule.pairModule X X) τ (middleToSimplePair q H₁ H₂)) :=
+  FiniteLeftModule.stableResolutionIso_hom_of_class τ _ _ (middleSimpleStableIso_hom q H₁ H₂)
+
+def middleProductResolutionIso :
+    (Q).obj ((evaluatedMiddle q H₁ H₂).completeCochain τ) ≅
+      ((Q).obj ((X).completeCochain τ) ⊞ (Q).obj ((X).completeCochain τ)) :=
+  (middlePairResolutionIso q H₁ H₂).trans (FiniteLeftModule.resolutionPairIso τ X X)
+
+ theorem fiberInclusion_pairResolution :
+    (Q).map (FiniteLeftModule.resolutionMap (M := evaluatedFiber q H₁ H₂)
+      (N := evaluatedMiddle q H₁ H₂) τ (evaluatedFiberInclusion q H₁ H₂)) ≫
+      (middlePairResolutionIso q H₁ H₂).hom =
+    (Q).map (FiniteLeftModule.resolutionMap (M := evaluatedFiber q H₁ H₂)
+      (N := FiniteLeftModule.pairModule X X) τ
+      ((evaluatedRho₁ q H₁ H₂).prod (evaluatedRho₂ q H₁ H₂))) := by
+  erw [middlePairResolutionIso_hom, ← FiniteLeftModule.resolutionMap_comp,
+    middleToSimplePair_fiberInclusion]
+
+theorem fiberInclusion_product_fst :
+    (Q).map (FiniteLeftModule.resolutionMap (M := evaluatedFiber q H₁ H₂)
+      (N := evaluatedMiddle q H₁ H₂) τ (evaluatedFiberInclusion q H₁ H₂)) ≫
+      (middleProductResolutionIso q H₁ H₂).hom ≫ biprod.fst =
+    (Q).map (FiniteLeftModule.resolutionMap (M := evaluatedFiber q H₁ H₂)
+      (N := X) τ (evaluatedRho₁ q H₁ H₂)) := by
+  simp only [middleProductResolutionIso, Iso.trans_hom, Category.assoc,
+    FiniteLeftModule.resolutionPairIso_hom_fst]
+  rw [← Category.assoc]
+  erw [fiberInclusion_pairResolution q H₁ H₂]
+  exact (FiniteLeftModule.resolutionMap_comp (M := evaluatedFiber q H₁ H₂)
+    (N := FiniteLeftModule.pairModule X X) (L := X) τ
+    ((evaluatedRho₁ q H₁ H₂).prod (evaluatedRho₂ q H₁ H₂))
+    (FiniteLeftModule.pairFst X X)).symm
+
+theorem fiberInclusion_product_snd :
+    (Q).map (FiniteLeftModule.resolutionMap (M := evaluatedFiber q H₁ H₂)
+      (N := evaluatedMiddle q H₁ H₂) τ (evaluatedFiberInclusion q H₁ H₂)) ≫
+      (middleProductResolutionIso q H₁ H₂).hom ≫ biprod.snd =
+    (Q).map (FiniteLeftModule.resolutionMap (M := evaluatedFiber q H₁ H₂)
+      (N := X) τ (evaluatedRho₂ q H₁ H₂)) := by
+  simp only [middleProductResolutionIso, Iso.trans_hom, Category.assoc,
+    FiniteLeftModule.resolutionPairIso_hom_snd]
+  rw [← Category.assoc]
+  erw [fiberInclusion_pairResolution q H₁ H₂]
+  exact (FiniteLeftModule.resolutionMap_comp (M := evaluatedFiber q H₁ H₂)
+    (N := FiniteLeftModule.pairModule X X) (L := X) τ
+    ((evaluatedRho₁ q H₁ H₂).prod (evaluatedRho₂ q H₁ H₂))
+    (FiniteLeftModule.pairSnd X X)).symm
+
+end ArExplicit.T
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/ConcreteFiberProfile.lean

@@ -0,0 +1,68 @@
+import OAI.Algebra.AuslanderReiten.Coordinates.BranchHomProfile
+import OAI.Algebra.AuslanderReiten.Evaluation.ConcreteBranchDetector
+import OAI.Algebra.AuslanderReiten.Fibers.FiberBranchConsequences
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.T
+open CategoryTheory
+open CochainComplex.HomComplex CompleteComparison
+open scoped TensorProduct ModuleCat.Algebra
+universe u
+variable {k : Type u} [Field k] [CharP k 2] (q : k)
+variable [HasDerivedCategory (ModuleCat.{u} (T k q))]
+variable [HasDerivedCategory (ModuleCat.{u} (A k q))]
+variable (hq : q ≠ 0) (hq1 : 1+q ≠ 0) (h : Resolution.NoPositivePowerOne q)
+variable (H₁ H₂ : kˣ)
+local notation "P₀" => A.simpleComplete q
+
+include hq hq1 h
+
+theorem normalizedBranches_equal : branchHom q H₁ = branchHom q H₂ :=
+  branchHom_common_of_scalarCoordinate q hq1 (branchPlainScalarEquiv q hq hq1 h) H₁ H₂
+
+theorem normalizedBranch_ne_zero (H : kˣ) : branchHom q H ≠ 0 :=
+  branchHom_ne_zero_of_scalarCoordinate q hq1 (branchPlainScalarEquiv q hq hq1 h) H
+
+theorem fiberPositiveRhoPair_bijective (n : ℤ) (hn : 0 < n) :
+    Function.Bijective (fiberFullRhoPair q H₁ H₂ n) :=
+  fiberFullRhoPair_positive_bijective q H₁ H₂ hq1 (branchZeroScalarEquiv q hq hq1 h)
+    (normalizedBranches_equal q hq hq1 h H₁ H₂)
+    (normalizedBranch_ne_zero q hq hq1 h H₁)
+    (fun a ha => branchHom_subsingleton q hq hq1 h a (by omega) (by omega)) n hn
+
+def fiberDiagonalClass : CohomologyClass P₀ (fiberComplete q H₁ H₂) 0 := by
+  letI := branchHom_subsingleton q hq hq1 h (-1) (by omega) (by omega)
+  exact fiberZeroClassOfBranches q H₁ H₂ hq1 (branchZeroScalarEquiv q hq hq1 h)
+    (normalizedBranches_equal q hq hq1 h H₁ H₂)
+    (normalizedBranch_ne_zero q hq hq1 h H₁)
+
+theorem fiberDiagonalClass_image :
+    fiberFullRhoPair q H₁ H₂ 0 (fiberDiagonalClass q hq hq1 h H₁ H₂) =
+      (fullHomIdentity P₀, fullHomIdentity P₀) := by
+  let := branchHom_subsingleton q hq hq1 h (-1) (by omega) (by omega)
+  exact fiberZeroClassOfBranches_image q H₁ H₂ hq1 (branchZeroScalarEquiv q hq hq1 h)
+    (normalizedBranches_equal q hq hq1 h H₁ H₂)
+    (normalizedBranch_ne_zero q hq hq1 h H₁)
+
+theorem fiberDiagonalClass_spans (x : CohomologyClass P₀ (fiberComplete q H₁ H₂) 0) :
+    ∃ c : k, x = c • fiberDiagonalClass q hq hq1 h H₁ H₂ := by
+  let := branchHom_subsingleton q hq hq1 h (-1) (by omega) (by omega)
+  exact fiberZeroClassOfBranches_spans q H₁ H₂ hq1 (branchZeroScalarEquiv q hq hq1 h)
+    (normalizedBranches_equal q hq hq1 h H₁ H₂)
+    (normalizedBranch_ne_zero q hq hq1 h H₁) x
+
+theorem fiberDiagonalClass_ne_zero : fiberDiagonalClass q hq hq1 h H₁ H₂ ≠ 0 := by
+  intro hz
+  have hp := fiberDiagonalClass_image q hq hq1 h H₁ H₂
+  rw [hz, map_zero] at hp
+  have hs := congrArg (fun z => A.fullHomZeroScalarEquiv q hq1 z.1) hp
+  simp only [Prod.fst_zero, map_zero, fullHomIdentity, A.fullHomZeroScalarEquiv_identity] at hs
+  exact zero_ne_one hs
+
+end ArExplicit.T
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/ConcreteFiberRow.lean

@@ -0,0 +1,70 @@
+import OAI.Algebra.AuslanderReiten.Fibers.ConcreteFiberComponentMaps
+import OAI.Algebra.AuslanderReiten.Coordinates.MappedBiproductRow
+import OAI.Algebra.AuslanderReiten.Algebras.SimpleHomScalars
+import OAI.Algebra.AuslanderReiten.Homology.TriangleConnectingProduct
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.T
+open CategoryTheory CategoryTheory.Limits
+open scoped TensorProduct ModuleCat.Algebra
+universe u
+variable {k : Type u} [Field k] [CharP k 2] (q : k) (H₁ H₂ : kˣ)
+local notation "HC" => HomotopyCategory (ModuleCat (A k q)) (ComplexShape.up ℤ)
+local notation "X₀" => simpleHomotopyObject q
+local notation "T₀" => fiberProductTriangle q H₁ H₂
+
+def fiberProductMiddleEquiv (n : ℤ) :
+    TriangleGradedSequence.Middle T₀ X₀ n ≃ₗ[k] (SimpleHom q n × SimpleHom q n) :=
+  mappedBiproductHomEquiv k (CategoryTheory.shiftFunctor HC n) X₀ X₀ X₀
+
+def fiberProductMiddleScalarEquiv (hq1 : 1+q ≠ 0) :
+    TriangleGradedSequence.Middle T₀ X₀ 0 ≃ₗ[k] k × k :=
+  (fiberProductMiddleEquiv q H₁ H₂ 0).trans
+    ((simpleZeroScalarEquiv q hq1).prodCongr (simpleZeroScalarEquiv q hq1))
+
+def branchZeroHom (H : kˣ) : BranchHom q 0 :=
+  branchHom q H ≫ (shiftFunctorZero HC ℤ).inv.app (branchTargetObject q)
+
+theorem fiberProductSecond_row (n : ℤ)
+    (m : TriangleGradedSequence.Middle T₀ X₀ n) :
+    TriangleGradedSequence.second k T₀ X₀ n m =
+      (fiberProductMiddleEquiv q H₁ H₂ n m).1 ≫ (branchHom q H₁)⟦n⟧' +
+      (fiberProductMiddleEquiv q H₁ H₂ n m).2 ≫ (branchHom q H₂)⟦n⟧' := by
+  erw [TriangleGradedSequence.second_eq_shift,
+    mappedBiproduct_row k (CategoryTheory.shiftFunctor HC n) X₀ X₀ X₀,
+    fiberProductTriangle_inl_second, fiberProductTriangle_inr_second]
+  rfl
+
+theorem fiberProductSecond_zero (hq1 : 1+q ≠ 0)
+    (m : TriangleGradedSequence.Middle T₀ X₀ 0) :
+    TriangleGradedSequence.second k T₀ X₀ 0 m =
+      (fiberProductMiddleScalarEquiv q H₁ H₂ hq1 m).1 • branchZeroHom q H₁ +
+      (fiberProductMiddleScalarEquiv q H₁ H₂ hq1 m).2 • branchZeroHom q H₂ := by
+  have h₁ := congrArg (fun v => v ≫ (branchHom q H₁)⟦(0 : ℤ)⟧')
+    (simpleHom_eq_scalar_unit q hq1 (fiberProductMiddleEquiv q H₁ H₂ 0 m).1)
+  have h₂ := congrArg (fun v => v ≫ (branchHom q H₂)⟦(0 : ℤ)⟧')
+    (simpleHom_eq_scalar_unit q hq1 (fiberProductMiddleEquiv q H₁ H₂ 0 m).2)
+  refine (fiberProductSecond_row q H₁ H₂ 0 m).trans ((congrArg₂ (· + ·) h₁ h₂).trans ?_)
+  rw [Linear.smul_comp, Linear.smul_comp, simpleZeroUnit_postcomp, simpleZeroUnit_postcomp]
+  rfl
+
+theorem fiberProductSecond_zero_common (hq1 : 1+q ≠ 0)
+    (e : BranchHom q 0 ≃ₗ[k] k) (hg : branchHom q H₁ = branchHom q H₂)
+    (m : TriangleGradedSequence.Middle T₀ X₀ 0) :
+    e (TriangleGradedSequence.second k T₀ X₀ 0 m) =
+      e (branchZeroHom q H₁) *
+        ((fiberProductMiddleScalarEquiv q H₁ H₂ hq1 m).1 +
+          (fiberProductMiddleScalarEquiv q H₁ H₂ hq1 m).2) := by
+  have hz : branchZeroHom q H₁ = branchZeroHom q H₂ :=
+    congrArg (fun f => f ≫ (shiftFunctorZero HC ℤ).inv.app (branchTargetObject q)) hg
+  rw [fiberProductSecond_zero q H₁ H₂ hq1, ← hz, map_add, map_smul, map_smul]
+  simp only [smul_eq_mul]
+  ring
+
+end ArExplicit.T
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/ConcreteFiberTriangle.lean

@@ -0,0 +1,50 @@
+import OAI.Algebra.AuslanderReiten.Fibers.ConcreteFiberHomotopy
+import OAI.Algebra.AuslanderReiten.Homology.TriangleMiddleTransport
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.T
+open CategoryTheory CategoryTheory.Limits CategoryTheory.Pretriangulated
+universe u
+variable {k : Type u} [Field k] [CharP k 2] (q : k) (H₁ H₂ : kˣ)
+local notation "R" => A k q
+local notation "X" => A.simpleFiniteModule q
+local notation "τ" => AFrobeniusTrace k q
+local notation "HC" => HomotopyCategory (ModuleCat R) (ComplexShape.up ℤ)
+local notation "Q" => HomotopyCategory.quotient (ModuleCat R) (ComplexShape.up ℤ)
+
+@[simp] theorem fiberEvaluationTriangle_first : (fiberEvaluationTriangle q H₁ H₂).mor₁ =
+    (Q).map (FiniteLeftModule.resolutionMap (M := evaluatedFiber q H₁ H₂)
+      (N := evaluatedMiddle q H₁ H₂) τ (evaluatedFiberInclusion q H₁ H₂)) := rfl
+
+def fiberProductTriangle : Triangle HC :=
+  triangleReplaceMiddle (fiberEvaluationTriangle q H₁ H₂) (middleProductResolutionIso q H₁ H₂)
+
+def fiberProductTriangleIso : fiberEvaluationTriangle q H₁ H₂ ≅ fiberProductTriangle q H₁ H₂ :=
+  triangleReplaceMiddleIso _ _
+
+ theorem fiberProductTriangle_distinguished : fiberProductTriangle q H₁ H₂ ∈ distTriang HC :=
+  triangleReplaceMiddle_distinguished _ _ (fiberEvaluationTriangle_distinguished q H₁ H₂)
+
+theorem fiberProductTriangle_first_fst : (fiberProductTriangle q H₁ H₂).mor₁ ≫ biprod.fst =
+    (Q).map (FiniteLeftModule.resolutionMap (M := evaluatedFiber q H₁ H₂)
+      (N := X) τ (evaluatedRho₁ q H₁ H₂)) := by
+  change ((fiberEvaluationTriangle q H₁ H₂).mor₁ ≫
+    (middleProductResolutionIso q H₁ H₂).hom) ≫ biprod.fst = _
+  erw [fiberEvaluationTriangle_first, Category.assoc]
+  exact fiberInclusion_product_fst q H₁ H₂
+
+theorem fiberProductTriangle_first_snd : (fiberProductTriangle q H₁ H₂).mor₁ ≫ biprod.snd =
+    (Q).map (FiniteLeftModule.resolutionMap (M := evaluatedFiber q H₁ H₂)
+      (N := X) τ (evaluatedRho₂ q H₁ H₂)) := by
+  change ((fiberEvaluationTriangle q H₁ H₂).mor₁ ≫
+    (middleProductResolutionIso q H₁ H₂).hom) ≫ biprod.snd = _
+  erw [fiberEvaluationTriangle_first, Category.assoc]
+  exact fiberInclusion_product_snd q H₁ H₂
+
+end ArExplicit.T
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/ExplicitBimoduleFiber.lean

@@ -0,0 +1,74 @@
+import OAI.Algebra.AuslanderReiten.Coordinates.TensorFiniteLift
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.T
+open CategoryTheory
+open scoped TensorProduct
+universe u
+variable {k : Type u} [Field k] [CharP k 2] (q : k) (H H₁ H₂ : kˣ)
+local notation "R" => A k q
+local notation "Ae" => R ⊗[k] Rᵐᵒᵖ
+
+abbrev fiberTarget : FiniteLeftModule k Ae := (firstTailModule q).canonicalCosyzygies 4
+
+def normalizedLift : (twistedFiniteModule (sourceTwist q H)).carrier ⟶ (fiberTarget q).carrier :=
+  ModuleCat.ofHom (X := (twistedFiniteModule (sourceTwist q H)).carrier)
+    (Y := (fiberTarget q).carrier) (((H : k)^2)⁻¹ • finiteLift q H)
+
+@[simp] theorem normalizedLift_apply (x : (twistedFiniteModule (sourceTwist q H)).carrier) :
+    normalizedLift q H x = ((H : k)^2)⁻¹ • finiteLift q H x := rfl
+
+abbrev finiteFiber : FiniteLeftModule k Ae :=
+  BimoduleFiber.finiteModule (firstTailModule q) (sourceTwist q H₁) (sourceTwist q H₂)
+    (normalizedLift q H₁) (normalizedLift q H₂)
+
+abbrev explicitBimodule :=
+  BimoduleFiber.bimodule (firstTailModule q) (sourceTwist q H₁) (sourceTwist q H₂)
+    (normalizedLift q H₁) (normalizedLift q H₂)
+
+def rho₁ : (finiteFiber q H₁ H₂).carrier ⟶ (twistedFiniteModule (sourceTwist q H₁)).carrier :=
+  FiniteLeftModule.fiberProjection₁
+    (twistedFiniteModule (sourceTwist q H₁)) (twistedFiniteModule (sourceTwist q H₂))
+    (fiberTarget q) (normalizedLift q H₁) (normalizedLift q H₂)
+
+def rho₂ : (finiteFiber q H₁ H₂).carrier ⟶ (twistedFiniteModule (sourceTwist q H₂)).carrier :=
+  FiniteLeftModule.fiberProjection₂
+    (twistedFiniteModule (sourceTwist q H₁)) (twistedFiniteModule (sourceTwist q H₂))
+    (fiberTarget q) (normalizedLift q H₁) (normalizedLift q H₂)
+
+def explicitFiberSequence :=
+  FiniteLeftModule.fiberSequence
+    (twistedFiniteModule (sourceTwist q H₁)) (twistedFiniteModule (sourceTwist q H₂))
+    (fiberTarget q) (normalizedLift q H₁) (normalizedLift q H₂)
+
+theorem explicitFiberSequence_shortExact : (explicitFiberSequence q H₁ H₂).ShortExact :=
+  FiniteLeftModule.fiberSequence_shortExact
+    (twistedFiniteModule (sourceTwist q H₁)) (twistedFiniteModule (sourceTwist q H₂))
+    (fiberTarget q) (normalizedLift q H₁) (normalizedLift q H₂)
+
+theorem explicitBimodule_finite_k : Module.Finite k (explicitBimodule q H₁ H₂) := by
+  infer_instance
+
+theorem explicitBimodule_left :
+    Module.Finite R (explicitBimodule q H₁ H₂) ∧
+      Module.Projective R (explicitBimodule q H₁ H₂) := by
+  let := firstTailModule_left_finite q
+  let := firstTailModule_left_projective q
+  exact BimoduleFiber.left (firstTailModule q) (sourceTwist q H₁) (sourceTwist q H₂)
+    (normalizedLift q H₁) (normalizedLift q H₂) (AEnvelopingFrobeniusTrace k q)
+
+theorem explicitBimodule_right :
+    Module.Finite Rᵐᵒᵖ (explicitBimodule q H₁ H₂) ∧
+      Module.Projective Rᵐᵒᵖ (explicitBimodule q H₁ H₂) := by
+  let := firstTailModule_right_finite q
+  let := firstTailModule_right_projective q
+  exact BimoduleFiber.right (firstTailModule q) (sourceTwist q H₁) (sourceTwist q H₂)
+    (normalizedLift q H₁) (normalizedLift q H₂) (AEnvelopingFrobeniusTrace k q)
+
+end ArExplicit.T
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/ExplicitBimoduleProjective.lean

@@ -0,0 +1,26 @@
+import OAI.Algebra.AuslanderReiten.Fibers.ExplicitBimoduleFiber
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.T
+universe u
+variable {k : Type u} [Field k] [CharP k 2] (q : k) (H₁ H₂ : kˣ)
+
+instance explicitBimodule_finite_left : Module.Finite (A k q) (explicitBimodule q H₁ H₂) :=
+  (explicitBimodule_left q H₁ H₂).1
+
+instance explicitBimodule_projective_left : Module.Projective (A k q) (explicitBimodule q H₁ H₂) :=
+  (explicitBimodule_left q H₁ H₂).2
+
+instance explicitBimodule_finite_right : Module.Finite (A k q)ᵐᵒᵖ (explicitBimodule q H₁ H₂) :=
+  (explicitBimodule_right q H₁ H₂).1
+
+instance explicitBimodule_projective_right : Module.Projective (A k q)ᵐᵒᵖ (explicitBimodule q H₁ H₂) :=
+  (explicitBimodule_right q H₁ H₂).2
+
+end ArExplicit.T
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/FiberBranchConsequences.lean

@@ -0,0 +1,110 @@
+import OAI.Algebra.AuslanderReiten.Fibers.FiberProductCoordinates
+import OAI.Algebra.AuslanderReiten.Fibers.FiberDiagonalGenerator
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.T
+open CategoryTheory
+open CochainComplex.HomComplex CompleteComparison
+open scoped TensorProduct ModuleCat.Algebra
+universe u
+variable {k : Type u} [Field k] [CharP k 2] (q : k) (H₁ H₂ : kˣ)
+local notation "HC" => HomotopyCategory (ModuleCat (A k q)) (ComplexShape.up ℤ)
+local notation "T₀" => fiberProductTriangle q H₁ H₂
+local notation "X₀" => simpleHomotopyObject q
+local notation "P₀" => A.simpleComplete q
+
+theorem branchZeroHom_ne_zero (H : kˣ) (hn : branchHom q H ≠ 0) :
+    branchZeroHom q H ≠ 0 := by
+  intro h
+  apply hn
+  apply (cancel_mono ((shiftFunctorZero HC ℤ).inv.app (branchTargetObject q))).1
+  simpa only [branchZeroHom, Limits.zero_comp] using h
+
+variable (hq1 : 1+q ≠ 0) (e : BranchHom q 0 ≃ₗ[k] k)
+variable (hg : branchHom q H₁ = branchHom q H₂) (hn : branchHom q H₁ ≠ 0)
+
+include hn in
+theorem branchScalar_ne_zero : e (branchZeroHom q H₁) ≠ 0 := by
+  intro hz
+  exact branchZeroHom_ne_zero q H₁ hn (e.injective (hz.trans (map_zero e).symm))
+
+include hq1 e hg hn
+
+theorem fiberSecondZero_surjective :
+    Function.Surjective (TriangleGradedSequence.second k T₀ X₀ 0) :=
+  TriangleGradedSequence.second_zero_surjective k T₀ X₀
+    (fiberProductMiddleScalarEquiv q H₁ H₂ hq1) e
+    (e (branchZeroHom q H₁)) (branchScalar_ne_zero q H₁ e hn)
+    (fiberProductSecond_zero_common q H₁ H₂ hq1 e hg)
+
+theorem fiberFullRhoPair_positive_bijective
+    (hpos : ∀ n : ℤ, 0 < n → Subsingleton (BranchHom q n))
+    (n : ℤ) (hnpos : 0 < n) :
+    Function.Bijective (fiberFullRhoPair q H₁ H₂ n) := by
+  apply fiberFullRhoPair_bijective_of_rho
+  apply fiberRhoPair_bijective_of_productFirst
+  exact TriangleGradedSequence.first_positive_bijective k T₀
+    (fiberProductTriangle_distinguished q H₁ H₂) X₀ hpos
+    (fiberSecondZero_surjective q H₁ H₂ hq1 e hg hn) n hnpos
+
+variable [Subsingleton (BranchHom q (-1))]
+local instance : Subsingleton (TriangleGradedSequence.Top T₀ X₀ (-1)) :=
+  inferInstanceAs (Subsingleton (BranchHom q (-1)))
+
+def fiberZeroScalarEquivOfBranches : FiberHom q H₁ H₂ 0 ≃ₗ[k] k :=
+  TriangleGradedSequence.zeroScalarEquiv k T₀
+    (fiberProductTriangle_distinguished q H₁ H₂) X₀
+    (fiberProductMiddleScalarEquiv q H₁ H₂ hq1) e
+    (e (branchZeroHom q H₁)) (branchScalar_ne_zero q H₁ e hn)
+    (fiberProductSecond_zero_common q H₁ H₂ hq1 e hg)
+
+def fiberZeroClassOfBranches : CohomologyClass P₀ (fiberComplete q H₁ H₂) 0 :=
+  (fiberFullHomEquiv q H₁ H₂ 0).symm
+    ((fiberZeroScalarEquivOfBranches q H₁ H₂ hq1 e hg hn).symm 1)
+
+omit e hg hn [Subsingleton (BranchHom q (-1))] in
+theorem fiberFullRhoPair_zero_coordinates
+    (x : CohomologyClass P₀ (fiberComplete q H₁ H₂) 0) :
+    ((A.fullHomZeroScalarEquiv q hq1).prodCongr (A.fullHomZeroScalarEquiv q hq1))
+      (fiberFullRhoPair q H₁ H₂ 0 x) =
+    fiberProductMiddleScalarEquiv q H₁ H₂ hq1
+      (TriangleGradedSequence.first k T₀ X₀ 0 (fiberFullHomEquiv q H₁ H₂ 0 x)) := by
+  change _ = ((simpleZeroScalarEquiv q hq1).prodCongr (simpleZeroScalarEquiv q hq1))
+    (fiberProductMiddleEquiv q H₁ H₂ 0 _)
+  rw [fiberProductFirst_coordinates]
+  rfl
+
+theorem fiberZeroClassOfBranches_image :
+    fiberFullRhoPair q H₁ H₂ 0 (fiberZeroClassOfBranches q H₁ H₂ hq1 e hg hn) =
+      (fullHomIdentity P₀, fullHomIdentity P₀) := by
+  apply ((A.fullHomZeroScalarEquiv q hq1).prodCongr (A.fullHomZeroScalarEquiv q hq1)).injective
+  rw [fiberFullRhoPair_zero_coordinates]
+  simp only [LinearEquiv.prodCongr_apply, fullHomIdentity, A.fullHomZeroScalarEquiv_identity]
+  rw [fiberZeroClassOfBranches, LinearEquiv.apply_symm_apply]
+  change fiberProductMiddleScalarEquiv q H₁ H₂ hq1
+    (TriangleGradedSequence.first k T₀ X₀ 0
+      ((fiberZeroScalarEquivOfBranches q H₁ H₂ hq1 e hg hn).symm 1)) = (1, 1)
+  exact TriangleGradedSequence.diagonalGenerator_image k T₀
+    (fiberProductTriangle_distinguished q H₁ H₂) X₀
+    (fiberProductMiddleScalarEquiv q H₁ H₂ hq1) e
+    (e (branchZeroHom q H₁)) (branchScalar_ne_zero q H₁ e hn)
+    (fiberProductSecond_zero_common q H₁ H₂ hq1 e hg)
+
+theorem fiberZeroClassOfBranches_spans
+    (x : CohomologyClass P₀ (fiberComplete q H₁ H₂) 0) :
+    ∃ c : k, x = c • fiberZeroClassOfBranches q H₁ H₂ hq1 e hg hn := by
+  let f := (fiberFullHomEquiv q H₁ H₂ 0).trans
+    (fiberZeroScalarEquivOfBranches q H₁ H₂ hq1 e hg hn)
+  refine ⟨f x, f.injective ?_⟩
+  rw [map_smul]
+  change f x = f x • f (f.symm 1)
+  rw [f.apply_symm_apply]
+  exact (mul_one _).symm
+
+end ArExplicit.T
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/FiberDiagonalGenerator.lean

@@ -0,0 +1,53 @@
+import OAI.Algebra.AuslanderReiten.Fibers.FiberProjectionZero
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.TriangleGradedSequence
+open CategoryTheory CategoryTheory.Pretriangulated
+universe u v w
+variable (k : Type u) [Field k] [CharP k 2]
+variable {C : Type w} [Category.{v} C] [Preadditive C] [Linear k C]
+variable [Limits.HasZeroObject C] [HasShift C ℤ]
+variable [∀ n : ℤ, (CategoryTheory.shiftFunctor C n).Additive] [Pretriangulated C]
+variable (T : Triangle C) (hT : T ∈ distTriang C) (X : C)
+variable (em : Middle T X 0 ≃ₗ[k] k × k) (et : Top T X 0 ≃ₗ[k] k)
+variable (c : k) (hc : c ≠ 0)
+variable (hrow : ∀ m, et (second k T X 0 m) = c * ((em m).1 + (em m).2))
+variable [Subsingleton (Top T X (-1))]
+
+def zeroScalarEquiv : Bottom T X 0 ≃ₗ[k] k :=
+  (zeroDiagonalEquiv k T hT X em et c hc hrow).trans (scalarDiagonalEquiv k)
+
+def diagonalGenerator : Bottom T X 0 :=
+  (zeroScalarEquiv k T hT X em et c hc hrow).symm 1
+
+@[simp] theorem zeroScalarEquiv_diagonalGenerator :
+    zeroScalarEquiv k T hT X em et c hc hrow (diagonalGenerator k T hT X em et c hc hrow) = 1 :=
+  LinearEquiv.apply_symm_apply _ _
+
+theorem diagonalGenerator_image :
+    em (first k T X 0 (diagonalGenerator k T hT X em et c hc hrow)) = (1,1) := by
+  have h := congrArg Subtype.val
+    ((zeroDiagonalEquiv k T hT X em et c hc hrow).apply_symm_apply
+      ((scalarDiagonalEquiv k).symm 1))
+  exact h
+
+theorem diagonalGenerator_ne_zero : diagonalGenerator k T hT X em et c hc hrow ≠ 0 := by
+  intro hz
+  have h := zeroScalarEquiv_diagonalGenerator k T hT X em et c hc hrow
+  rw [hz, map_zero] at h
+  exact zero_ne_one h
+
+theorem eq_scalar_diagonalGenerator (z : Bottom T X 0) :
+    z = zeroScalarEquiv k T hT X em et c hc hrow z •
+      diagonalGenerator k T hT X em et c hc hrow := by
+  apply (zeroScalarEquiv k T hT X em et c hc hrow).injective
+  rw [map_smul, zeroScalarEquiv_diagonalGenerator]
+  exact (mul_one _).symm
+
+end ArExplicit.TriangleGradedSequence
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/FiberEvaluationMap.lean

@@ -0,0 +1,30 @@
+import OAI.Algebra.AuslanderReiten.Fibers.FiniteEvaluatedFiber
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.FiniteLeftModule
+open CategoryTheory
+open scoped TensorProduct
+universe u
+variable {k R : Type u} [Field k] [Ring R] [Algebra k R] [Module.Finite k R]
+variable (X : FiniteLeftModule k R)
+variable (U₁ U₂ Y : FiniteLeftModule k (R ⊗[k] Rᵐᵒᵖ))
+variable (g₁ : U₁.carrier ⟶ Y.carrier) (g₂ : U₂.carrier ⟶ Y.carrier)
+
+def fiberEvaluationInclusion : (evaluated X (fiber U₁ U₂ Y g₁ g₂)).carrier →ₗ[R]
+    (evaluated X (fiberSource U₁ U₂ Y)).carrier :=
+  evaluationMap X (M := fiber U₁ U₂ Y g₁ g₂) (N := fiberSource U₁ U₂ Y)
+    (fiberInclusion U₁ U₂ Y g₁ g₂).hom
+
+theorem middlePairMap_fiberEvaluationInclusion :
+    (middlePairMap X U₁ U₂ Y).comp (fiberEvaluationInclusion X U₁ U₂ Y g₁ g₂) =
+    (evaluationMap X (fiberProjection₁ U₁ U₂ Y g₁ g₂).hom).prod
+      (evaluationMap X (fiberProjection₂ U₁ U₂ Y g₁ g₂).hom) :=
+  middlePairMap_fiberInclusion X U₁ U₂ Y g₁ g₂
+
+end ArExplicit.FiniteLeftModule
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/FiberExactness.lean

@@ -0,0 +1,43 @@
+import Mathlib.LinearAlgebra.Prod
+
+namespace OAI
+
+namespace ArExplicit
+
+section Fiber
+
+variable {k : Type*} [Ring k]
+variable {B₀ B₁ B₂ C₀ C₁ C₂ : Type*}
+variable [AddCommGroup B₀] [AddCommGroup B₁] [AddCommGroup B₂]
+variable [AddCommGroup C₀] [AddCommGroup C₁] [AddCommGroup C₂]
+variable [Module k B₀] [Module k B₁] [Module k B₂]
+variable [Module k C₀] [Module k C₁] [Module k C₂]
+
+theorem fiber_cocycle_is_boundary
+    (dB₀ : B₀ →ₗ[k] B₁) (dB₁ : B₁ →ₗ[k] B₂)
+    (dC₀ : C₀ →ₗ[k] C₁) (dC₁ : C₁ →ₗ[k] C₂)
+    (f₀ : B₀ →ₗ[k] C₁) (f₁ : B₁ →ₗ[k] C₂)
+    (hf : ∀ a, f₁ (dB₀ a) = dC₁ (f₀ a))
+    (hinj : ∀ b, dB₁ b = 0 → (∃ c, f₁ b = dC₁ c) → ∃ a, dB₀ a = b)
+    (hsurj : ∀ c, dC₁ c = 0 → ∃ a, dB₀ a = 0 ∧ ∃ e, f₀ a - dC₀ e = c)
+    (b : B₁) (c : C₁) (hb : dB₁ b = 0) (hc : f₁ b = dC₁ c) :
+    ∃ a : B₀, ∃ e : C₀, dB₀ a = b ∧ f₀ a - dC₀ e = c := by
+  obtain ⟨a, ha⟩ := hinj b hb ⟨c, hc⟩
+  have hcycle : dC₁ (c - f₀ a) = 0 := by
+    rw [map_sub, ← hf, ha, hc, sub_self]
+  obtain ⟨u, hu, e, he⟩ := hsurj (c - f₀ a) hcycle
+  refine ⟨a + u, e, ?_, ?_⟩
+  · rw [map_add, ha, hu, add_zero]
+  · rw [map_add, add_sub_assoc, he, add_sub_cancel]
+
+theorem fiber_nonboundary_of_projection
+    (dB₀ : B₀ →ₗ[k] B₁) (dC₀ : C₀ →ₗ[k] C₁) (f₀ : B₀ →ₗ[k] C₁)
+    (b : B₁) (c : C₁) (hb : ¬ ∃ a, dB₀ a = b) :
+    ¬ ∃ a : B₀, ∃ e : C₀, dB₀ a = b ∧ f₀ a - dC₀ e = c := by
+  rintro ⟨a, e, ha, he⟩
+  exact hb ⟨a, ha⟩
+
+end Fiber
+end ArExplicit
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/FiberFullHomCoordinates.lean

@@ -0,0 +1,50 @@
+import OAI.Algebra.AuslanderReiten.Fibers.ConcreteFiberHomCoordinates
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomShiftedMaps
+import OAI.Algebra.AuslanderReiten.HomComplex.TensorFullHomZero
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.T
+open CategoryTheory
+open CochainComplex.HomComplex
+open scoped TensorProduct ModuleCat.Algebra
+universe u
+variable {k : Type u} [Field k] [CharP k 2] (q : k) (H₁ H₂ : kˣ)
+local notation "τ₀" => AFrobeniusTrace k q
+local notation "P₀" => A.simpleComplete q
+
+abbrev fiberComplete := (evaluatedFiber q H₁ H₂).completeCochain τ₀
+
+def fiberFullHomEquiv (n : ℤ) :
+    CohomologyClass P₀ (fiberComplete q H₁ H₂) n ≃ₗ[k] FiberHom q H₁ H₂ n :=
+  fullHomShiftedHomotopyEquiv k P₀ (fiberComplete q H₁ H₂) n
+
+def simpleFullHomEquiv (n : ℤ) : CohomologyClass P₀ P₀ n ≃ₗ[k] SimpleHom q n :=
+  fullHomShiftedHomotopyEquiv k P₀ P₀ n
+
+def fiberFullRhoPair (n : ℤ) :
+    CohomologyClass P₀ (fiberComplete q H₁ H₂) n →ₗ[k]
+      (CohomologyClass P₀ P₀ n × CohomologyClass P₀ P₀ n) :=
+  (((simpleFullHomEquiv q n).symm.prodCongr (simpleFullHomEquiv q n).symm).toLinearMap.comp
+    (fiberHomRhoPair q H₁ H₂ n)).comp (fiberFullHomEquiv q H₁ H₂ n).toLinearMap
+
+theorem fiberFullRhoPair_apply (n : ℤ)
+    (x : CohomologyClass P₀ (fiberComplete q H₁ H₂) n) :
+    fiberFullRhoPair q H₁ H₂ n x =
+      (fullHomPostcomp (FiniteLeftModule.resolutionMap τ₀ (evaluatedRho₁ q H₁ H₂)) n x,
+       fullHomPostcomp (FiniteLeftModule.resolutionMap τ₀ (evaluatedRho₂ q H₁ H₂)) n x) := by
+  apply ((simpleFullHomEquiv q n).prodCongr (simpleFullHomEquiv q n)).injective
+  simp only [fiberFullRhoPair, LinearMap.comp_apply, LinearEquiv.coe_coe,
+    LinearEquiv.prodCongr_apply, LinearEquiv.apply_symm_apply]
+  apply Prod.ext
+  · exact (fullHomShiftedHomotopyEquiv_postcomp k n
+      (FiniteLeftModule.resolutionMap τ₀ (evaluatedRho₁ q H₁ H₂)) x).symm
+  · exact (fullHomShiftedHomotopyEquiv_postcomp k n
+      (FiniteLeftModule.resolutionMap τ₀ (evaluatedRho₂ q H₁ H₂)) x).symm
+
+end ArExplicit.T
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/FiberProductCoordinates.lean

@@ -0,0 +1,44 @@
+import OAI.Algebra.AuslanderReiten.Fibers.ConcreteFiberRow
+import OAI.Algebra.AuslanderReiten.Fibers.FiberSequenceCoordinates
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.T
+open CategoryTheory CategoryTheory.Limits
+open scoped TensorProduct ModuleCat.Algebra
+universe u
+variable {k : Type u} [Field k] [CharP k 2] (q : k) (H₁ H₂ : kˣ)
+local notation "R₀" => A k q
+local notation "X₀" => simpleHomotopyObject q
+local notation "τ₀" => AFrobeniusTrace k q
+local notation "T₀" => fiberProductTriangle q H₁ H₂
+local notation "Q₀" => HomotopyCategory.quotient (ModuleCat R₀) (ComplexShape.up ℤ)
+
+theorem fiberProductFirst_coordinates (n : ℤ) (v : FiberHom q H₁ H₂ n) :
+    fiberProductMiddleEquiv q H₁ H₂ n
+      (TriangleGradedSequence.first k T₀ X₀ n v) = fiberHomRhoPair q H₁ H₂ n v := by
+  erw [TriangleGradedSequence.first_eq_shift]
+  apply Prod.ext
+  · change (v ≫ (T₀).mor₁⟦n⟧') ≫ biprod.fst⟦n⟧' =
+      v ≫ ((Q₀).map (FiniteLeftModule.resolutionMap τ₀ (evaluatedRho₁ q H₁ H₂)))⟦n⟧'
+    erw [Category.assoc, ← Functor.map_comp, fiberProductTriangle_first_fst]
+  · change (v ≫ (T₀).mor₁⟦n⟧') ≫ biprod.snd⟦n⟧' =
+      v ≫ ((Q₀).map (FiniteLeftModule.resolutionMap τ₀ (evaluatedRho₂ q H₁ H₂)))⟦n⟧'
+    erw [Category.assoc, ← Functor.map_comp, fiberProductTriangle_first_snd]
+
+theorem fiberRhoPair_bijective_of_productFirst (n : ℤ)
+    (hf : Function.Bijective (TriangleGradedSequence.first k T₀ X₀ n)) :
+    Function.Bijective (fiberHomRhoPair q H₁ H₂ n) := by
+  have he : (fiberHomRhoPair q H₁ H₂ n : FiberHom q H₁ H₂ n → _) =
+      (fiberProductMiddleEquiv q H₁ H₂ n) ∘ (TriangleGradedSequence.first k T₀ X₀ n) := by
+    funext v
+    exact (fiberProductFirst_coordinates q H₁ H₂ n v).symm
+  rw [he]
+  exact (fiberProductMiddleEquiv q H₁ H₂ n).bijective.comp hf
+
+end ArExplicit.T
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/FiberProjectionProfile.lean

@@ -0,0 +1,75 @@
+import OAI.Algebra.AuslanderReiten.Homology.TriangleGradedSequence
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.TriangleGradedSequence
+open CategoryTheory CategoryTheory.Pretriangulated
+universe u v w
+variable (k : Type u) [Field k]
+variable {C : Type w} [Category.{v} C] [Preadditive C] [Linear k C]
+variable [Limits.HasZeroObject C] [HasShift C ℤ]
+variable [∀ n : ℤ, (CategoryTheory.shiftFunctor C n).Additive] [Pretriangulated C]
+variable (T : Triangle C) (hT : T ∈ distTriang C) (X : C)
+include hT
+
+theorem first_injective_of_previous_surjective (n : ℤ)
+    (hs : Function.Surjective (second k T X n)) :
+    Function.Injective (first k T X (n+1)) := by
+  have hc : connecting k T X n = 0 := by
+    apply LinearMap.ext
+    intro x
+    have hx : x ∈ LinearMap.range (second k T X n) := hs x
+    rw [exact_top k T X hT n] at hx
+    exact hx
+  rw [← LinearMap.ker_eq_bot, ← exact_next k T X hT n, hc, LinearMap.range_zero]
+
+theorem first_surjective_of_top_subsingleton (n : ℤ) [Subsingleton (Top T X n)] :
+    Function.Surjective (first k T X n) := by
+  rw [← LinearMap.range_eq_top, exact_middle k T X hT n]
+  apply top_unique
+  intro x _
+  exact Subsingleton.elim _ _
+
+omit hT [Limits.HasZeroObject C] [Pretriangulated C] in
+
+theorem second_surjective_of_top_subsingleton (n : ℤ) [Subsingleton (Top T X n)] :
+    Function.Surjective (second k T X n) := by
+  intro y
+  exact ⟨0, Subsingleton.elim _ _⟩
+
+theorem first_positive_bijective
+    (hpos : ∀ n : ℤ, 0 < n → Subsingleton (Top T X n))
+    (hs₀ : Function.Surjective (second k T X 0)) (n : ℤ) (hn : 0 < n) :
+    Function.Bijective (first k T X n) := by
+  constructor
+  · have hs : Function.Surjective (second k T X (n-1)) := by
+      by_cases h1 : n = 1
+      · subst n
+        exact hs₀
+      · let := hpos (n-1) (by omega)
+        exact second_surjective_of_top_subsingleton k T X (n-1)
+    generalize hm : n - 1 = m at hs
+    have he : n = m + 1 := by omega
+    subst n
+    exact first_injective_of_previous_surjective k T hT X m hs
+  · let := hpos n hn
+    exact first_surjective_of_top_subsingleton k T hT X n
+
+def firstPositiveEquiv
+    (hpos : ∀ n : ℤ, 0 < n → Subsingleton (Top T X n))
+    (hs₀ : Function.Surjective (second k T X 0)) (n : ℤ) (hn : 0 < n) :
+    Bottom T X n ≃ₗ[k] Middle T X n :=
+  LinearEquiv.ofBijective (first k T X n) (first_positive_bijective k T hT X hpos hs₀ n hn)
+
+theorem first_zero_injective [Subsingleton (Top T X (-1))] :
+    Function.Injective (first k T X 0) := by
+  have hinj := first_injective_of_previous_surjective k T hT X (-1)
+    (second_surjective_of_top_subsingleton k T X (-1))
+  exact hinj
+
+end ArExplicit.TriangleGradedSequence
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/FiberProjectionZero.lean

@@ -0,0 +1,87 @@
+import OAI.Algebra.AuslanderReiten.Fibers.FiberProjectionProfile
+import OAI.Algebra.AuslanderReiten.Coordinates.TwoTwistLinear
+import Mathlib.Algebra.CharP.Two
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.TriangleGradedSequence
+open CategoryTheory CategoryTheory.Pretriangulated
+universe u v w
+variable (k : Type u) [Field k] [CharP k 2]
+variable {C : Type w} [Category.{v} C] [Preadditive C] [Linear k C]
+variable [Limits.HasZeroObject C] [HasShift C ℤ]
+variable [∀ n : ℤ, (CategoryTheory.shiftFunctor C n).Additive] [Pretriangulated C]
+variable (T : Triangle C) (hT : T ∈ distTriang C) (X : C)
+variable (em : Middle T X 0 ≃ₗ[k] k × k) (et : Top T X 0 ≃ₗ[k] k)
+variable (c : k) (hc : c ≠ 0)
+variable (hrow : ∀ m, et (second k T X 0 m) = c * ((em m).1 + (em m).2))
+
+include hc hrow in
+omit [CharP k 2] [Limits.HasZeroObject C] [Pretriangulated C] in
+theorem second_zero_surjective : Function.Surjective (second k T X 0) := by
+  intro y
+  refine ⟨em.symm (c⁻¹ * et y, 0), et.injective ?_⟩
+  rw [hrow, em.apply_symm_apply, add_zero, ← mul_assoc, mul_inv_cancel₀ hc, one_mul]
+
+include hT hc hrow in
+
+theorem first_zero_diagonal (x : Bottom T X 0) :
+    (em (first k T X 0 x)).1 = (em (first k T X 0 x)).2 := by
+  have hz : second k T X 0 (first k T X 0 x) = 0 := by
+    have hmem := LinearMap.mem_range_self (first k T X 0) x
+    rw [exact_middle k T X hT 0] at hmem
+    exact hmem
+  have h := hrow (first k T X 0 x)
+  rw [hz, map_zero] at h
+  exact CharTwo.add_eq_zero.mp ((mul_eq_zero.mp h.symm).resolve_left hc)
+
+def zeroDiagonalProjection : Bottom T X 0 →ₗ[k] diagonalSubmodule (k := k) (V := k) :=
+  (em.toLinearMap.comp (first k T X 0)).codRestrict _
+    (first_zero_diagonal k T hT X em et c hc hrow)
+
+variable [Subsingleton (Top T X (-1))]
+
+theorem zeroDiagonalProjection_bijective :
+    Function.Bijective (zeroDiagonalProjection k T hT X em et c hc hrow) := by
+  constructor
+  · intro x y h
+    apply first_zero_injective k T hT X
+    apply em.injective
+    exact congrArg Subtype.val h
+  · intro z
+    have hz : second k T X 0 (em.symm z.val) = 0 := by
+      apply et.injective
+      rw [hrow, em.apply_symm_apply, map_zero]
+      rw [CharTwo.add_eq_zero.mpr z.property, mul_zero]
+    have hm : em.symm z.val ∈ LinearMap.range (first k T X 0) := by
+      rw [exact_middle k T X hT 0]
+      exact hz
+    obtain ⟨x, hx⟩ := hm
+    refine ⟨x, Subtype.ext ?_⟩
+    change em (first k T X 0 x) = z.val
+    rw [hx, em.apply_symm_apply]
+
+def zeroDiagonalEquiv : Bottom T X 0 ≃ₗ[k] diagonalSubmodule (k := k) (V := k) :=
+  LinearEquiv.ofBijective (zeroDiagonalProjection k T hT X em et c hc hrow)
+    (zeroDiagonalProjection_bijective k T hT X em et c hc hrow)
+
+end ArExplicit.TriangleGradedSequence
+
+namespace ArExplicit
+universe u
+variable (k : Type u) [Field k]
+
+def scalarDiagonalEquiv : diagonalSubmodule (k := k) (V := k) ≃ₗ[k] k where
+  toFun z := z.val.1
+  invFun a := ⟨(a,a), rfl⟩
+  left_inv z := Subtype.ext (Prod.ext rfl z.property)
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+end ArExplicit
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/FiberSequenceCoordinates.lean

@@ -0,0 +1,49 @@
+import OAI.Algebra.AuslanderReiten.Fibers.ConcreteFiberTriangle
+import OAI.Algebra.AuslanderReiten.Fibers.FiberFullHomCoordinates
+import OAI.Algebra.AuslanderReiten.Homology.TriangleConnectingProduct
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.T
+open CategoryTheory
+open CochainComplex.HomComplex
+open scoped TensorProduct ModuleCat.Algebra
+universe u
+variable {k : Type u} [Field k] [CharP k 2] (q : k) (H₁ H₂ : kˣ)
+
+theorem fiberSequenceFirst (n : ℤ) (v : FiberHom q H₁ H₂ n) :
+    TriangleGradedSequence.first k (fiberEvaluationTriangle q H₁ H₂)
+      (simpleHomotopyObject q) n v = fiberHomInclusion q H₁ H₂ n v := by
+  erw [TriangleGradedSequence.first_eq_shift, fiberEvaluationTriangle_first]
+  rfl
+
+theorem fiberRhoPair_eq_first (n : ℤ) (v : FiberHom q H₁ H₂ n) :
+    fiberHomRhoPair q H₁ H₂ n v = middleHomEquiv q H₁ H₂ n
+      (TriangleGradedSequence.first k (fiberEvaluationTriangle q H₁ H₂)
+        (simpleHomotopyObject q) n v) := by
+  rw [fiberSequenceFirst]
+  exact (middleHomEquiv_inclusion q H₁ H₂ n v).symm
+
+theorem fiberRhoPair_bijective_of_first (n : ℤ)
+    (hf : Function.Bijective (TriangleGradedSequence.first k
+      (fiberEvaluationTriangle q H₁ H₂) (simpleHomotopyObject q) n)) :
+    Function.Bijective (fiberHomRhoPair q H₁ H₂ n) := by
+  have hmap : (fiberHomRhoPair q H₁ H₂ n : FiberHom q H₁ H₂ n → _) =
+      (middleHomEquiv q H₁ H₂ n) ∘
+        (TriangleGradedSequence.first k (fiberEvaluationTriangle q H₁ H₂)
+          (simpleHomotopyObject q) n) := funext (fiberRhoPair_eq_first q H₁ H₂ n)
+  rw [hmap]
+  exact (middleHomEquiv q H₁ H₂ n).bijective.comp hf
+
+theorem fiberFullRhoPair_bijective_of_rho (n : ℤ)
+    (hf : Function.Bijective (fiberHomRhoPair q H₁ H₂ n)) :
+    Function.Bijective (fiberFullRhoPair q H₁ H₂ n) :=
+  ((simpleFullHomEquiv q n).symm.prodCongr (simpleFullHomEquiv q n).symm).bijective.comp
+    (hf.comp (fiberFullHomEquiv q H₁ H₂ n).bijective)
+
+end ArExplicit.T
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/FiniteEvaluatedFiber.lean

@@ -0,0 +1,115 @@
+import OAI.Algebra.AuslanderReiten.Modules.FiniteModuleEvaluation
+import OAI.Algebra.AuslanderReiten.Fibers.FiniteFiberSides
+import OAI.Algebra.AuslanderReiten.Stable.StableProjectiveSummand
+import OAI.Algebra.AuslanderReiten.Tensor.EnvelopingBalancedProduct
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.FiniteLeftModule
+open CategoryTheory CategoryTheory.Pretriangulated
+open scoped TensorProduct
+universe u
+variable {k S : Type u} [Field k] [Ring S] [Algebra k S] [Module.Finite k S]
+
+def pairModule (U V : FiniteLeftModule k S) : FiniteLeftModule k S where
+  carrier := ModuleCat.of S (U.carrier × V.carrier)
+  scalar := inferInstance
+  tower := inferInstance
+  finite := inferInstance
+
+variable (U V Y : FiniteLeftModule k S)
+
+def fiberReassociate : (fiberSource U V Y).carrier ≃ₗ[S]
+    ((pairModule U V).carrier × Y.canonicalFreeCover.carrier) where
+  toFun z := ((z.1, z.2.1), z.2.2)
+  invFun z := (z.1.1, z.1.2, z.2)
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+def fiberPairProjection : (fiberSource U V Y).carrier →ₗ[S] (pairModule U V).carrier :=
+  (LinearMap.fst S U.carrier (V.carrier × Y.canonicalFreeCover.carrier)).prod
+    ((LinearMap.fst S V.carrier Y.canonicalFreeCover.carrier).comp
+      (LinearMap.snd S U.carrier (V.carrier × Y.canonicalFreeCover.carrier)))
+
+def fiberPairStableIso : StableIsomorphism S (fiberSource U V Y).carrier (pairModule U V).carrier := by
+  letI := Y.canonicalFreeCover_projective
+  letI := Y.canonicalFreeCover_finite
+  exact (StableIsomorphism.ofLinearEquiv (fiberReassociate U V Y)).trans
+    (StableIsomorphism.dropRight (R := S))
+
+@[simp] theorem fiberPairStableIso_hom : (fiberPairStableIso U V Y).hom =
+    StableHom.classOf S _ _ (fiberPairProjection U V Y) := by
+  change StableHom.comp (StableHom.classOf S _ _ (LinearMap.fst S _ _))
+    (StableHom.classOf S _ _ (fiberReassociate U V Y).toLinearMap) = _
+  rw [StableHom.comp_classOf]
+  rfl
+
+section Evaluation
+variable {R : Type u} [Ring R] [Algebra k R] [Module.Finite k R]
+variable (X : FiniteLeftModule k R)
+variable (U₁ U₂ Y₀ : FiniteLeftModule k (R ⊗[k] Rᵐᵒᵖ))
+
+def evaluatedPairEquiv : (evaluated X (pairModule U₁ U₂)).carrier ≃ₗ[R]
+    ((evaluated X U₁).carrier × (evaluated X U₂).carrier) :=
+  EnvelopingBimodule.tensorProdEquiv U₁.carrier U₂.carrier X.carrier
+
+def middlePairMap : (evaluated X (fiberSource U₁ U₂ Y₀)).carrier →ₗ[R]
+    ((evaluated X U₁).carrier × (evaluated X U₂).carrier) :=
+  (evaluatedPairEquiv X U₁ U₂).toLinearMap.comp
+    (evaluationMap X (fiberPairProjection U₁ U₂ Y₀))
+
+def evaluatedMiddleStableIso : StableIsomorphism R
+    (evaluated X (fiberSource U₁ U₂ Y₀)).carrier
+    ((evaluated X U₁).carrier × (evaluated X U₂).carrier) :=
+  (evaluationStableIso X (fiberPairStableIso U₁ U₂ Y₀)).trans
+    (StableIsomorphism.ofLinearEquiv (evaluatedPairEquiv X U₁ U₂))
+
+@[simp] theorem evaluatedMiddleStableIso_hom : (evaluatedMiddleStableIso X U₁ U₂ Y₀).hom =
+    StableHom.classOf R _ _ (middlePairMap X U₁ U₂ Y₀) := by
+  change StableHom.comp (StableHom.classOf R _ _ (evaluatedPairEquiv X U₁ U₂).toLinearMap)
+    (EnvelopingBimodule.stableEvaluation X.carrier (fiberPairStableIso U₁ U₂ Y₀).hom) = _
+  rw [fiberPairStableIso_hom, EnvelopingBimodule.stableEvaluation_classOf]
+  erw [StableHom.comp_classOf]
+
+variable (g₁ : U₁.carrier ⟶ Y₀.carrier) (g₂ : U₂.carrier ⟶ Y₀.carrier)
+
+theorem middlePairMap_fiberInclusion :
+    (middlePairMap X U₁ U₂ Y₀).comp
+      (evaluationMap X (fiberInclusion U₁ U₂ Y₀ g₁ g₂).hom) =
+    (evaluationMap X (fiberProjection₁ U₁ U₂ Y₀ g₁ g₂).hom).prod
+      (evaluationMap X (fiberProjection₂ U₁ U₂ Y₀ g₁ g₂).hom) := by
+  apply BalancedTensor.leftHom_ext (k := k) (R := R)
+  intro m x
+  rfl
+
+theorem fiberFunctionExact : Function.Exact
+    (fiberInclusion U₁ U₂ Y₀ g₁ g₂).hom (fiberMap U₁ U₂ Y₀ g₁ g₂).hom := by
+  intro x
+  constructor
+  · intro hx
+    exact ⟨⟨x, hx⟩, rfl⟩
+  · rintro ⟨x, rfl⟩
+    exact x.property
+
+variable [Module.Projective Rᵐᵒᵖ (EnvelopingBimodule k R Y₀.carrier)]
+
+def evaluatedFiberTriangle (τ : FrobeniusTrace k R) :
+    Triangle (HomotopyCategory (ModuleCat.{u} R) (ComplexShape.up ℤ)) :=
+  evaluationTriangle X (fiberInclusion U₁ U₂ Y₀ g₁ g₂).hom (fiberMap U₁ U₂ Y₀ g₁ g₂).hom
+    Subtype.val_injective (fiberMap_surjective U₁ U₂ Y₀ g₁ g₂)
+    (fiberFunctionExact U₁ U₂ Y₀ g₁ g₂) τ
+
+ theorem evaluatedFiberTriangle_distinguished (τ : FrobeniusTrace k R) :
+    evaluatedFiberTriangle X U₁ U₂ Y₀ g₁ g₂ τ ∈
+      distTriang (HomotopyCategory (ModuleCat.{u} R) (ComplexShape.up ℤ)) :=
+  evaluationTriangle_distinguished _ _ _ _ _ _ _
+
+end Evaluation
+end ArExplicit.FiniteLeftModule
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/FiniteFiberComponents.lean

@@ -0,0 +1,74 @@
+import OAI.Algebra.AuslanderReiten.Fibers.FiniteEvaluatedFiber
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.FiniteLeftModule
+open CategoryTheory
+open scoped TensorProduct
+universe u
+variable {k S : Type u} [Field k] [Ring S] [Algebra k S] [Module.Finite k S]
+variable (U V Y : FiniteLeftModule k S)
+
+def fiberSourceInl : U.carrier →ₗ[S] (fiberSource U V Y).carrier :=
+  (LinearMap.id : U.carrier →ₗ[S] U.carrier).prod (0 : U.carrier →ₗ[S] V.carrier × Y.canonicalFreeCover.carrier)
+
+def fiberSourceInr : V.carrier →ₗ[S] (fiberSource U V Y).carrier :=
+  (0 : V.carrier →ₗ[S] U.carrier).prod
+    ((LinearMap.id : V.carrier →ₗ[S] V.carrier).prod (0 : V.carrier →ₗ[S] Y.canonicalFreeCover.carrier))
+
+theorem fiberMap_inl (g : U.carrier ⟶ Y.carrier) (h : V.carrier ⟶ Y.carrier) :
+    (fiberMap U V Y g h).hom.comp (fiberSourceInl U V Y) = g.hom := by
+  ext x
+  change g.hom x + (h.hom 0 + Y.canonicalFreeCoverMap.hom 0) = g.hom x
+  simp
+
+theorem fiberMap_inr (g : U.carrier ⟶ Y.carrier) (h : V.carrier ⟶ Y.carrier) :
+    (fiberMap U V Y g h).hom.comp (fiberSourceInr U V Y) = h.hom := by
+  ext x
+  change g.hom 0 + (h.hom x + Y.canonicalFreeCoverMap.hom 0) = h.hom x
+  simp
+
+section Evaluation
+variable {R : Type u} [Ring R] [Algebra k R] [Module.Finite k R]
+variable (X : FiniteLeftModule k R)
+variable (U₁ U₂ Y₀ : FiniteLeftModule k (R ⊗[k] Rᵐᵒᵖ))
+
+theorem middlePairMap_inl :
+    (middlePairMap X U₁ U₂ Y₀).comp
+      (evaluationMap X (fiberSourceInl U₁ U₂ Y₀)) =
+        LinearMap.inl R (evaluated X U₁).carrier (evaluated X U₂).carrier := by
+  apply BalancedTensor.leftHom_ext (k := k)
+  intro m x
+  change (BalancedTensor.tmul (k := k) (R := R) m x,
+    BalancedTensor.tmul (k := k) (R := R) (0 : EnvelopingBimodule k R U₂.carrier) x) =
+      (BalancedTensor.tmul (k := k) (R := R) m x, 0)
+  rw [BalancedTensor.zero_tmul]
+
+theorem middlePairMap_inr :
+    (middlePairMap X U₁ U₂ Y₀).comp
+      (evaluationMap X (fiberSourceInr U₁ U₂ Y₀)) =
+        LinearMap.inr R (evaluated X U₁).carrier (evaluated X U₂).carrier := by
+  apply BalancedTensor.leftHom_ext (k := k)
+  intro m x
+  change (BalancedTensor.tmul (k := k) (R := R) (0 : EnvelopingBimodule k R U₁.carrier) x,
+    BalancedTensor.tmul (k := k) (R := R) m x) =
+      (0, BalancedTensor.tmul (k := k) (R := R) m x)
+  rw [BalancedTensor.zero_tmul]
+
+theorem evaluatedFiberMap_inl (g : U₁.carrier ⟶ Y₀.carrier) (h : U₂.carrier ⟶ Y₀.carrier) :
+    (evaluationMap X (fiberMap U₁ U₂ Y₀ g h).hom).comp
+      (evaluationMap X (fiberSourceInl U₁ U₂ Y₀)) = evaluationMap X g.hom := by
+  rw [← evaluationMap_comp, fiberMap_inl]
+
+theorem evaluatedFiberMap_inr (g : U₁.carrier ⟶ Y₀.carrier) (h : U₂.carrier ⟶ Y₀.carrier) :
+    (evaluationMap X (fiberMap U₁ U₂ Y₀ g h).hom).comp
+      (evaluationMap X (fiberSourceInr U₁ U₂ Y₀)) = evaluationMap X h.hom := by
+  rw [← evaluationMap_comp, fiberMap_inr]
+
+end Evaluation
+end ArExplicit.FiniteLeftModule
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/FiniteFiberSides.lean

@@ -0,0 +1,99 @@
+import OAI.Algebra.AuslanderReiten.Fibers.FiniteModuleFiber
+import Mathlib.Algebra.Homology.ShortComplex.ModuleCat
+import Mathlib.RingTheory.Finiteness.Prod
+
+namespace OAI
+
+noncomputable section
+
+namespace ArExplicit.FiniteLeftModule
+
+open CategoryTheory
+
+universe u
+
+variable {k R S : Type u} [Field k] [Ring R] [Algebra k R] [Module.Finite k R]
+variable [Ring S] (j : S →+* R)
+variable (U₁ U₂ Y : FiniteLeftModule k R)
+
+def fiberSourceSideEquiv :
+    ((ModuleCat.restrictScalars j).obj (fiberSource U₁ U₂ Y).carrier) ≃ₗ[S]
+      (((ModuleCat.restrictScalars j).obj U₁.carrier) ×
+        ((ModuleCat.restrictScalars j).obj U₂.carrier) ×
+        ((ModuleCat.restrictScalars j).obj Y.canonicalFreeCover.carrier)) where
+  toFun x := x
+  invFun x := x
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+variable [Module.Finite S ((ModuleCat.restrictScalars j).obj (ModuleCat.of R R))]
+variable [Module.Projective S ((ModuleCat.restrictScalars j).obj (ModuleCat.of R R))]
+
+theorem canonicalFreeCover_side :
+    Module.Finite S ((ModuleCat.restrictScalars j).obj Y.canonicalFreeCover.carrier) ∧
+      Module.Projective S ((ModuleCat.restrictScalars j).obj Y.canonicalFreeCover.carrier) := by
+  let := canonicalFreeCover_finite Y
+  let := canonicalFreeCover_projective Y
+  exact ⟨restrict_finite j _, restrict_projective j _⟩
+
+variable [Module.Finite S ((ModuleCat.restrictScalars j).obj U₁.carrier)]
+variable [Module.Projective S ((ModuleCat.restrictScalars j).obj U₁.carrier)]
+variable [Module.Finite S ((ModuleCat.restrictScalars j).obj U₂.carrier)]
+variable [Module.Projective S ((ModuleCat.restrictScalars j).obj U₂.carrier)]
+
+theorem fiberSource_side :
+    Module.Finite S ((ModuleCat.restrictScalars j).obj (fiberSource U₁ U₂ Y).carrier) ∧
+      Module.Projective S ((ModuleCat.restrictScalars j).obj (fiberSource U₁ U₂ Y).carrier) := by
+  obtain ⟨hfin, hproj⟩ := canonicalFreeCover_side j Y
+  let := hfin
+  let := hproj
+  exact ⟨Module.Finite.equiv (fiberSourceSideEquiv j U₁ U₂ Y).symm,
+    Module.Projective.of_equiv (fiberSourceSideEquiv j U₁ U₂ Y).symm⟩
+
+theorem fiber_side [Module.Projective S ((ModuleCat.restrictScalars j).obj Y.carrier)]
+    (g₁ : U₁.carrier ⟶ Y.carrier) (g₂ : U₂.carrier ⟶ Y.carrier) :
+    Module.Finite S ((ModuleCat.restrictScalars j).obj (fiber U₁ U₂ Y g₁ g₂).carrier) ∧
+      Module.Projective S ((ModuleCat.restrictScalars j).obj (fiber U₁ U₂ Y g₁ g₂).carrier) := by
+  obtain ⟨hfin, hproj⟩ := fiberSource_side j U₁ U₂ Y
+  let := hfin
+  let := hproj
+  exact ⟨kernel_restrict_finite j (fiberMap U₁ U₂ Y g₁ g₂)
+      (fiberMap_surjective U₁ U₂ Y g₁ g₂),
+    kernel_restrict_projective j (fiberMap U₁ U₂ Y g₁ g₂)
+      (fiberMap_surjective U₁ U₂ Y g₁ g₂)⟩
+
+variable (g₁ : U₁.carrier ⟶ Y.carrier) (g₂ : U₂.carrier ⟶ Y.carrier)
+
+def fiberInclusion : (fiber U₁ U₂ Y g₁ g₂).carrier ⟶ (fiberSource U₁ U₂ Y).carrier :=
+  ModuleCat.ofHom (LinearMap.ker (fiberMap U₁ U₂ Y g₁ g₂).hom).subtype
+
+def fiberProjection₁ : (fiber U₁ U₂ Y g₁ g₂).carrier ⟶ U₁.carrier :=
+  fiberInclusion U₁ U₂ Y g₁ g₂ ≫ ModuleCat.ofHom (LinearMap.fst R _ _)
+
+def fiberProjection₂ : (fiber U₁ U₂ Y g₁ g₂).carrier ⟶ U₂.carrier :=
+  fiberInclusion U₁ U₂ Y g₁ g₂ ≫ ModuleCat.ofHom
+    ((LinearMap.fst R _ _).comp (LinearMap.snd R _ _))
+
+def fiberSequence : ShortComplex (ModuleCat.{u} R) :=
+  ShortComplex.mk (fiberInclusion U₁ U₂ Y g₁ g₂) (fiberMap U₁ U₂ Y g₁ g₂) (by
+    ext x
+    exact x.property)
+
+theorem fiberSequence_shortExact : (fiberSequence U₁ U₂ Y g₁ g₂).ShortExact where
+  exact := (ShortComplex.ShortExact.moduleCat_exact_iff_function_exact _).mpr (by
+    intro x
+    constructor
+    · intro hx
+      exact ⟨⟨x, hx⟩, rfl⟩
+    · rintro ⟨y, rfl⟩
+      exact y.property)
+  mono_f := (ModuleCat.mono_iff_injective _).mpr Subtype.val_injective
+  epi_g := (ModuleCat.epi_iff_surjective _).mpr (fiberMap_surjective U₁ U₂ Y g₁ g₂)
+
+end ArExplicit.FiniteLeftModule
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/FiniteModuleFiber.lean

@@ -0,0 +1,96 @@
+import OAI.Algebra.AuslanderReiten.Stable.CanonicalCosyzygy
+import Mathlib.LinearAlgebra.TensorProduct.Basis
+import Mathlib.LinearAlgebra.FreeModule.Finite.Basic
+import Mathlib.RingTheory.TensorProduct.Finite
+
+namespace OAI
+
+noncomputable section
+
+namespace ArExplicit.FiniteLeftModule
+
+open CategoryTheory
+open scoped TensorProduct
+
+universe u
+
+variable {k R : Type u} [Field k] [Ring R] [Algebra k R] [Module.Finite k R]
+
+def canonicalFreeCover (Y : FiniteLeftModule k R) : FiniteLeftModule k R where
+  carrier := ModuleCat.of R (R ⊗[k] Y.carrier)
+  scalar := inferInstance
+  tower := inferInstance
+  finite := inferInstanceAs (Module.Finite k (R ⊗[k] Y.carrier))
+
+private def freeCoverMapScalar (Y : FiniteLeftModule k R) : R ⊗[k] Y.carrier →ₗ[k] Y.carrier :=
+  TensorProduct.lift
+    { toFun := fun r =>
+        { toFun := fun y => r • y
+          map_add' := smul_add r
+          map_smul' := fun a y => by
+            rw [← IsScalarTower.algebraMap_smul R a y, ← mul_smul,
+              ← Algebra.commutes, mul_smul, IsScalarTower.algebraMap_smul]
+            rfl }
+      map_add' := fun r s => by ext y; exact add_smul r s y
+      map_smul' := fun a r => by ext y; exact smul_assoc a r y }
+
+def canonicalFreeCoverMap (Y : FiniteLeftModule k R) : Y.canonicalFreeCover.carrier ⟶ Y.carrier :=
+  ModuleCat.ofHom
+    { __ := (freeCoverMapScalar Y).toAddHom
+      map_smul' r z := by
+        change freeCoverMapScalar Y (r • z) = r • freeCoverMapScalar Y z
+        induction z using TensorProduct.inductionOn with
+        | add x y hx hy => simp [smul_add, hx, hy]
+        | tmul s y => exact mul_smul r s y }
+
+@[simp] theorem canonicalFreeCoverMap_tmul (Y : FiniteLeftModule k R) (r : R) (y : Y.carrier) :
+    Y.canonicalFreeCoverMap.hom (r ⊗ₜ[k] y) = r • y := rfl
+
+theorem canonicalFreeCoverMap_surjective (Y : FiniteLeftModule k R) :
+    Function.Surjective Y.canonicalFreeCoverMap.hom := by
+  intro y
+  exact ⟨1 ⊗ₜ[k] y, one_smul R y⟩
+
+theorem canonicalFreeCover_finite (Y : FiniteLeftModule k R) :
+    Module.Finite R Y.canonicalFreeCover.carrier :=
+  Module.Finite.of_basis ((Module.finBasis k Y.carrier).baseChange R)
+
+theorem canonicalFreeCover_projective (Y : FiniteLeftModule k R) :
+    Module.Projective R Y.canonicalFreeCover.carrier := by
+  change Module.Projective R (R ⊗[k] Y.carrier)
+  infer_instance
+
+variable (U₁ U₂ Y : FiniteLeftModule k R)
+
+def fiberSource : FiniteLeftModule k R where
+  carrier := ModuleCat.of R (U₁.carrier × U₂.carrier × Y.canonicalFreeCover.carrier)
+  scalar := inferInstance
+  tower := inferInstance
+  finite := inferInstance
+
+def fiberMap (g₁ : U₁.carrier ⟶ Y.carrier) (g₂ : U₂.carrier ⟶ Y.carrier) :
+    (fiberSource U₁ U₂ Y).carrier ⟶ Y.carrier :=
+  ModuleCat.ofHom (g₁.hom.coprod (g₂.hom.coprod Y.canonicalFreeCoverMap.hom))
+
+theorem fiberMap_surjective (g₁ : U₁.carrier ⟶ Y.carrier) (g₂ : U₂.carrier ⟶ Y.carrier) :
+    Function.Surjective (fiberMap U₁ U₂ Y g₁ g₂).hom := by
+  intro y
+  obtain ⟨z, hz⟩ := canonicalFreeCoverMap_surjective Y y
+  refine ⟨(0, 0, z), ?_⟩
+  change g₁.hom 0 + (g₂.hom 0 + Y.canonicalFreeCoverMap.hom z) = y
+  simpa using hz
+
+def fiber (g₁ : U₁.carrier ⟶ Y.carrier) (g₂ : U₂.carrier ⟶ Y.carrier) : FiniteLeftModule k R where
+  carrier := kernelObject (fiberMap U₁ U₂ Y g₁ g₂)
+  scalar := inferInstanceAs (Module k (LinearMap.ker (fiberMap U₁ U₂ Y g₁ g₂).hom))
+  tower := inferInstanceAs (IsScalarTower k R (LinearMap.ker (fiberMap U₁ U₂ Y g₁ g₂).hom))
+  finite := by
+    change Module.Finite k (LinearMap.ker (fiberMap U₁ U₂ Y g₁ g₂).hom)
+    exact Module.Finite.of_injective
+      (((LinearMap.ker (fiberMap U₁ U₂ Y g₁ g₂).hom).subtype).restrictScalars k) Subtype.val_injective
+
+end ArExplicit.FiniteLeftModule
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/Fibers/TensorFiberCoordinateIso.lean

@@ -0,0 +1,28 @@
+import OAI.Algebra.AuslanderReiten.Evaluation.ConcreteTensorFiber
+
+namespace OAI
+
+noncomputable section
+open CochainComplex.HomComplex
+open scoped ModuleCat.Algebra
+namespace ArExplicit.T
+universe u
+variable {k : Type u} [Field k] [CharP k 2] (q : k) (H₁ H₂ : kˣ)
+
+def tensorFiberRhoEquiv (n : ℤ) (h : Function.Bijective (fiberFullRhoPair q H₁ H₂ n)) :
+    CohomologyClass (A.simpleComplete q) (tensorFiberComplete q H₁ H₂) n ≃ₗ[k]
+      (CohomologyClass (A.simpleComplete q) (A.simpleComplete q) n ×
+        CohomologyClass (A.simpleComplete q) (A.simpleComplete q) n) :=
+  (tensorFiberFullEquiv q H₁ H₂ n).trans
+    (LinearEquiv.ofBijective (fiberFullRhoPair q H₁ H₂ n) h)
+
+theorem tensorFiberRhoEquiv_apply (n : ℤ)
+    (h : Function.Bijective (fiberFullRhoPair q H₁ H₂ n))
+    (x : CohomologyClass (A.simpleComplete q) (tensorFiberComplete q H₁ H₂) n) :
+    tensorFiberRhoEquiv q H₁ H₂ n h x = tensorFiberRhoPair q H₁ H₂ n x := rfl
+
+end ArExplicit.T
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FiniteFullHomExt.lean

@@ -0,0 +1,45 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FiniteFullHomZero
+import OAI.Algebra.AuslanderReiten.HomComplex.PositiveFullHomProducts
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomDegreeProducts
+import OAI.Algebra.AuslanderReiten.Ext.ExtIsoCongr
+
+namespace OAI
+
+noncomputable section
+open CategoryTheory CategoryTheory.Abelian
+open CochainComplex CochainComplex.HomComplex
+open scoped ModuleCat.Algebra
+namespace ArExplicit.FiniteLeftModule
+universe u
+variable {k R : Type u} [Field k] [Ring R] [Algebra k R] [Module.Finite k R] [CharP k 2]
+variable [HasDerivedCategory (ModuleCat.{u} R)]
+open CompleteComparison
+variable (τ : FrobeniusTrace k R) (M : FiniteLeftModule k R)
+
+def fullPositiveModuleExtEquiv (n : ℕ) :
+    CohomologyClass (M.completeCochain τ) (M.completeCochain τ) ((n+1:ℕ):ℤ) ≃ₗ[k]
+      Ext M.carrier M.carrier (n+1) :=
+  (fullPositiveExtEquiv (k := k) _ _ (M.completeCochain_totallyAcyclic τ).to_chain
+    (M.completeCochain_totallyAcyclic τ).to_chain.toExactProjectiveComplex n).trans
+      (selfExtIso (k := k) (M.fullCokernelEquiv τ).toModuleIso (n+1))
+
+theorem fullPositiveModuleExtEquiv_product (n m : ℕ)
+    (x : CohomologyClass (M.completeCochain τ) (M.completeCochain τ) ((n+1:ℕ):ℤ))
+    (y : CohomologyClass (M.completeCochain τ) (M.completeCochain τ) ((m+1:ℕ):ℤ)) :
+    fullPositiveModuleExtEquiv τ M (n+1+m)
+      (TateKoszul.degreeEquiv (k := k) (CohomologyClass (M.completeCochain τ) (M.completeCochain τ))
+        (show ((n+1:ℕ):ℤ)+((m+1:ℕ):ℤ)=((n+1+m+1:ℕ):ℤ) by omega) (fullHomProduct x y)) =
+      (fullPositiveModuleExtEquiv τ M n x).comp (fullPositiveModuleExtEquiv τ M m y) (by omega) := by
+  obtain ⟨x,rfl⟩ := CohomologyClass.mk_surjective x
+  obtain ⟨y,rfl⟩ := CohomologyClass.mk_surjective y
+  rw [fullHomProduct_degree_mk _ x y (ResolutionProducts.natCocycleProduct x y) rfl]
+  change selfExtIso _ _ (fullPositiveExtEquiv _ _ _ _ _ _) =
+    (selfExtIso _ _ (fullPositiveExtEquiv _ _ _ _ _ _)).comp
+      (selfExtIso _ _ (fullPositiveExtEquiv _ _ _ _ _ _)) _
+  rw [← selfExtIso_comp, fullPositiveExtEquiv_product]
+
+end ArExplicit.FiniteLeftModule
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FiniteFullHomZero.lean

@@ -0,0 +1,107 @@
+import OAI.Algebra.AuslanderReiten.Stable.SourceStableCoordinates
+import OAI.Algebra.AuslanderReiten.Modules.FiniteModuleTriangle
+
+namespace OAI
+
+noncomputable section
+open CategoryTheory HomologicalComplex
+open CochainComplex CochainComplex.HomComplex
+open scoped ModuleCat.Algebra
+namespace ArExplicit
+universe u
+variable {k R : Type u} [Field k] [Ring R] [Algebra k R] [CharP k 2]
+
+namespace CompleteComparison
+variable {K L : CochainComplex (ModuleCat.{u} R) ℤ}
+
+include k in
+theorem sourceCocycleMap_ofHom (f : K ⟶ L) :
+    sourceCocycleMap (Cocycle.ofHom f) = cokernelMap (extendMap f negIndexEmbedding) 0 := by
+  apply LinearMap.ext
+  intro z
+  obtain ⟨x, rfl⟩ := (LinearMap.range ((chainOfCochain K).d 1 0).hom).mkQ_surjective z
+  change sourceCocycleMap (Cocycle.ofHom f) (Submodule.Quotient.mk x) = _
+  rw [sourceCocycleMap_mk (k := k)]
+  change Submodule.Quotient.mk ((sourceCocycleComponent (Cocycle.ofHom f)).hom x) =
+    Submodule.Quotient.mk (((extendMap f negIndexEmbedding).f 0).hom x)
+  congr 2
+  unfold sourceCocycleComponent
+  rw [extendMap_f f negIndexEmbedding (show negIndexEmbedding.f 0 = 0 from rfl)]
+  rfl
+
+end CompleteComparison
+
+namespace FiniteLeftModule
+open CompleteComparison
+variable [Module.Finite k R] (τ : FrobeniusTrace k R) (M N : FiniteLeftModule k R)
+
+def fullCokernelEquiv : Cokernel (chainOfCochain (M.completeCochain τ)) 0 ≃ₗ[R] M.carrier :=
+  (cochainCokernelLinearEquiv _).trans (M.completeCochainCokernelEquiv τ)
+
+def fullHomZeroEquiv : CohomologyClass (M.completeCochain τ) (N.completeCochain τ) 0 ≃ₗ[k]
+    StableHom R M.carrier N.carrier :=
+  (fullHomSourceStableLinearEquiv _ _ 0 (M.completeCochain_totallyAcyclic τ).to_chain
+    (N.completeCochain_totallyAcyclic τ).to_chain.toExactProjectiveComplex).trans
+      ((StableHom.sourceEquiv (k := k) (M.fullCokernelEquiv τ).symm).trans
+        (StableHom.targetEquiv (k := k) (N.fullCokernelEquiv τ)))
+
+theorem fullHomZeroEquiv_ofHom (f : M.completeCochain τ ⟶ N.completeCochain τ) :
+    fullHomZeroEquiv τ M N (CohomologyClass.mk (Cocycle.ofHom f)) =
+      StableHom.classOf R _ _ ((N.completeCochainCokernelEquiv τ).toLinearMap.comp
+        ((cochainCokernelMap f).comp (M.completeCochainCokernelEquiv τ).symm.toLinearMap)) := by
+  change StableHom.targetEquiv (k := k) (N.fullCokernelEquiv τ)
+    (StableHom.sourceEquiv (k := k) (M.fullCokernelEquiv τ).symm
+      (fullHomSourceStableLinearEquiv _ _ 0
+        (M.completeCochain_totallyAcyclic τ).to_chain
+        (N.completeCochain_totallyAcyclic τ).to_chain.toExactProjectiveComplex
+        (CohomologyClass.mk (Cocycle.ofHom f)))) = _
+  rw [fullHomSourceStableLinearEquiv_mk, sourceCocycleMap_ofHom (k := k),
+    StableHom.sourceEquiv_classOf, StableHom.targetEquiv_classOf]
+  congr 1
+  apply LinearMap.ext
+  intro x
+  have h := DFunLike.congr_fun (cochainCokernelLinearEquiv_natural f)
+    ((M.fullCokernelEquiv τ).symm x)
+  change (cochainCokernelLinearEquiv _) (cokernelMap (extendMap f negIndexEmbedding) 0
+    ((M.fullCokernelEquiv τ).symm x)) = cochainCokernelMap f
+      ((cochainCokernelLinearEquiv _) ((M.fullCokernelEquiv τ).symm x)) at h
+  change (N.completeCochainCokernelEquiv τ)
+    ((cochainCokernelLinearEquiv _) (cokernelMap (extendMap f negIndexEmbedding) 0
+      ((M.fullCokernelEquiv τ).symm x))) = _
+  rw [h]
+  simp only [fullCokernelEquiv, LinearEquiv.trans_symm, LinearEquiv.trans_apply,
+    LinearEquiv.apply_symm_apply, LinearMap.comp_apply, LinearEquiv.coe_coe]
+
+@[simp]
+theorem fullHomZeroEquiv_lift (f : M.carrier →ₗ[R] N.carrier) :
+    fullHomZeroEquiv τ M N (CohomologyClass.mk (Cocycle.ofHom (resolutionMap τ f))) =
+      StableHom.classOf R _ _ f := by
+  rw [fullHomZeroEquiv_ofHom, resolutionMap_cokernel]
+  congr 1
+  ext x
+  simp [resolutionCokernelMap]
+
+@[simp]
+theorem fullHomZeroEquiv_identity :
+    fullHomZeroEquiv τ M M (CohomologyClass.mk (Cocycle.ofHom (𝟙 (M.completeCochain τ)))) =
+      StableHom.identity := by
+  rw [fullHomZeroEquiv_ofHom]
+  change StableHom.classOf R _ _ _ = StableHom.classOf R _ _ LinearMap.id
+  congr 1
+  ext x
+  change (M.completeCochainCokernelEquiv τ)
+    (cochainCokernelMap (𝟙 _) ((M.completeCochainCokernelEquiv τ).symm x)) = x
+  have hid : cochainCokernelMap (𝟙 (M.completeCochain τ)) = LinearMap.id := by
+    apply LinearMap.ext
+    intro z
+    obtain ⟨y, rfl⟩ := (LinearMap.range ((M.completeCochain τ).d (-1) 0).hom).mkQ_surjective z
+    rfl
+  rw [hid]
+  exact LinearEquiv.apply_symm_apply _ _
+
+end FiniteLeftModule
+end ArExplicit
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullCochainProducts.lean

@@ -0,0 +1,79 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullCochainTail
+
+namespace OAI
+
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+open CochainComplex CochainComplex.HomComplex
+namespace ArExplicit.CompleteComparison
+universe u
+variable {k R : Type u} [Field k] [Ring R] [Algebra k R] [CharP k 2]
+attribute [local instance] moduleCatBaseModule moduleCatBaseTower
+variable (K : CochainComplex (ModuleCat.{u} R) ℤ)
+variable (hK : TotallyAcyclicComplex (chainOfCochain K))
+
+private theorem tailPrefix_congr {r : ℤ} (x : Cochain K K r) (p q : ℤ)
+    (a b : ℕ) (hab : a=b) (ha : -(a : ℤ)=p) (hb : -(b : ℤ)=p)
+    (hxa : -(a : ℤ)+r=q) (hxb : -(b : ℤ)+r=q) :
+    ((completeExtResolution hK).cochainComplexXIso p a ha).hom ≫
+      (tailTermIso K a).hom ≫ x.v (-(a : ℤ)) q hxa =
+    ((completeExtResolution hK).cochainComplexXIso p b hb).hom ≫
+      (tailTermIso K b).hom ≫ x.v (-(b : ℤ)) q hxb := by
+  subst b
+  rfl
+
+theorem restrictedCocycle_product {r s : ℕ}
+    (x : Cocycle K K (r : ℤ)) (y : Cocycle K K (s : ℤ)) :
+    restrictedCocycle (k := k) K K hK hK.toExactProjectiveComplex (r+s)
+      (ResolutionProducts.natCocycleProduct x y) =
+      ResolutionProducts.natCocycleProduct
+        (restrictedCocycle (k := k) K K hK hK.toExactProjectiveComplex r x)
+        (restrictedCocycle (k := k) K K hK hK.toExactProjectiveComplex s y) := by
+  change ↥(cocycle K K (r : ℤ)) at x
+  change ↥(cocycle K K (s : ℤ)) at y
+  apply Subtype.ext
+  apply Cochain.ext
+  intro p q hpq
+  by_cases hq : q ≤ 0
+  · obtain ⟨n,rfl⟩ := Int.exists_eq_neg_ofNat hq
+    change (ResolutionProducts.natComparisonCochain _ _ (r+s) _).v _ _ _ = _
+    erw [ResolutionProducts.natComparisonCochain_v_of_eq]
+    erw [Cochain.comp_v _ _ _ _ (-((s+n : ℕ) : ℤ)) _ (by omega) (by omega)]
+    change _ =
+      (ResolutionProducts.natComparisonCochain _ _ r _).v _ _ _ ≫
+        (ResolutionProducts.natComparisonCochain _ _ s _).v _ _ _
+    erw [ResolutionProducts.natComparisonCochain_v_of_eq,
+      ResolutionProducts.natComparisonCochain_v_of_eq]
+    simp only [cochainTailMap, ResolutionProducts.natCocycleProduct,
+      Cocycle.mk]
+    try simp only [Nat.add_assoc]
+    erw [Cochain.comp_v _ _ _ _ (-((s+n : ℕ) : ℤ)) _ (by omega) (by omega)]
+    all_goals try omega
+    let P := completeExtResolution hK
+    let a := P.cochainComplexXIso p (r+(s+n)) (by omega)
+    let b : P.complex.X (r+(s+n)) ≅ K.X (-((r+(s+n) : ℕ) : ℤ)) := tailTermIso K (r+(s+n))
+    let c : P.complex.X (s+n) ≅ K.X (-((s+n : ℕ) : ℤ)) := tailTermIso K (s+n)
+    let d := P.cochainComplexXIso (-((s+n : ℕ) : ℤ)) (s+n) rfl
+    let e : P.complex.X n ≅ K.X (-(n : ℤ)) := tailTermIso K n
+    let f := P.cochainComplexXIso (-(n : ℤ)) n rfl
+    let xv := x.val.v (-((r+(s+n) : ℕ) : ℤ)) (-((s+n : ℕ) : ℤ)) (by omega)
+    let yv := y.val.v (-((s+n : ℕ) : ℤ)) (-(n : ℤ)) (by omega)
+    have hh : a.hom ≫ (b.hom ≫ xv ≫ yv ≫ e.inv) ≫ f.inv =
+        a.hom ≫ ((b.hom ≫ xv ≫ c.inv) ≫ d.inv) ≫ d.hom ≫
+          (c.hom ≫ yv ≫ e.inv) ≫ f.inv := by
+      simp only [Category.assoc, Iso.inv_hom_id_assoc]
+    convert! hh using 1
+    dsimp only [a, b, c, d, e, f, xv, yv, P]
+    have he := tailPrefix_congr K hK x.val p (-((s+n : ℕ) : ℤ))
+      (r+s+n) (r+(s+n)) (by omega) (by omega) (by omega) (by omega) (by omega)
+    have hh' := congrArg (fun z => (z ≫ yv ≫ e.inv) ≫ f.inv) he
+    exact hh'
+
+  · exact ((completeExtResolution hK).cochainComplex.isZero_of_isStrictlyLE 0 q
+      (by omega)).eq_of_tgt _ _
+
+end ArExplicit.CompleteComparison
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullCochainTail.lean

@@ -0,0 +1,73 @@
+import OAI.Algebra.AuslanderReiten.Resolutions.NatResolutionCochain
+import OAI.Algebra.AuslanderReiten.HomComplex.PositiveFullHomExt
+import OAI.Algebra.AuslanderReiten.Resolutions.ResolutionProductCompatibility
+
+namespace OAI
+
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+open CochainComplex CochainComplex.HomComplex
+namespace ArExplicit.CompleteComparison
+universe u
+variable {k R : Type u} [Field k] [Ring R] [Algebra k R] [CharP k 2]
+attribute [local instance] moduleCatBaseModule moduleCatBaseTower
+variable (K L : CochainComplex (ModuleCat.{u} R) ℤ)
+
+def tailTermIso (n : ℕ) :
+    (nonnegativeTail (chainOfCochain K)).X n ≅ K.X (-(n : ℤ)) :=
+  K.extendXIso negIndexEmbedding (by change -(-(n : ℤ))=(n : ℤ); omega)
+
+theorem tailTerm_d (i j : ℕ) (h : j+1=i) :
+    (nonnegativeTail (chainOfCochain K)).d i j =
+      (tailTermIso K i).hom ≫ K.d (-(i : ℤ)) (-(j : ℤ)) ≫ (tailTermIso K j).inv := by
+  subst i
+  rw [nonnegativeTail_d]
+  exact K.extend_d_eq negIndexEmbedding
+    (show negIndexEmbedding.f (-((j+1 : ℕ) : ℤ))=((j+1 : ℕ) : ℤ) by
+      change -(-((j+1 : ℕ) : ℤ))=((j+1 : ℕ) : ℤ); omega)
+    (show negIndexEmbedding.f (-(j : ℤ))=(j : ℤ) by change -(-(j : ℤ))=(j : ℤ); omega)
+
+def cochainTailMap (r : ℕ) (x : Cochain K L (r : ℤ)) (n : ℕ) :
+    (nonnegativeTail (chainOfCochain K)).X (r+n) ⟶
+      (nonnegativeTail (chainOfCochain L)).X n :=
+  (tailTermIso K (r+n)).hom ≫ x.v (-((r+n : ℕ) : ℤ)) (-(n : ℤ)) (by omega) ≫
+    (tailTermIso L n).inv
+
+include k in
+theorem cochainTailMap_comm (r : ℕ) (x : Cocycle K L (r : ℤ)) (n : ℕ) :
+    cochainTailMap K L r x.val (n+1) ≫ (nonnegativeTail (chainOfCochain L)).d (n+1) n =
+      (nonnegativeTail (chainOfCochain K)).d (r+(n+1)) (r+n) ≫ cochainTailMap K L r x.val n := by
+  let i : ℤ := -((r+(n+1) : ℕ) : ℤ)
+  let j : ℤ := -(n : ℤ)
+  have hx := congrArg (fun z : Cochain K L ((r : ℤ)+1) => z.v i j (by dsimp [i,j]; omega))
+    (show δ (r : ℤ) ((r : ℤ)+1) x.val=0 by simp)
+  rw [δ_v _ _ rfl _ _ _ (by dsimp [i,j]; omega)
+    (-((n+1 : ℕ) : ℤ)) (-((r+n : ℕ) : ℤ)) (by dsimp [i,j]; omega) (by dsimp [i,j]; omega),
+    ResolutionProducts.intUnit_smul_charTwo (k := k), Cochain.zero_v] at hx
+  let a := x.val.v i (-((n+1 : ℕ) : ℤ)) (by dsimp [i]; omega) ≫
+    L.d (-((n+1 : ℕ) : ℤ)) j
+  let b := K.d i (-((r+n : ℕ) : ℤ)) ≫
+    x.val.v (-((r+n : ℕ) : ℤ)) j (by dsimp [j]; omega)
+  have hab : a=b := by
+    have hb : b+b=0 := by
+      rw [← two_smul k b, show (2 : k)=0 from CharP.cast_eq_zero k 2, zero_smul]
+    exact (eq_neg_of_add_eq_zero_left hx).trans (eq_neg_iff_add_eq_zero.mpr hb).symm
+  rw [tailTerm_d L _ _ rfl, tailTerm_d K _ _ (by omega)]
+  simp only [cochainTailMap, Category.assoc, Iso.inv_hom_id_assoc]
+  exact congrArg (fun z => (tailTermIso K (r+(n+1))).hom ≫ z ≫ (tailTermIso L n).inv) hab
+
+variable (hK : TotallyAcyclicComplex (chainOfCochain K))
+variable (hL : ExactProjectiveComplex (chainOfCochain L))
+
+def restrictedCocycle (r : ℕ) (x : Cocycle K L (r : ℤ)) :
+    Cocycle (completeExtResolution hK).cochainComplex
+      (completeCokernelResolution (chainOfCochain L) hL.projective hL.exactAt).cochainComplex (r : ℤ) :=
+  ResolutionProducts.natComparisonCocycle (k := k) (completeExtResolution hK)
+    (completeCokernelResolution (chainOfCochain L) hL.projective hL.exactAt) r
+    (cochainTailMap K L r x.val) (cochainTailMap_comm (k := k) K L r x)
+
+end ArExplicit.CompleteComparison
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomAugmentedExt.lean

@@ -0,0 +1,30 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.PositiveFullHomProducts
+
+namespace OAI
+
+noncomputable section
+open CategoryTheory CategoryTheory.Abelian
+open CochainComplex CochainComplex.HomComplex
+namespace ArExplicit.CompleteComparison
+universe u
+variable {k R : Type u} [Field k] [Ring R] [Algebra k R] [CharP k 2]
+variable [HasDerivedCategory (ModuleCat.{u} R)]
+variable (K : CochainComplex (ModuleCat.{u} R) ℤ)
+variable (hK : TotallyAcyclicComplex (chainOfCochain K))
+
+theorem fullPositiveExtEquiv_augmented (n : ℕ) (x : Cocycle K K ((n+1 : ℕ) : ℤ)) :
+    fullPositiveExtEquiv (k := k) K K hK hK.toExactProjectiveComplex n (CohomologyClass.mk x) =
+    (completeExtResolution hK).extMk
+      (ResolutionProducts.natComparisonAugmentation (completeExtResolution hK) (n+1)
+        (cochainTailMap K K (n+1) x.val)) (n+2) rfl
+      (ResolutionProducts.natComparison_augmented_cycle (completeExtResolution hK) (n+1)
+        (cochainTailMap K K (n+1) x.val) (cochainTailMap_comm (k := k) K K (n+1) x)) := by
+  rw [fullPositiveExtEquiv_mk]
+  exact ResolutionProducts.natComparison_endExt_eq (completeExtResolution hK) (n+1)
+    (cochainTailMap K K (n+1) x.val) (cochainTailMap_comm (k := k) K K (n+1) x)
+
+end ArExplicit.CompleteComparison
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomComparison.lean

@@ -0,0 +1,57 @@
+import OAI.Algebra.AuslanderReiten.Complete.CompleteStableComparison
+import Mathlib.Algebra.Homology.Embedding.ExtendHomotopy
+import Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology
+
+namespace OAI
+
+open CategoryTheory
+
+namespace ArExplicit.CompleteComparison
+
+universe u
+
+variable {R : Type u} [Ring R]
+
+def negIndexEmbedding : (ComplexShape.up ℤ).Embedding (ComplexShape.down ℤ) :=
+  ComplexShape.Embedding.mk' _ _ (fun i : ℤ => -i) neg_injective (by
+    intro i j
+    change i + 1 = j ↔ -j + 1 = -i
+    omega)
+
+instance : negIndexEmbedding.IsRelIff := by
+  dsimp [negIndexEmbedding]
+  infer_instance
+
+noncomputable abbrev chainOfCochain (K : CochainComplex (ModuleCat.{u} R) ℤ) :=
+  K.extend negIndexEmbedding
+
+private instance negIndexFunctor_additive :
+    (negIndexEmbedding.extendHomotopyFunctor (ModuleCat.{u} R)).Additive := by
+  have := Functor.additive_of_iso
+    (negIndexEmbedding.extendHomotopyFunctorFactors (ModuleCat.{u} R)).symm
+  exact Functor.additive_of_full_essSurj_comp
+    (HomotopyCategory.quotient (ModuleCat.{u} R) (ComplexShape.up ℤ)) _
+
+noncomputable def fullHomStableEquiv
+    (K L : CochainComplex (ModuleCat.{u} R) ℤ) (n : ℤ)
+    (hK : TotallyAcyclicComplex (chainOfCochain K))
+    (hL : ExactProjectiveComplex (chainOfCochain (L⟦n⟧))) :
+    CochainComplex.HomComplex.CohomologyClass K L n ≃+
+      StableHom R (Cokernel (chainOfCochain K) 0) (Cokernel (chainOfCochain (L⟦n⟧)) 0) :=
+  CochainComplex.HomComplex.CohomologyClass.homAddEquiv.trans
+    ((AddEquiv.ofBijective
+      (Functor.mapAddHom (negIndexEmbedding.extendHomotopyFunctor (ModuleCat.{u} R)))
+      ⟨Functor.map_injective _, Functor.map_surjective _⟩).trans
+        (homotopyCokernelEquiv hK hL))
+
+theorem fullHomStableEquiv_eq_zero_iff
+    (K L : CochainComplex (ModuleCat.{u} R) ℤ) (n : ℤ)
+    (hK : TotallyAcyclicComplex (chainOfCochain K))
+    (hL : ExactProjectiveComplex (chainOfCochain (L⟦n⟧)))
+    (x : CochainComplex.HomComplex.CohomologyClass K L n) :
+    fullHomStableEquiv K L n hK hL x = 0 ↔ x = 0 :=
+  map_eq_zero_iff (fullHomStableEquiv K L n hK hL) (fullHomStableEquiv K L n hK hL).injective
+
+end ArExplicit.CompleteComparison
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomComposition.lean

@@ -0,0 +1,53 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomProducts
+
+namespace OAI
+
+noncomputable section
+
+namespace ArExplicit
+
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex
+
+variable {C : Type*} [Category* C] [Preadditive C]
+variable {F G K : CochainComplex C ℤ} (φ : F ⟶ G) (n : ℤ)
+
+def fullHomPrecompCocycle : Cocycle G K n →+ Cocycle F K n where
+  toFun x := x.precomp φ
+  map_zero' := by apply Cocycle.ext; simp
+  map_add' x y := by apply Cocycle.ext; simp
+
+def fullHomPostcompCocycle : Cocycle K F n →+ Cocycle K G n where
+  toFun x := x.postcomp φ
+  map_zero' := by apply Cocycle.ext; simp
+  map_add' x y := by apply Cocycle.ext; simp
+
+def fullHomPrecomp : CohomologyClass G K n →+ CohomologyClass F K n :=
+  CohomologyClass.descAddMonoidHom
+    ((CohomologyClass.mkAddMonoidHom _ _ _).comp (fullHomPrecompCocycle φ n)) (by
+      intro x hx
+      apply (CohomologyClass.mk_eq_zero_iff _).mpr
+      obtain ⟨m, hm, y, hy⟩ := hx
+      refine ⟨m, hm, (Cochain.ofHom φ).comp y (zero_add m), ?_⟩
+      simpa [fullHomPrecompCocycle] using congrArg (fun z => (Cochain.ofHom φ).comp z (zero_add n)) hy)
+
+def fullHomPostcomp : CohomologyClass K F n →+ CohomologyClass K G n :=
+  CohomologyClass.descAddMonoidHom
+    ((CohomologyClass.mkAddMonoidHom _ _ _).comp (fullHomPostcompCocycle φ n)) (by
+      intro x hx
+      apply (CohomologyClass.mk_eq_zero_iff _).mpr
+      obtain ⟨m, hm, y, hy⟩ := hx
+      refine ⟨m, hm, y.comp (Cochain.ofHom φ) (add_zero m), ?_⟩
+      simpa [fullHomPostcompCocycle] using congrArg (fun z => z.comp (Cochain.ofHom φ) (add_zero n)) hy)
+
+@[simp] theorem fullHomPrecomp_mk (x : Cocycle G K n) :
+    fullHomPrecomp φ n (CohomologyClass.mk x) = CohomologyClass.mk (x.precomp φ) := rfl
+
+@[simp] theorem fullHomPostcomp_mk (x : Cocycle K F n) :
+    fullHomPostcomp φ n (CohomologyClass.mk x) = CohomologyClass.mk (x.postcomp φ) := rfl
+
+end ArExplicit
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomCompositionLinear.lean

@@ -0,0 +1,39 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomMapLinear
+
+namespace OAI
+
+noncomputable section
+open CategoryTheory CochainComplex.HomComplex
+namespace ArExplicit
+universe u v w
+variable (k : Type u) [CommRing k]
+variable {C : Type w} [Category.{v} C] [Preadditive C] [Linear k C]
+variable {K L M : CochainComplex C ℤ} (n : ℤ)
+
+def fullHomPostcompLinear (f : L ⟶ M) : CohomologyClass K L n →ₗ[k] CohomologyClass K M n where
+  __ := fullHomPostcomp f n
+  map_smul' a x := by
+    change fullHomPostcomp f n (a • x) = a • fullHomPostcomp f n x
+    obtain ⟨x, rfl⟩ := CohomologyClass.mk_surjective x
+    rw [← CompleteComparison.fullHom_mk_smul, fullHomPostcomp_mk, fullHomPostcomp_mk,
+      ← CompleteComparison.fullHom_mk_smul]
+    congr 1
+    apply Subtype.ext
+    exact Cochain.smul_comp a x.val (Cochain.ofHom f) (add_zero n)
+
+def fullHomPrecompLinear (f : K ⟶ L) : CohomologyClass L M n →ₗ[k] CohomologyClass K M n where
+  __ := fullHomPrecomp f n
+  map_smul' a x := by
+    change fullHomPrecomp f n (a • x) = a • fullHomPrecomp f n x
+    obtain ⟨x, rfl⟩ := CohomologyClass.mk_surjective x
+    rw [← CompleteComparison.fullHom_mk_smul, fullHomPrecomp_mk, fullHomPrecomp_mk,
+      ← CompleteComparison.fullHom_mk_smul]
+    congr 1
+    apply Subtype.ext
+    exact Cochain.comp_smul (Cochain.ofHom f) a x.val (zero_add n)
+
+end ArExplicit
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomCompositionSquare.lean

@@ -0,0 +1,28 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomHomotopyMaps
+
+namespace OAI
+
+noncomputable section
+open CategoryTheory CochainComplex.HomComplex
+namespace ArExplicit
+universe u v w
+variable (k : Type u) [CommRing k]
+variable {C : Type w} [Category.{v} C] [Preadditive C] [Linear k C]
+variable {K L M N P : CochainComplex C ℤ}
+variable {a : L ⟶ M} {b : M ⟶ N} {c : L ⟶ P} {d : P ⟶ N}
+include k
+
+theorem fullHomPostcomp_square (n : ℤ)
+    (h : (HomotopyCategory.quotient C _).map (a ≫ b) =
+      (HomotopyCategory.quotient C _).map (c ≫ d))
+    (x : CohomologyClass K L n) :
+    fullHomPostcomp b n (fullHomPostcomp a n x) =
+      fullHomPostcomp d n (fullHomPostcomp c n x) := by
+  rw [fullHomPostcomp_comp, fullHomPostcomp_comp]
+  exact fullHomPostcomp_congr k n h x
+
+end ArExplicit
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomDegreeProducts.lean

@@ -0,0 +1,47 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomProductLinear
+import OAI.Algebra.AuslanderReiten.Complete.TateKoszul
+import OAI.Algebra.AuslanderReiten.Resolutions.ResolutionProductCompatibility
+
+namespace OAI
+
+noncomputable section
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex
+namespace ArExplicit.CompleteComparison
+universe u v
+variable {k : Type u} [Field k]
+variable {C : Type v} [Category.{u} C] [Preadditive C] [Linear k C]
+variable {K L M : CochainComplex C ℤ} {n m l : ℤ}
+
+theorem fullHomProduct_degree_mk (h : n+m=l)
+    (x : Cocycle K L n) (y : Cocycle L M m) (z : Cocycle K M l)
+    (hz : z.val=x.val.comp y.val h) :
+    TateKoszul.degreeEquiv (k := k) (CohomologyClass K M) h
+      (fullHomProduct (CohomologyClass.mk x) (CohomologyClass.mk y)) = CohomologyClass.mk z := by
+  subst l
+  change CohomologyClass.mk (cocycleProduct x y) = CohomologyClass.mk z
+  congr 1
+  exact Subtype.ext hz.symm
+
+def fullHomIdentity (K : CochainComplex C ℤ) : CohomologyClass K K 0 :=
+  CohomologyClass.mk (Cocycle.ofHom (𝟙 K))
+
+theorem fullHomProduct_identity_right (x : CohomologyClass K L n) :
+    TateKoszul.degreeEquiv (k := k) (CohomologyClass K L) (add_zero n)
+      (fullHomProduct x (fullHomIdentity L)) = x := by
+  obtain ⟨x,rfl⟩ := CohomologyClass.mk_surjective x
+  apply fullHomProduct_degree_mk
+  exact (Cochain.comp_id x.val).symm
+
+theorem fullHomProduct_identity_left (x : CohomologyClass K L n) :
+    TateKoszul.degreeEquiv (k := k) (CohomologyClass K L) (zero_add n)
+      (fullHomProduct (fullHomIdentity K) x) = x := by
+  obtain ⟨x,rfl⟩ := CohomologyClass.mk_surjective x
+  apply fullHomProduct_degree_mk
+  exact (Cochain.id_comp x.val).symm
+
+end ArExplicit.CompleteComparison
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomDuality.lean

@@ -0,0 +1,39 @@
+import OAI.Algebra.AuslanderReiten.Stable.SourceStableShift
+import OAI.Algebra.AuslanderReiten.Duality.ProjectiveStablePairing
+
+namespace OAI
+
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex
+open scoped ModuleCat.Algebra
+
+namespace ArExplicit.FrobeniusTrace
+
+universe u
+
+variable {k R : Type u} [Field k] [Ring R] [Algebra k R] [Module.Finite k R]
+variable (τ : FrobeniusTrace k R)
+variable (hs : ∀ a b : R, τ.trace (a * b) = τ.trace (b * a))
+
+open CompleteComparison
+
+noncomputable def fullHomSymmetricDuality
+    (K : CochainComplex (ModuleCat.{u} R) ℤ)
+    (hK : TotallyAcyclicComplex (chainOfCochain K)) (a : ℤ) :
+    Module.Dual k (CohomologyClass K K a) ≃ₗ[k] CohomologyClass K K (-a - 1) := by
+  let E := fullHomStableLinearEquiv (k := k) K K a hK
+    (hK.toExactProjectiveComplex.cochainShift a)
+  let D := τ.completeStableDuality hs (chainOfCochain K) hK.toExactProjectiveComplex
+    (N := Cokernel (chainOfCochain (K⟦a⟧)) 0)
+  let B := StableHom.targetEquiv (k := k)
+    (M := Cokernel (chainOfCochain (K⟦a⟧)) 0)
+    (shiftedCokernelEquiv K (-1) 1 rfl).symm
+  let C := fullHomStableZeroLinearEquiv (k := k) (K⟦a⟧) (K⟦(-1 : ℤ)⟧)
+    (hK.cochainShift a) (hK.toExactProjectiveComplex.cochainShift (-1))
+  let L := leftShiftCohomologyEquiv k K (K⟦(-1 : ℤ)⟧) (-a) a 0 (by omega)
+  let T := rightShiftCohomologyEquiv k K K (-a - 1) (-1) (-a) (by omega)
+  exact E.symm.dualMap.trans (D.trans (B.trans (C.symm.trans (L.symm.trans T.symm))))
+
+end ArExplicit.FrobeniusTrace
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomExt.lean

@@ -0,0 +1,49 @@
+import OAI.Algebra.AuslanderReiten.Stable.StableExt
+import OAI.Algebra.AuslanderReiten.Stable.SourceStableShift
+
+namespace OAI
+
+noncomputable section
+
+namespace ArExplicit
+
+open CategoryTheory CompleteComparison
+open CochainComplex CochainComplex.HomComplex
+
+universe u
+
+variable {k R : Type u} [CommRing k] [Ring R] [Algebra k R]
+variable {K L : CochainComplex (ModuleCat.{u} R) ℤ}
+
+include k
+
+theorem positiveExtVanish_of_fullHom
+    (hK : TotallyAcyclicComplex (chainOfCochain K))
+    (hL : ExactProjectiveComplex (chainOfCochain L))
+    (h : ∀ n : ℕ, 0 < n → Subsingleton (CohomologyClass K L (n : ℤ))) :
+    PositiveExtVanish R (Cokernel (chainOfCochain K) 0) (Cokernel (chainOfCochain L) 0) := by
+  apply positiveExtVanish_of_stableCokernels hK
+  intro n
+  let := h (n + 1) (Nat.zero_lt_succ n)
+  exact (fullHomSourceStableLinearEquiv (k := k) K L ((n + 1 : ℕ) : ℤ) hK hL).symm.injective.subsingleton
+
+theorem not_projective_of_fullHom_nontrivial
+    (hK : TotallyAcyclicComplex (chainOfCochain K))
+    (h : Nontrivial (CohomologyClass K K 0)) :
+    ¬ Module.Projective R (Cokernel (chainOfCochain K) 0) := by
+  intro hp
+  let := hK.finite 0
+  let := hp
+  have : Subsingleton (StableHom R (Cokernel (chainOfCochain K) 0)
+      (Cokernel (chainOfCochain K) 0)) := ⟨fun a b =>
+    (StableHom.eq_zero_of_projective_source a).trans (StableHom.eq_zero_of_projective_source b).symm⟩
+  have : Subsingleton (CohomologyClass K K 0) :=
+    (fullHomStableZeroLinearEquiv (k := k) K K hK hK.toExactProjectiveComplex).injective.subsingleton
+  obtain ⟨a, b, hab⟩ := h.exists_pair_ne
+  exact hab (Subsingleton.elim a b)
+
+end ArExplicit
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomFunctor.lean

@@ -0,0 +1,123 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomProducts
+
+namespace OAI
+
+noncomputable section
+
+namespace ArExplicit
+
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex
+
+variable {C D : Type*} [Category* C] [Category* D] [Preadditive C] [Preadditive D]
+variable (Φ : C ⥤ D) [Φ.Additive] [Φ.Full] [Φ.Faithful]
+variable (K L : CochainComplex C ℤ) (n : ℤ)
+
+def fullHomCochainEquiv : Cochain K L n ≃+
+    Cochain ((Φ.mapHomologicalComplex _).obj K) ((Φ.mapHomologicalComplex _).obj L) n where
+  toFun x := x.map Φ
+  invFun y := Cochain.mk fun p q hpq => Φ.preimage (y.v p q hpq)
+  left_inv x := by
+    apply Cochain.ext
+    intro p q hpq
+    exact Φ.preimage_map _
+  right_inv y := by
+    apply Cochain.ext
+    intro p q hpq
+    exact Φ.map_preimage _
+  map_add' := fun x y => Cochain.map_add x y Φ
+
+theorem fullHomCochainEquiv_differential (m : ℤ) (x : Cochain K L n) :
+    δ n m (fullHomCochainEquiv Φ K L n x) = fullHomCochainEquiv Φ K L m (δ n m x) :=
+  δ_map n m x Φ
+
+def fullHomCocycleMap : Cocycle K L n →+
+    Cocycle ((Φ.mapHomologicalComplex _).obj K) ((Φ.mapHomologicalComplex _).obj L) n where
+  toFun x := Cocycle.mk (x.1.map Φ) (n + 1) rfl (by
+    rw [δ_map, Cocycle.δ_eq_zero, Cochain.map_zero])
+  map_zero' := by apply Cocycle.ext; exact Cochain.map_zero K L n Φ
+  map_add' x y := by apply Cocycle.ext; exact Cochain.map_add x.1 y.1 Φ
+
+theorem fullHomCocycleMap_bijective : Function.Bijective (fullHomCocycleMap Φ K L n) := by
+  constructor
+  · intro x y h
+    apply Cocycle.ext
+    apply (fullHomCochainEquiv Φ K L n).injective
+    exact congrArg Subtype.val h
+  · intro y
+    let x := (fullHomCochainEquiv Φ K L n).symm y.1
+    have hx : δ n (n + 1) x = 0 := by
+      apply (fullHomCochainEquiv Φ K L (n + 1)).injective
+      rw [← fullHomCochainEquiv_differential, map_zero]
+      change δ n (n + 1) (fullHomCochainEquiv Φ K L n
+        ((fullHomCochainEquiv Φ K L n).symm y.1)) = 0
+      rw [AddEquiv.apply_symm_apply, Cocycle.δ_eq_zero]
+    refine ⟨Cocycle.mk x (n + 1) rfl hx, ?_⟩
+    apply Cocycle.ext
+    exact (fullHomCochainEquiv Φ K L n).apply_symm_apply y.1
+
+theorem fullHomCocycleMap_boundary (x : Cocycle K L n) :
+    fullHomCocycleMap Φ K L n x ∈
+      coboundaries ((Φ.mapHomologicalComplex _).obj K) ((Φ.mapHomologicalComplex _).obj L) n ↔
+      x ∈ coboundaries K L n := by
+  rw [mem_coboundaries_iff _ (n - 1) (by omega), mem_coboundaries_iff _ (n - 1) (by omega)]
+  constructor
+  · rintro ⟨y, hy⟩
+    refine ⟨(fullHomCochainEquiv Φ K L (n - 1)).symm y, ?_⟩
+    apply (fullHomCochainEquiv Φ K L n).injective
+    rw [← fullHomCochainEquiv_differential, AddEquiv.apply_symm_apply]
+    exact hy
+  · rintro ⟨y, hy⟩
+    refine ⟨y.map Φ, ?_⟩
+    rw [δ_map, hy]
+    rfl
+
+def fullHomCohomologyMap : CohomologyClass K L n →+
+    CohomologyClass ((Φ.mapHomologicalComplex _).obj K) ((Φ.mapHomologicalComplex _).obj L) n :=
+  CohomologyClass.descAddMonoidHom
+    ((CohomologyClass.mkAddMonoidHom _ _ _).comp (fullHomCocycleMap Φ K L n)) (by
+      intro x hx
+      exact (CohomologyClass.mk_eq_zero_iff _).mpr
+        ((fullHomCocycleMap_boundary Φ K L n x).mpr hx))
+
+@[simp] theorem fullHomCohomologyMap_mk (x : Cocycle K L n) :
+    fullHomCohomologyMap Φ K L n (CohomologyClass.mk x) =
+      CohomologyClass.mk (fullHomCocycleMap Φ K L n x) := rfl
+
+theorem fullHomCohomologyMap_bijective : Function.Bijective (fullHomCohomologyMap Φ K L n) := by
+  constructor
+  · apply (injective_iff_map_eq_zero _).mpr
+    intro x hx
+    obtain ⟨y, rfl⟩ := CohomologyClass.mk_surjective x
+    exact (CohomologyClass.mk_eq_zero_iff y).mpr
+      ((fullHomCocycleMap_boundary Φ K L n y).mp
+        ((CohomologyClass.mk_eq_zero_iff _).mp hx))
+  · intro y
+    obtain ⟨y, rfl⟩ := CohomologyClass.mk_surjective y
+    obtain ⟨x, rfl⟩ := (fullHomCocycleMap_bijective Φ K L n).surjective y
+    exact ⟨CohomologyClass.mk x, rfl⟩
+
+def fullHomCohomologyEquiv : CohomologyClass K L n ≃+
+    CohomologyClass ((Φ.mapHomologicalComplex _).obj K) ((Φ.mapHomologicalComplex _).obj L) n :=
+  AddEquiv.ofBijective (fullHomCohomologyMap Φ K L n) (fullHomCohomologyMap_bijective Φ K L n)
+
+variable {K L n}
+
+theorem fullHomCohomologyMap_product {M : CochainComplex C ℤ} {m : ℤ}
+    (x : CohomologyClass K L n) (y : CohomologyClass L M m) :
+    fullHomCohomologyMap Φ K M (n + m) (CompleteComparison.fullHomProduct x y) =
+      CompleteComparison.fullHomProduct (fullHomCohomologyMap Φ K L n x)
+        (fullHomCohomologyMap Φ L M m y) := by
+  obtain ⟨x, rfl⟩ := CohomologyClass.mk_surjective x
+  obtain ⟨y, rfl⟩ := CohomologyClass.mk_surjective y
+  simp only [CompleteComparison.fullHomProduct_mk, fullHomCohomologyMap_mk]
+  congr 1
+  apply Cocycle.ext
+  apply Cochain.map_comp
+  rfl
+
+end ArExplicit
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomHomotopyMaps.lean

@@ -0,0 +1,60 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomShiftedMaps
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomNaturality
+
+namespace OAI
+
+noncomputable section
+open CategoryTheory CochainComplex.HomComplex
+namespace ArExplicit
+universe u v w
+variable (k : Type u) [CommRing k]
+variable {C : Type w} [Category.{v} C] [Preadditive C] [Linear k C]
+variable {K L M : CochainComplex C ℤ} (n : ℤ)
+include k
+
+theorem fullHomPostcomp_congr {f g : L ⟶ M}
+    (h : (HomotopyCategory.quotient C _).map f = (HomotopyCategory.quotient C _).map g)
+    (x : CohomologyClass K L n) : fullHomPostcomp f n x = fullHomPostcomp g n x := by
+  apply (fullHomShiftedHomotopyEquiv k K M n).injective
+  rw [fullHomShiftedHomotopyEquiv_postcomp, fullHomShiftedHomotopyEquiv_postcomp, h]
+
+theorem fullHomPrecomp_congr {f g : K ⟶ L}
+    (h : (HomotopyCategory.quotient C _).map f = (HomotopyCategory.quotient C _).map g)
+    (x : CohomologyClass L M n) : fullHomPrecomp f n x = fullHomPrecomp g n x := by
+  apply (fullHomShiftedHomotopyEquiv k K M n).injective
+  rw [fullHomShiftedHomotopyEquiv_precomp, fullHomShiftedHomotopyEquiv_precomp, h]
+
+theorem fullHomPostcomp_id (x : CohomologyClass K L n) :
+    fullHomPostcomp (𝟙 L) n x = x := by
+  apply (fullHomShiftedHomotopyEquiv k K L n).injective
+  rw [fullHomShiftedHomotopyEquiv_postcomp, CategoryTheory.Functor.map_id,
+    CategoryTheory.Functor.map_id, Category.comp_id]
+
+theorem fullHomPrecomp_id (x : CohomologyClass K L n) :
+    fullHomPrecomp (𝟙 K) n x = x := by
+  apply (fullHomShiftedHomotopyEquiv k K L n).injective
+  rw [fullHomShiftedHomotopyEquiv_precomp, CategoryTheory.Functor.map_id, Category.id_comp]
+
+theorem fullHomPostcomp_homotopy_inverse (f : L ⟶ M) (g : M ⟶ L)
+    (h : (HomotopyCategory.quotient C _).map (f ≫ g) = 𝟙 _)
+    (x : CohomologyClass K L n) : fullHomPostcomp g n (fullHomPostcomp f n x) = x := by
+  rw [fullHomPostcomp_comp]
+  rw [fullHomPostcomp_congr k n (h.trans (CategoryTheory.Functor.map_id _ _).symm),
+    fullHomPostcomp_id k n]
+
+theorem fullHomPostcomp_bijective (f : L ⟶ M) (g : M ⟶ L)
+    (hfg : (HomotopyCategory.quotient C _).map (f ≫ g) = 𝟙 _)
+    (hgf : (HomotopyCategory.quotient C _).map (g ≫ f) = 𝟙 _) :
+    Function.Bijective (fullHomPostcomp (K := K) f n) := by
+  constructor
+  · intro x y h
+    have hh := congrArg (fullHomPostcomp g n) h
+    simpa only [fullHomPostcomp_homotopy_inverse k n f g hfg] using hh
+  · intro x
+    exact ⟨fullHomPostcomp g n x, fullHomPostcomp_homotopy_inverse k n g f hgf x⟩
+
+end ArExplicit
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomLinear.lean

@@ -0,0 +1,90 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomProducts
+import Mathlib.Algebra.Homology.Linear
+
+namespace OAI
+
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex
+
+namespace ArExplicit.CompleteComparison
+
+universe u v
+
+section Cochains
+
+variable (k : Type u) [CommRing k]
+variable {C : Type*} [Category* C] [Preadditive C] [Linear k C]
+variable (K L : CochainComplex C ℤ) (n : ℤ)
+
+def fullHomCoboundaries : Submodule k (Cocycle K L n) where
+  __ := coboundaries K L n
+  smul_mem' a x hx := by
+    obtain ⟨m, hm, y, hy⟩ := hx
+    refine ⟨m, hm, a • y, ?_⟩
+    rw [δ_smul, hy]
+    rfl
+
+instance fullHomModule : Module k (CohomologyClass K L n) :=
+  inferInstanceAs (Module k ((Cocycle K L n) ⧸ fullHomCoboundaries k K L n))
+
+variable {K L n}
+
+@[simp]
+theorem fullHom_mk_smul (a : k) (x : Cocycle K L n) :
+    CohomologyClass.mk (a • x) = a • CohomologyClass.mk x := rfl
+
+theorem cocycleHom_smul (a : k) (x : Cocycle K L n) :
+    Cocycle.equivHomShift.symm (a • x) = a • Cocycle.equivHomShift.symm x := by
+  apply HomologicalComplex.Hom.ext
+  funext i
+  simp only [cocycleHom_component, HomologicalComplex.smul_f_apply,
+    Cocycle.coe_smul, Cochain.smul_v]
+
+end Cochains
+
+variable {k R : Type u} [CommRing k] [Ring R] [Algebra k R]
+open scoped ModuleCat.Algebra
+
+variable {P Q : ChainComplex (ModuleCat.{u} R) ℤ}
+
+theorem cokernelMap_smul (a : k) (F : P ⟶ Q) (n : ℤ) :
+    cokernelMap (a • F) n = a • cokernelMap F n := by
+  apply LinearMap.ext
+  intro z
+  obtain ⟨x, rfl⟩ := Submodule.mkQ_surjective (LinearMap.range (P.d (n + 1) n).hom) z
+  change (LinearMap.range (Q.d (n + 1) n).hom).mkQ (a • (F.f n).hom x) =
+    a • (LinearMap.range (Q.d (n + 1) n).hom).mkQ ((F.f n).hom x)
+  exact ((LinearMap.range (Q.d (n + 1) n).hom).mkQ.restrictScalars k).map_smul a _
+
+variable {K L : CochainComplex (ModuleCat.{u} R) ℤ} {n : ℤ}
+
+theorem cocycleComparisonMap_smul (a : k) (x : Cocycle K L n) :
+    cocycleComparisonMap (a • x) = a • cocycleComparisonMap x := by
+  unfold cocycleComparisonMap
+  rw [cocycleHom_smul]
+  apply HomologicalComplex.Hom.ext
+  funext i
+  have hi : negIndexEmbedding.f (-i) = i := neg_neg i
+  simp only [HomologicalComplex.extendMap_f _ _ hi,
+    HomologicalComplex.smul_f_apply, Linear.comp_smul, Linear.smul_comp]
+
+theorem fullHomStableEquiv_smul (hK : TotallyAcyclicComplex (chainOfCochain K))
+    (hL : ExactProjectiveComplex (chainOfCochain (L⟦n⟧)))
+    (a : k) (x : CohomologyClass K L n) :
+    fullHomStableEquiv K L n hK hL (a • x) = a • fullHomStableEquiv K L n hK hL x := by
+  obtain ⟨x, rfl⟩ := CohomologyClass.mk_surjective x
+  rw [← fullHom_mk_smul, fullHomStableEquiv_mk, fullHomStableEquiv_mk,
+    cocycleComparisonMap_smul, cokernelMap_smul, StableHom.classOf_smul]
+
+noncomputable def fullHomStableLinearEquiv
+    (K L : CochainComplex (ModuleCat.{u} R) ℤ) (n : ℤ)
+    (hK : TotallyAcyclicComplex (chainOfCochain K))
+    (hL : ExactProjectiveComplex (chainOfCochain (L⟦n⟧))) :
+    CohomologyClass K L n ≃ₗ[k]
+      StableHom R (Cokernel (chainOfCochain K) 0) (Cokernel (chainOfCochain (L⟦n⟧)) 0) :=
+  { fullHomStableEquiv K L n hK hL with
+    map_smul' := fullHomStableEquiv_smul hK hL }
+
+end ArExplicit.CompleteComparison
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomMap.lean

@@ -0,0 +1,49 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomFunctor
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit
+open CategoryTheory CochainComplex.HomComplex
+variable {C D : Type*} [Category* C] [Category* D] [Preadditive C] [Preadditive D]
+variable (Φ : C ⥤ D) [Φ.Additive]
+variable (K L : CochainComplex C ℤ) (n : ℤ)
+
+def mapFullHom : CohomologyClass K L n →+
+    CohomologyClass ((Φ.mapHomologicalComplex _).obj K)
+      ((Φ.mapHomologicalComplex _).obj L) n :=
+  CohomologyClass.descAddMonoidHom
+    ((CohomologyClass.mkAddMonoidHom _ _ _).comp (fullHomCocycleMap Φ K L n)) (by
+      intro x hx
+      apply (CohomologyClass.mk_eq_zero_iff _).mpr
+      obtain ⟨m, hm, y, hy⟩ := hx
+      refine ⟨m, hm, y.map Φ, ?_⟩
+      rw [δ_map, hy]
+      rfl)
+
+@[simp] theorem mapFullHom_mk (x : Cocycle K L n) :
+    mapFullHom Φ K L n (CohomologyClass.mk x) =
+      CohomologyClass.mk (fullHomCocycleMap Φ K L n x) := rfl
+
+theorem mapFullHom_eq [Φ.Full] [Φ.Faithful] :
+    mapFullHom Φ K L n = fullHomCohomologyMap Φ K L n := rfl
+
+variable {K L n}
+theorem mapFullHom_product {M : CochainComplex C ℤ} {m : ℤ}
+    (x : CohomologyClass K L n) (y : CohomologyClass L M m) :
+    mapFullHom Φ K M (n+m) (CompleteComparison.fullHomProduct x y) =
+      CompleteComparison.fullHomProduct (mapFullHom Φ K L n x)
+        (mapFullHom Φ L M m y) := by
+  obtain ⟨x, rfl⟩ := CohomologyClass.mk_surjective x
+  obtain ⟨y, rfl⟩ := CohomologyClass.mk_surjective y
+  simp only [CompleteComparison.fullHomProduct_mk, mapFullHom_mk]
+  congr 1
+  apply Cocycle.ext
+  apply Cochain.map_comp
+  rfl
+
+end ArExplicit
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomMapLinear.lean

@@ -0,0 +1,85 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomMap
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomProductLinear
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomComposition
+
+namespace OAI
+
+noncomputable section
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex
+namespace ArExplicit
+variable {k : Type*} [CommRing k]
+variable {C D : Type*} [Category* C] [Category* D] [Preadditive C] [Preadditive D]
+  [Linear k C] [Linear k D]
+variable (Φ : C ⥤ D) [Φ.Additive] [Φ.Linear k]
+variable (K L : CochainComplex C ℤ) (n : ℤ)
+
+theorem mapFullHom_smul (a : k) (x : CohomologyClass K L n) :
+    mapFullHom Φ K L n (a • x) = a • mapFullHom Φ K L n x := by
+  obtain ⟨x,rfl⟩ := CohomologyClass.mk_surjective x
+  rw [← CompleteComparison.fullHom_mk_smul, mapFullHom_mk, mapFullHom_mk,
+    ← CompleteComparison.fullHom_mk_smul]
+  congr 1
+  apply Subtype.ext
+  apply Cochain.ext
+  intro p q hpq
+  exact Φ.map_smul a (x.val.v p q hpq)
+
+def mapFullHomLinear : CohomologyClass K L n →ₗ[k]
+    CohomologyClass ((Φ.mapHomologicalComplex _).obj K)
+      ((Φ.mapHomologicalComplex _).obj L) n where
+  __ := mapFullHom Φ K L n
+  map_smul' := mapFullHom_smul Φ K L n
+
+theorem mapFullHom_identity :
+    mapFullHom Φ K K 0 (CohomologyClass.mk (Cocycle.ofHom (𝟙 K))) =
+      CohomologyClass.mk (Cocycle.ofHom (𝟙 ((Φ.mapHomologicalComplex _).obj K))) := by
+  rw [mapFullHom_mk]
+  congr 1
+  apply Subtype.ext
+  change (Cochain.ofHom (𝟙 K)).map Φ =
+    Cochain.ofHom (𝟙 ((Φ.mapHomologicalComplex _).obj K))
+  rw [Cochain.map_ofHom, CategoryTheory.Functor.map_id]
+
+variable {K L n}
+theorem fullHomPostcomp_smul (f : K ⟶ L) (n : ℤ) (a : k)
+    (x : CohomologyClass K K n) :
+    fullHomPostcomp f n (a • x) = a • fullHomPostcomp f n x := by
+  obtain ⟨x,rfl⟩ := CohomologyClass.mk_surjective x
+  rw [← CompleteComparison.fullHom_mk_smul, fullHomPostcomp_mk, fullHomPostcomp_mk,
+    ← CompleteComparison.fullHom_mk_smul]
+  congr 1
+  apply Subtype.ext
+  exact Cochain.smul_comp a x.val (Cochain.ofHom f) (add_zero n)
+
+theorem fullHomPrecomp_smul (f : K ⟶ L) (n : ℤ) (a : k)
+    (x : CohomologyClass L L n) :
+    fullHomPrecomp f n (a • x) = a • fullHomPrecomp f n x := by
+  obtain ⟨x,rfl⟩ := CohomologyClass.mk_surjective x
+  rw [← CompleteComparison.fullHom_mk_smul, fullHomPrecomp_mk, fullHomPrecomp_mk,
+    ← CompleteComparison.fullHom_mk_smul]
+  congr 1
+  apply Subtype.ext
+  exact Cochain.comp_smul (Cochain.ofHom f) a x.val (zero_add n)
+
+theorem fullHomPostcomp_identity (f : K ⟶ L) :
+    fullHomPostcomp f 0 (CohomologyClass.mk (Cocycle.ofHom (𝟙 K))) =
+      CohomologyClass.mk (Cocycle.ofHom f) := by
+  rw [fullHomPostcomp_mk]
+  congr 1
+  apply Subtype.ext
+  exact Cochain.id_comp _
+
+theorem fullHomPrecomp_identity (f : K ⟶ L) :
+    fullHomPrecomp f 0 (CohomologyClass.mk (Cocycle.ofHom (𝟙 L))) =
+      CohomologyClass.mk (Cocycle.ofHom f) := by
+  rw [fullHomPrecomp_mk]
+  congr 1
+  apply Subtype.ext
+  exact Cochain.comp_id _
+
+end ArExplicit
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomNaturality.lean

@@ -0,0 +1,86 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomMap
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomComposition
+
+namespace OAI
+
+noncomputable section
+open CategoryTheory CochainComplex CochainComplex.HomComplex
+namespace ArExplicit
+variable {C D : Type*} [Category* C] [Category* D] [Preadditive C] [Preadditive D]
+variable {Φ Ψ : C ⥤ D} [Φ.Additive] [Ψ.Additive]
+variable {K L : CochainComplex C ℤ} {n : ℤ}
+
+theorem mapFullHom_naturality (η : Φ ⟶ Ψ) (x : CohomologyClass K L n) :
+    fullHomPostcomp ((η.mapHomologicalComplex _).app L) n (mapFullHom Φ K L n x) =
+      fullHomPrecomp ((η.mapHomologicalComplex _).app K) n (mapFullHom Ψ K L n x) := by
+  obtain ⟨x,rfl⟩ := CohomologyClass.mk_surjective x
+  rw [mapFullHom_mk, mapFullHom_mk, fullHomPostcomp_mk, fullHomPrecomp_mk]
+  congr 1
+  apply Cocycle.ext
+  apply Cochain.ext
+  intro i j hij
+  change ((x.val.map Φ).comp (Cochain.ofHom ((η.mapHomologicalComplex _).app L))
+      (add_zero n)).v i j hij =
+    ((Cochain.ofHom ((η.mapHomologicalComplex _).app K)).comp (x.val.map Ψ)
+      (zero_add n)).v i j hij
+  rw [Cochain.comp_v _ _ (add_zero n) i j j hij (add_zero j),
+    Cochain.comp_v _ _ (zero_add n) i i j (add_zero i) hij]
+  simp only [Cochain.map_v, Cochain.ofHom_v, NatTrans.mapHomologicalComplex_app_f]
+  exact η.naturality (x.val.v i j hij)
+
+variable {F G H I : CochainComplex C ℤ}
+
+theorem fullHomPostcomp_comp (f : F ⟶ G) (g : G ⟶ H) (x : CohomologyClass I F n) :
+    fullHomPostcomp g n (fullHomPostcomp f n x) = fullHomPostcomp (f ≫ g) n x := by
+  obtain ⟨x,rfl⟩ := CohomologyClass.mk_surjective x
+  simp only [fullHomPostcomp_mk]
+  congr 1
+  apply Cocycle.ext
+  apply Cochain.ext
+  intro i j hij
+  change ((x.val.comp (Cochain.ofHom f) (add_zero n)).comp (Cochain.ofHom g)
+      (add_zero n)).v i j hij = (x.val.comp (Cochain.ofHom (f ≫ g)) (add_zero n)).v i j hij
+  rw [Cochain.comp_v _ _ (add_zero n) i j j hij (add_zero j),
+    Cochain.comp_v _ _ (add_zero n) i j j hij (add_zero j),
+    Cochain.comp_v _ _ (add_zero n) i j j hij (add_zero j)]
+  simp only [Cochain.ofHom_v, HomologicalComplex.comp_f, Category.assoc]
+
+theorem fullHomPostcomp_precomp (f : F ⟶ G) (g : H ⟶ I) (x : CohomologyClass G H n) :
+    fullHomPostcomp g n (fullHomPrecomp f n x) =
+      fullHomPrecomp f n (fullHomPostcomp g n x) := by
+  obtain ⟨x,rfl⟩ := CohomologyClass.mk_surjective x
+  simp only [fullHomPostcomp_mk, fullHomPrecomp_mk]
+  congr 1
+  apply Cocycle.ext
+  apply Cochain.ext
+  intro i j hij
+  change (((Cochain.ofHom f).comp x.val (zero_add n)).comp (Cochain.ofHom g)
+      (add_zero n)).v i j hij =
+    ((Cochain.ofHom f).comp (x.val.comp (Cochain.ofHom g) (add_zero n))
+      (zero_add n)).v i j hij
+  rw [Cochain.comp_v _ _ (add_zero n) i j j hij (add_zero j),
+    Cochain.comp_v _ _ (zero_add n) i i j (add_zero i) hij,
+    Cochain.comp_v _ _ (zero_add n) i i j (add_zero i) hij,
+    Cochain.comp_v _ _ (add_zero n) i j j hij (add_zero j)]
+  simp only [Cochain.ofHom_v, Category.assoc]
+
+theorem fullHomPrecomp_comp (f : F ⟶ G) (g : G ⟶ H) (x : CohomologyClass H I n) :
+    fullHomPrecomp f n (fullHomPrecomp g n x) = fullHomPrecomp (f ≫ g) n x := by
+  obtain ⟨x,rfl⟩ := CohomologyClass.mk_surjective x
+  simp only [fullHomPrecomp_mk]
+  congr 1
+  apply Cocycle.ext
+  apply Cochain.ext
+  intro i j hij
+  change ((Cochain.ofHom f).comp ((Cochain.ofHom g).comp x.val (zero_add n))
+      (zero_add n)).v i j hij = ((Cochain.ofHom (f ≫ g)).comp x.val (zero_add n)).v i j hij
+  rw [Cochain.comp_v _ _ (zero_add n) i i j (add_zero i) hij,
+    Cochain.comp_v _ _ (zero_add n) i i j (add_zero i) hij,
+    Cochain.comp_v _ _ (zero_add n) i i j (add_zero i) hij]
+  simp only [Cochain.ofHom_v, HomologicalComplex.comp_f, Category.assoc]
+
+end ArExplicit
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomPairing.lean

@@ -0,0 +1,83 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomDuality
+
+namespace OAI
+
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex
+open scoped ModuleCat.Algebra
+
+namespace ArExplicit.FrobeniusTrace
+
+universe u
+
+variable {k R : Type u} [Field k] [Ring R] [Algebra k R] [Module.Finite k R]
+variable (τ : FrobeniusTrace k R)
+variable (hs : ∀ a b : R, τ.trace (a * b) = τ.trace (b * a))
+variable {N N' : Type u}
+variable [AddCommGroup N] [Module R N] [Module k N] [IsScalarTower k R N]
+variable [SMulCommClass R k N]
+variable [AddCommGroup N'] [Module R N'] [Module k N'] [IsScalarTower k R N']
+variable [SMulCommClass R k N']
+
+open CompleteComparison
+
+theorem completeStableDuality_natural
+    (P : ChainComplex (ModuleCat.{u} R) ℤ) (hP : ExactProjectiveComplex P)
+    (u : N →ₗ[R] N') (f : StableHom R (Cokernel P 0) N)
+    (g : StableHom R N' (Cokernel P 1)) :
+    ((τ.completeStableDuality hs P hP).symm g) (StableHom.postcomp u f) =
+      ((τ.completeStableDuality hs P hP).symm (StableHom.precomp u g)) f := by
+  let : ∀ i, Module.Finite R (P.X i) := hP.finite
+  let : ∀ i, Module.Projective R (P.X i) := hP.projective
+  let E := cokernelSyzygyEquiv hP 0
+  change ((τ.projectiveStableDuality hs (P.d 1 0).hom (P.d 0 (-1)).hom
+    (differential_comp P 1 0 (-1)) (hP.exactAt 0)).symm
+      (StableHom.postcomp E.toLinearMap g)) (StableHom.postcomp u f) =
+    ((τ.projectiveStableDuality hs (P.d 1 0).hom (P.d 0 (-1)).hom
+    (differential_comp P 1 0 (-1)) (hP.exactAt 0)).symm
+      (StableHom.postcomp E.toLinearMap (StableHom.precomp u g))) f
+  rw [τ.projectiveStableDuality_natural]
+  congr 2
+  obtain ⟨g, rfl⟩ := StableHom.classOf_surjective g
+  rfl
+
+noncomputable def fullHomTracePairing
+    (K : CochainComplex (ModuleCat.{u} R) ℤ)
+    (hK : TotallyAcyclicComplex (chainOfCochain K)) (n : ℤ) :
+    StableHom R (Cokernel (chainOfCochain (K⟦n⟧)) 0) (Cokernel (chainOfCochain K) 1)
+      ≃ₗ[k] Module.Dual k (CohomologyClass K K n) :=
+  (τ.completeStableDuality hs (chainOfCochain K) hK.toExactProjectiveComplex).symm.trans
+    (fullHomStableLinearEquiv (k := k) K K n hK
+      (hK.toExactProjectiveComplex.cochainShift n)).dualMap
+
+theorem fullHomTracePairing_product
+    (K : CochainComplex (ModuleCat.{u} R) ℤ)
+    (hK : TotallyAcyclicComplex (chainOfCochain K)) {n m : ℤ}
+    (x : Cocycle K K n) (y : Cocycle K K m)
+    (g : StableHom R (Cokernel (chainOfCochain (K⟦n + m⟧)) 0)
+      (Cokernel (chainOfCochain K) 1)) :
+    (τ.fullHomTracePairing hs K hK (n + m) g) (CohomologyClass.mk (cocycleProduct x y)) =
+      (τ.fullHomTracePairing hs K hK n
+        (StableHom.precomp
+          (cokernelMap (HomologicalComplex.extendMap (shiftedCocycleHom y n) negIndexEmbedding) 0)
+          g)) (CohomologyClass.mk x) := by
+  change ((τ.completeStableDuality hs (chainOfCochain K) hK.toExactProjectiveComplex).symm g)
+    (fullHomStableEquiv K K (n + m) hK (hK.toExactProjectiveComplex.cochainShift (n + m))
+      (CohomologyClass.mk (cocycleProduct x y))) = _
+  rw [fullHomStableEquiv_product hK (hK.toExactProjectiveComplex.cochainShift n)
+    (hK.toExactProjectiveComplex.cochainShift (n + m))]
+  let u := cokernelMap
+    (HomologicalComplex.extendMap (shiftedCocycleHom y n) negIndexEmbedding) 0
+  have hc (z : StableHom R (Cokernel (chainOfCochain K) 0)
+      (Cokernel (chainOfCochain (K⟦n⟧)) 0)) :
+      StableHom.comp (StableHom.classOf R _ _ u) z = StableHom.postcomp u z := by
+    obtain ⟨z, rfl⟩ := StableHom.classOf_surjective z
+    rw [StableHom.comp_classOf, StableHom.postcomp_classOf]
+  rw [hc]
+  exact τ.completeStableDuality_natural hs (chainOfCochain K) hK.toExactProjectiveComplex u
+    (fullHomStableEquiv K K n hK (hK.toExactProjectiveComplex.cochainShift n)
+      (CohomologyClass.mk x)) g
+
+end ArExplicit.FrobeniusTrace
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomPlainZero.lean

@@ -0,0 +1,41 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomZeroRepresentative
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex CompleteComparison
+universe u v w
+variable (k : Type u) [CommRing k]
+variable {C : Type w} [Category.{v} C] [Preadditive C] [Linear k C]
+variable (K L : CochainComplex C ℤ)
+
+def fullHomPlainZeroEquiv : CohomologyClass K L 0 ≃ₗ[k]
+    ((HomotopyCategory.quotient C _).obj K ⟶ (HomotopyCategory.quotient C _).obj L) :=
+  (fullHomShiftedHomotopyEquiv k K L 0).trans
+    (Linear.homCongr k (Iso.refl _)
+      ((shiftFunctorZero (HomotopyCategory C (ComplexShape.up ℤ)) ℤ).app _))
+
+theorem fullHomPlainZeroEquiv_mk (f : K ⟶ L) :
+    fullHomPlainZeroEquiv k K L (CohomologyClass.mk (Cocycle.ofHom f)) =
+      (HomotopyCategory.quotient C _).map f := by
+  simp only [fullHomPlainZeroEquiv, LinearEquiv.trans_apply, Linear.homCongr_apply,
+    Iso.refl_inv, Category.id_comp]
+  change fullHomShiftedHomotopyEquiv k K L 0
+    (CohomologyClass.mk (Cocycle.ofHom f)) ≫
+      (shiftFunctorZero (HomotopyCategory C (ComplexShape.up ℤ)) ℤ).hom.app _ = _
+  rw [← fullHomPrecomp_identity f, fullHomShiftedHomotopyEquiv_precomp]
+  change (_ ≫ fullHomShiftedHomotopyEquiv k L L 0 (fullHomIdentity L)) ≫ _ = _
+  erw [fullHomShiftedHomotopyEquiv_identity, Category.assoc, Iso.inv_hom_id_app,
+    Category.comp_id]
+
+theorem fullHomPlainZeroEquiv_identity :
+    fullHomPlainZeroEquiv k K K (fullHomIdentity K) = 𝟙 _ := by
+  rw [fullHomIdentity, fullHomPlainZeroEquiv_mk, CategoryTheory.Functor.map_id]
+
+end ArExplicit
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomProductCoordinate.lean

@@ -0,0 +1,26 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomProductReindex
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.CompleteComparison
+open CategoryTheory CochainComplex CochainComplex.HomComplex
+universe u w
+variable {k : Type u} [Field k]
+variable {C : Type w} [Category.{u} C] [Preadditive C] [Linear k C]
+variable {K L M : CochainComplex C ℤ} {a b c d : ℤ}
+
+theorem fullHomProduct_coordinate
+    (h : a=b) (h₁ : b+c=d) (h₂ : a+c=d)
+    {x : CohomologyClass K L a} {y : CohomologyClass K L b}
+    {p : CohomologyClass L M c} {z : CohomologyClass K M d}
+    (hy : y = TateKoszul.degreeEquiv (k := k) (CohomologyClass K L) h x)
+    (hz : z = TateKoszul.degreeEquiv (k := k) (CohomologyClass K M) h₁ (fullHomProduct y p)) :
+    z = TateKoszul.degreeEquiv (k := k) (CohomologyClass K M) h₂ (fullHomProduct x p) := by
+  rw [hz, hy, fullHomProduct_reindex_left]
+
+end ArExplicit.CompleteComparison
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomProductLinear.lean

@@ -0,0 +1,71 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomLinear
+
+namespace OAI
+
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex
+namespace ArExplicit.CompleteComparison
+universe u v
+variable {k : Type u} [CommRing k]
+variable {C : Type v} [Category* C] [Preadditive C] [Linear k C]
+variable {K L M : CochainComplex C ℤ} {n m : ℤ}
+
+theorem fullHomProduct_add_left (x x' : CohomologyClass K L n)
+    (y : CohomologyClass L M m) :
+    fullHomProduct (x+x') y = fullHomProduct x y + fullHomProduct x' y := by
+  obtain ⟨x,rfl⟩ := CohomologyClass.mk_surjective x
+  obtain ⟨x',rfl⟩ := CohomologyClass.mk_surjective x'
+  obtain ⟨y,rfl⟩ := CohomologyClass.mk_surjective y
+  rw [← CohomologyClass.mk_add, fullHomProduct_mk, fullHomProduct_mk, fullHomProduct_mk,
+    ← CohomologyClass.mk_add]
+  congr 1
+  apply Subtype.ext
+  exact Cochain.add_comp x.val x'.val y.val rfl
+
+theorem fullHomProduct_add_right (x : CohomologyClass K L n)
+    (y y' : CohomologyClass L M m) :
+    fullHomProduct x (y+y') = fullHomProduct x y + fullHomProduct x y' := by
+  obtain ⟨x,rfl⟩ := CohomologyClass.mk_surjective x
+  obtain ⟨y,rfl⟩ := CohomologyClass.mk_surjective y
+  obtain ⟨y',rfl⟩ := CohomologyClass.mk_surjective y'
+  rw [← CohomologyClass.mk_add, fullHomProduct_mk, fullHomProduct_mk, fullHomProduct_mk,
+    ← CohomologyClass.mk_add]
+  congr 1
+  apply Subtype.ext
+  exact Cochain.comp_add x.val y.val y'.val rfl
+
+theorem fullHomProduct_smul_left (c : k) (x : CohomologyClass K L n)
+    (y : CohomologyClass L M m) :
+    fullHomProduct (c • x) y = c • fullHomProduct x y := by
+  obtain ⟨x,rfl⟩ := CohomologyClass.mk_surjective x
+  obtain ⟨y,rfl⟩ := CohomologyClass.mk_surjective y
+  rw [← fullHom_mk_smul, fullHomProduct_mk, fullHomProduct_mk, ← fullHom_mk_smul]
+  congr 1
+  apply Subtype.ext
+  exact Cochain.smul_comp c x.val y.val rfl
+
+theorem fullHomProduct_smul_right (c : k) (x : CohomologyClass K L n)
+    (y : CohomologyClass L M m) :
+    fullHomProduct x (c • y) = c • fullHomProduct x y := by
+  obtain ⟨x,rfl⟩ := CohomologyClass.mk_surjective x
+  obtain ⟨y,rfl⟩ := CohomologyClass.mk_surjective y
+  rw [← fullHom_mk_smul, fullHomProduct_mk, fullHomProduct_mk, ← fullHom_mk_smul]
+  congr 1
+  apply Subtype.ext
+  exact Cochain.comp_smul x.val c y.val rfl
+
+def fullHomRightMultiply (y : CohomologyClass L M m) :
+    CohomologyClass K L n →ₗ[k] CohomologyClass K M (n+m) where
+  toFun x := fullHomProduct x y
+  map_add' x x' := fullHomProduct_add_left x x' y
+  map_smul' c x := fullHomProduct_smul_left c x y
+
+def fullHomLeftMultiply (x : CohomologyClass K L n) :
+    CohomologyClass L M m →ₗ[k] CohomologyClass K M (n+m) where
+  toFun y := fullHomProduct x y
+  map_add' y y' := fullHomProduct_add_right x y y'
+  map_smul' c y := fullHomProduct_smul_right c x y
+
+end ArExplicit.CompleteComparison
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomProductReindex.lean

@@ -0,0 +1,35 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomProductLinear
+import OAI.Algebra.AuslanderReiten.Complete.TateKoszul
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit.CompleteComparison
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex
+universe u w
+variable {k : Type u} [Field k]
+variable {C : Type w} [Category.{u} C] [Preadditive C] [Linear k C]
+variable {K L M : CochainComplex C ℤ} {a b c d : ℤ}
+
+theorem fullHomProduct_reindex_left (h : a=b) (h₁ : b+c=d) (h₂ : a+c=d)
+    (x : CohomologyClass K L a) (y : CohomologyClass L M c) :
+    TateKoszul.degreeEquiv (k := k) (CohomologyClass K M) h₁
+      (fullHomProduct (TateKoszul.degreeEquiv (k := k) (CohomologyClass K L) h x) y) =
+    TateKoszul.degreeEquiv (k := k) (CohomologyClass K M) h₂ (fullHomProduct x y) := by
+  subst b
+  rfl
+
+theorem degreeEquiv_trans_apply {H : ℤ → Type u} [∀ i, AddCommGroup (H i)] [∀ i, Module k (H i)]
+    (h₁ : a=b) (h₂ : b=c) (x : H a) :
+    TateKoszul.degreeEquiv (k := k) H h₂ (TateKoszul.degreeEquiv (k := k) H h₁ x) =
+      TateKoszul.degreeEquiv (k := k) H (h₁.trans h₂) x := by
+  subst b
+  subst c
+  rfl
+
+end ArExplicit.CompleteComparison
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomProducts.lean

@@ -0,0 +1,116 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomComparison
+
+namespace OAI
+
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex
+
+namespace ArExplicit.CompleteComparison
+
+universe u
+
+section Cochains
+
+variable {C : Type*} [Category* C] [Preadditive C]
+variable {K L M : CochainComplex C ℤ} {n m : ℤ}
+
+def cocycleProduct (x : Cocycle K L n) (y : Cocycle L M m) : Cocycle K M (n + m) :=
+  Cocycle.mk (x.1.comp y.1 rfl) _ rfl (by
+    rw [δ_comp x.1 y.1 rfl (n + 1) (m + 1) (n + m + 1) rfl rfl rfl]
+    simp)
+
+@[simp]
+theorem cocycleProduct_coe (x : Cocycle K L n) (y : Cocycle L M m) :
+    (cocycleProduct x y).1 = x.1.comp y.1 rfl := rfl
+
+def shiftedCocycleHom (y : Cocycle L M m) (n : ℤ) : L⟦n⟧ ⟶ M⟦n + m⟧ :=
+  (Cocycle.equivHomShift.symm y)⟦n⟧' ≫
+    (CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) m n (n + m)
+      (add_comm m n)).inv.app M
+
+theorem cocycleHom_component (x : Cocycle K L n) (i : ℤ) :
+    (Cocycle.equivHomShift.symm x).f i = x.1.v i (i + n) rfl := by
+  simp only [Cocycle.equivHomShift_symm_apply, Cocycle.homOf_f,
+    Cocycle.rightShift_coe, Cochain.rightShift_v, shiftFunctorObjXIso,
+    HomologicalComplex.XIsoOfEq_rfl, Iso.refl_inv]
+  exact Category.comp_id _
+
+private theorem cochain_component_transport (x : Cochain K L n)
+    (p q r : ℤ) (hpq : p + n = q) (hqr : q = r) :
+    x.v p q hpq ≫ (L.XIsoOfEq hqr).hom = x.v p r (hpq.trans hqr) := by
+  subst r
+  simp
+
+theorem cocycleHom_product (x : Cocycle K L n) (y : Cocycle L M m) :
+    Cocycle.equivHomShift.symm (cocycleProduct x y) =
+      Cocycle.equivHomShift.symm x ≫ shiftedCocycleHom y n := by
+  apply HomologicalComplex.Hom.ext
+  funext i
+  simp only [HomologicalComplex.comp_f, shiftedCocycleHom, cocycleHom_component,
+    shiftFunctor_map_f', shiftFunctorAdd'_inv_app_f']
+  change (x.1.comp y.1 rfl).v i (i + (n + m)) rfl =
+    x.1.v i (i + n) rfl ≫ y.1.v (i + n) (i + n + m) rfl ≫
+      (M.XIsoOfEq (show i + n + m = i + (n + m) by omega)).hom
+  rw [cochain_component_transport]
+  exact Cochain.comp_v x.1 y.1 rfl i (i + n) (i + (n + m)) rfl (by omega)
+
+theorem cocycleProduct_respects_classes
+    (x x' : Cocycle K L n) (y y' : Cocycle L M m)
+    (hx : CohomologyClass.mk x = CohomologyClass.mk x')
+    (hy : CohomologyClass.mk y = CohomologyClass.mk y') :
+    CohomologyClass.mk (cocycleProduct x y) = CohomologyClass.mk (cocycleProduct x' y') := by
+  have hx' := congrArg CohomologyClass.toHom hx
+  have hy' := congrArg CohomologyClass.toHom hy
+  let Hx := HomotopyCategory.homotopyOfEq _ _ hx'
+  let Hy := HomotopyCategory.homotopyOfEq _ _ hy'
+  apply (CohomologyClass.toHom_bijective K M (n + m)).1
+  change (HomotopyCategory.quotient _ _).map
+      (Cocycle.equivHomShift.symm (cocycleProduct x y)) =
+    (HomotopyCategory.quotient _ _).map (Cocycle.equivHomShift.symm (cocycleProduct x' y'))
+  rw [cocycleHom_product, cocycleHom_product]
+  exact HomotopyCategory.eq_of_homotopy _ _ (Hx.comp ((Hy.shift n).compRight _))
+
+def fullHomProduct (x : CohomologyClass K L n) (y : CohomologyClass L M m) :
+    CohomologyClass K M (n + m) :=
+  Quotient.liftOn₂ x y (fun a b => CohomologyClass.mk (cocycleProduct a b)) (by
+    intro a b a' b' ha hb
+    exact cocycleProduct_respects_classes a a' b b' (Quotient.sound ha) (Quotient.sound hb))
+
+@[simp]
+theorem fullHomProduct_mk (x : Cocycle K L n) (y : Cocycle L M m) :
+    fullHomProduct (CohomologyClass.mk x) (CohomologyClass.mk y) =
+      CohomologyClass.mk (cocycleProduct x y) := rfl
+
+end Cochains
+
+variable {R : Type u} [Ring R]
+variable {K L M : CochainComplex (ModuleCat.{u} R) ℤ} {n m : ℤ}
+
+noncomputable def cocycleComparisonMap (x : Cocycle K L n) :
+    chainOfCochain K ⟶ chainOfCochain (L⟦n⟧) :=
+  HomologicalComplex.extendMap (Cocycle.equivHomShift.symm x) negIndexEmbedding
+
+@[simp]
+theorem fullHomStableEquiv_mk (hK : TotallyAcyclicComplex (chainOfCochain K))
+    (hL : ExactProjectiveComplex (chainOfCochain (L⟦n⟧))) (x : Cocycle K L n) :
+    fullHomStableEquiv K L n hK hL (CohomologyClass.mk x) =
+      StableHom.classOf R _ _ (cokernelMap (cocycleComparisonMap x) 0) := by
+  exact homotopyCokernelEquiv_map hK hL (cocycleComparisonMap x)
+
+theorem fullHomStableEquiv_product
+    (hK : TotallyAcyclicComplex (chainOfCochain K))
+    (hL : ExactProjectiveComplex (chainOfCochain (L⟦n⟧)))
+    (hM : ExactProjectiveComplex (chainOfCochain (M⟦n + m⟧)))
+    (x : Cocycle K L n) (y : Cocycle L M m) :
+    fullHomStableEquiv K M (n + m) hK hM (CohomologyClass.mk (cocycleProduct x y)) =
+      StableHom.comp
+        (StableHom.classOf R _ _ (cokernelMap
+          (HomologicalComplex.extendMap (shiftedCocycleHom y n) negIndexEmbedding) 0))
+        (fullHomStableEquiv K L n hK hL (CohomologyClass.mk x)) := by
+  rw [fullHomStableEquiv_mk, fullHomStableEquiv_mk, StableHom.comp_classOf]
+  unfold cocycleComparisonMap
+  rw [cocycleHom_product, HomologicalComplex.extendMap_comp, cokernelMap_comp]
+
+end ArExplicit.CompleteComparison
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomShift.lean

@@ -0,0 +1,102 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomLinear
+
+namespace OAI
+
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex
+
+namespace ArExplicit.CompleteComparison
+
+universe u
+
+variable (k : Type u) [CommRing k]
+variable {C : Type*} [Category* C] [Preadditive C] [Linear k C]
+variable (K L : CochainComplex C ℤ) (n a n' : ℤ)
+
+noncomputable def rightShiftCocycleLinearEquiv (hn : n' + a = n) :
+    Cocycle K L n ≃ₗ[k] Cocycle K (L⟦a⟧) n' :=
+  { Cocycle.rightShiftAddEquiv n a n' hn with
+    map_smul' := by
+      intro c x
+      apply Subtype.ext
+      exact Cochain.rightShift_smul x.val a n' hn c }
+
+variable {k K L n a n'}
+
+theorem rightShift_boundary (hn : n' + a = n) (x : Cocycle K L n)
+    (hx : x ∈ coboundaries K L n) : x.rightShift a n' hn ∈ coboundaries K (L⟦a⟧) n' := by
+  obtain ⟨m, hm, y, hy⟩ := hx
+  have hm' : n' - 1 + a = m := by omega
+  refine ⟨n' - 1, by omega, a.negOnePow • y.rightShift a (n' - 1) hm', ?_⟩
+  rw [δ_units_smul, Cochain.δ_rightShift y a (n' - 1) n' hm' n hn, hy]
+  simp only [smul_smul, Int.units_mul_self, one_smul]
+  rfl
+
+theorem rightUnshift_boundary (hn : n' + a = n) (x : Cocycle K (L⟦a⟧) n')
+    (hx : x ∈ coboundaries K (L⟦a⟧) n') : x.rightUnshift n hn ∈ coboundaries K L n := by
+  obtain ⟨m', hm', y, hy⟩ := hx
+  have hm : m' + a = n - 1 := by omega
+  refine ⟨n - 1, by omega, a.negOnePow • y.rightUnshift (n - 1) hm, ?_⟩
+  rw [δ_units_smul, Cochain.δ_rightUnshift y (n - 1) hm n n' hn, hy]
+  simp only [smul_smul, Int.units_mul_self, one_smul]
+  rfl
+
+variable (k K L n a n')
+
+noncomputable def rightShiftCohomologyEquiv (hn : n' + a = n) :
+    CohomologyClass K L n ≃ₗ[k] CohomologyClass K (L⟦a⟧) n' :=
+  Submodule.Quotient.equiv (fullHomCoboundaries k K L n)
+    (fullHomCoboundaries k K (L⟦a⟧) n') (rightShiftCocycleLinearEquiv k K L n a n' hn) (by
+      ext y
+      constructor
+      · rintro ⟨x, hx, rfl⟩
+        exact rightShift_boundary hn x hx
+      · intro hy
+        let E := rightShiftCocycleLinearEquiv k K L n a n' hn
+        refine ⟨E.symm y, rightUnshift_boundary hn y hy, E.apply_symm_apply y⟩)
+
+noncomputable def leftShiftCocycleLinearEquiv (hn : n + a = n') :
+    Cocycle K L n ≃ₗ[k] Cocycle (K⟦a⟧) L n' :=
+  { Cocycle.leftShiftAddEquiv n a n' hn with
+    map_smul' := by
+      intro c x
+      apply Subtype.ext
+      exact Cochain.leftShift_smul x.val a n' hn c }
+
+variable {k K L n a n'}
+
+theorem leftShift_boundary (hn : n + a = n') (x : Cocycle K L n)
+    (hx : x ∈ coboundaries K L n) : x.leftShift a n' hn ∈ coboundaries (K⟦a⟧) L n' := by
+  obtain ⟨m, hm, y, hy⟩ := hx
+  have hm' : m + a = n' - 1 := by omega
+  refine ⟨n' - 1, by omega, a.negOnePow • y.leftShift a (n' - 1) hm', ?_⟩
+  rw [δ_units_smul, Cochain.δ_leftShift y a (n' - 1) n' hm' n hn, hy]
+  simp only [smul_smul, Int.units_mul_self, one_smul]
+  rfl
+
+theorem leftUnshift_boundary (hn : n + a = n') (x : Cocycle (K⟦a⟧) L n')
+    (hx : x ∈ coboundaries (K⟦a⟧) L n') : x.leftUnshift n hn ∈ coboundaries K L n := by
+  obtain ⟨m', hm', y, hy⟩ := hx
+  have hm : n - 1 + a = m' := by omega
+  refine ⟨n - 1, by omega, a.negOnePow • y.leftUnshift (n - 1) hm, ?_⟩
+  rw [δ_units_smul, Cochain.δ_leftUnshift y (n - 1) hm n n' hn, hy]
+  simp only [smul_smul, Int.units_mul_self, one_smul]
+  rfl
+
+variable (k K L n a n')
+
+noncomputable def leftShiftCohomologyEquiv (hn : n + a = n') :
+    CohomologyClass K L n ≃ₗ[k] CohomologyClass (K⟦a⟧) L n' :=
+  Submodule.Quotient.equiv (fullHomCoboundaries k K L n)
+    (fullHomCoboundaries k (K⟦a⟧) L n') (leftShiftCocycleLinearEquiv k K L n a n' hn) (by
+      ext y
+      constructor
+      · rintro ⟨x, hx, rfl⟩
+        exact leftShift_boundary hn x hx
+      · intro hy
+        let E := leftShiftCocycleLinearEquiv k K L n a n' hn
+        refine ⟨E.symm y, leftUnshift_boundary hn y hy, E.apply_symm_apply y⟩)
+
+end ArExplicit.CompleteComparison
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomShiftedHomotopy.lean

@@ -0,0 +1,33 @@
+import OAI.Algebra.AuslanderReiten.Homology.TriangleHomExact
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex
+universe u v w
+variable (k : Type u) [CommRing k]
+variable {C : Type w} [Category.{v} C] [Preadditive C] [Linear k C]
+variable (K L : CochainComplex C ℤ) (n : ℤ)
+
+def fullHomShiftedHomotopyEquiv : CohomologyClass K L n ≃ₗ[k]
+    ((HomotopyCategory.quotient C _).obj K ⟶ ((HomotopyCategory.quotient C _).obj L)⟦n⟧) :=
+  (fullHomHomotopyLinearEquiv k K L n).trans
+    (Linear.homCongr k (Iso.refl _)
+      (((HomotopyCategory.quotient C _).commShiftIso n).app L))
+
+@[simp]
+theorem fullHomShiftedHomotopyEquiv_mk (x : Cocycle K L n) :
+    fullHomShiftedHomotopyEquiv k K L n (CohomologyClass.mk x) =
+      (HomotopyCategory.quotient C _).map (Cocycle.equivHomShift.symm x) ≫
+        (((HomotopyCategory.quotient C _).commShiftIso n).app L).hom := by
+  simp only [fullHomShiftedHomotopyEquiv, LinearEquiv.trans_apply,
+    Linear.homCongr_apply, Iso.refl_inv, Category.id_comp]
+  rfl
+
+end ArExplicit
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomShiftedIdentity.lean

@@ -0,0 +1,39 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomShiftedProducts
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomDegreeProducts
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex CompleteComparison
+universe u v w
+variable (k : Type u) [CommRing k]
+variable {C : Type w} [Category.{v} C] [Preadditive C] [Linear k C]
+
+theorem fullHomShiftedHomotopyEquiv_identity (K : CochainComplex C ℤ) :
+    fullHomShiftedHomotopyEquiv k K K 0 (fullHomIdentity K) =
+      (shiftFunctorZero (HomotopyCategory C (ComplexShape.up ℤ)) ℤ).inv.app
+        ((HomotopyCategory.quotient C _).obj K) := by
+  have h : Cocycle.equivHomShift.symm (Cocycle.ofHom (𝟙 K)) =
+      ShiftedHom.mk₀ (0 : ℤ) rfl (𝟙 K) := by
+    apply HomologicalComplex.Hom.ext
+    funext i
+    simp only [cocycleHom_component, Cocycle.ofHom_coe]
+    simp only [ShiftedHom.mk₀, CategoryTheory.shiftFunctorZero',
+      eqToIso_refl, Iso.trans_inv, Iso.refl_inv,
+      Category.id_comp, CochainComplex.shiftFunctorZero_inv_app_f, Category.comp_id]
+    change (Cochain.ofHom (𝟙 K)).v i (i+0) rfl =
+      (K.XIsoOfEq (show i=i+0 by omega)).hom
+    simpa only [Cochain.ofHom_v, HomologicalComplex.id_f, Category.id_comp] using
+      (Cochain.v_comp_XIsoOfEq_hom (Cochain.ofHom (𝟙 K)) i i (i+0) (add_zero i) (by omega)).symm
+  rw [fullHomIdentity, fullHomShiftedHomotopyEquiv_mk, h]
+  change (ShiftedHom.mk₀ (0 : ℤ) rfl (𝟙 K)).map (HomotopyCategory.quotient C _) = _
+  rw [ShiftedHom.map_mk₀, CategoryTheory.Functor.map_id]
+  simp [ShiftedHom.mk₀, CategoryTheory.shiftFunctorZero']
+
+end ArExplicit
+
+end
+
+end OAI

lean/OAI/Algebra/AuslanderReiten/HomComplex/FullHomShiftedMaps.lean

@@ -0,0 +1,38 @@
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomShiftedHomotopy
+import OAI.Algebra.AuslanderReiten.HomComplex.FullHomComposition
+
+namespace OAI
+
+noncomputable section
+namespace ArExplicit
+open CategoryTheory
+open CochainComplex CochainComplex.HomComplex
+universe u v w
+variable (k : Type u) [CommRing k]
+variable {C : Type w} [Category.{v} C] [Preadditive C] [Linear k C]
+variable {K L M : CochainComplex C ℤ} (n : ℤ)
+
+theorem fullHomShiftedHomotopyEquiv_postcomp (f : L ⟶ M) (x : CohomologyClass K L n) :
+    fullHomShiftedHomotopyEquiv k K M n (fullHomPostcomp f n x) =
+      fullHomShiftedHomotopyEquiv k K L n x ≫
+        ((HomotopyCategory.quotient C _).map f)⟦n⟧' := by
+  obtain ⟨x, rfl⟩ := CohomologyClass.mk_surjective x
+  rw [fullHomPostcomp_mk, fullHomShiftedHomotopyEquiv_mk,
+    fullHomShiftedHomotopyEquiv_mk, Cocycle.equivHomShift_symm_postcomp,
+    Functor.map_comp, Category.assoc]
+  simpa only [Category.assoc, Iso.app_hom] using congrArg
+    (fun g => (HomotopyCategory.quotient C _).map (Cocycle.equivHomShift.symm x) ≫ g)
+    ((HomotopyCategory.quotient C _).commShiftIso_hom_naturality f n)
+
+theorem fullHomShiftedHomotopyEquiv_precomp (f : K ⟶ L) (x : CohomologyClass L M n) :
+    fullHomShiftedHomotopyEquiv k K M n (fullHomPrecomp f n x) =
+      (HomotopyCategory.quotient C _).map f ≫ fullHomShiftedHomotopyEquiv k L M n x := by
+  obtain ⟨x, rfl⟩ := CohomologyClass.mk_surjective x
+  rw [fullHomPrecomp_mk, fullHomShiftedHomotopyEquiv_mk,
+    fullHomShiftedHomotopyEquiv_mk, Cocycle.equivHomShift_symm_precomp,
+    Functor.map_comp, Category.assoc]
+end ArExplicit
+
+end
+
+end OAI