| import OAI.Algebra.AuslanderReiten.Complete.CompleteResolution |
| import Mathlib.Algebra.Category.ModuleCat.Basic |
| import Mathlib.Algebra.Homology.HomologicalComplex |
| import Mathlib.Algebra.Homology.Additive |
|
|
| namespace OAI |
|
|
| open CategoryTheory |
|
|
| namespace ArExplicit |
|
|
| universe u |
|
|
| variable {R : Type u} [Ring R] |
|
|
| structure ExactProjectiveComplex (P : ChainComplex (ModuleCat.{u} R) ℤ) : Prop where |
| finite : ∀ n, Module.Finite R (P.X n) |
| projective : ∀ n, Module.Projective R (P.X n) |
| exactAt : ∀ n, LinearMap.range (P.d (n + 1) n).hom = |
| LinearMap.ker (P.d n (n - 1)).hom |
|
|
| structure TotallyAcyclicComplex (P : ChainComplex (ModuleCat.{u} R) ℤ) : Prop |
| extends ExactProjectiveComplex P where |
| dualExact : ∀ n, HomExactAt (P.d (n + 1) n).hom (P.d n (n - 1)).hom |
|
|
| theorem ExactProjectiveComplex.exactAt_of_indices |
| {P : ChainComplex (ModuleCat.{u} R) ℤ} (h : ExactProjectiveComplex P) |
| {i j k : ℤ} (hi : i = j + 1) (hk : k = j - 1) : |
| LinearMap.range (P.d i j).hom = LinearMap.ker (P.d j k).hom := by |
| subst i |
| subst k |
| exact h.exactAt j |
|
|
| theorem TotallyAcyclicComplex.dualExact_of_indices |
| {P : ChainComplex (ModuleCat.{u} R) ℤ} (h : TotallyAcyclicComplex P) |
| {i j k : ℤ} (hi : i = j + 1) (hk : k = j - 1) : |
| HomExactAt (P.d i j).hom (P.d j k).hom := by |
| subst i |
| subst k |
| exact h.dualExact j |
|
|
| namespace CompleteComparison |
|
|
| variable {P Q : ChainComplex (ModuleCat.{u} R) ℤ} |
|
|
| theorem differential_comp (P : ChainComplex (ModuleCat.{u} R) ℤ) (i j k : ℤ) : |
| (P.d j k).hom.comp (P.d i j).hom = 0 := |
| congrArg (fun f : P.X i ⟶ P.X k => f.hom) (P.d_comp_d i j k) |
|
|
| abbrev Cokernel (P : ChainComplex (ModuleCat.{u} R) ℤ) (n : ℤ) := |
| P.X n ⧸ LinearMap.range (P.d (n + 1) n).hom |
|
|
| private structure UpPair (P Q : ChainComplex (ModuleCat.{u} R) ℤ) (n : ℕ) where |
| lo : P.X (n : ℤ) →ₗ[R] Q.X (n : ℤ) |
| hi : P.X ((n + 1 : ℕ) : ℤ) →ₗ[R] Q.X ((n + 1 : ℕ) : ℤ) |
| comm : (Q.d (n + 1) n).hom.comp hi = lo.comp (P.d (n + 1) n).hom |
|
|
| private theorem exists_upStep (hP : ExactProjectiveComplex P) |
| (hQ : ExactProjectiveComplex Q) (n : ℕ) (c : UpPair P Q n) : |
| ∃ c' : UpPair P Q (n + 1), c'.lo = c.hi := by |
| let := hP.projective (n + 2) |
| have hex : LinearMap.range (Q.d (n + 2) (n + 1)).hom = |
| LinearMap.ker (Q.d (n + 1) n).hom := by |
| exact hQ.exactAt_of_indices (by omega) (by omega) |
| obtain ⟨f, hf⟩ := extend_comparison_up |
| (P.d (n + 2) (n + 1)).hom (P.d (n + 1) n).hom |
| (differential_comp P _ _ _) |
| (Q.d (n + 2) (n + 1)).hom (Q.d (n + 1) n).hom hex c.hi c.lo c.comm |
| exact ⟨⟨c.hi, f, hf⟩, rfl⟩ |
|
|
| private noncomputable def upSequence (hP : ExactProjectiveComplex P) |
| (hQ : ExactProjectiveComplex Q) (c : UpPair P Q 0) : (n : ℕ) → UpPair P Q n |
| | 0 => c |
| | n + 1 => Classical.choose (exists_upStep hP hQ n (upSequence hP hQ c n)) |
|
|
| private theorem upSequence_succ_lo (hP : ExactProjectiveComplex P) |
| (hQ : ExactProjectiveComplex Q) (c : UpPair P Q 0) (n : ℕ) : |
| (upSequence hP hQ c (n + 1)).lo = (upSequence hP hQ c n).hi := |
| Classical.choose_spec (exists_upStep hP hQ n (upSequence hP hQ c n)) |
|
|
| private structure DownPair (P Q : ChainComplex (ModuleCat.{u} R) ℤ) (n : ℕ) where |
| hi : P.X (-(n : ℤ)) →ₗ[R] Q.X (-(n : ℤ)) |
| lo : P.X (Int.negSucc n) →ₗ[R] Q.X (Int.negSucc n) |
| comm : (Q.d (-(n : ℤ)) (Int.negSucc n)).hom.comp hi = |
| lo.comp (P.d (-(n : ℤ)) (Int.negSucc n)).hom |
|
|
| private theorem exists_downStep (hP : TotallyAcyclicComplex P) |
| (hQ : ExactProjectiveComplex Q) (n : ℕ) (c : DownPair P Q n) : |
| ∃ c' : DownPair P Q (n + 1), c'.hi = c.lo := by |
| let := hQ.finite (Int.negSucc (n + 1)) |
| let := hQ.projective (Int.negSucc (n + 1)) |
| have hd : HomExactAt (P.d (-(n : ℤ)) (Int.negSucc n)).hom |
| (P.d (Int.negSucc n) (Int.negSucc (n + 1))).hom := by |
| exact hP.dualExact_of_indices (by omega) (by omega) |
| obtain ⟨f, hf⟩ := extend_comparison_down |
| (P.d (-(n : ℤ)) (Int.negSucc n)).hom |
| (P.d (Int.negSucc n) (Int.negSucc (n + 1))).hom hd |
| (Q.d (-(n : ℤ)) (Int.negSucc n)).hom |
| (Q.d (Int.negSucc n) (Int.negSucc (n + 1))).hom |
| (differential_comp Q _ _ _) c.hi c.lo c.comm |
| exact ⟨⟨c.lo, f, hf.symm⟩, rfl⟩ |
|
|
| private noncomputable def downSequence (hP : TotallyAcyclicComplex P) |
| (hQ : ExactProjectiveComplex Q) (c : DownPair P Q 0) : (n : ℕ) → DownPair P Q n |
| | 0 => c |
| | n + 1 => Classical.choose (exists_downStep hP hQ n (downSequence hP hQ c n)) |
|
|
| private theorem downSequence_succ_hi (hP : TotallyAcyclicComplex P) |
| (hQ : ExactProjectiveComplex Q) (c : DownPair P Q 0) (n : ℕ) : |
| (downSequence hP hQ c (n + 1)).hi = (downSequence hP hQ c n).lo := |
| Classical.choose_spec (exists_downStep hP hQ n (downSequence hP hQ c n)) |
|
|
| private theorem exists_downStart (hP : TotallyAcyclicComplex P) |
| (hQ : ExactProjectiveComplex Q) (c : UpPair P Q 0) : |
| ∃ d : DownPair P Q 0, d.hi = c.lo := by |
| let := hQ.finite (-1) |
| let := hQ.projective (-1) |
| obtain ⟨f, hf⟩ := extend_comparison_down |
| (P.d 1 0).hom (P.d 0 (-1)).hom |
| (hP.dualExact_of_indices (by omega) (by omega)) |
| (Q.d 1 0).hom (Q.d 0 (-1)).hom |
| (differential_comp Q _ _ _) c.hi c.lo c.comm |
| exact ⟨⟨c.lo, f, hf.symm⟩, rfl⟩ |
|
|
| private noncomputable def components (hP : TotallyAcyclicComplex P) |
| (hQ : ExactProjectiveComplex Q) (c : UpPair P Q 0) (d : DownPair P Q 0) : |
| (n : ℤ) → P.X n →ₗ[R] Q.X n |
| | Int.ofNat n => (upSequence hP.toExactProjectiveComplex hQ c n).lo |
| | Int.negSucc n => (downSequence hP hQ d n).lo |
|
|
| private noncomputable def fromPairs (hP : TotallyAcyclicComplex P) |
| (hQ : ExactProjectiveComplex Q) (c : UpPair P Q 0) (d : DownPair P Q 0) |
| (hd : d.hi = c.lo) : P ⟶ Q where |
| f n := ModuleCat.ofHom (components hP hQ c d n) |
| comm' i j hij := by |
| change j + 1 = i at hij |
| subst i |
| apply ModuleCat.hom_ext |
| cases j with |
| | ofNat n => |
| change (Q.d (n + 1) n).hom.comp |
| (upSequence hP.toExactProjectiveComplex hQ c (n + 1)).lo = |
| (upSequence hP.toExactProjectiveComplex hQ c n).lo.comp (P.d (n + 1) n).hom |
| rw [upSequence_succ_lo] |
| exact (upSequence hP.toExactProjectiveComplex hQ c n).comm |
| | negSucc n => |
| cases n with |
| | zero => |
| change (Q.d 0 (-1)).hom.comp c.lo = d.lo.comp (P.d 0 (-1)).hom |
| rw [← hd] |
| exact d.comm |
| | succ n => |
| change (Q.d (Int.negSucc n) (Int.negSucc (n + 1))).hom.comp |
| (downSequence hP hQ d n).lo = |
| (downSequence hP hQ d (n + 1)).lo.comp |
| (P.d (Int.negSucc n) (Int.negSucc (n + 1))).hom |
| rw [← downSequence_succ_hi] |
| exact (downSequence hP hQ d (n + 1)).comm |
| |
| theorem lift_cokernels (hP : TotallyAcyclicComplex P) (hQ : ExactProjectiveComplex Q) |
| (u : Cokernel P 0 →ₗ[R] Cokernel Q 0) : |
| ∃ F : P ⟶ Q, |
| (LinearMap.range (Q.d 1 0).hom).mkQ.comp (F.f 0).hom = |
| u.comp (LinearMap.range (P.d 1 0).hom).mkQ := by |
| let := hP.projective 0 |
| let := hP.projective 1 |
| obtain ⟨f₀, f₁, hf₀, hf₁⟩ := lift_cokernel_map (P.d 1 0).hom (Q.d 1 0).hom u |
| let c : UpPair P Q 0 := ⟨f₀, f₁, hf₁⟩ |
| obtain ⟨d, hd⟩ := exists_downStart hP hQ c |
| exact ⟨fromPairs hP hQ c d hd, hf₀⟩ |
| |
| def cokernelMap (F : P ⟶ Q) (n : ℤ) : Cokernel P n →ₗ[R] Cokernel Q n := |
| (LinearMap.range (P.d (n + 1) n).hom).mapQ |
| (LinearMap.range (Q.d (n + 1) n).hom) (F.f n).hom (by |
| rintro _ ⟨x, rfl⟩ |
| refine ⟨(F.f (n + 1)).hom x, ?_⟩ |
| exact DFunLike.congr_fun |
| (congrArg (fun f : P.X (n + 1) ⟶ Q.X n => f.hom) (F.comm (n + 1) n)) x) |
| |
| @[simp] |
| theorem cokernelMap_mkQ (F : P ⟶ Q) (n : ℤ) : |
| (cokernelMap F n).comp (LinearMap.range (P.d (n + 1) n).hom).mkQ = |
| (LinearMap.range (Q.d (n + 1) n).hom).mkQ.comp (F.f n).hom := |
| Submodule.mapQ_mkQ _ _ _ |
| |
| @[simp] |
| theorem cokernelMap_id (n : ℤ) : cokernelMap (𝟙 P) n = LinearMap.id := by |
| apply LinearMap.ext |
| intro x |
| obtain ⟨y, rfl⟩ := Submodule.mkQ_surjective (LinearMap.range (P.d (n + 1) n).hom) x |
| rfl |
| |
| @[simp] |
| theorem cokernelMap_comp {S : ChainComplex (ModuleCat.{u} R) ℤ} |
| (F : P ⟶ Q) (G : Q ⟶ S) (n : ℤ) : |
| cokernelMap (F ≫ G) n = (cokernelMap G n).comp (cokernelMap F n) := by |
| apply LinearMap.ext |
| intro x |
| obtain ⟨y, rfl⟩ := Submodule.mkQ_surjective (LinearMap.range (P.d (n + 1) n).hom) x |
| rfl |
| |
| @[simp] |
| theorem cokernelMap_add (F G : P ⟶ Q) (n : ℤ) : |
| cokernelMap (F + G) n = cokernelMap F n + cokernelMap G n := by |
| apply LinearMap.ext |
| intro x |
| obtain ⟨y, rfl⟩ := Submodule.mkQ_surjective (LinearMap.range (P.d (n + 1) n).hom) x |
| exact map_add (LinearMap.range (Q.d (n + 1) n).hom).mkQ _ _ |
| |
| @[simp] |
| theorem cokernelMap_zero (n : ℤ) : cokernelMap (0 : P ⟶ Q) n = 0 := by |
| apply LinearMap.ext |
| intro x |
| obtain ⟨y, rfl⟩ := Submodule.mkQ_surjective (LinearMap.range (P.d (n + 1) n).hom) x |
| exact map_zero (LinearMap.range (Q.d (n + 1) n).hom).mkQ |
| |
| theorem cokernelMap_surjective (hP : TotallyAcyclicComplex P) |
| (hQ : ExactProjectiveComplex Q) : Function.Surjective (fun F : P ⟶ Q => cokernelMap F 0) := by |
| intro u |
| obtain ⟨F, hF⟩ := lift_cokernels hP hQ u |
| refine ⟨F, ?_⟩ |
| apply LinearMap.ext |
| intro x |
| obtain ⟨y, rfl⟩ := Submodule.mkQ_surjective (LinearMap.range (P.d 1 0).hom) x |
| exact DFunLike.congr_fun hF y |
| |
| end CompleteComparison |
| |
| end ArExplicit |
| |
| end OAI |
| |
