| import Mathlib.Algebra.Module.Projective |
| import Mathlib.RingTheory.Finiteness.Cardinality |
| import Mathlib.LinearAlgebra.Pi |
| import Mathlib.LinearAlgebra.Quotient.Basic |
|
|
| namespace OAI |
|
|
| namespace ArExplicit |
|
|
| universe u v w x y z |
|
|
| variable {R : Type u} [Ring R] |
| variable {K : Type v} [AddCommGroup K] [Module R K] |
| variable {L : Type w} [AddCommGroup L] [Module R L] |
| variable {M : Type x} [AddCommGroup M] [Module R M] |
| variable {Q : Type y} [AddCommGroup Q] [Module R Q] |
|
|
| def HomExactAt (e : K →ₗ[R] L) (d : L →ₗ[R] M) : Prop := |
| ∀ f : L →ₗ[R] R, f.comp e = 0 → ∃ g : M →ₗ[R] R, g.comp d = f |
|
|
| namespace HomExactAt |
|
|
| variable {e : K →ₗ[R] L} {d : L →ₗ[R] M} |
|
|
| theorem projective [Module.Finite R Q] [Module.Projective R Q] |
| (h : HomExactAt e d) (f : L →ₗ[R] Q) (hf : f.comp e = 0) : |
| ∃ g : M →ₗ[R] Q, g.comp d = f := by |
| obtain ⟨n, π, hπ⟩ := Module.Finite.exists_fin' R Q |
| obtain ⟨s, hs⟩ := Module.projective_lifting_property π (LinearMap.id : Q →ₗ[R] Q) hπ |
| have coordinate_exists (i : Fin n) : |
| ∃ g : M →ₗ[R] R, g.comp d = (LinearMap.proj i).comp (s.comp f) := by |
| apply h |
| ext z |
| change (s (f (e z))) i = 0 |
| rw [show f (e z) = 0 from DFunLike.congr_fun hf z, map_zero] |
| rfl |
| choose g hg using coordinate_exists |
| let G : M →ₗ[R] (Fin n → R) := LinearMap.pi g |
| refine ⟨π.comp G, ?_⟩ |
| ext z |
| have hz : G (d z) = s (f z) := by |
| funext i |
| exact DFunLike.congr_fun (hg i) z |
| change π (G (d z)) = f z |
| rw [hz] |
| exact DFunLike.congr_fun hs (f z) |
|
|
| theorem extend_range [Module.Finite R Q] [Module.Projective R Q] |
| (h : HomExactAt e d) (hde : d.comp e = 0) |
| (f : LinearMap.range d →ₗ[R] Q) : |
| ∃ g : M →ₗ[R] Q, g.comp (LinearMap.range d).subtype = f := by |
| have hf : (f.comp d.rangeRestrict).comp e = 0 := by |
| ext z |
| have hz : d.rangeRestrict (e z) = 0 := by |
| apply Subtype.ext |
| exact DFunLike.congr_fun hde z |
| change f (d.rangeRestrict (e z)) = 0 |
| rw [hz, map_zero] |
| obtain ⟨g, hg⟩ := h.projective (f.comp d.rangeRestrict) hf |
| refine ⟨g, ?_⟩ |
| apply LinearMap.ext |
| intro z |
| obtain ⟨z, rfl⟩ := d.surjective_rangeRestrict z |
| exact DFunLike.congr_fun hg z |
|
|
| theorem extend_kernel {N : Type z} [AddCommGroup N] [Module R N] |
| [Module.Finite R Q] [Module.Projective R Q] |
| (h : HomExactAt e d) (hde : d.comp e = 0) |
| (d' : M →ₗ[R] N) (hex : LinearMap.range d = LinearMap.ker d') |
| (f : LinearMap.ker d' →ₗ[R] Q) : |
| ∃ g : M →ₗ[R] Q, g.comp (LinearMap.ker d').subtype = f := by |
| obtain ⟨g, hg⟩ := h.extend_range hde (f.comp (Submodule.inclusion hex.le)) |
| refine ⟨g, ?_⟩ |
| apply LinearMap.ext |
| intro t |
| have ht : (t : M) ∈ LinearMap.range d := by |
| rw [hex] |
| exact t.property |
| exact DFunLike.congr_fun hg ⟨t, ht⟩ |
|
|
| end HomExactAt |
|
|
| section ProjectiveLifting |
|
|
| theorem lift_through_exact [Module.Projective R Q] |
| (e : K →ₗ[R] L) (d : L →ₗ[R] M) |
| (hex : LinearMap.range e = LinearMap.ker d) |
| (f : Q →ₗ[R] L) (hf : d.comp f = 0) : |
| ∃ g : Q →ₗ[R] K, e.comp g = f := by |
| let f' : Q →ₗ[R] LinearMap.range e := f.codRestrict _ (by |
| intro q |
| rw [hex] |
| exact DFunLike.congr_fun hf q) |
| obtain ⟨g, hg⟩ := Module.projective_lifting_property e.rangeRestrict f' |
| e.surjective_rangeRestrict |
| refine ⟨g, ?_⟩ |
| ext q |
| exact congrArg Subtype.val (DFunLike.congr_fun hg q) |
|
|
| theorem lift_cokernel_map [Module.Projective R K] [Module.Projective R L] |
| (e : K →ₗ[R] L) (d : M →ₗ[R] Q) |
| (u : (L ⧸ LinearMap.range e) →ₗ[R] (Q ⧸ LinearMap.range d)) : |
| ∃ (f₀ : L →ₗ[R] Q) (f₁ : K →ₗ[R] M), |
| (LinearMap.range d).mkQ.comp f₀ = u.comp (LinearMap.range e).mkQ ∧ |
| d.comp f₁ = f₀.comp e := by |
| obtain ⟨f₀, hf₀⟩ := Module.projective_lifting_property (LinearMap.range d).mkQ |
| (u.comp (LinearMap.range e).mkQ) (Submodule.mkQ_surjective _) |
| have hz : (LinearMap.range d).mkQ.comp (f₀.comp e) = 0 := by |
| ext q |
| change (LinearMap.range d).mkQ (f₀ (e q)) = 0 |
| calc |
| (LinearMap.range d).mkQ (f₀ (e q)) = |
| u ((LinearMap.range e).mkQ (e q)) := DFunLike.congr_fun hf₀ (e q) |
| _ = 0 := by |
| rw [show (LinearMap.range e).mkQ (e q) = 0 by |
| exact (Submodule.Quotient.mk_eq_zero _).mpr ⟨q, rfl⟩, map_zero] |
| obtain ⟨f₁, hf₁⟩ := lift_through_exact d (LinearMap.range d).mkQ |
| (Submodule.ker_mkQ _).symm (f₀.comp e) hz |
| exact ⟨f₀, f₁, hf₀, hf₁⟩ |
|
|
| end ProjectiveLifting |
|
|
| section ComparisonSteps |
|
|
| universe a b c |
|
|
| variable {U : Type a} [AddCommGroup U] [Module R U] |
| variable {V : Type b} [AddCommGroup V] [Module R V] |
| variable {W : Type c} [AddCommGroup W] [Module R W] |
|
|
| theorem extend_comparison_up [Module.Projective R K] |
| (e : K →ₗ[R] L) (d : L →ₗ[R] M) (hde : d.comp e = 0) |
| (e' : U →ₗ[R] V) (d' : V →ₗ[R] W) |
| (hex : LinearMap.range e' = LinearMap.ker d') |
| (f : L →ₗ[R] V) (g : M →ₗ[R] W) (hfg : d'.comp f = g.comp d) : |
| ∃ h : K →ₗ[R] U, e'.comp h = f.comp e := by |
| apply lift_through_exact e' d' hex (f.comp e) |
| ext t |
| change d' (f (e t)) = 0 |
| calc |
| d' (f (e t)) = g (d (e t)) := DFunLike.congr_fun hfg (e t) |
| _ = 0 := by rw [show d (e t) = 0 from DFunLike.congr_fun hde t, map_zero] |
|
|
| theorem extend_comparison_down [Module.Finite R W] [Module.Projective R W] |
| (e : K →ₗ[R] L) (d : L →ₗ[R] M) (hdual : HomExactAt e d) |
| (e' : U →ₗ[R] V) (d' : V →ₗ[R] W) (hde' : d'.comp e' = 0) |
| (f : K →ₗ[R] U) (g : L →ₗ[R] V) (hfg : e'.comp f = g.comp e) : |
| ∃ h : M →ₗ[R] W, h.comp d = d'.comp g := by |
| apply hdual.projective (d'.comp g) |
| ext t |
| change d' (g (e t)) = 0 |
| calc |
| d' (g (e t)) = d' (e' (f t)) := congrArg d' (DFunLike.congr_fun hfg t).symm |
| _ = 0 := DFunLike.congr_fun hde' (f t) |
|
|
| end ComparisonSteps |
|
|
| end ArExplicit |
|
|
| end OAI |
|
|
