| import OAI.Algebra.Finitistic.Localization.KaroubiEvaluation |
| import OAI.Algebra.Finitistic.Localization.DerivedActionCompatibility |
|
|
| namespace OAI |
| noncomputable section |
| open CategoryTheory CategoryTheory.Idempotents |
| attribute [local instance] HasDerivedCategory.standard |
| namespace LittleFinitistic.QuadraticEncoding |
| universe u v w z |
| section Image |
| variable {k : Type u} [Field k] {V : Type v} [AddCommGroup V] [Module k V] |
| variable (p : Module.End k V) (hp : p*p=p) |
|
|
| def imageProjection : ModuleCat.of k V ⟶ ModuleCat.of k (LinearMap.range p) := |
| ModuleCat.ofHom p.rangeRestrict |
|
|
| def imageInclusion : ModuleCat.of k (LinearMap.range p) ⟶ ModuleCat.of k V := |
| ModuleCat.ofHom (LinearMap.range p).subtype |
|
|
| lemma image_projection_inclusion : imageProjection p ≫ imageInclusion p = ModuleCat.ofHom p := rfl |
| include hp in |
| lemma image_inclusion_projection : imageInclusion p ≫ imageProjection p = 𝟙 _ := by |
| apply ModuleCat.hom_ext |
| apply LinearMap.ext |
| intro x |
| apply Subtype.ext |
| obtain ⟨y,hy⟩ := x.property |
| change p x.val = x.val |
| rw [← hy] |
| exact LinearMap.congr_fun hp y |
|
|
| variable {D : Type w} [Category.{z} D] (F : ModuleCat.{v} k ⥤ D) |
|
|
| /-- A functor takes a concrete linear idempotent's formal image to the actual image module. -/ |
| def linearImageKaroubiIso : |
| (⟨F.obj (ModuleCat.of k V), F.map (ModuleCat.ofHom p), by |
| rw [← F.map_comp] |
| congr 1 |
| exact congrArg ModuleCat.ofHom hp⟩ : Karoubi D) ≅ |
| (toKaroubi D).obj (F.obj (ModuleCat.of k (LinearMap.range p))) := |
| splitKaroubiIso _ _ (F.map (imageProjection p)) (F.map (imageInclusion p)) |
| (by rw [← F.map_comp, image_projection_inclusion]) |
| (by rw [← F.map_comp, image_inclusion_projection p hp, F.map_id]) |
| end Image |
|
|
| variable {k : Type u} [Field k] {d t : ℕ} {P : Relations k d t} |
| variable {Y : Type v} [AddCommGroup Y] [Module k Y] (X : Representation P Y) |
| variable (r : PresentedAlgebra P) (hr : r*r=r) |
|
|
| /-- The actual image eY, represented in the same universe as tensor evaluation. -/ |
| def evaluatedImage := LinearMap.range ((liftedEndHom (givenAction X r)).hom) |
|
|
| include hr in |
| lemma lifted_action_idempotent : |
| (liftedEndHom (givenAction X r)).hom * (liftedEndHom (givenAction X r)).hom = |
| (liftedEndHom (givenAction X r)).hom := by |
| have h := congrArg (fun a => (liftedEndHom (givenAction X a)).hom) hr |
| simp only [map_mul] at h |
| exact h |
|
|
| /-- The formal evaluated summand is the stalk of the concrete image of the action. -/ |
| def stalkSummandImageIso : stalkSummand X r hr ≅ |
| (toKaroubi _).obj ((vectorStalk (k := k)).obj (ModuleCat.of k (evaluatedImage X r))) := by |
| let e := linearImageKaroubiIso ((liftedEndHom (givenAction X r)).hom) |
| (lifted_action_idempotent X r hr) (vectorStalk (k := k)) |
| dsimp [stalkSummand, givenStalkAction, identifiedEndHom, evaluatedImage] at e ⊢ |
| exact e |
|
|
| /-- Section 3: evaluation sends the formal quotient summand U to eY. -/ |
| def quotientSummandImageIso : (karoubiEvaluation X).obj (quotientSummand r hr) ≅ |
| (toKaroubi _).obj ((vectorStalk (k := k)).obj (ModuleCat.of k (evaluatedImage X r))) := |
| evaluatedSummandIso X r hr ≪≫ stalkSummandImageIso X r hr |
|
|
| instance evaluatedImageFinite [FiniteDimensional k Y] : FiniteDimensional k (evaluatedImage X r) := by |
| have : FiniteDimensional k (ULift.{u} Y) := |
| Module.Finite.of_injective (ULift.moduleEquiv : ULift.{u} Y ≃ₗ[k] Y).toLinearMap |
| ULift.moduleEquiv.injective |
| let p : Module.End k (ULift.{u} Y) := (liftedEndHom (givenAction X r)).hom |
| have hp : FiniteDimensional k p.range := inferInstance |
| exact hp |
| end LittleFinitistic.QuadraticEncoding |
|
|
| end |
|
|
| end OAI |
|
|
