Datasets:

roseking
/

openAI-math-dataset

import Mathlib.Algebra.Algebra.Hom
import OAI.Algebra.Finitistic.Localization.OddDouble

namespace OAI

open CategoryTheory CategoryTheory.Category CategoryTheory.Preadditive
open CategoryTheory.Idempotents CategoryTheory.Limits

namespace LittleFinitistic.FormalSummandAction

universe u v w
variable {k : Type w} [CommRing k]
variable {C : Type u} [Category.{v} C] [Preadditive C] [Linear k C]
instance karoubiHomSMul (P Q : Karoubi C) : SMul k (P ⟶ Q) where
  smul r f := ⟨r • f.f, by rw [Linear.smul_comp,Linear.comp_smul,f.comm]⟩

@[simp] theorem smul_f (P Q : Karoubi C) (r : k) (f : P ⟶ Q) :
    (r • f).f = r • f.f := rfl
instance karoubiHomModule (P Q : Karoubi C) : Module k (P ⟶ Q) :=
  Function.Injective.module k (Karoubi.inclusionHom P Q)
    (fun _ _ h => Karoubi.hom_ext _ _ h) (fun _ _ => rfl)
instance karoubiLinear : Linear k (Karoubi C) where
  smul_comp _ _ _ _ _ _ := by apply Karoubi.hom_ext; exact Linear.smul_comp _ _ _ _ _ _
  comp_smul _ _ _ _ _ _ := by apply Karoubi.hom_ext; exact Linear.comp_smul _ _ _ _ _ _
instance toKaroubiLinear : (toKaroubi C).Linear k where
  map_smul := by intros; rfl

variable {R : Type*} [Ring R] [Algebra k R]
variable {L : C} (θ : R →ₐ[k] End L) (e : R) (he : e * e = e)

/-- The formal image of the central selecting idempotent. -/
def summand : Karoubi C :=
  ⟨L,θ e,by change θ e * θ e = θ e; rw [← map_mul,he]⟩

variable (hc : ∀ r : R, e * r = r * e)

include he hc in
lemma sandwich (r : R) : e * r * e = e * r := by
  calc
    e * r * e = e * e * r := by rw [mul_assoc,← hc r,← mul_assoc]
    _ = e * r := by rw [he]

include he hc in
lemma compressed_mul (r s : R) : (e*r)*(e*s) = e*(r*s) := by
  rw [← mul_assoc,sandwich e he hc,mul_assoc]

/-- The action on the formal summand, with restriction along alpha. -/
def action (α : R →ₐ[k] R) : R →ₐ[k] End (summand θ e he) where
  toFun r := ⟨θ (e * α r),by
    change θ e ≫ θ (e * α r) ≫ θ e = θ (e * α r)
    change (θ e * θ (e * α r)) * θ e = θ (e * α r)
    rw [← map_mul,← map_mul]
    congr 1
    rw [← mul_assoc e e,he,sandwich e he hc]⟩
  map_one' := by apply Karoubi.hom_ext; change θ (e * α 1) = θ e; rw [map_one,mul_one]
  map_mul' r s := by
    apply Karoubi.hom_ext
    change θ (e * α (r*s)) = θ (e * α r) * θ (e * α s)
    rw [← map_mul θ,map_mul α,compressed_mul e he hc]
  map_zero' := by apply Karoubi.hom_ext; change θ (e * α 0) = 0; simp
  map_add' r s := by apply Karoubi.hom_ext; change θ (e * α (r+s)) = θ (e * α r) + θ (e * α s); simp [mul_add]
  commutes' r := by
    apply Karoubi.hom_ext
    change θ (e * α (algebraMap k R r)) = (algebraMap k (End (summand θ e he)) r).f
    rw [α.commutes]
    change θ (e * algebraMap k R r) = (r • (𝟙 (summand θ e he))).f
    rw [smul_f]
    change θ (e * algebraMap k R r) = r • θ e
    rw [hc,Algebra.algebraMap_eq_smul_one,smul_mul_assoc,one_mul,map_smul]

@[simp] theorem action_f (α : R →ₐ[k] R) (r : R) :
    ((action θ e he hc α r) : End (summand θ e he)).f = θ (e * α r * e) := by
  rw [sandwich e he hc]
  rfl

variable {D : Type*} [Category D] [Preadditive D] [Linear k D]

/-- A linear functor transports an algebra action on endomorphisms. -/
def mapAction (F : C ⥤ D) [F.Additive] [F.Linear k] {X : C}
    (ρ : R →ₐ[k] End X) : R →ₐ[k] End (F.obj X) where
  toFun r := F.map (ρ r)
  map_one' := by simp
  map_mul' r s := by simp [End.mul_def]
  map_zero' := by simp
  map_add' r s := by rw [map_add]; exact F.map_add
  commutes' r := by
    rw [ρ.commutes]
    change F.map (r • (𝟙 X)) = r • (𝟙 (F.obj X))
    rw [Functor.map_smul,F.map_id]

/-- Direct sum of two actions of the same algebra. -/
noncomputable def biprodAction [HasBinaryBiproducts C] {X Y : C}
    (ρ : R →ₐ[k] End X) (σ : R →ₐ[k] End Y) : R →ₐ[k] End (X ⊞ Y) where
  toFun r := biprod.map (ρ r) (σ r)
  map_one' := by apply biprod.hom_ext <;> simp
  map_mul' r s := by apply biprod.hom_ext <;> simp [End.mul_def]
  map_zero' := by apply biprod.hom_ext <;> simp
  map_add' r s := by
    rw [map_add,map_add]
    change biprod.map ((ρ r : X ⟶ X) + (ρ s : X ⟶ X))
      ((σ r : Y ⟶ Y) + (σ s : Y ⟶ Y)) =
      (biprod.map (ρ r) (σ r) : X ⊞ Y ⟶ X ⊞ Y) + biprod.map (ρ s) (σ s)
    apply biprod.hom_ext <;> simp only [biprod.map_fst,biprod.map_snd,
      Preadditive.add_comp]
    all_goals exact Preadditive.comp_add _ _ _ _ _ _
  commutes' r := by
    rw [ρ.commutes,σ.commutes]
    change biprod.map (r • (𝟙 X)) (r • (𝟙 Y)) = r • (𝟙 (X ⊞ Y))
    apply biprod.hom_ext <;> simp

/-- Conjugating an action along an isomorphism. -/
def transportAction {X Y : C} (i : X ≅ Y) (ρ : R →ₐ[k] End Y) :
    R →ₐ[k] End X where
  toFun r := i.hom ≫ ρ r ≫ i.inv
  map_one' := by simp
  map_mul' r s := by simp [End.mul_def]
  map_zero' := by simp
  map_add' r s := by
    rw [map_add]
    change i.hom ≫ ((ρ r : Y ⟶ Y) + (ρ s : Y ⟶ Y)) ≫ i.inv = _
    rw [add_comp,comp_add]
  commutes' r := by
    rw [ρ.commutes]
    change i.hom ≫ (r • (𝟙 Y)) ≫ i.inv = r • (𝟙 X)
    simp

/-- An action on an old object in the completion is an actual old action. -/
def oldAction {X : C} (ρ : R →ₐ[k] End ((toKaroubi C).obj X)) :
    R →ₐ[k] End X where
  toFun r := (ρ r).f
  map_one' := by rw [map_one]; rfl
  map_mul' r s := by rw [map_mul]; rfl
  map_zero' := by rw [map_zero]; rfl
  map_add' r s := by rw [map_add]; rfl
  commutes' r := by rw [ρ.commutes]; rfl

@[simp] theorem oldAction_lift {X : C} (ρ : R →ₐ[k] End ((toKaroubi C).obj X))
    (r : R) : (toKaroubi C).map (oldAction ρ r) = ρ r := by
  apply Karoubi.hom_ext
  rfl

variable [HasShift C ℤ] [HasZeroObject C]
  [∀ n : ℤ, (shiftFunctor C n).Additive] [Pretriangulated C]
  [∀ n : ℤ, (shiftFunctor C n).Linear k]
instance formalShiftLinear (n : ℤ) :
    (OddDouble.formalShiftFunctor (C := C) n).Linear k where
  map_smul := by
    intro X Y f r
    apply Karoubi.hom_ext
    exact Functor.map_smul (shiftFunctor C n) r f.f

local instance : HasFiniteBiproducts (Karoubi C) := Karoubi.karoubi_hasFiniteBiproducts
local instance : HasBinaryBiproducts (Karoubi C) :=
  hasBinaryBiproducts_of_finite_biproducts (Karoubi C)

/-- The selecting action on the odd double. -/
noncomputable def oddDoubleAction (α : R →ₐ[k] R) :
    R →ₐ[k] End (summand θ e he ⊞ OddDouble.formalShift (summand θ e he) 3) :=
  biprodAction (action θ e he hc α)
    (mapAction (OddDouble.formalShiftFunctor 3) (action θ e he hc α))

/-- The object and its unital action are both chosen before any evaluation module. -/
theorem fixed_old_object_with_action (α : R →ₐ[k] R) :
    ∃ (V₀ : C) (ρ₀ : R →ₐ[k] End V₀)
      (i : (toKaroubi C).obj V₀ ≅
        summand θ e he ⊞ OddDouble.formalShift (summand θ e he) 3),
      ∀ r : R, (toKaroubi C).map (ρ₀ r) ≫ i.hom =
        i.hom ≫ oddDoubleAction θ e he hc α r := by
  obtain ⟨V₀,⟨i⟩⟩ := OddDouble.odd_double_three (summand θ e he)
  let σ := oddDoubleAction θ e he hc α
  let τ := transportAction i σ
  refine ⟨V₀,oldAction τ,i,?_⟩
  intro r
  rw [oldAction_lift]
  change (i.hom ≫ σ r ≫ i.inv) ≫ i.hom = i.hom ≫ σ r
  simp

end LittleFinitistic.FormalSummandAction

end OAI

	import Mathlib.Algebra.Algebra.Hom
	import OAI.Algebra.Finitistic.Localization.OddDouble

	namespace OAI

	open CategoryTheory CategoryTheory.Category CategoryTheory.Preadditive
	open CategoryTheory.Idempotents CategoryTheory.Limits

	namespace LittleFinitistic.FormalSummandAction

	universe u v w
	variable {k : Type w} [CommRing k]
	variable {C : Type u} [Category.{v} C] [Preadditive C] [Linear k C]

	instance karoubiHomSMul (P Q : Karoubi C) : SMul k (P ⟶ Q) where
	smul r f := ⟨r • f.f, by rw [Linear.smul_comp,Linear.comp_smul,f.comm]⟩

	@[simp] theorem smul_f (P Q : Karoubi C) (r : k) (f : P ⟶ Q) :
	(r • f).f = r • f.f := rfl

	instance karoubiHomModule (P Q : Karoubi C) : Module k (P ⟶ Q) :=
	Function.Injective.module k (Karoubi.inclusionHom P Q)
	(fun _ _ h => Karoubi.hom_ext _ _ h) (fun _ _ => rfl)

	instance karoubiLinear : Linear k (Karoubi C) where
	smul_comp _ _ _ _ _ _ := by apply Karoubi.hom_ext; exact Linear.smul_comp _ _ _ _ _ _
	comp_smul _ _ _ _ _ _ := by apply Karoubi.hom_ext; exact Linear.comp_smul _ _ _ _ _ _

	instance toKaroubiLinear : (toKaroubi C).Linear k where
	map_smul := by intros; rfl

	variable {R : Type*} [Ring R] [Algebra k R]
	variable {L : C} (θ : R →ₐ[k] End L) (e : R) (he : e * e = e)

	/-- The formal image of the central selecting idempotent. -/
	def summand : Karoubi C :=
	⟨L,θ e,by change θ e * θ e = θ e; rw [← map_mul,he]⟩

	variable (hc : ∀ r : R, e * r = r * e)

	include he hc in
	lemma sandwich (r : R) : e * r * e = e * r := by
	calc
	e * r * e = e * e * r := by rw [mul_assoc,← hc r,← mul_assoc]
	_ = e * r := by rw [he]

	include he hc in
	lemma compressed_mul (r s : R) : (er)(es) = e(r*s) := by
	rw [← mul_assoc,sandwich e he hc,mul_assoc]

	/-- The action on the formal summand, with restriction along alpha. -/
	def action (α : R →ₐ[k] R) : R →ₐ[k] End (summand θ e he) where
	toFun r := ⟨θ (e * α r),by
	change θ e ≫ θ (e * α r) ≫ θ e = θ (e * α r)
	change (θ e * θ (e * α r)) * θ e = θ (e * α r)
	rw [← map_mul,← map_mul]
	congr 1
	rw [← mul_assoc e e,he,sandwich e he hc]⟩
	map_one' := by apply Karoubi.hom_ext; change θ (e * α 1) = θ e; rw [map_one,mul_one]
	map_mul' r s := by
	apply Karoubi.hom_ext
	change θ (e * α (rs)) = θ (e α r) * θ (e * α s)
	rw [← map_mul θ,map_mul α,compressed_mul e he hc]
	map_zero' := by apply Karoubi.hom_ext; change θ (e * α 0) = 0; simp
	map_add' r s := by apply Karoubi.hom_ext; change θ (e * α (r+s)) = θ (e * α r) + θ (e * α s); simp [mul_add]
	commutes' r := by
	apply Karoubi.hom_ext
	change θ (e * α (algebraMap k R r)) = (algebraMap k (End (summand θ e he)) r).f
	rw [α.commutes]
	change θ (e * algebraMap k R r) = (r • (𝟙 (summand θ e he))).f
	rw [smul_f]
	change θ (e * algebraMap k R r) = r • θ e
	rw [hc,Algebra.algebraMap_eq_smul_one,smul_mul_assoc,one_mul,map_smul]

	@[simp] theorem action_f (α : R →ₐ[k] R) (r : R) :
	((action θ e he hc α r) : End (summand θ e he)).f = θ (e * α r * e) := by
	rw [sandwich e he hc]
	rfl

	variable {D : Type*} [Category D] [Preadditive D] [Linear k D]

	/-- A linear functor transports an algebra action on endomorphisms. -/
	def mapAction (F : C ⥤ D) [F.Additive] [F.Linear k] {X : C}
	(ρ : R →ₐ[k] End X) : R →ₐ[k] End (F.obj X) where
	toFun r := F.map (ρ r)
	map_one' := by simp
	map_mul' r s := by simp [End.mul_def]
	map_zero' := by simp
	map_add' r s := by rw [map_add]; exact F.map_add
	commutes' r := by
	rw [ρ.commutes]
	change F.map (r • (𝟙 X)) = r • (𝟙 (F.obj X))
	rw [Functor.map_smul,F.map_id]

	/-- Direct sum of two actions of the same algebra. -/
	noncomputable def biprodAction [HasBinaryBiproducts C] {X Y : C}
	(ρ : R →ₐ[k] End X) (σ : R →ₐ[k] End Y) : R →ₐ[k] End (X ⊞ Y) where
	toFun r := biprod.map (ρ r) (σ r)
	map_one' := by apply biprod.hom_ext <;> simp
	map_mul' r s := by apply biprod.hom_ext <;> simp [End.mul_def]
	map_zero' := by apply biprod.hom_ext <;> simp
	map_add' r s := by
	rw [map_add,map_add]
	change biprod.map ((ρ r : X ⟶ X) + (ρ s : X ⟶ X))
	((σ r : Y ⟶ Y) + (σ s : Y ⟶ Y)) =
	(biprod.map (ρ r) (σ r) : X ⊞ Y ⟶ X ⊞ Y) + biprod.map (ρ s) (σ s)
	apply biprod.hom_ext <;> simp only [biprod.map_fst,biprod.map_snd,
	Preadditive.add_comp]
	all_goals exact Preadditive.comp_add _ _ _ _ _ _
	commutes' r := by
	rw [ρ.commutes,σ.commutes]
	change biprod.map (r • (𝟙 X)) (r • (𝟙 Y)) = r • (𝟙 (X ⊞ Y))
	apply biprod.hom_ext <;> simp

	/-- Conjugating an action along an isomorphism. -/
	def transportAction {X Y : C} (i : X ≅ Y) (ρ : R →ₐ[k] End Y) :
	R →ₐ[k] End X where
	toFun r := i.hom ≫ ρ r ≫ i.inv
	map_one' := by simp
	map_mul' r s := by simp [End.mul_def]
	map_zero' := by simp
	map_add' r s := by
	rw [map_add]
	change i.hom ≫ ((ρ r : Y ⟶ Y) + (ρ s : Y ⟶ Y)) ≫ i.inv = _
	rw [add_comp,comp_add]
	commutes' r := by
	rw [ρ.commutes]
	change i.hom ≫ (r • (𝟙 Y)) ≫ i.inv = r • (𝟙 X)
	simp

	/-- An action on an old object in the completion is an actual old action. -/
	def oldAction {X : C} (ρ : R →ₐ[k] End ((toKaroubi C).obj X)) :
	R →ₐ[k] End X where
	toFun r := (ρ r).f
	map_one' := by rw [map_one]; rfl
	map_mul' r s := by rw [map_mul]; rfl
	map_zero' := by rw [map_zero]; rfl
	map_add' r s := by rw [map_add]; rfl
	commutes' r := by rw [ρ.commutes]; rfl

	@[simp] theorem oldAction_lift {X : C} (ρ : R →ₐ[k] End ((toKaroubi C).obj X))
	(r : R) : (toKaroubi C).map (oldAction ρ r) = ρ r := by
	apply Karoubi.hom_ext
	rfl

	variable [HasShift C ℤ] [HasZeroObject C]
	[∀ n : ℤ, (shiftFunctor C n).Additive] [Pretriangulated C]
	[∀ n : ℤ, (shiftFunctor C n).Linear k]

	instance formalShiftLinear (n : ℤ) :
	(OddDouble.formalShiftFunctor (C := C) n).Linear k where
	map_smul := by
	intro X Y f r
	apply Karoubi.hom_ext
	exact Functor.map_smul (shiftFunctor C n) r f.f

	local instance : HasFiniteBiproducts (Karoubi C) := Karoubi.karoubi_hasFiniteBiproducts
	local instance : HasBinaryBiproducts (Karoubi C) :=
	hasBinaryBiproducts_of_finite_biproducts (Karoubi C)

	/-- The selecting action on the odd double. -/
	noncomputable def oddDoubleAction (α : R →ₐ[k] R) :
	R →ₐ[k] End (summand θ e he ⊞ OddDouble.formalShift (summand θ e he) 3) :=
	biprodAction (action θ e he hc α)
	(mapAction (OddDouble.formalShiftFunctor 3) (action θ e he hc α))

	/-- The object and its unital action are both chosen before any evaluation module. -/
	theorem fixed_old_object_with_action (α : R →ₐ[k] R) :
	∃ (V₀ : C) (ρ₀ : R →ₐ[k] End V₀)
	(i : (toKaroubi C).obj V₀ ≅
	summand θ e he ⊞ OddDouble.formalShift (summand θ e he) 3),
	∀ r : R, (toKaroubi C).map (ρ₀ r) ≫ i.hom =
	i.hom ≫ oddDoubleAction θ e he hc α r := by
	obtain ⟨V₀,⟨i⟩⟩ := OddDouble.odd_double_three (summand θ e he)
	let σ := oddDoubleAction θ e he hc α
	let τ := transportAction i σ
	refine ⟨V₀,oldAction τ,i,?_⟩
	intro r
	rw [oldAction_lift]
	change (i.hom ≫ σ r ≫ i.inv) ≫ i.hom = i.hom ≫ σ r
	simp

	end LittleFinitistic.FormalSummandAction

	end OAI