math / data /lean /OAI /Algebra /Finitistic /Localization /QuotientAction.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
4.37 kB
import Mathlib.CategoryTheory.Linear.Basic
import OAI.Algebra.Finitistic.Encoding.QuadraticEncoding
import OAI.Algebra.Finitistic.Encoding.QuadraticPresentation
namespace OAI
namespace LittleFinitistic.QuotientAction
open CategoryTheory CategoryTheory.Category CategoryTheory.Limits CategoryTheory.Preadditive
open QuadraticEncoding
variable {k : Type*} [Field k] {C : Type*} [Category C] [Preadditive C] [Linear k C]
variable {Xβ‚€ X₁ Xβ‚‚ : C} {d t : β„•} (P : Relations k d t)
(s : Xβ‚€ ⟢ X₁) (s' : X₁ ⟢ Xβ‚‚) [IsIso s] [IsIso s']
(a : Fin d β†’ (Xβ‚€ ⟢ X₁)) (b : Fin d β†’ (X₁ ⟢ Xβ‚‚))
(hc : βˆ€ h, s ≫ b h = a h ≫ s')
noncomputable def normalized (h : Fin d) : End Xβ‚€ := a h ≫ inv s
include hc in
omit [Preadditive C] [IsIso s'] in
lemma normalized_product_comp (h l : Fin d) :
(normalized s a h * normalized s a l) ≫ s ≫ s' = a l ≫ b h := by
simp only [normalized,End.mul_def,assoc,IsIso.inv_hom_id_assoc]
rw [← hc h]
simp only [IsIso.inv_hom_id_assoc]
omit [Preadditive C] [IsIso s'] in
lemma normalized_comp (h : Fin d) : normalized s a h ≫ s ≫ s' = a h ≫ s' := by
simp [normalized]
variable (hr : βˆ€ j,
(βˆ‘ h, βˆ‘ l, P.quadratic j h l β€’ (a l ≫ b h)) +
(βˆ‘ h, P.linear j h β€’ (a h ≫ s')) + P.constant j β€’ (s ≫ s') = 0)
include hc hr in
/-- Normalizing the invertible arrows recovers the original quadratic equations. -/
theorem normalized_relations (j : Fin t) :
(βˆ‘ h, βˆ‘ l, P.quadratic j h l β€’ (normalized s a h * normalized s a l)) +
(βˆ‘ h, P.linear j h β€’ normalized s a h) + P.constant j β€’ (1 : End Xβ‚€) = 0 := by
apply (cancel_mono (s ≫ s')).mp
dsimp only [End]
simp only [Preadditive.add_comp,Preadditive.sum_comp,Linear.smul_comp,End.one_def,id_comp,zero_comp]
simpa only [← End.mul_def,normalized_product_comp s s' a b hc,normalized_comp] using hr j
/-- The degree-at-most-two defining polynomial with the displayed coefficients. -/
def polynomial (j : Fin t) : FreeAlgebra k (Fin d) :=
(βˆ‘ h, βˆ‘ l, P.quadratic j h l β€’ (FreeAlgebra.ΞΉ k h * FreeAlgebra.ΞΉ k l)) +
(βˆ‘ h, P.linear j h β€’ FreeAlgebra.ΞΉ k h) + P.constant j β€’ 1
noncomputable def freeAction : FreeAlgebra k (Fin d) →ₐ[k] End Xβ‚€ :=
FreeAlgebra.lift k (normalized s a)
include hc hr in
lemma freeAction_polynomial (j : Fin t) : freeAction s a (polynomial P j) = 0 := by
simpa only [freeAction,polynomial,map_add,map_sum,map_smul,map_mul,map_one,
FreeAlgebra.lift_ΞΉ_apply] using normalized_relations P s s' a b hc hr j
/-- The genuine quotient action theta, obtained by descending the free action. -/
noncomputable def quotientAction :
QuadraticPresentation.Original k (Fin d) (polynomial P) →ₐ[k] End Xβ‚€ :=
(QuadraticPresentation.original k (Fin d) (polynomial P)).liftₐ (freeAction s a)
(RingCon.ringConGen_le.mpr (by
rintro x y ⟨j,rfl,rfl⟩
change freeAction s a (polynomial P j) = freeAction s a 0
rw [map_zero,freeAction_polynomial P s s' a b hc hr]))
@[simp] theorem quotientAction_generator (h : Fin d) :
quotientAction P s s' a b hc hr
(QuadraticPresentation.originalMap k (Fin d) (polynomial P) (FreeAlgebra.ΞΉ k h)) =
normalized s a h := by
simp [quotientAction,QuadraticPresentation.originalMap,freeAction]
/-- Transport the descended action through the actual presentation equivalence. -/
noncomputable def presentedAction {R : Type*} [Ring R] [Algebra k R]
(E : QuadraticPresentation.Original k (Fin d) (polynomial P) ≃ₐ[k] R) :
R →ₐ[k] End Xβ‚€ := (quotientAction P s s' a b hc hr).comp E.symm.toAlgHom
omit [Preadditive C] in
/-- Evaluation of normalized generators, with the natural vertex identifications. -/
theorem normalized_evaluation {D : Type*} [Category D] (F : C β₯€ D)
{Y : D} (eβ‚€ : F.obj Xβ‚€ β‰… Y) (e₁ : F.obj X₁ β‰… Y)
(x : Fin d β†’ (Y ⟢ Y))
(hs : F.map s ≫ e₁.hom = eβ‚€.hom)
(ha : βˆ€ h, F.map (a h) ≫ e₁.hom = eβ‚€.hom ≫ x h) (h : Fin d) :
F.map (normalized s a h) ≫ eβ‚€.hom = eβ‚€.hom ≫ x h := by
have hsi : F.map (inv s) ≫ eβ‚€.hom = e₁.hom := by
apply (cancel_epi (F.map s)).mp
rw [← assoc,← F.map_comp,IsIso.hom_inv_id,F.map_id,id_comp,hs]
change F.map (a h ≫ inv s) ≫ eβ‚€.hom = _
rw [F.map_comp,assoc,hsi,ha]
end LittleFinitistic.QuotientAction
end OAI