Add lean source and binary files (part 8)

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFirstDerivedRetraction.lean

@@ -0,0 +1,66 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFirstDerivedCompatibility
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFirstComponentExact
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.BlockModule
+universe u
+variable (L R : Type u) [Ring L] [Ring R]
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} L)]
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} (L × R))]
+
+/-- The exact derived first-component functor on the whole product-ring derived category. -/
+abbrev derivedFirstComponent := (ProductModules.firstFunctor.{u,u} L R).mapDerivedCategory
+
+def firstComplexComponentIso : firstComplexFunctor L R ⋙
+    (ProductModules.firstFunctor L R).mapHomologicalComplex (.up ℤ) ≅
+      𝟭 (CochainComplex (ModuleCat.{u} L) ℤ) :=
+  Functor.mapHomologicalComplexCompIso (ProductModules.firstInflationComponentIso L R) (.up ℤ) ≪≫
+    Functor.mapHomologicalComplexIdIso (ModuleCat.{u} L) (.up ℤ)
+
+/-- On chain representatives, the composite is the identity localization. -/
+def derivedFirstComponentFactors : DerivedCategory.Q ⋙ derivedFirst L R ⋙
+    derivedFirstComponent L R ≅ (DerivedCategory.Q : CochainComplex (ModuleCat.{u} L) ℤ ⥤ _) :=
+  (Functor.associator ..).symm ≪≫
+    Functor.isoWhiskerRight (derivedFirstComparison L R) _ ≪≫
+    Functor.associator .. ≪≫
+    Functor.isoWhiskerLeft _ (ProductModules.firstFunctor L R).mapDerivedCategoryFactors ≪≫
+    (Functor.associator ..).symm ≪≫
+    Functor.isoWhiskerRight (firstComplexComponentIso L R) _ ≪≫ Functor.leftUnitor _
+
+/-- Taking the first component recovers every derived object, naturally. -/
+def derivedFirstRetraction : derivedFirst L R ⋙ derivedFirstComponent L R ≅
+    𝟭 (DerivedCategory (ModuleCat.{u} L)) := by
+  letI : Localization.Lifting DerivedCategory.Q
+      (HomologicalComplex.quasiIso (ModuleCat.{u} L) (.up ℤ)) DerivedCategory.Q
+      (derivedFirst L R ⋙ derivedFirstComponent L R) := ⟨derivedFirstComponentFactors L R⟩
+  exact Localization.liftNatIso DerivedCategory.Q
+    (HomologicalComplex.quasiIso (ModuleCat.{u} L) (.up ℤ))
+    DerivedCategory.Q DerivedCategory.Q _ _ (Iso.refl _)
+
+/-- The same retraction for mathlib's exact derived inflation. -/
+def exactFirstRetraction : (ProductModules.firstInflation L R).mapDerivedCategory ⋙
+    derivedFirstComponent L R ≅ 𝟭 (DerivedCategory (ModuleCat.{u} L)) :=
+  Functor.isoWhiskerRight (derivedFirstIso L R).symm _ ≪≫ derivedFirstRetraction L R
+
+instance derivedFirst_additive : (derivedFirst L R).Additive :=
+  Functor.additive_of_iso (derivedFirstIso L R).symm
+
+/-- No derived object becomes zero merely by putting it in the first block. -/
+theorem derivedFirst_isZero_iff (Y : DerivedCategory (ModuleCat.{u} L)) :
+    IsZero ((derivedFirst L R).obj Y) ↔ IsZero Y := by
+  constructor
+  · intro h
+    exact ((derivedFirstRetraction L R).app Y).isZero_iff.mp
+      ((derivedFirstComponent L R).map_isZero h)
+  · exact (derivedFirst L R).map_isZero
+
+theorem exactFirst_isZero_iff (Y : DerivedCategory (ModuleCat.{u} L)) :
+    IsZero ((ProductModules.firstInflation L R).mapDerivedCategory.obj Y) ↔ IsZero Y :=
+  ((derivedFirstIso L R).app Y).isZero_iff.symm.trans (derivedFirst_isZero_iff L R Y)
+end LittleFinitistic.BlockModule
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFixedTensorFunctor.lean

@@ -0,0 +1,86 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorExactness
+import Mathlib.Algebra.Category.ModuleCat.ChangeOfRings
+import Mathlib.Algebra.Homology.ShortComplex.ModuleCat
+import Mathlib.CategoryTheory.Abelian.Exact
+import Mathlib.Algebra.Homology.QuasiIso
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.BalancedTensor
+universe u
+variable (k A : Type u) [Field k] [Ring A] [Algebra k A]
+
+abbrev ScalarLeftModule (N : ModuleCat.{u} A) :=
+  (ModuleCat.restrictScalars (algebraMap k A)).obj N
+
+instance scalarLeftTower (N : ModuleCat.{u} A) : IsScalarTower k A (ScalarLeftModule k A N) where
+  smul_assoc r a n := by
+    change (r • a) • (n : N) = algebraMap k A r • (a • (n : N))
+    rw [Algebra.smul_def,mul_smul]
+
+variable (M : Type u) [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M]
+
+/-- Tensor by a fixed actual right module on every left module. -/
+def fixedTensorFunctor : ModuleCat.{u} A ⥤ ModuleCat.{u} k where
+  obj N := ModuleCat.of k (Tensor k A M (ScalarLeftModule k A N))
+  map {N N'} f := ModuleCat.ofHom
+    (mapRightTo (k := k) (M := M) (N := ScalarLeftModule k A N) (N' := ScalarLeftModule k A N') f.hom)
+  map_id N := by
+    apply ModuleCat.hom_ext
+    apply BalancedTensor.ext
+    intro m n
+    rfl
+  map_comp f g := by
+    apply ModuleCat.hom_ext
+    apply BalancedTensor.ext
+    intro m n
+    rfl
+
+instance fixedTensorFunctor_additive : (fixedTensorFunctor k A M).Additive where
+  map_add {N N'} {f g} := by
+    apply ModuleCat.hom_ext
+    apply BalancedTensor.ext
+    intro m n
+    exact (mk k A M (ScalarLeftModule k A N') m).map_add (f.hom n) (g.hom n)
+
+variable (e : A) (he : e*e=e)
+
+include he in
+theorem idempotentTensor_mapsExact (S : ShortComplex (ModuleCat.{u} A)) (hS : S.Exact) :
+    (S.map (fixedTensorFunctor k A (IdempotentTensor.rightIdeal e))).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff]
+  have h : Function.Exact
+      (S.f.hom : ScalarLeftModule k A S.X₁ →ₗ[A] ScalarLeftModule k A S.X₂)
+      (S.g.hom : ScalarLeftModule k A S.X₂ →ₗ[A] ScalarLeftModule k A S.X₃) := by
+    intro n
+    constructor
+    · exact (ShortComplex.moduleCat_exact_iff S).mp hS n
+    · rintro ⟨m,rfl⟩
+      exact congrArg (fun f => f.hom m) S.zero
+  have ht := @IdempotentTensor.tensor_exact k A
+    (ScalarLeftModule k A S.X₁) (ScalarLeftModule k A S.X₂) (ScalarLeftModule k A S.X₃)
+    _ _ _ _ _ _ (scalarLeftTower k A S.X₁)
+    _ _ _ (scalarLeftTower k A S.X₂) _ _ _ (scalarLeftTower k A S.X₃)
+    e he S.f.hom S.g.hom h
+  intro z hz
+  exact (ht z).mp hz
+
+include he in
+/-- Derived input complexes remain arbitrary: this functor preserves homology. -/
+theorem idempotentTensor_preservesHomology :
+    (fixedTensorFunctor k A (IdempotentTensor.rightIdeal e)).PreservesHomology :=
+  Functor.preservesHomology_of_map_exact _ (idempotentTensor_mapsExact k A e he)
+
+include he in
+/-- No boundedness, dimension, projectivity, or flatness hypothesis on either input complex. -/
+theorem idempotentTensor_quasiIso
+    {Z Z' : CochainComplex (ModuleCat.{u} A) ℤ} (f : Z ⟶ Z') [QuasiIso f] :
+    QuasiIso (((fixedTensorFunctor k A (IdempotentTensor.rightIdeal e)).mapHomologicalComplex (.up ℤ)).map f) := by
+  let := idempotentTensor_preservesHomology k A e he
+  infer_instance
+end LittleFinitistic.BalancedTensor
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFreeTensor.lean

@@ -0,0 +1,80 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorExactness
+import Mathlib.LinearAlgebra.Finsupp.LSum
+import Mathlib.Algebra.Algebra.Opposite
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.BalancedTensor.Free
+universe u
+variable {k A : Type u} [Field k] [Ring A] [Algebra k A]
+variable (I N : Type u) [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+
+/-- A right-regular coefficient acts on the left tensor factor by its unop. -/
+def coefficientAction : Aᵐᵒᵖ →ₗ[k] N →ₗ[k] N :=
+  (Algebra.lsmul k k N).toLinearMap.comp (MulOpposite.opLinearEquiv k).symm.toLinearMap
+
+/-- Coordinate evaluation of a free right module tensor N. -/
+def evaluateBilinear : (I →₀ Aᵐᵒᵖ) →ₗ[k] N →ₗ[k] (I →₀ N) :=
+  Finsupp.lsum k (fun i => (coefficientAction (k := k) (A := A) N).compr₂ (Finsupp.lsingle i))
+
+@[simp] theorem evaluateBilinear_single (i : I) (x : Aᵐᵒᵖ) (n : N) :
+    evaluateBilinear (k := k) I N (Finsupp.single i x) n = Finsupp.single i (x.unop • n) := by
+  simp only [evaluateBilinear,Finsupp.lsum_single]
+  rfl
+
+def evaluation : Tensor k A (I →₀ Aᵐᵒᵖ) N →ₗ[k] (I →₀ N) :=
+  lift (evaluateBilinear (k := k) I N) (by
+    intro a m n
+    induction m using Finsupp.induction_linear with
+    | zero => simp only [smul_zero,map_zero,LinearMap.zero_apply]
+    | add x y hx hy => simp only [smul_add,map_add,LinearMap.add_apply,hx,hy]
+    | single i x =>
+      rw [Finsupp.smul_single,evaluateBilinear_single,evaluateBilinear_single]
+      change Finsupp.single i ((x.unop*a) • n) = Finsupp.single i (x.unop • (a • n))
+      rw [mul_smul])
+
+@[simp] theorem evaluation_single (i : I) (x : Aᵐᵒᵖ) (n : N) :
+    evaluation (k := k) I N (mk k A (I →₀ Aᵐᵒᵖ) N (Finsupp.single i x) n) =
+      Finsupp.single i (x.unop • n) := evaluateBilinear_single I N i x n
+
+def insertion : (I →₀ N) →ₗ[k] Tensor k A (I →₀ Aᵐᵒᵖ) N :=
+  Finsupp.lsum k (fun i => mk k A (I →₀ Aᵐᵒᵖ) N (Finsupp.single i 1))
+
+omit [IsScalarTower k A N] in
+@[simp] theorem insertion_single (i : I) (n : N) :
+    insertion (k := k) (A := A) I N (Finsupp.single i n) =
+      mk k A (I →₀ Aᵐᵒᵖ) N (Finsupp.single i 1) n := by
+  simp only [insertion,Finsupp.lsum_single]
+
+theorem evaluation_insertion (z : I →₀ N) :
+    evaluation (k := k) (A := A) I N (insertion I N z) = z := by
+  induction z using Finsupp.induction_linear with
+  | zero => simp only [map_zero]
+  | add x y hx hy => simp only [map_add,hx,hy]
+  | single i n => rw [insertion_single,evaluation_single,MulOpposite.unop_one,one_smul]
+
+theorem insertion_evaluation (z : Tensor k A (I →₀ Aᵐᵒᵖ) N) :
+    insertion I N (evaluation (k := k) I N z) = z := by
+  induction z using BalancedTensor.induction_on with
+  | hz => simp only [map_zero]
+  | ht m n =>
+    induction m using Finsupp.induction_linear with
+    | zero => simp only [map_zero,LinearMap.zero_apply]
+    | add x y hx hy => simp only [map_add,LinearMap.add_apply,hx,hy]
+    | single i x =>
+      rw [evaluation_single,insertion_single,← balance]
+      congr 1
+      rw [MulOpposite.op_unop,Finsupp.smul_single,smul_eq_mul,mul_one]
+  | ha x y hx hy => simp only [map_add,hx,hy]
+
+/-- The actual free balanced tensor, for arbitrary index sets and arbitrary modules N. -/
+def equivalence : Tensor k A (I →₀ Aᵐᵒᵖ) N ≃ₗ[k] (I →₀ N) where
+  __ := evaluation (k := k) I N
+  invFun := insertion I N
+  left_inv := insertion_evaluation I N
+  right_inv := evaluation_insertion I N
+end LittleFinitistic.BalancedTensor.Free
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFreeTensorExactness.lean

@@ -0,0 +1,83 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFreeTensor
+import Mathlib.LinearAlgebra.Finsupp.Defs
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.BalancedTensor.Free
+universe u
+variable {k A : Type u} [Field k] [Ring A] [Algebra k A]
+variable (I : Type u)
+variable {N N' N'' : Type u}
+variable [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+variable [AddCommGroup N'] [Module k N'] [Module A N'] [IsScalarTower k A N']
+variable [AddCommGroup N''] [Module k N''] [Module A N''] [IsScalarTower k A N'']
+
+theorem evaluation_naturality (f : N →ₗ[A] N') (z : Tensor k A (I →₀ Aᵐᵒᵖ) N) :
+    evaluation (k := k) I N' (mapRightTo f z) =
+      Finsupp.mapRange.linearMap (f.restrictScalars k) (evaluation (k := k) I N z) := by
+  induction z using BalancedTensor.induction_on with
+  | hz => simp only [map_zero]
+  | ht m n =>
+    induction m using Finsupp.induction_linear with
+    | zero => simp only [map_zero,LinearMap.zero_apply]
+    | add x y hx hy => simp only [map_add,LinearMap.add_apply,hx,hy]
+    | single i x =>
+      simp only [mapRightTo_mk,evaluation_single]
+      change Finsupp.single i (MulOpposite.unop x • f n) =
+        Finsupp.mapRange f f.map_zero (Finsupp.single i (MulOpposite.unop x • n))
+      rw [Finsupp.mapRange_single, f.map_smul]
+  | ha x y hx hy => simp only [map_add,hx,hy]
+
+/-- Direct sums preserve exactness, with a preimage supported on the given finite support. -/
+theorem finsupp_exact (f : N →ₗ[A] N') (g : N' →ₗ[A] N'') (h : Function.Exact f g) :
+    Function.Exact (Finsupp.mapRange.linearMap (f.restrictScalars k) : (I →₀ N) →ₗ[k] (I →₀ N'))
+      (Finsupp.mapRange.linearMap (g.restrictScalars k)) := by
+  classical
+  intro z
+  constructor
+  · intro hz
+    have hg (i : I) : g (z i) = 0 := congrArg (fun x : I →₀ N'' => x i) hz
+    let y : I →₀ N := Finsupp.onFinset z.support
+      (fun i => if hi : z i = 0 then 0 else Classical.choose ((h (z i)).mp (hg i))) (by
+        intro i hi
+        by_contra hn
+        have hz0 : z i = 0 := by simpa only [Finsupp.mem_support_iff,not_not] using hn
+        exact hi (by simp [hz0]))
+    refine ⟨y, ?_⟩
+    ext i
+    change f (if hi : z i = 0 then 0 else Classical.choose ((h (z i)).mp (hg i))) = z i
+    split_ifs with hi
+    · rw [map_zero,hi]
+    · exact Classical.choose_spec ((h (z i)).mp (hg i))
+  · rintro ⟨y,rfl⟩
+    ext i
+    exact (h (f (y i))).mpr ⟨y i,rfl⟩
+
+/-- Tensor by an arbitrary free right module preserves every exact module sequence. -/
+theorem tensor_exact (f : N →ₗ[A] N') (g : N' →ₗ[A] N'') (h : Function.Exact f g) :
+    Function.Exact (mapRightTo (k := k) (M := I →₀ Aᵐᵒᵖ) f)
+      (mapRightTo (k := k) (M := I →₀ Aᵐᵒᵖ) g) := by
+  intro z
+  constructor
+  · intro hz
+    have hz' : Finsupp.mapRange.linearMap (g.restrictScalars k) (evaluation (k := k) I N' z) = 0 := by
+      rw [← evaluation_naturality,hz,map_zero]
+    obtain ⟨y,hy⟩ := (finsupp_exact (k := k) I f g h _).mp hz'
+    refine ⟨(equivalence (k := k) (A := A) I N).symm y, ?_⟩
+    apply (equivalence (k := k) (A := A) I N').injective
+    change evaluation (k := k) I N' (mapRightTo f ((equivalence (k := k) (A := A) I N).symm y)) = _
+    rw [evaluation_naturality]
+    change Finsupp.mapRange.linearMap (f.restrictScalars k)
+      ((equivalence (k := k) (A := A) I N) ((equivalence (k := k) (A := A) I N).symm y)) = _
+    rw [LinearEquiv.apply_symm_apply]
+    exact hy
+  · rintro ⟨y,rfl⟩
+    induction y using BalancedTensor.induction_on with
+    | hz => simp only [map_zero]
+    | ht m n => rw [mapRightTo_mk,mapRightTo_mk,(h (f n)).mpr ⟨n,rfl⟩,map_zero]
+    | ha x y hx hy => simp only [map_add,hx,hy,add_zero]
+end LittleFinitistic.BalancedTensor.Free
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFullTensorComplex.lean

@@ -0,0 +1,89 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFullTensorTerms
+import Mathlib.Algebra.Homology.Embedding.Restriction
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.FullTensorTerm
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+attribute [local instance] VertexTensor.termScalar VertexTensor.termTower
+
+def differential (n : ℕ) : FullTensorTerm P a l n →ₗ[Enveloping k B] FullTensorTerm P a l (n+1) :=
+  TwoSidedTensor.map (T := Bᵐᵒᵖ) (N := BimoduleO P a l)
+    (TensorResolution.differential k B l n) (TensorResolution.differential_left k B l n)
+
+theorem differential_square (n : ℕ) : (differential P a l (n+1)).comp (differential P a l n) = 0 := by
+  apply LinearMap.restrictScalars_injective k
+  apply BalancedTensor.ext
+  intro m v
+  change BalancedTensor.mk k (B ⊗[k] ChainAlgebra k l) (TensorResolution.term k B l (n+2))
+    (BimoduleO P a l) (TensorResolution.differential k B l (n+1)
+      (TensorResolution.differential k B l n m)) v = 0
+  have h := congrArg (fun f => f m) (TensorResolution.differential_square k B l n)
+  change TensorResolution.differential k B l (n+1) (TensorResolution.differential k B l n m) = 0 at h
+  rw [h,map_zero,LinearMap.zero_apply]
+
+/-- Actual tensor complex, with both B-actions and the actual extended arrow maps. -/
+def complex : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℕ :=
+  CochainComplex.of (fun n => ModuleCat.of _ (FullTensorTerm P a l n))
+    (fun n => ModuleCat.ofHom (differential P a l n))
+    (fun n => ModuleCat.hom_ext (differential_square P a l n))
+
+/-- Supported evaluation is the product action followed by the source coordinate projection. -/
+theorem supportedEquiv_mk (n : ℕ) (hn : n ≤ l) (m : TensorResolution.term k B l n) (v : BimoduleO P a l) :
+    supportedEquiv P a l n hn
+      (TwoSidedTensor.mk k (B ⊗[k] ChainAlgebra k l) B Bᵐᵒᵖ (TensorResolution.term k B l n) (BimoduleO P a l) m v) =
+        (m.val • v : BimoduleO P a l) ⟨n,by omega⟩ := rfl
+
+theorem supported_differential (n : ℕ) (hn : n+1 ≤ l) (z : FullTensorTerm P a l n) :
+    supportedEquiv P a l (n+1) hn (differential P a l n z) =
+      (P.d (a+(n:ℤ)) (a+((n+1:ℕ):ℤ))).hom (supportedEquiv P a l n (by omega) z) := by
+  have h : (supportedEquiv P a l (n+1) hn).toLinearMap.comp (differential P a l n) =
+      (P.d (a+(n:ℤ)) (a+((n+1:ℕ):ℤ))).hom.comp
+        (supportedEquiv P a l n (by omega)).toLinearMap := by
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro m v
+    change ((((1:B) ⊗ₜ[k] ChainAlgebra.extendedArrow k l n) * m.val) • v : BimoduleO P a l) ⟨n+1,by omega⟩ =
+      (P.d (a+(n:ℤ)) (a+((n+1:ℕ):ℤ))).hom ((m.val • v : BimoduleO P a l) ⟨n,by omega⟩)
+    have hv : (((1:B) ⊗ₜ[k] ChainAlgebra.extendedArrow k l n) * m.val) • v =
+        ChainAlgebra.arrow k l ⟨n,by omega⟩ • (m.val • v) := by
+      rw [mul_smul,BimoduleO.tensor_smul,one_smul,ChainAlgebra.extendedArrow,dite_eq_left (by omega)]
+    exact (congrArg (fun w : BimoduleO P a l => w ⟨n+1,by omega⟩) hv).trans
+      (VertexTensor.arrow_coordinate P a l ⟨n,by omega⟩ (m.val • v))
+  exact congrArg (fun f => f z) h
+
+variable (hP : ∀ n : ℕ, l < n → IsZero (P.X (a+(n:ℤ))))
+
+theorem termEquiv_differential (n : ℕ) (z : FullTensorTerm P a l n) :
+    termEquiv P a l hP (n+1) (differential P a l n z) =
+      (P.d (a+(n:ℤ)) (a+((n+1:ℕ):ℤ))).hom (termEquiv P a l hP n z) := by
+  by_cases hn : n+1 ≤ l
+  · simp only [termEquiv,dite_eq_left hn,dite_eq_left (show n ≤ l by omega)]
+    exact supported_differential P a l n hn z
+  · let : Subsingleton (P.X (a+((n+1:ℕ):ℤ))) :=
+      ModuleCat.isZero_iff_subsingleton.mp (hP (n+1) (by omega))
+    exact Subsingleton.elim _ _
+
+/-- The entire actual tensor complex identifies with P on degrees a,a+1,... . -/
+def complexIso : complex P a l ≅ P.restriction (ComplexShape.embeddingUpIntGE a) :=
+  HomologicalComplex.Hom.isoOfComponents (fun n => (termEquiv P a l hP n).toModuleIso) (by
+    intro n m hnm
+    change n+1=m at hnm
+    subst m
+    change (termEquiv P a l hP n).toModuleIso.hom ≫ P.d (a+(n:ℤ)) (a+((n+1:ℕ):ℤ)) =
+      CochainComplex.of.d (fun j => ModuleCat.of (Enveloping k B) (FullTensorTerm P a l j))
+        (fun j => ModuleCat.ofHom (differential P a l j)) n (n+1) ≫ (termEquiv P a l hP (n+1)).toModuleIso.hom
+    rw [CochainComplex.of_d]
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro z
+    exact (termEquiv_differential P a l hP n z).symm)
+end LittleFinitistic.OrdinarySimulation.FullTensorTerm
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFullTensorTerms.lean

@@ -0,0 +1,86 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTwoSidedTensor
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorDifferential
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryIntegerResolution
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+
+instance BimoduleO.commuteRightTensor : SMulCommClass Bᵐᵒᵖ (B ⊗[k] ChainAlgebra k l) (BimoduleO P a l) :=
+  ⟨fun r x v => (smul_comm x r v).symm⟩
+
+/-- Every degree of Q_T tensor_BC O, carrying the actual outside B-actions. -/
+abbrev FullTensorTerm (n : ℕ) := TwoSidedTensor k (B ⊗[k] ChainAlgebra k l) B Bᵐᵒᵖ
+  (TensorResolution.term k B l n) (BimoduleO P a l)
+
+namespace FullTensorTerm
+open ChainAlgebra
+
+/-- Supported extended ideals are the same right ideals as the finite vertex terms. -/
+def supportedIdealEquiv (n : ℕ) (hn : n ≤ l) :
+    TensorResolution.term k B l n ≃ₗ[(B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ]
+      IdempotentTensor.rightIdeal (TensorIdeal.vertex (k := k) (B := B) (vertex k l ⟨n,by omega⟩)) where
+  toFun x := ⟨x.val, by
+    have hx := x.property
+    change TensorIdeal.vertex (k := k) (B := B) (extendedVertex k l n) * x.val = x.val at hx
+    rw [extendedVertex,dite_eq_left hn] at hx
+    exact hx⟩
+  invFun x := ⟨x.val, by
+    change TensorIdeal.vertex (k := k) (B := B) (extendedVertex k l n) * x.val = x.val
+    rw [extendedVertex,dite_eq_left hn]
+    exact x.property⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+def finiteModel (i : Fin (l+1)) :
+    TwoSidedTensor k (B ⊗[k] ChainAlgebra k l) B Bᵐᵒᵖ
+      (IdempotentTensor.rightIdeal (TensorIdeal.vertex (k := k) (B := B) (vertex k l i)))
+      (BimoduleO P a l) ≃ₗ[Enveloping k B] VertexTensor P a l i where
+  toFun z := z
+  invFun z := z
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+/-- Actual degreewise B-bimodule comparison throughout the supported range. -/
+def supportedEquiv (n : ℕ) (hn : n ≤ l) : FullTensorTerm P a l n ≃ₗ[Enveloping k B] P.X (a+(n:ℤ)) :=
+  (TwoSidedTensor.congrLeft (k := k) (S := B) (T := Bᵐᵒᵖ) (N := BimoduleO P a l)
+    (supportedIdealEquiv (k := k) (B := B) l n hn) (fun _ _ => rfl)).trans
+      ((finiteModel P a l ⟨n,by omega⟩).trans (VertexTensor.bimoduleEquiv P a l ⟨n,by omega⟩))
+
+theorem subsingleton_above (n : ℕ) (hn : l < n) : Subsingleton (FullTensorTerm P a l n) := by
+  let : Subsingleton (TensorResolution.term k B l n) :=
+    (ModuleCat.isZero_iff_subsingleton).mp (TensorResolution.term_vanishes k B l n hn)
+  exact inferInstanceAs (Subsingleton (BalancedTensor.Tensor k (B ⊗[k] ChainAlgebra k l)
+    (TensorResolution.term k B l n) (BimoduleO P a l)))
+
+/-- Use precisely the source's upper support bound for all remaining degrees. -/
+def outsideEquiv (n : ℕ) (hn : l < n) (hP : IsZero (P.X (a+(n:ℤ)))) :
+    FullTensorTerm P a l n ≃ₗ[Enveloping k B] P.X (a+(n:ℤ)) := by
+  letI := subsingleton_above P a l n hn
+  letI : Subsingleton (P.X (a+(n:ℤ))) := ModuleCat.isZero_iff_subsingleton.mp hP
+  exact { toFun := fun _ => 0
+          invFun := fun _ => 0
+          left_inv := fun _ => Subsingleton.elim _ _
+          right_inv := fun _ => Subsingleton.elim _ _
+          map_add' := fun _ _ => Subsingleton.elim _ _
+          map_smul' := fun _ _ => Subsingleton.elim _ _ }
+
+/-- No extra support assumptions: P is required to vanish only above a+l here. -/
+def termEquiv (hP : ∀ n : ℕ, l < n → IsZero (P.X (a+(n:ℤ)))) (n : ℕ) :
+    FullTensorTerm P a l n ≃ₗ[Enveloping k B] P.X (a+(n:ℤ)) :=
+  if hn : n ≤ l then supportedEquiv P a l n hn else outsideEquiv P a l n (by omega) (hP n (by omega))
+end FullTensorTerm
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFunctorExtension.lean

@@ -0,0 +1,42 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinarySupportedExtension
+import Mathlib.Algebra.Homology.Additive
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+namespace LittleFinitistic.FunctorExtension
+universe u v u' v' w w'
+variable {C : Type u} [Category.{v} C] [HasZeroMorphisms C] [HasZeroObject C]
+variable {D : Type u'} [Category.{v'} D] [HasZeroMorphisms D] [HasZeroObject D]
+variable (F : C ⥤ D) [F.PreservesZeroMorphisms]
+variable {I : Type w} {J : Type w'} {c : ComplexShape I} {c' : ComplexShape J}
+variable (K : HomologicalComplex C c) (e : c.Embedding c') [e.IsRelIff]
+
+omit [HasZeroObject D] [e.IsRelIff] in
+/-- Mapping an extended complex retains its proved zero terms outside the embedded degrees. -/
+theorem mappedSupport : ((F.mapHomologicalComplex c').obj (K.extend e)).IsStrictlySupported e where
+  isZero j hj := F.map_isZero (K.isZero_extend_X e j hj)
+
+/-- On the actual supported degrees, mapping and extension have the same original terms. -/
+def restrictionIso : ((F.mapHomologicalComplex c').obj (K.extend e)).restriction e ≅
+    (F.mapHomologicalComplex c).obj K :=
+  HomologicalComplex.Hom.isoOfComponents (fun i => F.mapIso (K.extendXIso e (i := i) rfl)) (by
+    intro i j _
+    change F.map (K.extendXIso e (i := i) rfl).hom ≫ F.map (K.d i j) =
+      F.map ((K.extend e).d (e.f i) (e.f j)) ≫ F.map (K.extendXIso e (i := j) rfl).hom
+    rw [← F.map_comp,← F.map_comp]
+    congr 1
+    rw [HomologicalComplex.extend_d_eq _ _ rfl rfl]
+    simp only [Category.assoc,Iso.inv_hom_id,Category.comp_id])
+
+/-- An actual chain isomorphism commuting a zero-preserving functor with extension by zero. -/
+def iso : (F.mapHomologicalComplex c').obj (K.extend e) ≅
+    ((F.mapHomologicalComplex c).obj K).extend e := by
+  letI := mappedSupport F K e
+  exact (OrdinarySimulation.SupportedExtension.iso ((F.mapHomologicalComplex c').obj (K.extend e)) e).symm ≪≫
+    (e.extendFunctor D).mapIso (restrictionIso F K e)
+end LittleFinitistic.FunctorExtension
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryGenuineBimoduleComparison.lean

@@ -0,0 +1,78 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleTensorFunctor
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorBimoduleResolution
+import OAI.Algebra.Finitistic.Ordinary.OrdinarySimulationComparison
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+
+abbrev genuineTensorFunctor :=
+  bimoduleTensorFunctor k B (B ⊗[k] ChainAlgebra k l) Bᵐᵒᵖ (BimoduleO P a l)
+
+def genuineFiniteTermIso (n : ℕ) :
+    (genuineTensorFunctor P a l).obj ((TensorResolution.bimoduleComplex k B l).X n) ≅
+      (FullTensorTerm.complex P a l).X n := by
+  let e : BimoduleCoefficients k B (B ⊗[k] ChainAlgebra k l)
+      ((TensorResolution.bimoduleComplex k B l).X n) ≃ₗ[(B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ]
+        TensorResolution.term k B l n := (TensorResolution.forgetBimoduleTerm k B l n).toLinearEquiv
+  have he (b : B) (x : BimoduleCoefficients k B (B ⊗[k] ChainAlgebra k l)
+      ((TensorResolution.bimoduleComplex k B l).X n)) : e (b • x) = b • e x := by
+    apply Subtype.ext
+    change TensorIdeal.coefficient b * (x.val * 1) = TensorIdeal.coefficient b * x.val
+    rw [mul_one]
+  exact (TwoSidedTensor.congrLeft (k := k) (S := B) (T := Bᵐᵒᵖ) (N := BimoduleO P a l) e he).toModuleIso
+
+/-- The actual finite bimodule tensor agrees with the existing full computation, preserving both B-actions. -/
+def genuineFiniteComplexIso :
+    ((genuineTensorFunctor P a l).mapHomologicalComplex (.up ℕ)).obj
+      (TensorResolution.bimoduleComplex k B l) ≅ FullTensorTerm.complex P a l :=
+  HomologicalComplex.Hom.isoOfComponents (genuineFiniteTermIso P a l) (by
+    intro n m h
+    change n+1=m at h
+    subst m
+    change (genuineFiniteTermIso P a l n).hom ≫ (FullTensorTerm.complex P a l).d n (n+1) =
+      (genuineTensorFunctor P a l).map ((TensorResolution.bimoduleComplex k B l).d n (n+1)) ≫
+        (genuineFiniteTermIso P a l (n+1)).hom
+    have h₁ : (FullTensorTerm.complex P a l).d n (n+1) = ModuleCat.ofHom (FullTensorTerm.differential P a l n) :=
+      CochainComplex.of_d (fun n => ModuleCat.of (Enveloping k B) (FullTensorTerm P a l n))
+        (fun n => ModuleCat.ofHom (FullTensorTerm.differential P a l n)) n
+    have h₂ : (TensorResolution.bimoduleComplex k B l).d n (n+1) =
+        ModuleCat.ofHom (TensorResolution.bimoduleDifferential k B l n) :=
+      CochainComplex.of_d (fun n => ModuleCat.of (B ⊗[k] (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ)
+        (TensorResolution.bimoduleTerm k B l n))
+        (fun n => ModuleCat.ofHom (TensorResolution.bimoduleDifferential k B l n)) n
+    rw [h₁,h₂]
+    apply ModuleCat.hom_ext
+    dsimp only [genuineTensorFunctor, bimoduleTensorFunctor, FullTensorTerm.complex]
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro q o
+    rfl)
+
+/-- The actual all-integer tensor of genuine Q_T with O, retaining both outside B-actions. -/
+def genuineComputedTensor : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ :=
+  ((genuineTensorFunctor P a l).mapHomologicalComplex (.up ℤ)).obj
+    (TensorResolution.integerBimoduleComplex k B l)
+
+/-- Agreement with the preserved full signed-comparison input in every integer degree. -/
+def genuineComputedTensorIso : genuineComputedTensor P a l ≅ computedTensorComplex P a l :=
+  FunctorExtension.iso (genuineTensorFunctor P a l) (TensorResolution.bimoduleComplex k B l)
+      (TensorResolution.degreeEmbedding l) ≪≫
+    ((TensorResolution.degreeEmbedding l).extendFunctor _).mapIso (genuineFiniteComplexIso P a l)
+
+/-- The actual ordinary tensor Q_T tensor O is isomorphic to P[b] as B-bimodule complexes.
+Only the manuscript support and indexing hypotheses are used. -/
+def genuineSourceShiftComparison (b : ℤ) (hb : a+(l:ℤ)=b)
+    (hP : ∀ n : ℤ, n < a ∨ b < n → IsZero (P.X n)) :
+    genuineComputedTensor P a l ≅ P⟦b⟧ :=
+  genuineComputedTensorIso P a l ≪≫ sourceShiftComparison P a l b hb hP
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryGlobalDimension.lean

@@ -0,0 +1,41 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductOpposite
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorGlobalDimension
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u v
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+
+/-- The manuscript's exact bound for D, on both sides and for arbitrary modules. -/
+theorem ordinary_globalDimension_bound (DB : DirectedBound.DirectedSystem k B 3) (l : ℕ) :
+    (⨆ M : ModuleCat.{max u v} (AlgebraD k l B), projectiveDimension M) ≤ (3*l+2 : ℕ) ∧
+    (⨆ M : ModuleCat.{max u v} (AlgebraD k l B)ᵐᵒᵖ, projectiveDimension M) ≤ (3*l+2 : ℕ) := by
+  have hB := DirectedBound.DirectedSystem.both_sides_projectiveDimension_le.{u,v} DB
+  have hBC := tensor_projectiveDimension_bound.{u,v} DB l
+  have hL (M : ModuleCat.{max u v} B) : projectiveDimension M ≤ (3*l+2 : ℕ) := by
+    apply (hB.1 M).trans
+    exact_mod_cast (show 3-1 ≤ 3*l+2 by omega)
+  have hR (M : ModuleCat.{max u v} Bᵐᵒᵖ) : projectiveDimension M ≤ (3*l+2 : ℕ) := by
+    apply (hB.2 M).trans
+    exact_mod_cast (show 3-1 ≤ 3*l+2 by omega)
+  exact ⟨iSup_le (fun M => ProductModules.product_module_bound B (B ⊗[k] ChainAlgebra k l)
+      (3*l+2) hL hBC.1 M),
+    iSup_le (fun M => ProductModules.opposite_product_module_bound B (B ⊗[k] ChainAlgebra k l)
+      (3*l+2) hR hBC.2 M)⟩
+
+variable {V W U : Type u} [AddCommGroup V] [Module k V] [AddCommGroup W] [Module k W]
+  [AddCommGroup U] [Module k U]
+
+/-- The bound for the actual three-vertex coefficient algebra and the actual Section 5 product D. -/
+theorem source_ordinary_globalDimension_bound (μ : W →ₗ[k] V →ₗ[k] U) (l : ℕ) :
+    (⨆ M : ModuleCat.{max u v} (AlgebraD k l (ThreeVertexAlgebra μ)), projectiveDimension M) ≤ (3*l+2 : ℕ) ∧
+    (⨆ M : ModuleCat.{max u v} (AlgebraD k l (ThreeVertexAlgebra μ))ᵐᵒᵖ, projectiveDimension M) ≤ (3*l+2 : ℕ) :=
+  ordinary_globalDimension_bound (ThreeVertexAlgebra.directedSystem μ) l
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryIntegerResolution.lean

@@ -0,0 +1,74 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorResolutionComplex
+import Mathlib.Algebra.Homology.Embedding.ExtendHomology
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.TensorResolution
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B] (l : ℕ)
+
+def degreeEmbedding : (ComplexShape.up ℕ).Embedding (ComplexShape.up ℤ) :=
+  ComplexShape.embeddingUpIntGE (-(l:ℤ))
+
+instance degreeEmbedding_rel : (degreeEmbedding l).IsRelIff :=
+  inferInstanceAs ((ComplexShape.embeddingUpIntGE (-(l:ℤ))).IsRelIff)
+
+@[simp] theorem degreeEmbedding_apply (n : ℕ) : (degreeEmbedding l).f n = -(l:ℤ)+n := rfl
+
+/-- Q_T in the manuscript's cohomological degrees -l,...,0. -/
+def integerComplex : CochainComplex (ModuleCat.{u} (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ) ℤ :=
+  (complex k B l).extend (degreeEmbedding l)
+
+def integerTermIso (n : ℕ) : (integerComplex k B l).X (-(l:ℤ)+n) ≅ termObject k B l n :=
+  (complex k B l).extendXIso (degreeEmbedding l) rfl
+
+/-- The terminal simple is in degree zero after the actual reindexing. -/
+def integerAugmentation : integerComplex k B l ⟶
+    (HomologicalComplex.single _ (.up ℤ) 0).obj
+      (ModuleCat.of (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B)) :=
+  HomologicalComplex.extendMap (augmentationMap k B l) (degreeEmbedding l) ≫
+    (HomologicalComplex.extendSingleIso (e := degreeEmbedding l)
+      (X := ModuleCat.of (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B)) l 0 (by simp)).hom
+
+theorem integerAugmentation_quasiIso : QuasiIso (integerAugmentation k B l) := by
+  have := augmentationMap_quasiIso k B l
+  exact inferInstanceAs (QuasiIso
+    (HomologicalComplex.extendMap (augmentationMap k B l) (degreeEmbedding l) ≫
+      (HomologicalComplex.extendSingleIso (e := degreeEmbedding l)
+        (X := ModuleCat.of (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B)) l 0 (by simp)).hom))
+
+theorem integerTerm_lower (n : ℤ) (h : n < -(l:ℤ)) : IsZero ((integerComplex k B l).X n) := by
+  apply (complex k B l).isZero_extend_X (degreeEmbedding l) n
+  intro j hj
+  simp only [degreeEmbedding_apply] at hj
+  omega
+
+theorem integerTerm_upper (n : ℤ) (h : 0 < n) : IsZero ((integerComplex k B l).X n) := by
+  let j := (n+(l:ℤ)).toNat
+  have hj : (degreeEmbedding l).f j = n := by
+    simp only [degreeEmbedding_apply]
+    dsimp [j]
+    rw [Int.toNat_of_nonneg (by omega)]
+    omega
+  have hjl : l < j := by
+    have hc : (j:ℤ) = n+(l:ℤ) := Int.toNat_of_nonneg (by omega)
+    omega
+  exact (term_vanishes k B l j hjl).of_iso ((complex k B l).extendXIso (degreeEmbedding l) hj)
+
+theorem integerTerm_projective (n : ℤ) : Projective ((integerComplex k B l).X n) := by
+  by_cases h : n < -(l:ℤ)
+  · exact (integerTerm_lower k B l n h).projective
+  let j := (n+(l:ℤ)).toNat
+  have hj : (degreeEmbedding l).f j = n := by
+    simp only [degreeEmbedding_apply]
+    dsimp [j]
+    rw [Int.toNat_of_nonneg (by omega)]
+    omega
+  exact Projective.of_iso ((complex k B l).extendXIso (degreeEmbedding l) hj).symm (projectiveTerm k B l j)
+end LittleFinitistic.OrdinarySimulation.TensorResolution
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryLeftTensorCongruence.lean

@@ -0,0 +1,27 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryLeftTensorMaps
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBalancedCongruence
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.LeftTensor
+universe u
+variable {k A S M M' N N' : Type u} [Field k] [Ring A] [Ring S] [Algebra k A] [Algebra k S]
+variable [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M] [IsScalarTower k Aᵐᵒᵖ M]
+  [Module S M] [IsScalarTower k S M] [SMulCommClass S Aᵐᵒᵖ M]
+variable [AddCommGroup M'] [Module k M'] [Module Aᵐᵒᵖ M'] [IsScalarTower k Aᵐᵒᵖ M']
+  [Module S M'] [IsScalarTower k S M'] [SMulCommClass S Aᵐᵒᵖ M']
+variable [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+variable [AddCommGroup N'] [Module k N'] [Module A N'] [IsScalarTower k A N']
+
+/-- Actual balanced tensor congruence retaining the outside left action. -/
+def congr (f : M ≃ₗ[Aᵐᵒᵖ] M') (hf : ∀ (s : S) m, f (s • m) = s • f m)
+    (g : N ≃ₗ[A] N') : LeftTensor k A S M N ≃ₗ[S] LeftTensor k A S M' N' where
+  __ := bimap f.toLinearMap hf g.toLinearMap
+  invFun := (BalancedTensor.congr (k := k) f g).symm
+  left_inv := (BalancedTensor.congr (k := k) f g).left_inv
+  right_inv := (BalancedTensor.congr (k := k) f g).right_inv
+end LittleFinitistic.LeftTensor
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryLeftTensorMaps.lean

@@ -0,0 +1,43 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryAssociativeTensorModules
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorBimap
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.LeftTensor
+universe u
+variable {k A S M M' N N' : Type u} [Field k] [Ring A] [Ring S] [Algebra k A] [Algebra k S]
+variable [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M] [IsScalarTower k Aᵐᵒᵖ M]
+  [Module S M] [IsScalarTower k S M] [SMulCommClass S Aᵐᵒᵖ M]
+variable [AddCommGroup M'] [Module k M'] [Module Aᵐᵒᵖ M'] [IsScalarTower k Aᵐᵒᵖ M']
+  [Module S M'] [IsScalarTower k S M'] [SMulCommClass S Aᵐᵒᵖ M']
+variable [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+variable [AddCommGroup N'] [Module k N'] [Module A N'] [IsScalarTower k A N']
+
+/-- The actual balanced bimap retains the outside left action. -/
+def bimap (f : M →ₗ[Aᵐᵒᵖ] M') (hf : ∀ (s : S) m, f (s • m) = s • f m)
+    (g : N →ₗ[A] N') : LeftTensor k A S M N →ₗ[S] LeftTensor k A S M' N' where
+  __ := (BalancedTensor.bimap (k := k) f g).toAddHom
+  map_smul' s z := by
+    change BalancedTensor.bimap (k := k) f g (action k S A M N s z) =
+      action k S A M' N' s (BalancedTensor.bimap (k := k) f g z)
+    induction z using BalancedTensor.induction_on with
+    | hz =>
+      exact ((BalancedTensor.bimap (k := k) f g).comp (action k S A M N s)).map_zero.trans
+        (((action k S A M' N' s).comp (BalancedTensor.bimap (k := k) f g)).map_zero).symm
+    | ht m n =>
+      change BalancedTensor.mk k A M' N' (f (s • m)) (g n) =
+        BalancedTensor.mk k A M' N' (s • f m) (g n)
+      rw [hf]
+    | ha x y hx hy =>
+      exact (((BalancedTensor.bimap (k := k) f g).comp (action k S A M N s)).map_add x y).trans
+        ((congrArg₂ (· + ·) hx hy).trans
+          (((action k S A M' N' s).comp (BalancedTensor.bimap (k := k) f g)).map_add x y).symm)
+
+@[simp] theorem bimap_mk (f : M →ₗ[Aᵐᵒᵖ] M') (hf : ∀ (s : S) m, f (s • m) = s • f m)
+    (g : N →ₗ[A] N') (m : M) (n : N) :
+    bimap f hf g (mk k S A M N m n) = mk k S A M' N' (f m) (g n) := rfl
+end LittleFinitistic.LeftTensor
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryMiddleTensorFunctors.lean

@@ -0,0 +1,83 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryAssociativityNaturality
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFixedTensorFunctor
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+universe u
+variable (k A B N : Type u) [Field k] [Ring A] [Ring B] [Algebra k A] [Algebra k B]
+variable [AddCommGroup N] [Module k N] [Module A N] [Module Bᵐᵒᵖ N]
+  [IsScalarTower k A N] [IsScalarTower k Bᵐᵒᵖ N] [SMulCommClass A Bᵐᵒᵖ N]
+
+/-- Tensor by the fixed middle bimodule, retaining its actual left action. -/
+def middleLeftFunctor : ModuleCat.{u} B ⥤ ModuleCat.{u} A where
+  obj Z := ModuleCat.of A (LeftTensor k B A N (BalancedTensor.ScalarLeftModule k B Z))
+  map {Z Z'} g := ModuleCat.ofHom
+    (LeftTensor.mapLast (k := k) (A := A) (N := N)
+      (Z := BalancedTensor.ScalarLeftModule k B Z) (Z' := BalancedTensor.ScalarLeftModule k B Z') g.hom)
+  map_id Z := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro n z
+    rfl
+  map_comp f g := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro n z
+    rfl
+
+instance middleLeftFunctor_additive : (middleLeftFunctor k A B N).Additive where
+  map_add {Z Z'} {f g} := by
+    dsimp only [middleLeftFunctor]
+    apply ModuleCat.hom_ext
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro n z
+    exact (BalancedTensor.mk k B N (BalancedTensor.ScalarLeftModule k B Z') n).map_add (f.hom z) (g.hom z)
+
+/-- Tensor a right module by the middle bimodule, retaining its actual right action. -/
+def middleRightFunctor : ModuleCat.{u} Aᵐᵒᵖ ⥤ ModuleCat.{u} Bᵐᵒᵖ where
+  obj M := ModuleCat.of Bᵐᵒᵖ (RightTensor k A B (BalancedTensor.ScalarLeftModule k Aᵐᵒᵖ M) N)
+  map {M M'} f := ModuleCat.ofHom
+    (RightTensor.mapFirst (k := k) (B := B) (N := N)
+      (M := BalancedTensor.ScalarLeftModule k Aᵐᵒᵖ M) (M' := BalancedTensor.ScalarLeftModule k Aᵐᵒᵖ M') f.hom)
+  map_id M := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro m n
+    rfl
+  map_comp f g := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro m n
+    rfl
+
+instance middleRightFunctor_additive : (middleRightFunctor k A B N).Additive where
+  map_add {M M'} {f g} := by
+    dsimp only [middleRightFunctor]
+    apply ModuleCat.hom_ext
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro m n
+    exact congrArg (fun h => h n)
+      ((BalancedTensor.mk k A (BalancedTensor.ScalarLeftModule k Aᵐᵒᵖ M') N).map_add (f.hom m) (g.hom m))
+
+/-- The genuine right tensor complex, with its right B-action. -/
+def middleRightComplex (Q : CochainComplex (ModuleCat.{u} Aᵐᵒᵖ) ℤ) :
+    CochainComplex (ModuleCat.{u} Bᵐᵒᵖ) ℤ :=
+  ((middleRightFunctor k A B N).mapHomologicalComplex (.up ℤ)).obj Q
+
+/-- The genuine left tensor complex, with its left A-action. -/
+def middleLeftComplex (Z : CochainComplex (ModuleCat.{u} B) ℤ) :
+    CochainComplex (ModuleCat.{u} A) ℤ :=
+  ((middleLeftFunctor k A B N).mapHomologicalComplex (.up ℤ)).obj Z
+end LittleFinitistic
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalComplex.lean

@@ -0,0 +1,44 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalMaps
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleCoefficients
+import Mathlib.Algebra.Homology.Additive
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable (k L R : Type u) [Field k] [Ring L] [Ring R] [Algebra k L] [Algebra k R]
+variable (O : CochainComplex (ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)) ℤ)
+variable (T : CochainComplex (ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ)) ℤ)
+
+abbrev complexTerm (n : ℤ) := RetainedBimodule k (L × R) (L × R)
+  (OffDiagonal (BimoduleCoefficients k R L (O.X n)) (BimoduleCoefficients k L R (T.X n)))
+
+def complexDifferential (n : ℤ) :=
+  RetainedBimodule.map (k := k) (S := L × R) (A := L × R)
+    (map (BimoduleCoefficients.map k R L (O.d n (n+1)))
+      (BimoduleCoefficients.map k L R (T.d n (n+1))))
+    (map_left (BimoduleCoefficients.map k R L (O.d n (n+1)))
+      (BimoduleCoefficients.map_left k R L (O.d n (n+1)))
+      (BimoduleCoefficients.map k L R (T.d n (n+1)))
+      (BimoduleCoefficients.map_left k L R (T.d n (n+1))))
+
+theorem complexDifferential_square (n : ℤ) :
+    (complexDifferential k L R O T (n+1)).comp (complexDifferential k L R O T n) = 0 := by
+  apply LinearMap.ext
+  intro x
+  apply Prod.ext
+  · exact congrArg (fun f => f.hom x.1) (O.d_comp_d n (n+1) ((n+1)+1))
+  · exact congrArg (fun f => f.hom x.2) (T.d_comp_d n (n+1) ((n+1)+1))
+
+/-- Actual off-diagonal complex with both actions of the product algebra retained. -/
+def complex : CochainComplex (ModuleCat.{u} ((L × R) ⊗[k] (L × R)ᵐᵒᵖ)) ℤ :=
+  CochainComplex.of (fun n => ModuleCat.of _ (complexTerm k L R O T n))
+    (fun n => ModuleCat.ofHom (complexDifferential k L R O T n))
+    (fun n => ModuleCat.hom_ext (complexDifferential_square k L R O T n))
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalComplexMaps.lean

@@ -0,0 +1,43 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalComplex
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable (k L R : Type u) [Field k] [Ring L] [Ring R] [Algebra k L] [Algebra k R]
+variable {O O' : CochainComplex (ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)) ℤ}
+variable {T T' : CochainComplex (ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ)) ℤ}
+
+def complexTermMap (f : O ⟶ O') (g : T ⟶ T') (n : ℤ) :=
+  RetainedBimodule.map (k := k) (S := L × R) (A := L × R)
+    (map (BimoduleCoefficients.map k R L (f.f n)) (BimoduleCoefficients.map k L R (g.f n)))
+    (map_left (BimoduleCoefficients.map k R L (f.f n))
+      (BimoduleCoefficients.map_left k R L (f.f n))
+      (BimoduleCoefficients.map k L R (g.f n))
+      (BimoduleCoefficients.map_left k L R (g.f n)))
+
+theorem complex_d (n : ℤ) : (complex k L R O T).d n (n+1) =
+    ModuleCat.ofHom (complexDifferential k L R O T n) :=
+  CochainComplex.of_d (fun n => ModuleCat.of _ (complexTerm k L R O T n))
+    (fun n => ModuleCat.ofHom (complexDifferential k L R O T n)) n
+
+/-- An actual map of off-diagonal complexes retaining both product-ring actions. -/
+def complexMap (f : O ⟶ O') (g : T ⟶ T') : complex k L R O T ⟶ complex k L R O' T' where
+  f n := ModuleCat.ofHom (complexTermMap k L R f g n)
+  comm' n m h := by
+    change n+1=m at h
+    subst m
+    rw [complex_d,complex_d]
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    apply Prod.ext
+    · exact congrArg (fun h => h.hom x.1) (f.comm n (n+1))
+    · exact congrArg (fun h => h.hom x.2) (g.comm n (n+1))
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalForget.lean

@@ -0,0 +1,66 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalComplexMaps
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedRestriction
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryPairQuasiIso
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRestrictionHomology
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable (k L R : Type u) [Field k] [Ring L] [Ring R] [Algebra k L] [Algebra k R]
+variable (O : CochainComplex (ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)) ℤ)
+variable (T : CochainComplex (ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ)) ℤ)
+
+def forgetTermIso (n : ℤ) : (underlyingComplex (k := k) (complex k L R O T)).X n ≅
+    (PairComplex.complex (underlyingComplex (k := k) O) (underlyingComplex (k := k) T)).X n :=
+  (RetainedBimodule.scalarEquiv k (L × R) (L × R)
+    (OffDiagonal (BimoduleCoefficients k R L (O.X n)) (BimoduleCoefficients k L R (T.X n)))).toModuleIso
+
+/-- Forgetting the two outside actions gives the actual coordinate direct-sum complex. -/
+def forgetIso : underlyingComplex (k := k) (complex k L R O T) ≅
+    PairComplex.complex (underlyingComplex (k := k) O) (underlyingComplex (k := k) T) :=
+  HomologicalComplex.Hom.isoOfComponents (forgetTermIso k L R O T) (by
+    intro n m h
+    change n+1=m at h
+    subst m
+    change (forgetTermIso k L R O T n).hom ≫ _ =
+      (ModuleCat.restrictScalars (algebraMap k ((L × R) ⊗[k] (L × R)ᵐᵒᵖ))).map
+        ((complex k L R O T).d n (n+1)) ≫ (forgetTermIso k L R O T (n+1)).hom
+    rw [complex_d,PairComplex.complex_d]
+    rfl)
+
+variable {O T} {O' : CochainComplex (ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)) ℤ}
+variable {T' : CochainComplex (ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ)) ℤ}
+
+theorem forgetIso_natural (f : O ⟶ O') (g : T ⟶ T') :
+    ((ModuleCat.restrictScalars (algebraMap k ((L × R) ⊗[k] (L × R)ᵐᵒᵖ))).mapHomologicalComplex (.up ℤ)).map
+      (complexMap k L R f g) ≫ (forgetIso k L R O' T').hom =
+    (forgetIso k L R O T).hom ≫ PairComplex.map
+      (((ModuleCat.restrictScalars (algebraMap k (R ⊗[k] Lᵐᵒᵖ))).mapHomologicalComplex (.up ℤ)).map f)
+      (((ModuleCat.restrictScalars (algebraMap k (L ⊗[k] Rᵐᵒᵖ))).mapHomologicalComplex (.up ℤ)).map g) := by
+  ext n x
+  rfl
+
+/-- The actual off-diagonal map is a quasi-isomorphism when its two components are. -/
+theorem complexMap_quasiIso (f : O ⟶ O') (g : T ⟶ T') [QuasiIso f] [QuasiIso g] :
+    QuasiIso (complexMap k L R f g) := by
+  apply (RestrictionHomology.quasiIso_iff (algebraMap k ((L × R) ⊗[k] (L × R)ᵐᵒᵖ)) _).mp
+  let f' := ((ModuleCat.restrictScalars (algebraMap k (R ⊗[k] Lᵐᵒᵖ))).mapHomologicalComplex (.up ℤ)).map f
+  let g' := ((ModuleCat.restrictScalars (algebraMap k (L ⊗[k] Rᵐᵒᵖ))).mapHomologicalComplex (.up ℤ)).map g
+  have : QuasiIso f' := (RestrictionHomology.quasiIso_iff (algebraMap k (R ⊗[k] Lᵐᵒᵖ)) f).mpr inferInstance
+  have : QuasiIso g' := (RestrictionHomology.quasiIso_iff (algebraMap k (L ⊗[k] Rᵐᵒᵖ)) g).mpr inferInstance
+  have := PairComplex.map_quasiIso f' g'
+  let h := ((ModuleCat.restrictScalars (algebraMap k ((L × R) ⊗[k] (L × R)ᵐᵒᵖ))).mapHomologicalComplex (.up ℤ)).map
+    (complexMap k L R f g)
+  have hh : QuasiIso (h ≫ (forgetIso k L R O' T').hom) := by
+    dsimp only [h]
+    rw [forgetIso_natural]
+    exact inferInstanceAs (QuasiIso ((forgetIso k L R O T).hom ≫ PairComplex.map f' g'))
+  exact (quasiIso_iff_comp_right h (forgetIso k L R O' T').hom).mp hh
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalMaps.lean

@@ -0,0 +1,31 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBlockBimodule
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedBimodule
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable {L R O O' T T' : Type u} [Ring L] [Ring R]
+variable [AddCommGroup O] [AddCommGroup O'] [AddCommGroup T] [AddCommGroup T']
+variable [Module R O] [Module R O'] [Module L T] [Module L T']
+variable [Module Lᵐᵒᵖ O] [Module Lᵐᵒᵖ O'] [Module Rᵐᵒᵖ T] [Module Rᵐᵒᵖ T']
+
+/-- Actual component maps of the off-diagonal right product-ring module. -/
+def map (f : O →ₗ[Lᵐᵒᵖ] O') (g : T →ₗ[Rᵐᵒᵖ] T') :
+    OffDiagonal O T →ₗ[(L × R)ᵐᵒᵖ] OffDiagonal O' T' where
+  toFun x := (f x.1,g x.2)
+  map_add' left right := Prod.ext (f.map_add left.1 right.1) (g.map_add left.2 right.2)
+  map_smul' d x := Prod.ext (f.map_smul (MulOpposite.op d.unop.1) x.1)
+    (g.map_smul (MulOpposite.op d.unop.2) x.2)
+
+/-- The same map retains the two prescribed left product-ring actions. -/
+theorem map_left (f : O →ₗ[Lᵐᵒᵖ] O') (hf : ∀ (r : R) x, f (r • x) = r • f x)
+    (g : T →ₗ[Rᵐᵒᵖ] T') (hg : ∀ (s : L) x, g (s • x) = s • g x)
+    (d : L × R) (x : OffDiagonal O T) :
+    map f g (d • x) = d • map f g x :=
+  Prod.ext (hf d.2 x.1) (hg d.1 x.2)
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalObjects.lean

@@ -0,0 +1,50 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalComplexMaps
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedRestriction
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable (k L R : Type u) [Field k] [Ring L] [Ring R] [Algebra k L] [Algebra k R]
+variable (O : ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)) (T : ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ))
+
+abbrev object : ModuleCat.{u} ((L × R) ⊗[k] (L × R)ᵐᵒᵖ) :=
+  RetainedBimodule.object k (L × R) (L × R)
+    (OffDiagonal (BimoduleCoefficients k R L O) (BimoduleCoefficients k L R T))
+
+variable {O T} {O' : ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)} {T' : ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ)}
+
+def objectMap (f : O ⟶ O') (g : T ⟶ T') : object k L R O T ⟶ object k L R O' T' :=
+  ModuleCat.ofHom (RetainedBimodule.map (k := k) (S := L × R) (A := L × R)
+    (map (BimoduleCoefficients.map k R L f) (BimoduleCoefficients.map k L R g))
+    (map_left (BimoduleCoefficients.map k R L f) (BimoduleCoefficients.map_left k R L f)
+      (BimoduleCoefficients.map k L R g) (BimoduleCoefficients.map_left k L R g)))
+
+def objectIso (f : O ≅ O') (g : T ≅ T') : object k L R O T ≅ object k L R O' T' where
+  hom := objectMap k L R f.hom g.hom
+  inv := objectMap k L R f.inv g.inv
+  hom_inv_id := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    exact Prod.ext (congrArg (fun h => h.hom x.1) f.hom_inv_id)
+      (congrArg (fun h => h.hom x.2) g.hom_inv_id)
+  inv_hom_id := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    exact Prod.ext (congrArg (fun h => h.hom x.1) f.inv_hom_id)
+      (congrArg (fun h => h.hom x.2) g.inv_hom_id)
+
+theorem object_isZero (hO : IsZero O) (hT : IsZero T) : IsZero (object k L R O T) := by
+  have := ModuleCat.isZero_iff_subsingleton.mp hO
+  have := ModuleCat.isZero_iff_subsingleton.mp hT
+  apply ModuleCat.isZero_iff_subsingleton.mpr
+  exact inferInstanceAs (Subsingleton (O × T))
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalProjective.lean

@@ -0,0 +1,52 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalMaps
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductOpposite
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable (L R O T : Type u) [Ring L] [Ring R]
+variable [AddCommGroup O] [AddCommGroup T] [Module Lᵐᵒᵖ O] [Module Rᵐᵒᵖ T]
+open ProductModules
+
+abbrev inflatedPair : ModuleCat.{u} (Lᵐᵒᵖ × Rᵐᵒᵖ) := ModuleCat.of _
+  (((firstInflation Lᵐᵒᵖ Rᵐᵒᵖ).obj (ModuleCat.of Lᵐᵒᵖ O)) ×
+    ((secondInflation Lᵐᵒᵖ Rᵐᵒᵖ).obj (ModuleCat.of Rᵐᵒᵖ T)))
+
+attribute [local instance] RingHomInvPair.of_ringEquiv
+
+def rightPairEquiv : OffDiagonal O T ≃ₛₗ[RingHomClass.toRingHom (oppositeEquiv L R)]
+    inflatedPair L R O T where
+  toFun x := x
+  invFun x := x
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+/-- Off-diagonal right projectivity follows from the actual two product-factor modules. -/
+theorem right_projective [Module.Projective Lᵐᵒᵖ O] [Module.Projective Rᵐᵒᵖ T] :
+    Module.Projective (L × R)ᵐᵒᵖ (OffDiagonal O T) := by
+  let P := ModuleCat.of Lᵐᵒᵖ O
+  let Q := ModuleCat.of Rᵐᵒᵖ T
+  have : Projective P := ModuleCat.projective_of_categoryTheory_projective P
+  have : Projective Q := ModuleCat.projective_of_categoryTheory_projective Q
+  have : HasProjectiveDimensionLE P 0 := (projective_iff_hasProjectiveDimensionLT_one (X := P)).mp inferInstance
+  have : HasProjectiveDimensionLE Q 0 := (projective_iff_hasProjectiveDimensionLT_one (X := Q)).mp inferInstance
+  have := firstInflation_dimensionLE Lᵐᵒᵖ Rᵐᵒᵖ 0 P
+  have := secondInflation_dimensionLE Lᵐᵒᵖ Rᵐᵒᵖ 0 Q
+  let e := ModuleCat.biprodIsoProd ((firstInflation Lᵐᵒᵖ Rᵐᵒᵖ).obj P)
+    ((secondInflation Lᵐᵒᵖ Rᵐᵒᵖ).obj Q)
+  have : HasProjectiveDimensionLT (inflatedPair L R O T) 1 := hasProjectiveDimensionLT_of_iso e 1
+  have : HasProjectiveDimensionLE (ModuleCat.of (L × R)ᵐᵒᵖ (OffDiagonal O T)) 0 :=
+    ModuleCat.hasProjectiveDimensionLE_of_semiLinearEquiv (oppositeEquiv L R).symm
+      (rightPairEquiv L R O T).symm 0
+  have : Projective (ModuleCat.of (L × R)ᵐᵒᵖ (OffDiagonal O T)) :=
+    (projective_iff_hasProjectiveDimensionLT_one (X := ModuleCat.of (L × R)ᵐᵒᵖ (OffDiagonal O T))).mpr inferInstance
+  exact ModuleCat.projective_of_module_projective (ModuleCat.of (L × R)ᵐᵒᵖ (OffDiagonal O T))
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalSingle.lean

@@ -0,0 +1,45 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalObjects
+import Mathlib.Algebra.Homology.Single
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable (k L R : Type u) [Field k] [Ring L] [Ring R] [Algebra k L] [Algebra k R]
+variable (O : ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)) (T : ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ))
+
+abbrev singles : CochainComplex (ModuleCat.{u} ((L × R) ⊗[k] (L × R)ᵐᵒᵖ)) ℤ :=
+  complex k L R ((HomologicalComplex.single _ (.up ℤ) 0).obj O)
+    ((HomologicalComplex.single _ (.up ℤ) 0).obj T)
+
+theorem singles_isZero (n : ℤ) (hn : n ≠ 0) : IsZero ((singles k L R O T).X n) :=
+  object_isZero k L R (HomologicalComplex.isZero_single_obj_X (.up ℤ) 0 O n hn)
+    (HomologicalComplex.isZero_single_obj_X (.up ℤ) 0 T n hn)
+
+def singleTermIso (n : ℤ) : (singles k L R O T).X n ≅
+    ((HomologicalComplex.single _ (.up ℤ) 0).obj (object k L R O T)).X n := by
+  by_cases hn : n = 0
+  · subst n
+    exact objectIso k L R (HomologicalComplex.singleObjXSelf (.up ℤ) 0 O)
+      (HomologicalComplex.singleObjXSelf (.up ℤ) 0 T) ≪≫
+      (HomologicalComplex.singleObjXSelf (.up ℤ) 0 (object k L R O T)).symm
+  · exact (singles_isZero k L R O T n hn).iso
+      (HomologicalComplex.isZero_single_obj_X (.up ℤ) 0 (object k L R O T) n hn)
+
+/-- The off-diagonal direct sum of two ordinary modules is their ordinary bimodule in degree zero. -/
+def singleIso : singles k L R O T ≅
+    (HomologicalComplex.single _ (.up ℤ) 0).obj (object k L R O T) :=
+  HomologicalComplex.Hom.isoOfComponents (singleTermIso k L R O T) (by
+    intro n m h
+    change n+1=m at h
+    by_cases hn : n = 0
+    · have hm : m ≠ 0 := by omega
+      exact (HomologicalComplex.isZero_single_obj_X (.up ℤ) 0 (object k L R O T) m hm).eq_of_tgt _ _
+    · exact (singles_isZero k L R O T n hn).eq_of_src _ _)
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryPairComplex.lean

@@ -0,0 +1,86 @@
+import Mathlib.Algebra.Homology.Additive
+import Mathlib.Algebra.Homology.QuasiIso
+import Mathlib.Algebra.Homology.HomologicalComplexBiprod
+import Mathlib.Algebra.Category.ModuleCat.Biproducts
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+namespace LittleFinitistic.PairComplex
+universe u
+variable {k : Type u} [Ring k]
+variable (O T : CochainComplex (ModuleCat.{u} k) ℤ)
+
+def complex : CochainComplex (ModuleCat.{u} k) ℤ :=
+  CochainComplex.of (fun n => ModuleCat.of k (O.X n × T.X n))
+    (fun n => ModuleCat.ofHom ((O.d n (n+1)).hom.prodMap (T.d n (n+1)).hom)) (by
+      intro n
+      apply ModuleCat.hom_ext
+      apply LinearMap.ext
+      intro x
+      exact Prod.ext (congrArg (fun h => h.hom x.1) (O.d_comp_d n (n+1) ((n+1)+1)))
+        (congrArg (fun h => h.hom x.2) (T.d_comp_d n (n+1) ((n+1)+1))))
+
+theorem complex_d (n : ℤ) : (complex O T).d n (n+1) =
+    ModuleCat.ofHom ((O.d n (n+1)).hom.prodMap (T.d n (n+1)).hom) :=
+  CochainComplex.of_d (fun n => ModuleCat.of k (O.X n × T.X n))
+    (fun n => ModuleCat.ofHom ((O.d n (n+1)).hom.prodMap (T.d n (n+1)).hom)) n
+
+def fst : complex O T ⟶ O where
+  f n := ModuleCat.ofHom (LinearMap.fst k (O.X n) (T.X n))
+  comm' n m h := by
+    change n+1=m at h
+    subst m
+    rw [complex_d]
+    rfl
+
+def snd : complex O T ⟶ T where
+  f n := ModuleCat.ofHom (LinearMap.snd k (O.X n) (T.X n))
+  comm' n m h := by
+    change n+1=m at h
+    subst m
+    rw [complex_d]
+    rfl
+
+def inl : O ⟶ complex O T where
+  f n := ModuleCat.ofHom (LinearMap.inl k (O.X n) (T.X n))
+  comm' n m h := by
+    change n+1=m at h
+    subst m
+    rw [complex_d]
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    exact Prod.ext rfl ((T.d n (n+1)).hom.map_zero)
+
+def inr : T ⟶ complex O T where
+  f n := ModuleCat.ofHom (LinearMap.inr k (O.X n) (T.X n))
+  comm' n m h := by
+    change n+1=m at h
+    subst m
+    rw [complex_d]
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    exact Prod.ext ((O.d n (n+1)).hom.map_zero) rfl
+
+@[simp] theorem inl_fst : inl O T ≫ fst O T = 𝟙 O := by ext degree element; rfl
+@[simp] theorem inl_snd : inl O T ≫ snd O T = 0 := by ext degree element; rfl
+@[simp] theorem inr_fst : inr O T ≫ fst O T = 0 := by ext degree element; rfl
+@[simp] theorem inr_snd : inr O T ≫ snd O T = 𝟙 T := by ext degree element; rfl
+
+/-- The actual coordinate complex is the native binary biproduct. -/
+def biprodIso : complex O T ≅ O ⊞ T where
+  hom := biprod.lift (fst O T) (snd O T)
+  inv := biprod.desc (inl O T) (inr O T)
+  hom_inv_id := by
+    rw [biprod.lift_desc]
+    ext n x
+    exact Prod.ext (add_zero _) (zero_add _)
+  inv_hom_id := by
+    apply biprod.hom_ext <;> apply biprod.hom_ext' <;> simp [Category.assoc]
+end LittleFinitistic.PairComplex
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryPairQuasiIso.lean

@@ -0,0 +1,74 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryPairComplex
+import Mathlib.Algebra.Homology.HomologicalComplexAbelian
+import Mathlib.CategoryTheory.Preadditive.AdditiveFunctor
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+namespace LittleFinitistic.PairComplex
+universe u
+variable {k : Type u} [Ring k]
+variable {O O' T T' : CochainComplex (ModuleCat.{u} k) ℤ}
+
+def map (f : O ⟶ O') (g : T ⟶ T') : complex O T ⟶ complex O' T' where
+  f n := ModuleCat.ofHom ((f.f n).hom.prodMap (g.f n).hom)
+  comm' n m h := by
+    change n+1=m at h
+    subst m
+    rw [complex_d,complex_d]
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    exact Prod.ext (congrArg (fun h => h.hom x.1) (f.comm n (n+1)))
+      (congrArg (fun h => h.hom x.2) (g.comm n (n+1)))
+
+theorem biprodIso_natural (f : O ⟶ O') (g : T ⟶ T') :
+    map f g ≫ (biprodIso O' T').hom = (biprodIso O T).hom ≫ biprod.map f g := by
+  apply biprod.hom_ext
+  · simp only [biprodIso,Category.assoc,biprod.lift_fst,biprod.map_fst,biprod.lift_fst_assoc]
+    ext n x
+    rfl
+  · simp only [biprodIso,Category.assoc,biprod.lift_snd,biprod.map_snd,biprod.lift_snd_assoc]
+    ext n x
+    rfl
+
+/-- Native binary biproducts preserve actual quasi-isomorphisms. -/
+theorem biprodMap_quasiIso (f : O ⟶ O') (g : T ⟶ T') [QuasiIso f] [QuasiIso g] :
+    QuasiIso (biprod.map f g) := by
+  constructor
+  intro i
+  apply (quasiIsoAt_iff_isIso_homologyMap _ i).mpr
+  let H := HomologicalComplex.homologyFunctor (ModuleCat.{u} k) (.up ℤ) i
+  let : H.Additive := inferInstanceAs ((HomologicalComplex.homologyFunctor (ModuleCat.{u} k) (.up ℤ) i).Additive)
+  let : PreservesFiniteBiproducts H := Functor.preservesFiniteBiproductsOfAdditive H
+  let : PreservesBinaryBiproducts H := preservesBinaryBiproducts_of_preservesBiproducts H
+  have : IsIso (H.map f) := (quasiIsoAt_iff_isIso_homologyMap f i).mp inferInstance
+  have : IsIso (H.map g) := (quasiIsoAt_iff_isIso_homologyMap g i).mp inferInstance
+  change IsIso (H.map (biprod.map f g))
+  have he : H.map (biprod.map f g) ≫ (H.mapBiprod O' T').hom =
+      (H.mapBiprod O T).hom ≫ biprod.map (H.map f) (H.map g) := by
+    apply biprod.hom_ext
+    · simp only [Functor.mapBiprod_hom,Category.assoc,biprod.lift_fst,biprod.map_fst,biprod.lift_fst_assoc,← H.map_comp]
+    · simp only [Functor.mapBiprod_hom,Category.assoc,biprod.lift_snd,biprod.map_snd,biprod.lift_snd_assoc,← H.map_comp]
+  have : IsIso (biprod.map (H.map f) (H.map g)) := by
+    refine ⟨⟨biprod.map (inv (H.map f)) (inv (H.map g)), ?_, ?_⟩⟩
+    · apply biprod.hom_ext <;> simp [Category.assoc]
+    · apply biprod.hom_ext <;> simp [Category.assoc]
+  have h : IsIso (H.map (biprod.map f g) ≫ (H.mapBiprod O' T').hom) := by
+    rw [he]
+    infer_instance
+  exact (isIso_comp_right_iff _ (H.mapBiprod O' T').hom).mp h
+
+/-- Coordinatewise quasi-isomorphisms give a quasi-isomorphism of the actual direct sum. -/
+theorem map_quasiIso (f : O ⟶ O') (g : T ⟶ T') [QuasiIso f] [QuasiIso g] :
+    QuasiIso (map f g) := by
+  have := biprodMap_quasiIso f g
+  have h : QuasiIso (map f g ≫ (biprodIso O' T').hom) := by
+    rw [biprodIso_natural]
+    infer_instance
+  exact (quasiIso_iff_comp_right (map f g) (biprodIso O' T').hom).mp h
+end LittleFinitistic.PairComplex
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductComponent.lean

@@ -0,0 +1,101 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRestrictionHomology
+import Mathlib.Algebra.Category.ModuleCat.Projective
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ProductModules
+universe u v
+variable (L R : Type u) [Ring L] [Ring R]
+variable (M : ModuleCat.{v} (L × R))
+
+/-- The actual first central-idempotent summand of an arbitrary product-ring module. -/
+def firstSpace : Submodule (L × R) M where
+  carrier := {m | ((1,0) : L × R) • m = m}
+  zero_mem' := smul_zero _
+  add_mem' {x y} hx hy := by
+    change ((1,0) : L × R) • (x+y) = x+y
+    rw [smul_add,hx,hy]
+  smul_mem' d x hx := by
+    change ((1,0) : L × R) • (d • x) = d • x
+    have he : ((1,0) : L × R) * d = d * (1,0) := by ext <;> simp
+    rw [← mul_smul,he,mul_smul,hx]
+
+def firstScalar (r : L) : firstSpace L R M →ₗ[ℤ] firstSpace L R M where
+  toFun x := ⟨(r,(0:R)) • x.val, by
+    change ((1,0) : L × R) • ((r,(0:R)) • x.val) = (r,(0:R)) • x.val
+    rw [← mul_smul]
+    have h : ((1,0) : L × R) * (r,(0:R)) = (r,(0:R)) := by ext <;> simp
+    rw [h]⟩
+  map_add' x y := Subtype.ext (smul_add _ _ _)
+  map_smul' n x := by
+    apply Subtype.ext
+    exact smul_comm ((r,(0:R)) : L × R) n x.val
+
+def firstAction : L →+* Module.End ℤ (firstSpace L R M) where
+  toFun := firstScalar L R M
+  map_one' := by
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    change ((1,0) : L × R) • x.val = x.val
+    exact x.property
+  map_zero' := by
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    change (0 : L × R) • x.val = 0
+    exact zero_smul (L × R) x.val
+  map_add' r s := by
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    change ((r+s,(0:R)) : L × R) • x.val = (r,(0:R)) • x.val + (s,(0:R)) • x.val
+    simpa only [Prod.mk_add_mk,add_zero] using add_smul ((r,(0:R)) : L × R) (s,(0:R)) x.val
+  map_mul' r s := by
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    change ((r*s,(0:R)) : L × R) • x.val = (r,(0:R)) • ((s,(0:R)) • x.val)
+    rw [← mul_smul]
+    have h : ((r,(0:R)) : L × R) * (s,0) = (r*s,0) := by ext <;> simp
+    rw [h]
+
+instance firstModule : Module L (firstSpace L R M) := Module.compHom _ (firstAction L R M)
+
+abbrev firstObject : ModuleCat.{v} L := ModuleCat.of L (firstSpace L R M)
+
+variable {M} {N : ModuleCat.{v} (L × R)}
+
+def firstMap (f : M ⟶ N) : firstSpace L R M →ₗ[L] firstSpace L R N where
+  toFun x := ⟨f.hom x.val, by
+    change ((1,0) : L × R) • f.hom x.val = f.hom x.val
+    rw [← f.hom.map_smul,x.property]⟩
+  map_add' x y := Subtype.ext (f.hom.map_add _ _)
+  map_smul' r x := Subtype.ext (f.hom.map_smul ((r,(0:R)) : L × R) x.val)
+
+/-- The actual component functor, constructed on every module and map. -/
+def firstFunctor : ModuleCat.{v} (L × R) ⥤ ModuleCat.{v} L where
+  obj M := firstObject L R M
+  map f := ModuleCat.ofHom (firstMap L R f)
+  map_id M := by rfl
+  map_comp f g := by rfl
+
+/-- Surjections remain surjections on the selected component, by projecting a preimage. -/
+theorem firstMap_surjective (f : M ⟶ N) (hf : Function.Surjective f.hom) :
+    Function.Surjective (firstMap L R f) := by
+  intro y
+  obtain ⟨x,hx⟩ := hf y.val
+  refine ⟨⟨((1,0) : L × R) • x,?_⟩,?_⟩
+  · change ((1,0) : L × R) • (((1,0) : L × R) • x) = ((1,0) : L × R) • x
+    rw [← mul_smul]
+    have h : ((1,0) : L × R) * (1,0) = (1,0) := by ext <;> simp
+    rw [h]
+  · apply Subtype.ext
+    change f.hom (((1,0) : L × R) • x) = y.val
+    rw [f.hom.map_smul,hx,y.property]
+end LittleFinitistic.ProductModules
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductDimension.lean

@@ -0,0 +1,46 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductProjective
+import Mathlib.Algebra.Category.ModuleCat.ProjectiveDimension
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ProductModules
+universe u v
+variable (L R : Type u) [Ring L] [Ring R] [Small.{v} L] [Small.{v} R]
+
+omit [Small.{v} L] [Small.{v} R] in
+/-- Exactness of actual inflation, with the module universe independent of the ring universe. -/
+theorem firstInflation_preservesHomology :
+    (firstInflation.{u,v} L R).PreservesHomology :=
+  CategoryTheory.Functor.preservesHomology_of_map_exact _ (fun K hK => by
+    rw [ShortComplex.moduleCat_exact_iff] at hK ⊢
+    exact hK)
+
+omit [Small.{v} R] in
+/-- Inflation from a factor preserves finite projective-dimension bounds, via actual projective covers. -/
+theorem firstInflation_dimensionLE (n : ℕ) (M : ModuleCat.{v} L) [HasProjectiveDimensionLE M n] :
+    HasProjectiveDimensionLE ((firstInflation L R).obj M) n := by
+  induction n generalizing M with
+  | zero =>
+    have : Projective M := (projective_iff_hasProjectiveDimensionLT_one (X := M)).mpr inferInstance
+    have := firstInflation_projective L R M
+    infer_instance
+  | succ n ih =>
+    let S := M.projectiveShortComplex
+    have hS := M.shortExact_projectiveShortComplex
+    have : HasProjectiveDimensionLT S.X₁ (n+1) :=
+      (hS.hasProjectiveDimensionLT_X₃_iff n inferInstance).mp inferInstance
+    have hk := ih S.X₁
+    have hp := firstInflation_projective L R S.X₂
+    have := firstInflation_preservesHomology.{u,v} L R
+    have : Mono ((firstInflation L R).map S.f) :=
+      (ModuleCat.mono_iff_injective _).mpr ((ModuleCat.mono_iff_injective S.f).mp hS.mono_f)
+    have : Epi ((firstInflation L R).map S.g) :=
+      (ModuleCat.epi_iff_surjective _).mpr ((ModuleCat.epi_iff_surjective S.g).mp hS.epi_g)
+    have hs : (S.map (firstInflation L R)).ShortExact := hS.map (firstInflation L R)
+    exact (hs.hasProjectiveDimensionLT_X₃_iff n hp).mpr hk
+end LittleFinitistic.ProductModules
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductOpposite.lean

@@ -0,0 +1,49 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductSecondDimension
+import Mathlib.Algebra.Algebra.Opposite
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ProductModules
+universe u v
+variable (L R : Type u) [Ring L] [Ring R]
+
+/-- The opposite of the actual product ring is the product of the two opposite rings. -/
+def oppositeEquiv : (L × R)ᵐᵒᵖ ≃+* Lᵐᵒᵖ × Rᵐᵒᵖ where
+  toFun x := (MulOpposite.op x.unop.1,MulOpposite.op x.unop.2)
+  invFun x := MulOpposite.op (x.1.unop,x.2.unop)
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_mul' _ _ := rfl
+
+abbrev oppositeModule (M : ModuleCat.{v} (L × R)ᵐᵒᵖ) : ModuleCat.{v} (Lᵐᵒᵖ × Rᵐᵒᵖ) :=
+  (ModuleCat.restrictScalars (oppositeEquiv L R).symm.toRingHom).obj M
+
+attribute [local instance] RingHomInvPair.of_ringEquiv
+
+def oppositeModuleEquiv (M : ModuleCat.{v} (L × R)ᵐᵒᵖ) :
+    M ≃ₛₗ[RingHomClass.toRingHom (oppositeEquiv L R)] oppositeModule L R M where
+  toFun x := x
+  invFun x := x
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+variable [Small.{v} L] [Small.{v} R]
+
+theorem opposite_product_module_bound (n : ℕ)
+    (hL : ∀ M : ModuleCat.{v} Lᵐᵒᵖ, projectiveDimension M ≤ (n : ℕ))
+    (hR : ∀ M : ModuleCat.{v} Rᵐᵒᵖ, projectiveDimension M ≤ (n : ℕ))
+    (M : ModuleCat.{v} (L × R)ᵐᵒᵖ) : projectiveDimension M ≤ (n : ℕ) := by
+  let : Small.{v} Lᵐᵒᵖ := small_of_injective (@MulOpposite.unop_injective L)
+  let : Small.{v} Rᵐᵒᵖ := small_of_injective (@MulOpposite.unop_injective R)
+  let : Small.{v} (L × R)ᵐᵒᵖ := small_of_injective (@MulOpposite.unop_injective (L × R))
+  rw [ModuleCat.projectiveDimension_eq_of_semiLinearEquiv (oppositeEquiv L R) (oppositeModuleEquiv L R M)]
+  exact product_module_bound Lᵐᵒᵖ Rᵐᵒᵖ n hL hR (oppositeModule L R M)
+end LittleFinitistic.ProductModules
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductProjective.lean

@@ -0,0 +1,61 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductComponent
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ProductModules
+universe u v
+variable (L R : Type u) [Ring L] [Ring R]
+
+abbrev firstInflation : ModuleCat.{v} L ⥤ ModuleCat.{v} (L × R) :=
+  ModuleCat.restrictScalars (RingHom.fst L R)
+
+variable {P : ModuleCat.{v} L} {M : ModuleCat.{v} (L × R)}
+
+def intoFirst (g : (firstInflation L R).obj P ⟶ M) : P ⟶ firstObject L R M :=
+  ModuleCat.ofHom
+    { toFun := fun x => ⟨g.hom x, by
+        have h := g.hom.map_smul ((1,0) : L × R) x
+        change g.hom ((1:L) • x) = ((1,0) : L × R) • g.hom x at h
+        rw [one_smul] at h
+        exact h.symm⟩
+      map_add' := fun x y => Subtype.ext (g.hom.map_add x y)
+      map_smul' := fun r x => Subtype.ext (g.hom.map_smul ((r,0) : L × R) x) }
+
+theorem firstSpace_product_smul (d : L × R) (x : firstSpace L R M) :
+    d • x.val = ((d.1,0) : L × R) • x.val := by
+  have he : d * ((1,0) : L × R) = (d.1,0) := by ext <;> simp
+  calc
+    d • x.val = d • (((1,0) : L × R) • x.val) := by rw [x.property]
+    _ = (d * ((1,0) : L × R)) • x.val := (mul_smul _ _ _).symm
+    _ = _ := by rw [he]
+
+def outOfFirst (g : P ⟶ firstObject L R M) : (firstInflation L R).obj P ⟶ M := by
+  letI : Module (L × R) P := Module.compHom P (RingHom.fst L R)
+  exact ModuleCat.ofHom (show (firstInflation L R).obj P →ₗ[L × R] M from
+    { toFun := fun x => (g.hom x).val
+      map_add' := fun x y => congrArg Subtype.val (g.hom.map_add x y)
+      map_smul' := fun d x => by
+        have h := congrArg Subtype.val (g.hom.map_smul d.1 x)
+        exact h.trans (firstSpace_product_smul L R d (g.hom x)).symm })
+
+/-- Inflation from one factor preserves actual projective objects. -/
+theorem firstInflation_projective (P : ModuleCat.{v} L) [Projective P] :
+    Projective ((firstInflation L R).obj P) := by
+  refine ⟨fun g E he => ?_⟩
+  let e : firstObject L R _ ⟶ firstObject L R _ := (firstFunctor L R).map E
+  let g' := intoFirst L R g
+  let : Epi e := (ModuleCat.epi_iff_surjective e).mpr
+    (firstMap_surjective L R E ((ModuleCat.epi_iff_surjective E).mp he))
+  let h := Projective.factorThru g' e
+  refine ⟨outOfFirst L R h,?_⟩
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  have hh := congrArg (fun f => f.hom x) (Projective.factorThru_comp g' e)
+  exact congrArg Subtype.val hh
+end LittleFinitistic.ProductModules
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductSecondDimension.lean

@@ -0,0 +1,52 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductDimension
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductSplitting
+import Mathlib.Algebra.Category.ModuleCat.Biproducts
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ProductModules
+universe u v
+variable (L R : Type u) [Ring L] [Ring R]
+
+attribute [local instance] RingHomInvPair.of_ringEquiv
+
+/-- Swapping product factors identifies the two actual inflation constructions. -/
+def swapInflationEquiv (P : ModuleCat.{v} R) :
+    (firstInflation R L).obj P ≃ₛₗ[RingHomClass.toRingHom (RingEquiv.prodComm : R × L ≃+* L × R)]
+      (secondInflation L R).obj P where
+  toFun x := x
+  invFun x := x
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+variable [Small.{v} L] [Small.{v} R]
+
+theorem secondInflation_dimensionLE (n : ℕ) (P : ModuleCat.{v} R) [HasProjectiveDimensionLE P n] :
+    HasProjectiveDimensionLE ((secondInflation L R).obj P) n := by
+  have := firstInflation_dimensionLE R L n P
+  exact ModuleCat.hasProjectiveDimensionLE_of_semiLinearEquiv
+    (RingEquiv.prodComm : R × L ≃+* L × R) (swapInflationEquiv L R P) n
+
+/-- Each module over the product has the same finite bound as its two factors. -/
+theorem product_module_bound (n : ℕ)
+    (hL : ∀ M : ModuleCat.{v} L, projectiveDimension M ≤ (n : ℕ))
+    (hR : ∀ M : ModuleCat.{v} R, projectiveDimension M ≤ (n : ℕ))
+    (M : ModuleCat.{v} (L × R)) : projectiveDimension M ≤ (n : ℕ) := by
+  have : HasProjectiveDimensionLE (firstObject L R M) n := (projectiveDimension_le_iff _ n).mp (hL _)
+  have : HasProjectiveDimensionLE (secondObject L R M) n := (projectiveDimension_le_iff _ n).mp (hR _)
+  have := firstInflation_dimensionLE L R n (firstObject L R M)
+  have := secondInflation_dimensionLE L R n (secondObject L R M)
+  let e := ModuleCat.biprodIsoProd ((firstInflation L R).obj (firstObject L R M))
+    ((secondInflation L R).obj (secondObject L R M))
+  have : HasProjectiveDimensionLT (pairObject L R M) (n+1) := hasProjectiveDimensionLT_of_iso e (n+1)
+  have : HasProjectiveDimensionLT M (n+1) :=
+    hasProjectiveDimensionLT_of_iso (splitting L R M).toModuleIso.symm (n+1)
+  exact (projectiveDimension_le_iff _ n).mpr inferInstance
+end LittleFinitistic.ProductModules
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductSplitting.lean

@@ -0,0 +1,101 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductProjective
+import Mathlib.Algebra.Ring.Prod
+import Mathlib.Algebra.Category.ModuleCat.Limits
+import Mathlib.Tactic.Abel
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ProductModules
+universe u v
+variable (L R : Type u) [Ring L] [Ring R]
+
+abbrev secondInflation : ModuleCat.{v} R ⥤ ModuleCat.{v} (L × R) :=
+  ModuleCat.restrictScalars (RingHom.snd L R)
+
+abbrev swapModule (M : ModuleCat.{v} (L × R)) : ModuleCat.{v} (R × L) :=
+  (ModuleCat.restrictScalars (RingEquiv.prodComm : R × L ≃+* L × R).toRingHom).obj M
+
+abbrev secondObject (M : ModuleCat.{v} (L × R)) : ModuleCat.{v} R :=
+  firstObject R L (swapModule L R M)
+
+abbrev pairObject (M : ModuleCat.{v} (L × R)) : ModuleCat.{v} (L × R) := ModuleCat.of (L × R)
+  (((firstInflation L R).obj (firstObject L R M)) × ((secondInflation L R).obj (secondObject L R M)))
+
+variable (M : ModuleCat.{v} (L × R))
+
+def splitTo : M →ₗ[L × R] pairObject L R M where
+  toFun m := (⟨((1,0) : L × R) • m, by
+    change ((1,0) : L × R) • (((1,0) : L × R) • m) = ((1,0) : L × R) • m
+    rw [← mul_smul]
+    have h : ((1,0) : L × R) * (1,0) = (1,0) := by ext <;> simp
+    rw [h]⟩, ⟨((0,1) : L × R) • m, by
+    change ((0,1) : L × R) • (((0,1) : L × R) • m) = ((0,1) : L × R) • m
+    rw [← mul_smul]
+    have h : ((0,1) : L × R) * (0,1) = (0,1) := by ext <;> simp
+    rw [h]⟩)
+  map_add' x y := Prod.ext (Subtype.ext (smul_add _ _ _)) (Subtype.ext (smul_add _ _ _))
+  map_smul' d m := by
+    apply Prod.ext
+    · apply Subtype.ext
+      change ((1,0) : L × R) • (d • m) = ((d.1,0) : L × R) • (((1,0) : L × R) • m)
+      rw [← mul_smul,← mul_smul]
+      congr 1
+      ext <;> simp
+    · apply Subtype.ext
+      change ((0,1) : L × R) • (d • m) = ((0,d.2) : L × R) • (((0,1) : L × R) • m)
+      rw [← mul_smul,← mul_smul]
+      congr 1
+      ext <;> simp
+
+def joinTo : pairObject L R M →ₗ[L × R] M where
+  toFun x := x.1.val + (show M from x.2.val)
+  map_add' x y := by
+    change (x.1.val+y.1.val) + ((show M from x.2.val)+(show M from y.2.val)) =
+      (x.1.val+(show M from x.2.val)) + (y.1.val+(show M from y.2.val))
+    abel
+  map_smul' d x := by
+    have h₁ := firstSpace_product_smul L R d x.1
+    have h₂ := firstSpace_product_smul R L (M := swapModule L R M) (d.2,d.1) x.2
+    change ((d.1,0) : L × R) • x.1.val + ((0,d.2) : L × R) • (show M from x.2.val) = d • (x.1.val + (show M from x.2.val))
+    rw [smul_add,← h₁]
+    exact congrArg (fun y : swapModule L R M => d • x.1.val + (show M from y)) h₂.symm
+
+/-- Every module over a product ring splits into its two actual central-idempotent components. -/
+def splitting : M ≃ₗ[L × R] pairObject L R M where
+  __ := splitTo L R M
+  invFun := joinTo L R M
+  left_inv m := by
+    change ((1,0) : L × R) • m + ((0,1) : L × R) • m = m
+    rw [← add_smul]
+    have h : ((1,0) : L × R) + (0,1) = 1 := by ext <;> simp
+    rw [h,one_smul]
+  right_inv x := by
+    have h₁ : ((1,0) : L × R) • x.1.val = x.1.val := x.1.property
+    have h₂ : ((0,1) : L × R) • (show M from x.2.val) = (show M from x.2.val) := x.2.property
+    have hz₁ : ((0,1) : L × R) • x.1.val = 0 := by
+      calc
+        _ = ((0,1) : L × R) • (((1,0) : L × R) • x.1.val) := by rw [h₁]
+        _ = 0 := by
+          rw [← mul_smul]
+          have h : ((0,1) : L × R) * (1,0) = 0 := by ext <;> simp
+          rw [h,zero_smul]
+    have hz₂ : ((1,0) : L × R) • (show M from x.2.val) = 0 := by
+      calc
+        _ = ((1,0) : L × R) • (((0,1) : L × R) • (show M from x.2.val)) := by rw [h₂]
+        _ = 0 := by
+          rw [← mul_smul]
+          have h : ((1,0) : L × R) * (0,1) = 0 := by ext <;> simp
+          rw [h,zero_smul]
+    apply Prod.ext
+    · apply Subtype.ext
+      change ((1,0) : L × R) • (x.1.val + (show M from x.2.val)) = x.1.val
+      rw [smul_add,h₁,hz₂,add_zero]
+    · apply Subtype.ext
+      change ((0,1) : L × R) • (x.1.val + (show M from x.2.val)) = (show M from x.2.val)
+      rw [smul_add,hz₁,h₂,zero_add]
+end LittleFinitistic.ProductModules
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProjectiveTensor.lean

@@ -0,0 +1,98 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFreeTensorExactness
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFixedTensorFunctor
+import OAI.Algebra.Finitistic.Tensor.BalancedTensorMaps
+import Mathlib.Algebra.Module.Projective
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.BalancedTensor
+universe u
+variable {k A M M' : Type u} [Field k] [Ring A] [Algebra k A]
+variable [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M] [IsScalarTower k Aᵐᵒᵖ M]
+variable [AddCommGroup M'] [Module k M'] [Module Aᵐᵒᵖ M'] [IsScalarTower k Aᵐᵒᵖ M']
+variable {N N' N'' : Type u}
+variable [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+variable [AddCommGroup N'] [Module k N'] [Module A N'] [IsScalarTower k A N']
+variable [AddCommGroup N''] [Module k N''] [Module A N''] [IsScalarTower k A N'']
+
+theorem mapLeft_mapRightTo (i : M →ₗ[Aᵐᵒᵖ] M') (f : N →ₗ[A] N') (z : Tensor k A M N) :
+    mapLeft N' i (mapRightTo f z) = mapRightTo f (mapLeft N i z) := by
+  induction z using BalancedTensor.induction_on with
+  | hz => simp only [map_zero]
+  | ht m n => rfl
+  | ha x y hx hy => simp only [map_add,hx,hy]
+
+omit [IsScalarTower k A N] in
+theorem mapLeft_split (i : M →ₗ[Aᵐᵒᵖ] M') (p : M' →ₗ[Aᵐᵒᵖ] M)
+    (hp : p.comp i = LinearMap.id) (z : Tensor k A M N) :
+    mapLeft N p (mapLeft N i z) = z := by
+  have hm := congrArg (fun f : Tensor k A M N →ₗ[k] Tensor k A M N => f z)
+    (mapLeft_comp (k := k) N i p).symm
+  simpa only [hp,mapLeft_id,LinearMap.id_apply,LinearMap.comp_apply] using hm
+
+/-- Exactness descends through an actual split right-module retract. -/
+theorem tensor_exact_of_split (i : M →ₗ[Aᵐᵒᵖ] M') (p : M' →ₗ[Aᵐᵒᵖ] M)
+    (hp : p.comp i = LinearMap.id) (f : N →ₗ[A] N') (g : N' →ₗ[A] N'')
+    (h : Function.Exact f g)
+    (h' : Function.Exact (mapRightTo (k := k) (M := M') f) (mapRightTo (k := k) (M := M') g)) :
+    Function.Exact (mapRightTo (k := k) (M := M) f) (mapRightTo (k := k) (M := M) g) := by
+  intro z
+  constructor
+  · intro hz
+    have hi : mapRightTo g (mapLeft N' i z) = 0 := by
+      rw [← mapLeft_mapRightTo,hz,map_zero]
+    obtain ⟨y,hy⟩ := (h' _).mp hi
+    refine ⟨mapLeft N p y, ?_⟩
+    rw [← mapLeft_mapRightTo,hy,mapLeft_split i p hp]
+  · rintro ⟨y,rfl⟩
+    induction y using BalancedTensor.induction_on with
+    | hz => simp only [map_zero]
+    | ht m n => rw [mapRightTo_mk,mapRightTo_mk,(h (f n)).mpr ⟨n,rfl⟩,map_zero]
+    | ha x y hx hy => simp only [map_add,hx,hy,add_zero]
+
+/-- Projectivity of the actual right module suffices, with no hypothesis on the left modules. -/
+theorem projectiveTensor_exact [Module.Projective Aᵐᵒᵖ M]
+    (f : N →ₗ[A] N') (g : N' →ₗ[A] N'') (h : Function.Exact f g) :
+    Function.Exact (mapRightTo (k := k) (M := M) f) (mapRightTo (k := k) (M := M) g) := by
+  obtain ⟨i,hi⟩ := (Module.projective_def' (R := Aᵐᵒᵖ) (P := M)).mp inferInstance
+  exact tensor_exact_of_split i (Finsupp.linearCombination Aᵐᵒᵖ id) hi f g h
+    (Free.tensor_exact (k := k) M f g h)
+
+variable (k A M)
+
+theorem projectiveTensor_mapsExact [Module.Projective Aᵐᵒᵖ M]
+    (S : ShortComplex (ModuleCat.{u} A)) (hS : S.Exact) :
+    (S.map (fixedTensorFunctor k A M)).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff]
+  have h : Function.Exact
+      (S.f.hom : ScalarLeftModule k A S.X₁ →ₗ[A] ScalarLeftModule k A S.X₂)
+      (S.g.hom : ScalarLeftModule k A S.X₂ →ₗ[A] ScalarLeftModule k A S.X₃) := by
+    intro n
+    constructor
+    · exact (ShortComplex.moduleCat_exact_iff S).mp hS n
+    · rintro ⟨m,rfl⟩
+      exact congrArg (fun f => f.hom m) S.zero
+  have ht := @projectiveTensor_exact k A M _ _ _ _ _ _ _
+    (ScalarLeftModule k A S.X₁) (ScalarLeftModule k A S.X₂) (ScalarLeftModule k A S.X₃)
+    _ _ _ (scalarLeftTower k A S.X₁)
+    _ _ _ (scalarLeftTower k A S.X₂) _ _ _ (scalarLeftTower k A S.X₃)
+    _ S.f.hom S.g.hom h
+  intro z hz
+  exact (ht z).mp hz
+
+theorem projectiveTensor_preservesHomology [Module.Projective Aᵐᵒᵖ M] :
+    (fixedTensorFunctor k A M).PreservesHomology :=
+  Functor.preservesHomology_of_map_exact _ (projectiveTensor_mapsExact k A M)
+
+/-- Degree-zero projective tensor preserves quasi-isomorphisms of arbitrary complexes. -/
+theorem projectiveTensor_quasiIso [Module.Projective Aᵐᵒᵖ M]
+    {Z Z' : CochainComplex (ModuleCat.{u} A) ℤ} (f : Z ⟶ Z') [QuasiIso f] :
+    QuasiIso (((fixedTensorFunctor k A M).mapHomologicalComplex (.up ℤ)).map f) := by
+  let := projectiveTensor_preservesHomology k A M
+  infer_instance
+end LittleFinitistic.BalancedTensor
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionComplex.lean

@@ -0,0 +1,85 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTerminalResolution
+import Mathlib.Algebra.Homology.HomologicalComplex
+import Mathlib.Algebra.Category.ModuleCat.Projective
+import Mathlib.Algebra.Category.ModuleCat.Abelian
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+namespace LittleFinitistic.OrdinarySimulation.ChainAlgebra
+universe u
+variable (k : Type u) [Field k] (l : ℕ)
+
+/-- Extending the source idempotents by zero keeps all right ideals in the same C. -/
+def extendedVertex (n : ℕ) : ChainAlgebra k l :=
+  if h : n ≤ l then vertex k l ⟨n,by omega⟩ else 0
+
+def extendedArrow (n : ℕ) : ChainAlgebra k l :=
+  if h : n < l then arrow k l ⟨n,h⟩ else 0
+
+theorem extendedVertex_idempotent (n : ℕ) :
+    extendedVertex k l n * extendedVertex k l n = extendedVertex k l n := by
+  unfold extendedVertex
+  split
+  · exact vertex_idempotent k l _
+  · exact zero_mul _
+
+theorem extendedArrow_target (n : ℕ) :
+    extendedVertex k l (n+1) * extendedArrow k l n = extendedArrow k l n := by
+  by_cases h : n < l
+  · have h1 : n+1 ≤ l := by omega
+    simp only [extendedVertex, extendedArrow, dite_eq_left h, dite_eq_left h1]
+    exact vertex_target_arrow k l ⟨n,h⟩
+  · rw [extendedArrow, dite_eq_right h, mul_zero]
+
+theorem extendedArrow_square (n : ℕ) : extendedArrow k l (n+1) * extendedArrow k l n = 0 := by
+  by_cases h1 : n+1 < l
+  · have h0 : n < l := by omega
+    simp only [extendedArrow, dite_eq_left h1, dite_eq_left h0, arrow_mul_arrow]
+  · rw [extendedArrow, dite_eq_right h1, zero_mul]
+
+abbrev resolutionIdeal (n : ℕ) := IdempotentTensor.rightIdeal (extendedVertex k l n)
+abbrev resolutionTerm (n : ℕ) : ModuleCat.{u} (ChainAlgebra k l)ᵐᵒᵖ :=
+  ModuleCat.of _ (resolutionIdeal k l n)
+
+/-- Actual left-arrow differentials, with no transport of module types. -/
+def resolutionDifferential (n : ℕ) : resolutionTerm k l n ⟶ resolutionTerm k l (n+1) :=
+  ModuleCat.ofHom (((leftMultiply (extendedArrow k l n)).comp (resolutionIdeal k l n).subtype).codRestrict _
+    (fun x => by
+      change extendedVertex k l (n+1) * (extendedArrow k l n * x.val) = extendedArrow k l n * x.val
+      rw [← mul_assoc, extendedArrow_target]))
+
+theorem resolutionDifferential_square (n : ℕ) :
+    resolutionDifferential k l n ≫ resolutionDifferential k l (n+1) = 0 := by
+  ext x
+  change extendedArrow k l (n+1) * (extendedArrow k l n * x.val) = 0
+  rw [← mul_assoc, extendedArrow_square, zero_mul]
+
+/-- The source's projective complex, extended by zero after degree l. -/
+def terminalProjectiveComplex : CochainComplex (ModuleCat.{u} (ChainAlgebra k l)ᵐᵒᵖ) ℕ :=
+  CochainComplex.of (resolutionTerm k l) (resolutionDifferential k l) (resolutionDifferential_square k l)
+
+theorem resolutionTerm_projective (n : ℕ) : Projective (resolutionTerm k l n) := by
+  let : Module.Projective (ChainAlgebra k l)ᵐᵒᵖ (ChainAlgebra k l) := Module.Projective.of_equiv rightRegularEquiv
+  let r : ChainAlgebra k l →ₗ[(ChainAlgebra k l)ᵐᵒᵖ] resolutionIdeal k l n :=
+    (leftMultiply (extendedVertex k l n)).codRestrict _ (fun x => by
+      change extendedVertex k l n * (extendedVertex k l n * x) = extendedVertex k l n * x
+      rw [← mul_assoc, extendedVertex_idempotent])
+  have : Module.Projective (ChainAlgebra k l)ᵐᵒᵖ (resolutionIdeal k l n) :=
+    Module.Projective.of_split (resolutionIdeal k l n).subtype r (by ext x; exact x.property)
+  infer_instance
+
+theorem resolutionTerm_vanishes (n : ℕ) (h : l < n) : IsZero (resolutionTerm k l n) := by
+  apply ModuleCat.isZero_iff_subsingleton.mpr
+  have hz (x : resolutionIdeal k l n) : x = 0 := by
+    apply Subtype.ext
+    have hp := x.property
+    change extendedVertex k l n * x.val = x.val at hp
+    rw [extendedVertex, dite_eq_right (Nat.not_le.mpr h), zero_mul] at hp
+    exact hp.symm
+  exact ⟨fun x y => (hz x).trans (hz y).symm⟩
+end LittleFinitistic.OrdinarySimulation.ChainAlgebra
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionExact.lean

@@ -0,0 +1,69 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryResolutionComplex
+import Mathlib.Algebra.Homology.ShortComplex.ModuleCat
+import Mathlib.Algebra.Homology.Single
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+namespace LittleFinitistic.OrdinarySimulation.ChainAlgebra
+universe u
+variable (k : Type u) [Field k] (l : ℕ)
+
+/-- In the supported range, the extended ideal is the source's actual right projective. -/
+def supportedIdealEquiv (n : ℕ) (h : n ≤ l) :
+    resolutionIdeal k l n ≃ₗ[(ChainAlgebra k l)ᵐᵒᵖ] rightTerm (k := k) (⟨n,by omega⟩ : Fin (l+1)) where
+  toFun x := ⟨x.val, by
+    have hp := x.property
+    change extendedVertex k l n * x.val = x.val at hp
+    change vertex k l ⟨n,by omega⟩ * x.val = x.val
+    simpa only [extendedVertex, dite_eq_left h] using hp⟩
+  invFun x := ⟨x.val, by
+    change extendedVertex k l n * x.val = x.val
+    rw [extendedVertex, dite_eq_left h]
+    exact x.property⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+@[simp] theorem supportedIdealEquiv_d (n : ℕ) (h : n < l) (x : resolutionIdeal k l n) :
+    supportedIdealEquiv k l (n+1) (by omega) ((resolutionDifferential k l n).hom x) =
+      resolutionMap (k := k) ⟨n,h⟩ (supportedIdealEquiv k l n (by omega) x) := by
+  apply Subtype.ext
+  change extendedArrow k l n * x.val = arrow k l ⟨n,h⟩ * x.val
+  rw [extendedArrow, dite_eq_left h]
+
+/-- The actual bundled complex is exact at every interior degree. -/
+theorem supported_complex_exact (n : ℕ) (h : n+1 < l) :
+    (ShortComplex.mk (resolutionDifferential k l n) (resolutionDifferential k l (n+1))
+      (resolutionDifferential_square k l n)).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff]
+  intro x hx
+  have hx' := congrArg (supportedIdealEquiv k l (n+2) (by omega)) hx
+  rw [supportedIdealEquiv_d k l (n+1) h, map_zero] at hx'
+  obtain ⟨y,hy⟩ := (resolution_exact (k := k) n h (supportedIdealEquiv k l (n+1) (by omega) x)).mp hx'
+  refine ⟨(supportedIdealEquiv k l n (by omega)).symm y, ?_⟩
+  apply (supportedIdealEquiv k l (n+1) (by omega)).injective
+  rw [supportedIdealEquiv_d k l n (by omega), LinearEquiv.apply_symm_apply, hy]
+
+/-- The actual augmentation of the bundled complex in its last degree. -/
+def resolutionAugmentation : resolutionTerm k l l ⟶ ModuleCat.of (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k) :=
+  ModuleCat.ofHom ((augmentation k l).comp (supportedIdealEquiv k l l le_rfl).toLinearMap)
+
+/-- A genuine chain map to the terminal simple placed in degree l. -/
+def terminalAugmentationMap : terminalProjectiveComplex k l ⟶
+    (HomologicalComplex.single _ (.up ℕ) l).obj (ModuleCat.of (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k)) :=
+  HomologicalComplex.mkHomToSingle (resolutionAugmentation k l) (by
+    intro i hi
+    change i+1=l at hi
+    subst l
+    change CochainComplex.of.d _ _ i (i+1) ≫ resolutionAugmentation k (i+1) = 0
+    rw [CochainComplex.of_d]
+    ext x
+    change (extendedArrow k (i+1) i * x.val).1 (Fin.last (i+1)) = (0:k)
+    rw [extendedArrow, dite_eq_left (by omega), mul_diagonal, arrow_diagonal, zero_mul])
+end LittleFinitistic.OrdinarySimulation.ChainAlgebra
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionModels.lean

@@ -0,0 +1,68 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleDerivedTensor
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleTensorFunctor
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic
+universe u
+
+/-- A finite model for tensoring a genuine bimodule complex, with its support and right projectivity proved. -/
+structure FiniteProjectiveBimoduleComplex (k S A : Type u) [Field k] [Ring S] [Ring A]
+    [Algebra k S] [Algebra k A] where
+  complex : CochainComplex (ModuleCat.{u} (S ⊗[k] Aᵐᵒᵖ)) ℤ
+  size : ℕ
+  degrees : Fin size → ℤ
+  strictMono : StrictMono degrees
+  support : ∀ n, n ∉ Set.range degrees → IsZero (complex.X n)
+  rightProjective : ∀ n, Module.Projective Aᵐᵒᵖ (BimoduleCoefficients k S A (complex.X n))
+
+namespace FiniteProjectiveBimoduleComplex
+variable {k S A : Type u} [Field k] [Ring S] [Ring A] [Algebra k S] [Algebra k A]
+variable (Q : FiniteProjectiveBimoduleComplex k S A)
+
+instance rightTerm_projective (n : ℤ) : Module.Projective Aᵐᵒᵖ
+    (ComplexTensor.rightTerm k A (BimoduleComplexTensor.rightComplex k S A Q.complex) n) := Q.rightProjective n
+
+abbrev tensorFunctor := BimoduleComplexTensor.totalFunctor k S A Q.complex Q.degrees Q.strictMono
+
+/-- The certified model inverts every input quasi-isomorphism; no condition is placed on the input complex. -/
+theorem tensorFunctor_quasiIso {Z Z' : CochainComplex (ModuleCat.{u} A) ℤ} (f : Z ⟶ Z') [QuasiIso f] :
+    QuasiIso (Q.tensorFunctor.map f) :=
+  BimoduleComplexTensor.totalFunctor_quasiIso k S A Q.complex Q.degrees Q.strictMono f
+
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} A)] [HasDerivedCategory.{u+1} (ModuleCat.{u} S)]
+
+def derivedTensor : DerivedCategory (ModuleCat.{u} A) ⥤ DerivedCategory (ModuleCat.{u} S) :=
+  BimoduleComplexTensor.derivedTotal k S A Q.complex Q.degrees Q.strictMono
+
+def comparison : DerivedCategory.Q ⋙ Q.derivedTensor ≅ Q.tensorFunctor ⋙ DerivedCategory.Q :=
+  BimoduleComplexTensor.derivedTotalComparison k S A Q.complex Q.degrees Q.strictMono
+end FiniteProjectiveBimoduleComplex
+
+/-- A genuine ordinary bimodule supplied with an actual bounded right-projective resolution. -/
+structure BoundedBimoduleResolution (k S A : Type u) [Field k] [Ring S] [Ring A]
+    [Algebra k S] [Algebra k A] (M : ModuleCat.{u} (S ⊗[k] Aᵐᵒᵖ)) extends FiniteProjectiveBimoduleComplex k S A where
+  augmentation : complex ⟶ (HomologicalComplex.single _ (.up ℤ) 0).obj M
+  augmentation_quasiIso : QuasiIso augmentation
+
+namespace BoundedBimoduleResolution
+variable {k S A : Type u} [Field k] [Ring S] [Ring A] [Algebra k S] [Algebra k A]
+variable {M : ModuleCat.{u} (S ⊗[k] Aᵐᵒᵖ)} (Q : BoundedBimoduleResolution k S A M)
+variable (B N : Type u) [Ring B] [Algebra k B]
+variable [AddCommGroup N] [Module k N] [Module A N] [Module Bᵐᵒᵖ N]
+  [IsScalarTower k A N] [IsScalarTower k Bᵐᵒᵖ N] [SMulCommClass A Bᵐᵒᵖ N]
+local instance : SMulCommClass Bᵐᵒᵖ A N := ⟨fun b a n => (smul_comm a b n).symm⟩
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} (S ⊗[k] Bᵐᵒᵖ))]
+
+/-- The resolved ordinary tensor object, in the native derived category retaining both outside actions.
+The resolution, its quasi-isomorphism, finite support and right projectivity are fields of Q. -/
+def tensorOrdinary : DerivedCategory (ModuleCat.{u} (S ⊗[k] Bᵐᵒᵖ)) :=
+  DerivedCategory.Q.obj (((bimoduleTensorFunctor k S A Bᵐᵒᵖ N).mapHomologicalComplex (.up ℤ)).obj Q.complex)
+end BoundedBimoduleResolution
+end LittleFinitistic
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionQuasiIso.lean

@@ -0,0 +1,155 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryResolutionExact
+import Mathlib.Algebra.Homology.QuasiIso
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+namespace LittleFinitistic.OrdinarySimulation.ChainAlgebra
+universe u
+variable (k : Type u) [Field k] (l : ℕ)
+
+theorem resolutionInitial_injective (h : 0 < l) :
+    Function.Injective (resolutionDifferential k l 0).hom := by
+  intro x y hxy
+  apply (supportedIdealEquiv k l 0 (by omega)).injective
+  apply resolution_first_injective (k := k) h
+  rw [← supportedIdealEquiv_d k l 0 h, ← supportedIdealEquiv_d k l 0 h, hxy]
+
+/-- Exactness in every degree except the terminal homology degree. -/
+theorem terminalProjectiveComplex_exactAt (n : ℕ) (hn : n ≠ l) :
+    (terminalProjectiveComplex k l).ExactAt n := by
+  by_cases h : l < n
+  · exact HomologicalComplex.ExactAt.of_isZero (resolutionTerm_vanishes k l n h)
+  have hnl : n < l := by omega
+  cases n with
+  | zero =>
+    rw [HomologicalComplex.exactAt_iff, ShortComplex.moduleCat_exact_iff]
+    intro x hx
+    have hx' : (resolutionDifferential k l 0).hom x = 0 := by
+      change ((terminalProjectiveComplex k l).d 0 ((ComplexShape.up ℕ).next 0)).hom x = 0 at hx
+      rw [show (ComplexShape.up ℕ).next 0 = 1 by simp] at hx
+      change (CochainComplex.of.d (resolutionTerm k l) (resolutionDifferential k l) 0 (0+1)).hom x = 0 at hx
+      rw [CochainComplex.of_d] at hx
+      exact hx
+    have hx0 : x = 0 := resolutionInitial_injective k l hnl (hx'.trans (map_zero _).symm)
+    refine ⟨0, ?_⟩
+    simp only [hx0, map_zero]
+  | succ n =>
+    apply (HomologicalComplex.exactAt_iff' _ n (n+1) (n+2) (by simp) (by simp)).2
+    change (ShortComplex.mk (CochainComplex.of.d _ _ n (n+1)) (CochainComplex.of.d _ _ (n+1) ((n+1)+1)) _).Exact
+    simpa only [CochainComplex.of_d] using supported_complex_exact k l n hnl
+
+theorem resolutionAugmentation_surjective : Function.Surjective (resolutionAugmentation k l).hom :=
+  (augmentation_surjective k l).comp (supportedIdealEquiv k l l le_rfl).surjective
+
+instance resolutionAugmentation_epi : Epi (resolutionAugmentation k l) :=
+  (ModuleCat.epi_iff_surjective _).mpr (resolutionAugmentation_surjective k l)
+
+theorem resolutionAugmentation_comp (n : ℕ) :
+    resolutionDifferential k (n+1) n ≫ resolutionAugmentation k (n+1) = 0 := by
+  ext x
+  change (extendedArrow k (n+1) n * x.val).1 (Fin.last (n+1)) = (0:k)
+  rw [extendedArrow, dite_eq_left (by omega), mul_diagonal, arrow_diagonal, zero_mul]
+
+theorem resolutionAugmentation_exact (n : ℕ) :
+    (ShortComplex.mk (resolutionDifferential k (n+1) n) (resolutionAugmentation k (n+1))
+      (resolutionAugmentation_comp k n)).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff]
+  intro x hx
+  have hx' : augmentation k (n+1) (supportedIdealEquiv k (n+1) (n+1) le_rfl x) = 0 := hx
+  obtain ⟨y,hy⟩ := (augmentation_exact k n _).mp hx'
+  refine ⟨(supportedIdealEquiv k (n+1) n (by omega)).symm y, ?_⟩
+  apply (supportedIdealEquiv k (n+1) (n+1) le_rfl).injective
+  rw [supportedIdealEquiv_d k (n+1) n (by omega), LinearEquiv.apply_symm_apply]
+  exact hy
+
+theorem resolutionAugmentation_zero_injective :
+    Function.Injective (resolutionAugmentation k 0).hom :=
+  (augmentation_zero_injective k).comp (supportedIdealEquiv k 0 0 le_rfl).injective
+
+theorem resolutionDifferential_last_zero : resolutionDifferential k l l = 0 := by
+  ext x
+  change extendedArrow k l l * x.val = 0
+  rw [extendedArrow, dite_eq_right (lt_irrefl l), zero_mul]
+
+/-- Postcomposing a short complex's second map by an isomorphism preserves exactness. -/
+theorem exact_post_iso {R : Type u} [Ring R] {X Y Z Z' : ModuleCat.{u} R}
+    (f : X ⟶ Y) (g : Y ⟶ Z) (hfg : f ≫ g = 0) (e : Z ≅ Z')
+    (h : (ShortComplex.mk f g hfg).Exact) :
+    (ShortComplex.mk f (g ≫ e.hom) (by rw [← Category.assoc, hfg, zero_comp])).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff] at h ⊢
+  intro x hx
+  apply h x
+  apply (ModuleCat.mono_iff_injective e.hom).mp inferInstance
+  exact hx.trans (map_zero _).symm
+
+/-- The augmentation is a quasi-isomorphism at the terminal degree. -/
+theorem terminalAugmentationMap_quasiIsoAt_last :
+    QuasiIsoAt (terminalAugmentationMap k l) l := by
+  rw [quasiIsoAt_iff]
+  refine (ShortComplex.quasiIso_iff_of_zeros' _ ?_ ?_ ?_).2 ?_
+  · change (terminalProjectiveComplex k l).d l ((ComplexShape.up ℕ).next l) = 0
+    rw [show (ComplexShape.up ℕ).next l = l+1 by simp]
+    change CochainComplex.of.d (resolutionTerm k l) (resolutionDifferential k l) l (l+1) = 0
+    rw [CochainComplex.of_d]
+    exact resolutionDifferential_last_zero k l
+  · exact HomologicalComplex.single_obj_d (.up ℕ) l (ModuleCat.of (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k)) ((ComplexShape.up ℕ).prev l) l
+  · exact HomologicalComplex.single_obj_d (.up ℕ) l (ModuleCat.of (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k)) l ((ComplexShape.up ℕ).next l)
+  · change (ShortComplex.mk ((terminalProjectiveComplex k l).d ((ComplexShape.up ℕ).prev l) l)
+        ((terminalAugmentationMap k l).f l) _).Exact ∧ Epi ((terminalAugmentationMap k l).f l)
+    have hf : (terminalAugmentationMap k l).f l = resolutionAugmentation k l ≫
+        (HomologicalComplex.singleObjXSelf (.up ℕ) l
+          (ModuleCat.of (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k))).inv := by
+      unfold terminalAugmentationMap
+      apply HomologicalComplex.mkHomToSingle_f
+    simp only [hf]
+    constructor
+    · refine exact_post_iso _ _ ?_
+        (HomologicalComplex.singleObjXSelf (.up ℕ) l
+          (ModuleCat.of (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k))).symm ?_
+      · cases l with
+        | zero =>
+          have hz := (terminalProjectiveComplex k 0).shape ((ComplexShape.up ℕ).prev 0) 0 (by simp)
+          erw [hz, zero_comp]
+        | succ n =>
+          rw [show (ComplexShape.up ℕ).prev (n+1) = n by simp]
+          simp only [terminalProjectiveComplex, CochainComplex.of_d]
+          convert resolutionAugmentation_comp k n using 1
+          rfl
+      cases l with
+      | zero =>
+        rw [ShortComplex.moduleCat_exact_iff]
+        intro x hx
+        have hx' : (resolutionAugmentation k 0).hom x = 0 := hx
+        have hx0 : x = 0 := resolutionAugmentation_zero_injective k (hx'.trans (map_zero _).symm)
+        refine ⟨0, ?_⟩
+        simp only [hx0, map_zero]
+      | succ n =>
+        rw [ShortComplex.moduleCat_exact_iff]
+        intro x hx
+        obtain ⟨y, hy⟩ := (ShortComplex.moduleCat_exact_iff _).mp
+          (resolutionAugmentation_exact k n) x hx
+        change ∃ z : resolutionTerm k (n+1) ((ComplexShape.up ℕ).prev (n+1)),
+          (CochainComplex.of.d (resolutionTerm k (n+1)) (resolutionDifferential k (n+1))
+            ((ComplexShape.up ℕ).prev (n+1)) (n+1)).hom z = x
+        rw [show (ComplexShape.up ℕ).prev (n+1) = n by simp]
+        exact ⟨y, by simpa only [CochainComplex.of_d] using hy⟩
+    · erw [ModuleCat.epi_iff_surjective]
+      exact ((ModuleCat.epi_iff_surjective _).mp (inferInstance : Epi
+        (HomologicalComplex.singleObjXSelf (.up ℕ) l
+          (ModuleCat.of (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k))).inv)).comp
+        (resolutionAugmentation_surjective k l)
+
+/-- The source's finite projective resolution now has its actual augmentation quasi-isomorphism. -/
+theorem terminalAugmentationMap_quasiIso : QuasiIso (terminalAugmentationMap k l) := by
+  constructor
+  intro n
+  by_cases hn : n = l
+  · subst n; exact terminalAugmentationMap_quasiIsoAt_last k l
+  · apply (quasiIsoAt_iff_exactAt' _ n ?_).2 (terminalProjectiveComplex_exactAt k l n hn)
+    exact HomologicalComplex.ExactAt.of_isZero (HomologicalComplex.isZero_single_obj_X _ _ _ _ hn)
+end LittleFinitistic.OrdinarySimulation.ChainAlgebra
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRestrictionHomology.lean

@@ -0,0 +1,30 @@
+import Mathlib.Algebra.Category.ModuleCat.ChangeOfRings
+import Mathlib.Algebra.Homology.ShortComplex.ModuleCat
+import Mathlib.Algebra.Homology.ShortComplex.PreservesHomology
+import Mathlib.Algebra.Homology.QuasiIso
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.RestrictionHomology
+universe u v
+variable {R S : Type u} [Ring R] [Ring S] (f : R →+* S)
+
+theorem mapsExact (K : ShortComplex (ModuleCat.{u} S)) (hK : K.Exact) :
+    (K.map (ModuleCat.restrictScalars f)).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff] at hK ⊢
+  exact hK
+
+theorem preservesHomology : (ModuleCat.restrictScalars.{u} f).PreservesHomology :=
+  CategoryTheory.Functor.preservesHomology_of_map_exact _ (mapsExact f)
+
+theorem quasiIso_iff {I : Type v} {c : ComplexShape I}
+    {K L : HomologicalComplex (ModuleCat.{u} S) c} (g : K ⟶ L) :
+    QuasiIso (((ModuleCat.restrictScalars f).mapHomologicalComplex c).map g) ↔ QuasiIso g := by
+  let := preservesHomology f
+  exact HomologicalComplex.quasiIso_map_iff_of_preservesHomology g (ModuleCat.restrictScalars f)
+end LittleFinitistic.RestrictionHomology
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRetainedBimodule.lean

@@ -0,0 +1,57 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleCoefficients
+
+namespace OAI
+noncomputable section
+open scoped TensorProduct
+namespace LittleFinitistic
+universe u
+/-- An ordinary bimodule packaged as a module over its actual tensor algebra. -/
+def RetainedBimodule (_k _S _A M : Type u) := M
+namespace RetainedBimodule
+variable (k S A M : Type u) [Field k] [Ring S] [Ring A] [Algebra k S] [Algebra k A]
+variable [AddCommGroup M] [Module k M] [Module S M] [Module Aᵐᵒᵖ M]
+  [IsScalarTower k S M] [IsScalarTower k Aᵐᵒᵖ M] [SMulCommClass S Aᵐᵒᵖ M]
+instance : AddCommGroup (RetainedBimodule k S A M) := inferInstanceAs (AddCommGroup M)
+instance : Module k (RetainedBimodule k S A M) := inferInstanceAs (Module k M)
+instance : Module S (RetainedBimodule k S A M) := inferInstanceAs (Module S M)
+instance : Module Aᵐᵒᵖ (RetainedBimodule k S A M) := inferInstanceAs (Module Aᵐᵒᵖ M)
+instance : IsScalarTower k S (RetainedBimodule k S A M) := inferInstanceAs (IsScalarTower k S M)
+instance : IsScalarTower k Aᵐᵒᵖ (RetainedBimodule k S A M) := inferInstanceAs (IsScalarTower k Aᵐᵒᵖ M)
+instance : SMulCommClass S Aᵐᵒᵖ (RetainedBimodule k S A M) := inferInstanceAs (SMulCommClass S Aᵐᵒᵖ M)
+
+
+def action : (S ⊗[k] Aᵐᵒᵖ) →ₐ[k] Module.End k (RetainedBimodule k S A M) :=
+  show (S ⊗[k] Aᵐᵒᵖ) →ₐ[k] Module.End k M from
+  Algebra.TensorProduct.lift (Algebra.lsmul k k M) (Algebra.lsmul k k M) (by
+    intro s a
+    ext m
+    exact smul_comm s a (m : M))
+instance : Module (S ⊗[k] Aᵐᵒᵖ) (RetainedBimodule k S A M) := Module.compHom _ (action k S A M).toRingHom
+instance tower : IsScalarTower k (S ⊗[k] Aᵐᵒᵖ) (RetainedBimodule k S A M) where
+  smul_assoc r x m := by
+    change action k S A M (r • x) m = r • action k S A M x m
+    rw [map_smul]
+    rfl
+
+variable {k S A M} {M' : Type u}
+variable [AddCommGroup M'] [Module k M'] [Module S M'] [Module Aᵐᵒᵖ M']
+  [IsScalarTower k S M'] [IsScalarTower k Aᵐᵒᵖ M'] [SMulCommClass S Aᵐᵒᵖ M']
+
+def map (f : M →ₗ[Aᵐᵒᵖ] M') (hf : ∀ (s : S) m, f (s • m) = s • f m) :
+    RetainedBimodule k S A M →ₗ[S ⊗[k] Aᵐᵒᵖ] RetainedBimodule k S A M' where
+  __ := f.toAddHom
+  map_smul' x m := by
+    change f (action k S A M x m) = action k S A M' x (f m)
+    induction x using TensorProduct.inductionOn with
+    | tmul s a =>
+      change f (s • (a • (m : M))) = s • (a • f (m : M))
+      exact (hf s (a • (m : M))).trans (congrArg (s • ·) (f.map_smul a (m : M)))
+    | add x y hx hy =>
+      rw [map_add, map_add]
+      exact (f.map_add _ _).trans (congrArg₂ (· + ·) hx hy)
+end RetainedBimodule
+end LittleFinitistic
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRetainedCongruence.lean

@@ -0,0 +1,42 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedRestriction
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalMaps
+
+namespace OAI
+noncomputable section
+open scoped TensorProduct
+namespace LittleFinitistic.RetainedBimodule
+universe u
+variable {k S A M N : Type u} [Field k] [Ring S] [Ring A] [Algebra k S] [Algebra k A]
+variable [AddCommGroup M] [Module k M] [Module S M] [Module Aᵐᵒᵖ M]
+  [IsScalarTower k S M] [IsScalarTower k Aᵐᵒᵖ M] [SMulCommClass S Aᵐᵒᵖ M]
+variable [AddCommGroup N] [Module k N] [Module S N] [Module Aᵐᵒᵖ N]
+  [IsScalarTower k S N] [IsScalarTower k Aᵐᵒᵖ N] [SMulCommClass S Aᵐᵒᵖ N]
+
+/-- An actual right-linear, left-equivariant equivalence retains both actions. -/
+def congr (f : M ≃ₗ[Aᵐᵒᵖ] N) (hf : ∀ (s : S) x, f (s • x) = s • f x) :
+    RetainedBimodule k S A M ≃ₗ[S ⊗[k] Aᵐᵒᵖ] RetainedBimodule k S A N where
+  __ := map (k := k) f.toLinearMap hf
+  invFun := f.symm
+  left_inv := f.left_inv
+  right_inv := f.right_inv
+end LittleFinitistic.RetainedBimodule
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable {L R O O' T T' : Type u} [Ring L] [Ring R]
+variable [AddCommGroup O] [AddCommGroup O'] [AddCommGroup T] [AddCommGroup T']
+variable [Module Lᵐᵒᵖ O] [Module Lᵐᵒᵖ O'] [Module Rᵐᵒᵖ T] [Module Rᵐᵒᵖ T']
+
+def congr (f : O ≃ₗ[Lᵐᵒᵖ] O') (g : T ≃ₗ[Rᵐᵒᵖ] T') :
+    OffDiagonal O T ≃ₗ[(L × R)ᵐᵒᵖ] OffDiagonal O' T' where
+  toFun x := (f x.1,g x.2)
+  invFun x := (f.symm x.1,g.symm x.2)
+  left_inv x := Prod.ext (f.left_inv x.1) (g.left_inv x.2)
+  right_inv x := Prod.ext (f.right_inv x.1) (g.right_inv x.2)
+  map_add' left right := Prod.ext (f.map_add left.1 right.1) (g.map_add left.2 right.2)
+  map_smul' d x := Prod.ext (f.map_smul (MulOpposite.op d.unop.1) x.1)
+    (g.map_smul (MulOpposite.op d.unop.2) x.2)
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRetainedRestriction.lean

@@ -0,0 +1,54 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedBimodule
+import Mathlib.Algebra.Category.ModuleCat.ChangeOfRings
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.RetainedBimodule
+universe u
+variable (k S A M : Type u) [Field k] [Ring S] [Ring A] [Algebra k S] [Algebra k A]
+variable [AddCommGroup M] [Module k M] [Module S M] [Module Aᵐᵒᵖ M]
+  [IsScalarTower k S M] [IsScalarTower k Aᵐᵒᵖ M] [SMulCommClass S Aᵐᵒᵖ M]
+
+abbrev object : ModuleCat.{u} (S ⊗[k] Aᵐᵒᵖ) := ModuleCat.of _ (RetainedBimodule k S A M)
+
+/-- Recover the exact original right action after packaging the ordinary bimodule. -/
+def rightEquiv : BimoduleCoefficients k S A (object k S A M) ≃ₗ[Aᵐᵒᵖ] M where
+  toFun x := x
+  invFun x := x
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' r x := by
+    change action k S A M ((1:S) ⊗ₜ[k] r) x = _
+    unfold action
+    erw [Algebra.TensorProduct.lift_tmul]
+    change (1:S) • (r • (show M from x)) = r • (show M from x)
+    exact one_smul _ _
+
+theorem rightEquiv_left (s : S) (x : BimoduleCoefficients k S A (object k S A M)) :
+    rightEquiv k S A M (s • x) = s • rightEquiv k S A M x := by
+  change action k S A M (s ⊗ₜ[k] (1:Aᵐᵒᵖ)) x = _
+  unfold action
+  erw [Algebra.TensorProduct.lift_tmul]
+  change s • ((1:Aᵐᵒᵖ) • (show M from x)) = s • (show M from x)
+  rw [one_smul]
+
+/-- Recover the exact original scalar module after retaining both actions. -/
+def scalarEquiv : (ModuleCat.restrictScalars (algebraMap k (S ⊗[k] Aᵐᵒᵖ))).obj
+    (object k S A M) ≃ₗ[k] M where
+  toFun x := x
+  invFun x := x
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' r x := by
+    have h (y : RetainedBimodule k S A M) :
+        (algebraMap k (S ⊗[k] Aᵐᵒᵖ) r) • y = r • y := algebraMap_smul _ r y
+    exact h x
+end LittleFinitistic.RetainedBimodule
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRightProjective.lean

@@ -0,0 +1,36 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimodule
+import Mathlib.Algebra.Module.Projective
+import Mathlib.LinearAlgebra.DFinsupp
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.OrdinarySimulation
+universe u v w
+
+/-- The finite direct sum of actual projective terms is projective. -/
+theorem finitePi_projective {R : Type u} [Ring R] {ι : Type v} [Fintype ι]
+    (V : ι → Type w) [∀ i, AddCommGroup (V i)] [∀ i, Module R (V i)]
+    [∀ i, Module.Projective R (V i)] : Module.Projective R (∀ i, V i) :=
+  Module.Projective.of_equiv (DFinsupp.linearEquivFunOnFintype (R := R) (M := V))
+
+open CategoryTheory
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+
+/-- The actual underlying right-B complex of the genuine dg bimodule. -/
+abbrev underlyingRightComplex (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) :
+    CochainComplex (ModuleCat.{u} Bᵐᵒᵖ) ℤ :=
+  ((ModuleCat.restrictScalars
+    (Algebra.TensorProduct.includeRight (R := k) (A := B) (B := Bᵐᵒᵖ)).toRingHom).mapHomologicalComplex (.up ℤ)).obj P
+
+theorem ordinaryO_right_projective (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ)
+    (a : ℤ) (l : ℕ)
+    [∀ n, Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X n)] :
+    Module.Projective Bᵐᵒᵖ (BimoduleO P a l) := by
+  let V : Fin (l+1) → Type u := fun i => (underlyingRightComplex P).X (a+(i.val:ℤ))
+  have : Module.Projective Bᵐᵒᵖ (∀ i, V i) := finitePi_projective V
+  exact Module.Projective.of_equiv (show (∀ i, V i) ≃ₗ[Bᵐᵒᵖ] BimoduleO P a l from LinearEquiv.refl _ _)
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySecondBlockTensor.lean

@@ -0,0 +1,102 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBlockModules
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBalancedCongruence
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.OrdinarySimulation.SecondBlockTensor
+universe u
+variable (k L R O T Z : Type u) [Field k] [Ring L] [Ring R] [Algebra k L] [Algebra k R]
+variable [AddCommGroup O] [Module k O] [Module R O] [Module Lᵐᵒᵖ O]
+  [IsScalarTower k R O] [IsScalarTower k Lᵐᵒᵖ O] [SMulCommClass R Lᵐᵒᵖ O]
+variable [AddCommGroup T] [Module k T] [Module L T] [Module Rᵐᵒᵖ T]
+  [IsScalarTower k L T] [IsScalarTower k Rᵐᵒᵖ T] [SMulCommClass L Rᵐᵒᵖ T]
+variable [AddCommGroup Z] [Module k Z] [Module R Z] [IsScalarTower k R Z]
+
+abbrev source := LeftTensor k (L × R) (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z)
+abbrev target := BlockModule.First k L R (LeftTensor k R L T Z)
+
+def forward : source k L R O T Z →ₗ[k] target k L R T Z :=
+  BalancedTensor.lift ((BalancedTensor.mk k R T Z).compl₁₂
+    (show OffDiagonal O T →ₗ[k] T from LinearMap.snd k O T)
+    (show BlockModule.Second k L R Z →ₗ[k] Z from LinearMap.id)) (by
+      intro d x z
+      exact BalancedTensor.balance (k := k) (A := R) (M := T) (N := Z) d.2 x.2 (show Z from z))
+
+def inverse : target k L R T Z →ₗ[k] source k L R O T Z :=
+  BalancedTensor.lift ((BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z)).compl₁₂
+    (show T →ₗ[k] OffDiagonal O T from LinearMap.inr k O T)
+    (show Z →ₗ[k] BlockModule.Second k L R Z from LinearMap.id)) (by
+      intro a t z
+      have h := BalancedTensor.balance (k := k) (A := L × R) (M := OffDiagonal O T)
+        (N := BlockModule.Second k L R Z) (0,a) (0,t) z
+      change BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z)
+          ((0:Lᵐᵒᵖ) • (0:O),MulOpposite.op a • t) (show BlockModule.Second k L R Z from z) =
+        BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z) (0,t)
+          (show BlockModule.Second k L R Z from a • z) at h
+      rw [smul_zero] at h
+      exact h)
+
+omit [Algebra k L] [Algebra k R] [Module R O] [IsScalarTower k R O]
+  [IsScalarTower k Lᵐᵒᵖ O] [SMulCommClass R Lᵐᵒᵖ O] [Module L T]
+  [IsScalarTower k L T] [IsScalarTower k Rᵐᵒᵖ T] [SMulCommClass L Rᵐᵒᵖ T]
+  [IsScalarTower k R Z] in
+theorem other_block_zero (o : O) (z : BlockModule.Second k L R Z) :
+    BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z) (o,0) z = 0 := by
+  have h := BalancedTensor.balance (k := k) (A := L × R) (M := OffDiagonal O T)
+    (N := BlockModule.Second k L R Z) (1,0) (o,0) z
+  change BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z)
+      ((1:Lᵐᵒᵖ) • o,(0:Rᵐᵒᵖ) • (0:T)) z =
+    BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z) (o,0) ((0:R) • (show Z from z)) at h
+  erw [one_smul, zero_smul, zero_smul, map_zero] at h
+  exact h
+
+omit [Module R O] [IsScalarTower k R O] [IsScalarTower k Lᵐᵒᵖ O]
+  [SMulCommClass R Lᵐᵒᵖ O] [Module L T] [IsScalarTower k L T]
+  [IsScalarTower k Rᵐᵒᵖ T] [SMulCommClass L Rᵐᵒᵖ T] [IsScalarTower k R Z] in
+theorem inverse_forward (x : source k L R O T Z) :
+    inverse k L R O T Z (forward k L R O T Z x) = x := by
+  let F := (inverse k L R O T Z).comp (forward k L R O T Z)
+  have h : F = LinearMap.id := by
+    apply BalancedTensor.ext
+    intro x z
+    change BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z) (0,x.2) z =
+      BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z) x z
+    let q := (BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z)).flip z
+    have hx : x = (x.1,0) + (0,x.2) := Prod.ext (add_zero _).symm (zero_add _).symm
+    exact ((congrArg q hx).trans ((q.map_add _ _).trans
+      ((congrArg (· + q (0,x.2)) (other_block_zero k L R O T Z x.1 z)).trans (zero_add _)))).symm
+  exact congrArg (fun f => f x) h
+
+omit [Module R O] [IsScalarTower k R O] [IsScalarTower k Lᵐᵒᵖ O]
+  [SMulCommClass R Lᵐᵒᵖ O] [Module L T] [IsScalarTower k L T]
+  [IsScalarTower k Rᵐᵒᵖ T] [SMulCommClass L Rᵐᵒᵖ T] [IsScalarTower k R Z] in
+theorem forward_inverse (x : target k L R T Z) :
+    forward k L R O T Z (inverse k L R O T Z x) = x := by
+  have h : (forward k L R O T Z).comp (inverse k L R O T Z) = LinearMap.id := by
+    apply BalancedTensor.ext
+    intro t z
+    rfl
+  exact congrArg (fun f => f x) h
+
+/-- Tensor on the second block selects T and has its actual output on the first block. -/
+def equivalence : source k L R O T Z ≃ₗ[L × R] target k L R T Z where
+  toFun := forward k L R O T Z
+  invFun := inverse k L R O T Z
+  left_inv := inverse_forward k L R O T Z
+  right_inv := forward_inverse k L R O T Z
+  map_add' := (forward k L R O T Z).map_add
+  map_smul' d x := by
+    let F := forward k L R O T Z
+    have h : F.comp (LeftTensor.action k (L × R) (L × R) (OffDiagonal O T)
+        (BlockModule.Second k L R Z) d) =
+        (Algebra.lsmul k k (target k L R T Z) d).comp F := by
+      apply BalancedTensor.ext
+      intro x z
+      rfl
+    exact congrArg (fun f => f x) h
+
+end LittleFinitistic.OrdinarySimulation.SecondBlockTensor
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySecondBlockTotal.lean

@@ -0,0 +1,113 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBlockTensorTerms
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleTensorTotal
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.BlockTensor
+universe u
+variable (k L R : Type u) [Field k] [Ring L] [Ring R] [Algebra k L] [Algebra k R]
+variable (O : CochainComplex (ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)) ℤ)
+variable (T : CochainComplex (ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ)) ℤ)
+variable (Z : CochainComplex (ModuleCat.{u} R) ℤ)
+variable {l : ℕ} (p : Fin l → ℤ) (hp : StrictMono p)
+open BimoduleComplexTensor
+
+def secondTotalEquiv (n : ℤ) :
+    totalTerm k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n ≃ₗ[L × R]
+      BlockModule.First k L R (totalTerm k L R T Z p n) :=
+  (LinearEquiv.piCongrRight (fun i => secondTermEquiv k L R O T Z (p i) (n + -(p i)))).trans
+    (show (∀ i : Fin l, BlockModule.First k L R (term k L R T Z (p i) (n + -(p i)))) ≃ₗ[L × R]
+      BlockModule.First k L R (totalTerm k L R T Z p n) from LinearEquiv.refl _ _)
+
+@[simp] theorem secondTotalEquiv_apply (n : ℤ)
+    (z : totalTerm k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n)
+    (i : Fin l) : secondTotalEquiv k L R O T Z p n z i =
+      secondTermEquiv k L R O T Z (p i) (n + -(p i)) (z i) := rfl
+
+theorem second_entry (n : ℤ) (i j : Fin l) :
+    (secondTermEquiv k L R O T Z (p j) ((n+1) + -(p j))).toLinearMap.comp
+      (entry k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n i j) =
+    (BlockModule.firstMap k L R (entry k L R T Z p n i j)).comp
+      (secondTermEquiv k L R O T Z (p i) (n + -(p i))).toLinearMap := by
+  unfold entry
+  split_ifs with h
+  · have he : n + -(p i) = (n+1) + -(p j) := by omega
+    have ht : (ProductModules.secondInflation L R).map (eqToHom (congrArg Z.X he)) =
+        eqToHom (congrArg (BlockModule.secondComplex L R Z).X he) := by
+      generalize n + -(p i) = q at he ⊢
+      generalize (n+1) + -(p j) = q' at he ⊢
+      subst q'
+      simp only [eqToHom_refl,CategoryTheory.Functor.map_id]
+      rfl
+    have hh := secondTermEquiv_map k L R O T Z (O.d (p i) (p j)) (T.d (p i) (p j)) (eqToHom (congrArg Z.X he))
+    rw [ht,← OffDiagonal.complex_d_all] at hh
+    exact hh
+  · apply LinearMap.ext
+    intro x
+    change secondTermEquiv k L R O T Z (p j) ((n+1) + -(p j)) 0 = 0
+    exact (secondTermEquiv k L R O T Z (p j) ((n+1) + -(p j))).map_zero
+
+theorem second_vertical (n : ℤ) (i : Fin l) :
+    (secondTermEquiv k L R O T Z (p i) ((n+1) + -(p i))).toLinearMap.comp
+      (map k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) (𝟙 _)
+        ((BlockModule.secondComplex L R Z).d (n + -(p i)) ((n+1) + -(p i)))) =
+    (BlockModule.firstMap k L R (map k L R T Z (𝟙 _) (Z.d (n + -(p i)) ((n+1) + -(p i))))).comp
+      (secondTermEquiv k L R O T Z (p i) (n + -(p i))).toLinearMap := by
+  exact secondTermEquiv_map k L R O T Z (𝟙 (O.X (p i))) (𝟙 (T.X (p i))) (Z.d _ _)
+
+theorem second_differential (n : ℤ)
+    (z : totalTerm k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n) :
+    secondTotalEquiv k L R O T Z p (n+1)
+      (differential k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n z) =
+    differential k L R T Z p n (secondTotalEquiv k L R O T Z p n z) := by
+  funext j
+  change secondTermEquiv k L R O T Z (p j) ((n+1) + -(p j))
+      (differential k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n z j) =
+    differential k L R T Z p n (secondTotalEquiv k L R O T Z p n z) j
+  simp only [differential,
+    LinearMap.pi_apply,LinearMap.add_apply,LinearMap.comp_apply,LinearMap.proj_apply,
+    LinearMap.sum_apply,map_add,map_sum]
+  apply congrArg₂ (· + ·)
+  · change secondTermEquiv k L R O T Z (p j) ((n+1) + -(p j))
+        ((((-(p j)).negOnePow : ℤ)) •
+          (map k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) (𝟙 _)
+            ((BlockModule.secondComplex L R Z).d (n + -(p j)) ((n+1) + -(p j))) (z j))) =
+      (((-(p j)).negOnePow : ℤ)) •
+        (map k L R T Z (𝟙 _) (Z.d (n + -(p j)) ((n+1) + -(p j))))
+          (secondTermEquiv k L R O T Z (p j) (n + -(p j)) (z j))
+    rw [map_zsmul]
+    congr 1
+    exact congrArg (fun f => f (z j)) (second_vertical k L R O T Z p n j)
+  · erw [LinearMap.sum_apply]
+    apply Finset.sum_congr rfl
+    intro i _
+    exact congrArg (fun f => f (z i)) (second_entry k L R O T Z p n i j)
+
+/-- Actual tensor with the off-diagonal complex on a second-block input is the first-block T-total. -/
+def secondTotalIso :
+    total k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p hp ≅
+      BlockModule.firstComplex L R (total k L R T Z p hp) :=
+  HomologicalComplex.Hom.isoOfComponents (fun n => (secondTotalEquiv k L R O T Z p n).toModuleIso) (by
+    intro n m h
+    change n+1=m at h
+    subst m
+    have h₁ : (total k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p hp).d n (n+1) =
+        ModuleCat.ofHom (differential k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n) :=
+      CochainComplex.of_d (fun n => ModuleCat.of (L × R) (totalTerm k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n))
+        (fun n => ModuleCat.ofHom (differential k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n)) n
+    have h₂ : (total k L R T Z p hp).d n (n+1) = ModuleCat.ofHom (differential k L R T Z p n) :=
+      CochainComplex.of_d (fun n => ModuleCat.of L (totalTerm k L R T Z p n))
+        (fun n => ModuleCat.ofHom (differential k L R T Z p n)) n
+    change _ ≫ (ProductModules.firstInflation L R).map ((total k L R T Z p hp).d n (n+1)) = _
+    rw [h₁,h₂]
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro z
+    exact (second_differential k L R O T Z p n z).symm)
+end LittleFinitistic.OrdinarySimulation.BlockTensor
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryShiftDerivedTensor.lean

@@ -0,0 +1,44 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleDerivedTensor
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRightProjective
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryShiftSign
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (b : ℤ) (l : ℕ)
+variable [∀ n, Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X n)]
+
+instance shifted_right_projective (n : ℤ) : Module.Projective Bᵐᵒᵖ
+    (ComplexTensor.rightTerm k B (BimoduleComplexTensor.rightComplex k B B (P⟦b⟧)) n) :=
+  inferInstanceAs (Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X (n+b)))
+
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} B)]
+
+/-- The native derived tensor functor computed by the source's actual bounded P[b]. -/
+def shiftedDerivedTensor : DerivedCategory (ModuleCat.{u} B) ⥤ DerivedCategory (ModuleCat.{u} B) :=
+  BimoduleComplexTensor.derivedTotal k B B (P⟦b⟧)
+    (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l)
+
+def shiftedDerivedTensorComparison : DerivedCategory.Q ⋙ shiftedDerivedTensor P b l ≅
+    BimoduleComplexTensor.totalFunctor k B B (P⟦b⟧)
+      (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l) ⋙ DerivedCategory.Q :=
+  BimoduleComplexTensor.derivedTotalComparison k B B (P⟦b⟧)
+    (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l)
+
+omit [∀ n, Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X n)]
+  [HasDerivedCategory.{u+1} (ModuleCat.{u} B)] in
+theorem shifted_support (a : ℤ) (hb : a+(l:ℤ)=b)
+    (hP : ∀ n : ℤ, n < a ∨ b < n → IsZero (P.X n)) (n : ℤ) (hn : n < -(l:ℤ) ∨ 0 < n) :
+    IsZero ((P⟦b⟧).X n) := by
+  change IsZero (P.X (n+b))
+  apply hP
+  omega
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryShiftSign.lean

@@ -0,0 +1,49 @@
+import Mathlib.Algebra.Homology.HomotopyCategory.Shift
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.OrdinarySimulation
+universe u v
+variable {C : Type u} [Category.{v} C] [Preadditive C]
+
+/-- Reindex P by b, retaining the original differential. This is what the resolution computes. -/
+def unsignedShift (P : CochainComplex C ℤ) (b : ℤ) : CochainComplex C ℤ where
+  X n := P.X (n+b)
+  d n m := P.d (n+b) (m+b)
+  shape n m h := P.shape _ _ (by
+    change ¬ (n+b)+1 = m+b
+    change ¬ n+1=m at h
+    omega)
+  d_comp_d' n m q _ _ := P.d_comp_d _ _ _
+
+/-- Multiplication by an integer unit is an actual isomorphism in any additive category. -/
+def integerUnitIso (X : C) (u : ℤˣ) : X ≅ X where
+  hom := u • 𝟙 X
+  inv := u⁻¹ • 𝟙 X
+  hom_inv_id := by
+    simp only [Linear.units_smul_comp, Linear.comp_units_smul, Category.id_comp,
+      smul_smul, inv_mul_cancel, one_smul]
+  inv_hom_id := by
+    simp only [Linear.units_smul_comp, Linear.comp_units_smul, Category.id_comp,
+      smul_smul, mul_inv_cancel, one_smul]
+
+/-- The source's degree-n sign (-1)^(b*n), for all integers b and n. -/
+def shiftSignIso (P : CochainComplex C ℤ) (b : ℤ) : unsignedShift P b ≅ P⟦b⟧ :=
+  HomologicalComplex.Hom.isoOfComponents
+    (fun n => integerUnitIso (P.X (n+b)) (b*n).negOnePow) (by
+      intro n m h
+      change n+1=m at h
+      subst m
+      change ((b*n).negOnePow • 𝟙 _) ≫ (b.negOnePow • P.d (n+b) (n+1+b)) =
+        P.d (n+b) (n+1+b) ≫ ((b*(n+1)).negOnePow • 𝟙 _)
+      simp only [Linear.units_smul_comp, Linear.comp_units_smul, Category.id_comp,
+        Category.comp_id, smul_smul]
+      rw [← Int.negOnePow_add]
+      congr 2
+      simp [mul_add, add_comm])
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySignedExactness.lean

@@ -0,0 +1,35 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorExactness
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic
+universe u
+variable {R E F G : Type u} [Ring R]
+variable [AddCommGroup E] [Module R E]
+variable [AddCommGroup F] [Module R F]
+variable [AddCommGroup G] [Module R G]
+
+/-- Multiplying both differentials by an integer unit preserves exactness. -/
+theorem exact_units_smul (u : ℤˣ) (f : E →ₗ[R] F) (g : F →ₗ[R] G)
+    (h : Function.Exact f g) : Function.Exact (u • f) (u • g) := by
+  intro z
+  constructor
+  · intro hz
+    have hg : g z = 0 := by
+      have hh := congrArg (fun x : G => u⁻¹ • x) hz
+      simpa only [LinearMap.smul_apply,smul_smul,inv_mul_cancel,one_smul,smul_zero] using hh
+    obtain ⟨y,hy⟩ := (h z).mp hg
+    refine ⟨u⁻¹ • y, ?_⟩
+    change u • f ((↑(u⁻¹) : ℤ) • y) = z
+    rw [map_zsmul]
+    change u • (u⁻¹ • f y) = z
+    rw [smul_smul,mul_inv_cancel,one_smul,hy]
+  · rintro ⟨y,rfl⟩
+    have hg : g (f y) = 0 := (h (f y)).mpr ⟨y,rfl⟩
+    change u • g ((↑u : ℤ) • f y) = 0
+    rw [map_zsmul,hg,smul_zero,smul_zero]
+end LittleFinitistic
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySimulationComparison.lean

@@ -0,0 +1,75 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFullTensorComplex
+import OAI.Algebra.Finitistic.Ordinary.OrdinarySupportedExtension
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryShiftSign
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+
+theorem differential_transport {n n' m m' : ℤ} (hn : n = n') (hm : m = m') :
+    eqToHom (congrArg P.X hn) ≫ P.d n' m' = P.d n m ≫ eqToHom (congrArg P.X hm) := by
+  subst n'
+  subst m'
+  simp only [eqToHom_refl,Category.id_comp,Category.comp_id]
+
+/-- Align the finite resolution's degree n with the source's degree a+n. -/
+def restrictedShiftIso : P.restriction (ComplexShape.embeddingUpIntGE a) ≅
+    (unsignedShift P (a+(l:ℤ))).restriction (TensorResolution.degreeEmbedding l) :=
+  HomologicalComplex.Hom.isoOfComponents (fun n => eqToIso (by
+    change P.X (a+(n:ℤ)) = P.X ((-(l:ℤ)+n)+(a+l))
+    congr 1
+    omega)) (by
+      intro n m _
+      have hn : (-(l:ℤ)+(n:ℤ))+(a+l) = a+n := by omega
+      have hm : (-(l:ℤ)+(m:ℤ))+(a+l) = a+m := by omega
+      change eqToHom (congrArg P.X hn.symm) ≫ P.d ((-(l:ℤ)+n)+(a+l)) ((-(l:ℤ)+m)+(a+l)) =
+        P.d (a+n) (a+m) ≫ eqToHom (congrArg P.X hm.symm)
+      exact differential_transport P hn.symm hm.symm)
+
+/-- The lower support condition of the manuscript supplies strict support after reindexing. -/
+theorem unsignedSupport (hP : ∀ n : ℤ, n < a → IsZero (P.X n)) :
+    (unsignedShift P (a+(l:ℤ))).IsStrictlySupported (TensorResolution.degreeEmbedding l) :=
+  ⟨fun n hn => by
+    have hlt : n < -(l:ℤ) := by
+      by_contra h
+      let j := (n+(l:ℤ)).toNat
+      have hj : (TensorResolution.degreeEmbedding l).f j = n := by
+        simp only [TensorResolution.degreeEmbedding_apply]
+        dsimp [j]
+        rw [Int.toNat_of_nonneg (by omega)]
+        omega
+      exact hn j hj
+    exact hP (n+(a+l)) (by omega)⟩
+
+/-- The computed BC-balanced tensor complex in degrees -l,...,0 with both B-actions. -/
+def computedTensorComplex : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ :=
+  (FullTensorTerm.complex P a l).extend (TensorResolution.degreeEmbedding l)
+
+/-- Full bimodule chain comparison, including all zero terms and the genuine integer shift sign. -/
+def computedTensorIso
+    (hLower : ∀ n : ℤ, n < a → IsZero (P.X n))
+    (hUpper : ∀ n : ℕ, l < n → IsZero (P.X (a+(n:ℤ)))) :
+    computedTensorComplex P a l ≅ P⟦a+(l:ℤ)⟧ := by
+  letI := unsignedSupport P a l hLower
+  exact ((TensorResolution.degreeEmbedding l).extendFunctor (ModuleCat.{u} (Enveloping k B))).mapIso
+      (FullTensorTerm.complexIso P a l hUpper ≪≫ restrictedShiftIso P a l) ≪≫
+    SupportedExtension.iso (unsignedShift P (a+(l:ℤ))) (TensorResolution.degreeEmbedding l) ≪≫
+    shiftSignIso P (a+(l:ℤ))
+
+/-- Exact source indexing: b=a+l, with only the manuscript's support hypothesis. -/
+def sourceShiftComparison (b : ℤ) (hb : a+(l:ℤ)=b)
+    (hP : ∀ n : ℤ, n < a ∨ b < n → IsZero (P.X n)) :
+    computedTensorComplex P a l ≅ P⟦b⟧ := by
+  subst b
+  exact computedTensorIso P a l (fun n hn => hP n (Or.inl hn))
+    (fun n hn => hP (a+(n:ℤ)) (Or.inr (by omega)))
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySingleTensorTerms.lean

@@ -0,0 +1,99 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleCoefficientEquiv
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleTensorTotal
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedRestriction
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFinitePiSupport
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryMiddleTensorFunctors
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryShiftSign
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.SingleBimoduleTensor
+universe u
+variable (k S A N : Type u) [Field k] [Ring S] [Ring A] [Algebra k S] [Algebra k A]
+variable [AddCommGroup N] [Module k N] [Module S N] [Module Aᵐᵒᵖ N]
+  [IsScalarTower k S N] [IsScalarTower k Aᵐᵒᵖ N] [SMulCommClass S Aᵐᵒᵖ N]
+
+abbrev complex : CochainComplex (ModuleCat.{u} (S ⊗[k] Aᵐᵒᵖ)) ℤ :=
+  (HomologicalComplex.single _ (.up ℤ) 0).obj (RetainedBimodule.object k S A N)
+
+variable (Z : CochainComplex (ModuleCat.{u} A) ℤ)
+open BimoduleComplexTensor
+
+def zeroCoefficientEquiv : BimoduleCoefficients k S A ((complex k S A N).X 0) ≃ₗ[Aᵐᵒᵖ] N :=
+  (BimoduleCoefficients.equiv k S A (HomologicalComplex.singleObjXSelf (.up ℤ) 0 (RetainedBimodule.object k S A N))).trans
+    (RetainedBimodule.rightEquiv k S A N)
+
+theorem zeroCoefficientEquiv_left (s : S) (x : BimoduleCoefficients k S A ((complex k S A N).X 0)) :
+    zeroCoefficientEquiv k S A N (s • x) = s • zeroCoefficientEquiv k S A N x := by
+  simp only [zeroCoefficientEquiv,LinearEquiv.trans_apply,BimoduleCoefficients.equiv_left,RetainedBimodule.rightEquiv_left]
+
+def zeroTermEquiv (n : ℤ) : term k S A (complex k S A N) Z 0 n ≃ₗ[S] (middleLeftComplex k S A N Z).X n :=
+  LeftTensor.congr (zeroCoefficientEquiv k S A N) (zeroCoefficientEquiv_left k S A N)
+    (LinearEquiv.refl A (ComplexTensor.leftTerm k A Z n))
+
+theorem zeroTermEquiv_map {n m : ℤ} (g : Z.X n ⟶ Z.X m) :
+    (zeroTermEquiv k S A N Z m).toLinearMap.comp (map k S A (complex k S A N) Z (𝟙 _) g) =
+    ((middleLeftFunctor k S A N).map g).hom.comp (zeroTermEquiv k S A N Z n).toLinearMap := by
+  let : Module k ((middleLeftComplex k S A N Z).X m) := inferInstanceAs (Module k (LeftTensor k A S N (ComplexTensor.leftTerm k A Z m)))
+  let : IsScalarTower k S ((middleLeftComplex k S A N Z).X m) := inferInstanceAs (IsScalarTower k S (LeftTensor k A S N (ComplexTensor.leftTerm k A Z m)))
+  apply LinearMap.restrictScalars_injective k
+  apply BalancedTensor.ext
+  intro x z
+  rfl
+
+variable {l : ℕ} (p : Fin l → ℤ) (hp : StrictMono p) (i₀ : Fin l) (h₀ : p i₀ = 0)
+
+include hp h₀ in
+theorem otherTerm_subsingleton (n : ℤ) (i : Fin l) (hi : i ≠ i₀) :
+    Subsingleton (term k S A (complex k S A N) Z (p i) (n + -(p i))) := by
+  have hz : p i ≠ 0 := by
+    intro h
+    exact hi (hp.injective (h.trans h₀.symm))
+  have : Subsingleton (BimoduleCoefficients k S A ((complex k S A N).X (p i))) :=
+    ModuleCat.isZero_iff_subsingleton.mp
+      (HomologicalComplex.isZero_single_obj_X (.up ℤ) 0 (RetainedBimodule.object k S A N) (p i) hz)
+  exact inferInstanceAs (Subsingleton (BalancedTensor.Tensor k A
+    (BimoduleCoefficients k S A ((complex k S A N).X (p i))) (ComplexTensor.leftTerm k A Z (n + -(p i)))))
+
+def coefficientEquivAt (q : ℤ) (hq : q = 0) :
+    BimoduleCoefficients k S A ((complex k S A N).X q) ≃ₗ[Aᵐᵒᵖ] N := by
+  subst q
+  exact zeroCoefficientEquiv k S A N
+
+theorem coefficientEquivAt_left (q : ℤ) (hq : q = 0) (s : S)
+    (x : BimoduleCoefficients k S A ((complex k S A N).X q)) :
+    coefficientEquivAt k S A N q hq (s • x) = s • coefficientEquivAt k S A N q hq x := by
+  subst q
+  exact zeroCoefficientEquiv_left k S A N s x
+
+def termEquivAt (q : ℤ) (hq : q = 0) (n : ℤ) :
+    term k S A (complex k S A N) Z q (n + -q) ≃ₗ[S] ((middleLeftComplex k S A N Z)⟦-q⟧).X n :=
+  LeftTensor.congr (coefficientEquivAt k S A N q hq) (coefficientEquivAt_left k S A N q hq)
+    (LinearEquiv.refl A (ComplexTensor.leftTerm k A Z (n + -q)))
+
+theorem termEquivAt_map (q : ℤ) (hq : q = 0) (n m : ℤ) (g : Z.X (n + -q) ⟶ Z.X (m + -q)) :
+    (termEquivAt k S A N Z q hq m).toLinearMap.comp (map k S A (complex k S A N) Z (𝟙 _) g) =
+    ((middleLeftFunctor k S A N).map g).hom.comp (termEquivAt k S A N Z q hq n).toLinearMap := by
+  let : Module k (((middleLeftComplex k S A N Z)⟦-q⟧).X m) :=
+    inferInstanceAs (Module k (LeftTensor k A S N (ComplexTensor.leftTerm k A Z (m + -q))))
+  let : IsScalarTower k S (((middleLeftComplex k S A N Z)⟦-q⟧).X m) :=
+    inferInstanceAs (IsScalarTower k S (LeftTensor k A S N (ComplexTensor.leftTerm k A Z (m + -q))))
+  apply LinearMap.restrictScalars_injective k
+  apply BalancedTensor.ext
+  intro x z
+  rfl
+
+abbrev selectedTermEquiv (n : ℤ) := termEquivAt k S A N Z (p i₀) h₀ n
+
+def totalTermEquiv (n : ℤ) : totalTerm k S A (complex k S A N) Z p n ≃ₗ[S]
+    ((middleLeftComplex k S A N Z)⟦-(p i₀)⟧).X n :=
+  (FinitePiSupport.equivalence (fun i => term k S A (complex k S A N) Z (p i) (n + -(p i)))
+    i₀ (otherTerm_subsingleton k S A N Z p hp i₀ h₀ n)).trans
+    (selectedTermEquiv k S A N Z p i₀ h₀ n)
+end LittleFinitistic.SingleBimoduleTensor
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySingleTensorTotal.lean

@@ -0,0 +1,84 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinarySingleTensorTerms
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.SingleBimoduleTensor
+universe u
+variable (k S A N : Type u) [Field k] [Ring S] [Ring A] [Algebra k S] [Algebra k A]
+variable [AddCommGroup N] [Module k N] [Module S N] [Module Aᵐᵒᵖ N]
+  [IsScalarTower k S N] [IsScalarTower k Aᵐᵒᵖ N] [SMulCommClass S Aᵐᵒᵖ N]
+variable (Z : CochainComplex (ModuleCat.{u} A) ℤ)
+variable {l : ℕ} (p : Fin l → ℤ) (hp : StrictMono p) (i₀ : Fin l) (h₀ : p i₀ = 0)
+open BimoduleComplexTensor
+
+include hp h₀ in
+theorem entry_selected_zero (n : ℤ) (z : totalTerm k S A (complex k S A N) Z p n) (i : Fin l) :
+    entry k S A (complex k S A N) Z p n i i₀ (z i) = 0 := by
+  by_cases hi : i = i₀
+  · subst i
+    unfold entry
+    rw [dite_eq_right (show ¬ p i₀ + 1 = p i₀ by omega)]
+    rfl
+  · have hs := otherTerm_subsingleton k S A N Z p hp i₀ h₀ n i hi
+    rw [hs.elim (z i) 0,map_zero]
+
+include hp h₀ in
+theorem differential_selected (n : ℤ) (z : totalTerm k S A (complex k S A N) Z p n) :
+    differential k S A (complex k S A N) Z p n z i₀ =
+      ((-(p i₀)).negOnePow • map k S A (complex k S A N) Z (𝟙 _)
+        (Z.d (n + -(p i₀)) ((n+1) + -(p i₀)))) (z i₀) := by
+  simp only [differential,LinearMap.pi_apply,LinearMap.add_apply,LinearMap.comp_apply,LinearMap.proj_apply,
+    LinearMap.sum_apply]
+  rw [Finset.sum_eq_zero (fun i _ => entry_selected_zero k S A N Z p hp i₀ h₀ n z i),add_zero]
+
+theorem termEquivAt_vertical (q : ℤ) (hq : q = 0) (n : ℤ)
+    (y : term k S A (complex k S A N) Z q (n + -q)) :
+    termEquivAt k S A N Z q hq (n+1)
+      (((-q).negOnePow • map k S A (complex k S A N) Z (𝟙 _)
+        (Z.d (n + -q) ((n+1) + -q))) y) =
+    (((middleLeftComplex k S A N Z)⟦-q⟧).d n (n+1)).hom (termEquivAt k S A N Z q hq n y) := by
+  change termEquivAt k S A N Z q hq (n+1)
+      ((((-q).negOnePow : ℤ)) • (map k S A (complex k S A N) Z (𝟙 _)
+        (Z.d (n + -q) ((n+1) + -q))) y) =
+    (((-q).negOnePow : ℤ)) • (((middleLeftFunctor k S A N).map (Z.d (n + -q) ((n+1) + -q))).hom
+      (termEquivAt k S A N Z q hq n y))
+  rw [map_zsmul]
+  congr 1
+  exact congrArg (fun f => f y) (termEquivAt_map k S A N Z q hq n (n+1) (Z.d _ _))
+
+theorem totalTermEquiv_differential (n : ℤ) (z : totalTerm k S A (complex k S A N) Z p n) :
+    totalTermEquiv k S A N Z p hp i₀ h₀ (n+1) (differential k S A (complex k S A N) Z p n z) =
+    (((middleLeftComplex k S A N Z)⟦-(p i₀)⟧).d n (n+1)).hom (totalTermEquiv k S A N Z p hp i₀ h₀ n z) := by
+  change termEquivAt k S A N Z (p i₀) h₀ (n+1)
+      (differential k S A (complex k S A N) Z p n z i₀) =
+    (((middleLeftComplex k S A N Z)⟦-(p i₀)⟧).d n (n+1)).hom (termEquivAt k S A N Z (p i₀) h₀ n (z i₀))
+  rw [differential_selected k S A N Z p hp i₀ h₀]
+  exact termEquivAt_vertical k S A N Z (p i₀) h₀ n (z i₀)
+
+/-- A genuine ordinary bimodule in degree zero has exactly its ordinary tensor complex as total. -/
+def shiftedTotalIso : total k S A (complex k S A N) Z p hp ≅ (middleLeftComplex k S A N Z)⟦-(p i₀)⟧ :=
+  HomologicalComplex.Hom.isoOfComponents (fun n => (totalTermEquiv k S A N Z p hp i₀ h₀ n).toModuleIso) (by
+    intro n m h
+    change n+1=m at h
+    subst m
+    have hd : (total k S A (complex k S A N) Z p hp).d n (n+1) = ModuleCat.ofHom (differential k S A (complex k S A N) Z p n) :=
+      CochainComplex.of_d (fun n => ModuleCat.of S (totalTerm k S A (complex k S A N) Z p n))
+        (fun n => ModuleCat.ofHom (differential k S A (complex k S A N) Z p n)) n
+    rw [hd]
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro z
+    exact (totalTermEquiv_differential k S A N Z p hp i₀ h₀ n z).symm)
+
+/-- Removing the proved zero shift identifies the ordinary tensor complex exactly. -/
+def totalIso : total k S A (complex k S A N) Z p hp ≅ middleLeftComplex k S A N Z :=
+  shiftedTotalIso k S A N Z p hp i₀ h₀ ≪≫
+    (eqToIso (congrArg (fun q : ℤ => (middleLeftComplex k S A N Z)⟦q⟧) (show -(p i₀) = 0 by omega))) ≪≫
+    (shiftFunctorZero (CochainComplex (ModuleCat.{u} S) ℤ) ℤ).app (middleLeftComplex k S A N Z)
+end LittleFinitistic.SingleBimoduleTensor
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySourceBimoduleTotal.lean

@@ -0,0 +1,35 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryGenuineBimoduleComparison
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleTotalAssociativity
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleTotalCongruence
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorTotalAcyclic
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+variable (b : ℤ) (hb : a+(l:ℤ)=b)
+variable (hP : ∀ n : ℤ, n < a ∨ b < n → IsZero (P.X n))
+variable (Z : CochainComplex (ModuleCat.{u} B) ℤ)
+
+/-- The source signed total comparison for every Z, with the actual outside B-action retained. -/
+def sourceBimoduleTotalComparison :
+    BimoduleComplexTensor.total k B (B ⊗[k] ChainAlgebra k l)
+      (TensorResolution.integerBimoduleComplex k B l)
+      (middleLeftComplex k (B ⊗[k] ChainAlgebra k l) B (BimoduleO P a l) Z)
+      (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l) ≅
+    BimoduleComplexTensor.total k B B (P⟦b⟧) Z
+      (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l) :=
+  (BimoduleComplexTensor.totalAssociativityIso k B (B ⊗[k] ChainAlgebra k l) B (BimoduleO P a l)
+    (TensorResolution.integerBimoduleComplex k B l) Z
+    (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l)).symm ≪≫
+  BimoduleComplexTensor.totalRightIso k B B (genuineSourceShiftComparison P a l b hb hP) Z
+    (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l)
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySourceDerivedComparison.lean

@@ -0,0 +1,42 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinarySourceResolutionModels
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryDerivedSquareComparison
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+variable (b : ℤ) (hb : a+(l:ℤ)=b)
+variable (hP : ∀ n : ℤ, n < a ∨ b < n → IsZero (P.X n))
+
+section Bimodule
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} (Enveloping k B))]
+
+/-- The source's resolved T tensor O comparison in the native derived category of genuine B-bimodules.
+Its left operand includes the actual bounded right-BC-projective resolution and augmentation to T. -/
+def resolvedBimoduleComparison :
+    (TensorResolution.resolutionModel k B l).tensorOrdinary B (BimoduleO P a l) ≅
+      DerivedCategory.Q.obj (P⟦b⟧) :=
+  DerivedCategory.Q.mapIso (genuineSourceShiftComparison P a l b hb hP)
+end Bimodule
+
+variable [∀ n, Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X n)]
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} B)]
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} (AlgebraD k l B))]
+
+/-- The source's native derived square with both tensor functors tied to their certified full-support models. -/
+def resolvedSquareComparison (Z : CochainComplex (ModuleCat.{u} B) ℤ) :
+    (XResolution.resolutionModel P a l).toFiniteProjectiveBimoduleComplex.derivedTensor.obj
+      ((XResolution.resolutionModel P a l).toFiniteProjectiveBimoduleComplex.derivedTensor.obj
+        ((BlockModule.derivedFirst B (B ⊗[k] ChainAlgebra k l)).obj (DerivedCategory.Q.obj Z))) ≅
+    (BlockModule.derivedFirst B (B ⊗[k] ChainAlgebra k l)).obj
+      ((shiftedResolutionModel P a l b hb hP).derivedTensor.obj (DerivedCategory.Q.obj Z)) :=
+  XResolution.derivedSquareComparison P a l b hb hP Z
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySourceResolutionModels.lean

@@ -0,0 +1,80 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryResolutionModels
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryXAugmentation
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryShiftDerivedTensor
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+
+namespace TensorResolution
+
+theorem finiteDegrees_range (l : ℕ) (n : ℤ) : n ∈ Set.range (finiteDegrees l) ↔ -(l:ℤ) ≤ n ∧ n ≤ 0 := by
+  constructor
+  · rintro ⟨i,rfl⟩
+    dsimp [finiteDegrees]
+    have hi := i.isLt
+    omega
+  · rintro ⟨hlo,hhi⟩
+    let j := (n+(l:ℤ)).toNat
+    have hj : (j:ℤ) = n+(l:ℤ) := Int.toNat_of_nonneg (by omega)
+    refine ⟨⟨j,by omega⟩,?_⟩
+    dsimp [finiteDegrees]
+    omega
+
+/-- The actual Q_T augmentation with all source resolution obligations proved. -/
+def resolutionModel (k B : Type u) [Field k] [Ring B] [Algebra k B] (l : ℕ) :
+    BoundedBimoduleResolution k B (B ⊗[k] ChainAlgebra k l) (bimoduleTerminalObject k B l) where
+  complex := integerBimoduleComplex k B l
+  size := l+1
+  degrees := finiteDegrees l
+  strictMono := finiteDegrees_strictMono l
+  support n hn := by
+    have h : n < -(l:ℤ) ∨ 0 < n := by
+      have := (finiteDegrees_range l n).not.mp hn
+      omega
+    exact h.elim (integerBimodule_lower k B l n) (integerBimodule_upper k B l n)
+  rightProjective n := integerBimoduleRight_projective k B l n
+  augmentation := integerBimoduleAugmentation k B l
+  augmentation_quasiIso := integerBimoduleAugmentation_quasiIso k B l
+end TensorResolution
+
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+variable [∀ n, Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X n)]
+
+/-- The actual Q_X resolution with no assumed augmentation, projectivity, or support theorem. -/
+def XResolution.resolutionModel :
+    BoundedBimoduleResolution k (AlgebraD k l B) (AlgebraD k l B) (XResolution.ordinaryXObject P a l) where
+  complex := XResolution.complex P a l
+  size := l+1
+  degrees := TensorResolution.finiteDegrees l
+  strictMono := TensorResolution.finiteDegrees_strictMono l
+  support n hn := by
+    apply XResolution.vanishes P a l n
+    have := (TensorResolution.finiteDegrees_range l n).not.mp hn
+    omega
+  rightProjective n := XResolution.right_projective P a l n
+  augmentation := XResolution.augmentationToX P a l
+  augmentation_quasiIso := XResolution.augmentationToX_quasiIso P a l
+
+/-- The actual P[b] itself is a finite right-projective tensor model with exactly the source support. -/
+def shiftedResolutionModel (b : ℤ) (hb : a+(l:ℤ)=b)
+    (hP : ∀ n : ℤ, n < a ∨ b < n → IsZero (P.X n)) : FiniteProjectiveBimoduleComplex k B B where
+  complex := P⟦b⟧
+  size := l+1
+  degrees := TensorResolution.finiteDegrees l
+  strictMono := TensorResolution.finiteDegrees_strictMono l
+  support n hn := by
+    change IsZero (P.X (n+b))
+    apply hP
+    have := (TensorResolution.finiteDegrees_range l n).not.mp hn
+    omega
+  rightProjective n := shifted_right_projective P b n
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI

lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySupportedExtension.lean

@@ -0,0 +1,53 @@
+import Mathlib.Algebra.Homology.Embedding.StupidTrunc
+
+namespace OAI
+noncomputable section
+attribute [local instance] Classical.propDecidable
+open CategoryTheory Limits
+namespace LittleFinitistic.OrdinarySimulation.SupportedExtension
+universe u v w w'
+variable {C : Type u} [Category.{v} C] [HasZeroMorphisms C] [HasZeroObject C]
+variable {I : Type w} {J : Type w'} {c : ComplexShape I} {c' : ComplexShape J}
+variable (K : HomologicalComplex C c') (e : c.Embedding c') [e.IsRelIff] [K.IsStrictlySupported e]
+
+/-- The supported complex's restriction and extension have its actual components. -/
+def component (j : J) : (K.stupidTrunc e).X j ≅ K.X j :=
+  if hj : ∃ i, e.f i = j then K.stupidTruncXIso e hj.choose_spec
+  else (K.isZero_stupidTrunc_X e j (by simpa using hj)).iso
+    (K.isZero_X_of_isStrictlySupported e j (by simpa using hj))
+
+omit [K.IsStrictlySupported e] in
+theorem component_iso_unique {i j : I} {n : J} (hi : e.f i = n) (hj : e.f j = n) :
+    K.stupidTruncXIso e hi = K.stupidTruncXIso e hj := by
+  have h : i = j := e.injective_f (hi.trans hj.symm)
+  subst j
+  rfl
+
+theorem component_at (i : I) : component K e (e.f i) = K.stupidTruncXIso e rfl := by
+  unfold component
+  rw [dite_eq_left (show ∃ j, e.f j = e.f i from ⟨i,rfl⟩)]
+  exact component_iso_unique K e _ _
+
+/-- An actual chain isomorphism, with support supplied by proved zero objects. -/
+def iso : K.stupidTrunc e ≅ K :=
+  HomologicalComplex.Hom.isoOfComponents (component K e) (by
+    intro i' j' _
+    by_cases hi : ∃ i, e.f i = i'
+    · obtain ⟨i,rfl⟩ := hi
+      by_cases hj : ∃ j, e.f j = j'
+      · obtain ⟨j,rfl⟩ := hj
+        rw [component_at,component_at]
+        change (((K.restriction e).extendXIso e rfl).hom ≫ 𝟙 _) ≫ K.d (e.f i) (e.f j) =
+          ((K.restriction e).extend e).d (e.f i) (e.f j) ≫
+            (((K.restriction e).extendXIso e rfl).hom ≫ 𝟙 _)
+        rw [Category.comp_id, Category.comp_id]
+        rw [HomologicalComplex.extend_d_eq _ _ rfl rfl]
+        simp only [Category.assoc,Iso.inv_hom_id,Category.comp_id]
+        rfl
+      · exact IsZero.eq_of_tgt (K.isZero_X_of_isStrictlySupported e j' (by simpa using hj)) _ _
+    · exact IsZero.eq_of_src (K.isZero_stupidTrunc_X e i' (by simpa using hi)) _ _)
+end LittleFinitistic.OrdinarySimulation.SupportedExtension
+
+end
+
+end OAI