| import OAI.Algebra.Finitistic.Localization.CompletedImageEvaluation |
|
|
| namespace OAI |
| noncomputable section |
| open CategoryTheory CategoryTheory.Idempotents |
| attribute [local instance] HasDerivedCategory.standard |
| namespace LittleFinitistic.QuadraticEncoding |
| universe u v w z |
| section General |
| variable {C : Type u} [Category.{v} C] [Preadditive C] |
| variable {D : Type w} [Category.{z} D] [Preadditive D] [IsIdempotentComplete D] |
| variable (F : C ⥤ D) [F.Additive] (U : Karoubi C) (I : D) |
| variable (π : F.obj U.X ⟶ I) (ι : I ⟶ F.obj U.X) |
| variable (hπι : π ≫ ι = F.map U.p) (hιπ : ι ≫ π = 𝟙 I) |
|
|
| omit [Preadditive C] [Preadditive D] [F.Additive] in |
| theorem completedExtensionImageSquare (a : U ⟶ U) (b : I ⟶ I) |
| (h : F.map a.f ≫ π = π ≫ b) : |
| ((functorExtension C D).obj F).map a ≫ |
| (completedExtensionImageIso F U I π ι hπι hιπ).hom = |
| (completedExtensionImageIso F U I π ι hπι hιπ).hom ≫ b := by |
| let e := splitKaroubiIso (F.map U.p) (by rw [← F.map_comp, U.idem]) π ι hπι hιπ |
| have he : ((functorExtension₂ C D).obj F).map a ≫ e.hom = |
| e.hom ≫ (toKaroubi D).map b := by |
| apply Karoubi.Hom.ext |
| exact h |
| change (toKaroubiEquivalence D).inverse.map (((functorExtension₂ C D).obj F).map a) ≫ |
| ((toKaroubiEquivalence D).inverse.map e.hom ≫ (toKaroubiEquivalence D).unitIso.inv.app I) = |
| ((toKaroubiEquivalence D).inverse.map e.hom ≫ (toKaroubiEquivalence D).unitIso.inv.app I) ≫ b |
| erw [← Category.assoc, ← Functor.map_comp, he, Functor.map_comp, Category.assoc] |
| erw [(toKaroubiEquivalence D).unitIso.inv.naturality b] |
| exact (Category.assoc _ _ _).symm |
| end General |
|
|
| section Image |
| variable {k : Type u} [Field k] {V : Type v} [AddCommGroup V] [Module k V] |
| variable (p a : Module.End k V) (hp : p*p=p) |
|
|
| def imageCornerEnd : ModuleCat.of k (LinearMap.range p) ⟶ ModuleCat.of k (LinearMap.range p) := |
| imageInclusion p ≫ ModuleCat.ofHom a ≫ imageProjection p |
|
|
| include hp in |
| lemma image_corner_square : |
| ModuleCat.ofHom (p*a*p) ≫ imageProjection p = imageProjection p ≫ imageCornerEnd p a := by |
| change ((ModuleCat.ofHom p ≫ ModuleCat.ofHom a) ≫ ModuleCat.ofHom p) ≫ imageProjection p = _ |
| rw [← image_projection_inclusion p] |
| simp only [imageCornerEnd, Category.assoc, image_inclusion_projection p hp, Category.comp_id] |
|
|
| include hp in |
| /-- When a commutes with p, the corner operator is the restriction of a to the image. -/ |
| lemma imageCornerEnd_apply (ha : p*a=a*p) (x : LinearMap.range p) : |
| ((imageCornerEnd p a) x).val = a x.val := by |
| change p (a x.val) = a x.val |
| have h := LinearMap.congr_fun ha x.val |
| change p (a x.val) = a (p x.val) at h |
| rw [h] |
| obtain ⟨y,hy⟩ := x.property |
| have hp' : p x.val = x.val := by rw [← hy]; exact LinearMap.congr_fun hp y |
| rw [hp'] |
| end Image |
| |
| variable {k : Type u} [Field k] {d t : ℕ} {P : Relations k d t} |
| variable {Y : Type v} [AddCommGroup Y] [Module k Y] [FiniteDimensional k Y] |
| variable (X : Representation P Y) (e a : PresentedAlgebra P) (he : e*e=e) |
|
|
| def quotientCornerEnd : quotientSummand e he ⟶ quotientSummand e he := |
| ⟨quotientAction P (e*a*e), by |
| change (quotientAction P e * quotientAction P (e*a*e)) * quotientAction P e = _ |
| simp only [← map_mul] |
| congr 1 |
| simp only [← mul_assoc, he] |
| rw [mul_assoc (e*a) e e, he]⟩ |
|
|
| def evaluatedCornerEnd : evaluatedImageDerived X e ⟶ evaluatedImageDerived X e := |
| (derivedTargetInclusion (k := k)).preimage (DerivedCategory.Qh.map |
| ((vectorStalk (k := k)).map (imageCornerEnd |
| (liftedEndHom (givenAction X e)).hom (liftedEndHom (givenAction X a)).hom))) |
|
|
| include he in |
| lemma derived_corner_projection_square : |
| (derivedQuotientEvaluation X ⋙ derivedTargetInclusion (k := k)).map |
| (quotientAction P (e*a*e)) ≫ derivedImageProjection X e = |
| derivedImageProjection X e ≫ (derivedTargetInclusion (k := k)).map (evaluatedCornerEnd X e a) := by |
| unfold evaluatedCornerEnd |
| erw [Functor.map_preimage] |
| unfold derivedImageProjection |
| erw [← Category.assoc, derived_quotientAction_square, Category.assoc] |
| erw [← Functor.map_comp, ← Functor.map_comp] |
| have h := image_corner_square (liftedEndHom (givenAction X e)).hom |
| (liftedEndHom (givenAction X a)).hom (lifted_action_idempotent X e he) |
| have hc : liftedEndHom (givenAction X (e*a*e)) = ModuleCat.ofHom |
| ((liftedEndHom (givenAction X e)).hom * (liftedEndHom (givenAction X a)).hom * |
| (liftedEndHom (givenAction X e)).hom) := by |
| simp only [map_mul] |
| rfl |
| erw [hc, h, Functor.map_comp, Functor.map_comp, ← Category.assoc] |
| rfl |
|
|
| /-- The complete derived evaluation intertwines every corner endomorphism with |
| its concrete action on eY; this includes e alpha(r) e from Section 3. -/ |
| theorem completed_corner_square : |
| (completedDerivedEvaluation X).map (quotientCornerEnd e a he) ≫ |
| (completedSummandImageIso X e he).hom = |
| (completedSummandImageIso X e he).hom ≫ evaluatedCornerEnd X e a := by |
| apply completedExtensionImageSquare |
| apply (derivedTargetInclusion (k := k)).map_injective |
| rw [Functor.map_comp, Functor.map_comp] |
| erw [Functor.map_preimage] |
| exact derived_corner_projection_square X e a he |
|
|
| omit [FiniteDimensional k Y] in |
| include he in |
| /-- For a central e and any algebra endomorphism alpha, the concrete map on eY |
| is the restriction of alpha(r), exactly as in the manuscript. -/ |
| theorem central_alpha_restriction (hec : ∀ b : PresentedAlgebra P, e*b=b*e) |
| (α : PresentedAlgebra P →ₐ[k] PresentedAlgebra P) (b : PresentedAlgebra P) |
| (y : evaluatedImage X e) : |
| ((imageCornerEnd (liftedEndHom (givenAction X e)).hom |
| (liftedEndHom (givenAction X (α b))).hom) y).val = |
| (liftedEndHom (givenAction X (α b))).hom y.val := by |
| apply imageCornerEnd_apply _ _ (lifted_action_idempotent X e he) |
| have h := congrArg (fun c => (liftedEndHom (givenAction X c)).hom) (hec (α b)) |
| simp only [map_mul] at h |
| exact h |
| end LittleFinitistic.QuadraticEncoding |
|
|
| end |
|
|
| end OAI |
|
|
