| import Mathlib |
| import OAI.RingTheory.Multiplicity.FiniteModuleCech |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace Lech.CarrierOperators |
| open CategoryTheory |
| universe u |
| variable {R : Type u} [CommRing R] {ι : Type} [DecidableEq ι] |
|
|
| structure Carrier (ι : Type) where |
| Index : Type |
| support : Index → Finset ι |
|
|
| variable (A B C : Carrier ι) |
|
|
| def Agree (M : Type u) (S : Finset ι) (f g : A.Index → M) : Prop := |
| ∀ a,A.support a⊆S → f a=g a |
|
|
| structure Op where |
| app : ∀ M : ModuleCat.{u} R, (A.Index → M) →ₗ[R] (B.Index → M) |
| natural : ∀ {M N : ModuleCat.{u} R} (l : M →ₗ[R] N) (f : A.Index → M), |
| app N (l ∘ f)=l ∘ app M f |
| locality : ∀ (M : ModuleCat.{u} R) (S : Finset ι) (f g : A.Index → M), |
| Agree A M S f g → Agree B M S (app M f) (app M g) |
|
|
| variable {A B C} |
|
|
| def Op.id (A : Carrier ι) : Op (R:=R) A A where |
| app _ := LinearMap.id |
| natural _ _ := rfl |
| locality _ _ _ _ h := h |
|
|
| def Op.comp (Q : Op (R:=R) B C) (P : Op (R:=R) A B) : Op (R:=R) A C where |
| app M := (Q.app M).comp (P.app M) |
| natural l f := by change Q.app _ (P.app _ (l ∘ f))=_; rw [P.natural,Q.natural]; rfl |
| locality M S f g h := Q.locality M S _ _ (P.locality M S f g h) |
|
|
| def Op.add (P Q : Op (R:=R) A B) : Op (R:=R) A B where |
| app M := P.app M+Q.app M |
| natural l f := by |
| ext b |
| change P.app _ (l ∘ f) b+Q.app _ (l ∘ f) b=l (P.app _ f b+Q.app _ f b) |
| rw [P.natural,Q.natural,map_add] |
| rfl |
| locality M S f g h b hb := by |
| change P.app M f b+Q.app M f b=P.app M g b+Q.app M g b |
| rw [P.locality M S f g h b hb,Q.locality M S f g h b hb] |
|
|
| def Op.sub (P Q : Op (R:=R) A B) : Op (R:=R) A B where |
| app M := P.app M-Q.app M |
| natural l f := by |
| ext b |
| change P.app _ (l ∘ f) b-Q.app _ (l ∘ f) b=l (P.app _ f b-Q.app _ f b) |
| rw [P.natural,Q.natural,map_sub] |
| rfl |
| locality M S f g h b hb := by |
| change P.app M f b-Q.app M f b=P.app M g b-Q.app M g b |
| rw [P.locality M S f g h b hb,Q.locality M S f g h b hb] |
|
|
| variable (D : FiniteModuleCech.Diagram R ι) |
| abbrev Sections (A : Carrier ι) := ∀ a : A.Index,D.obj (A.support a) |
|
|
| def toFixed (A : Carrier ι) (S : Finset ι) : Sections D A →ₗ[R] (A.Index → D.obj S) where |
| toFun f a := if ha : A.support a⊆S then (D.res ha).hom (f a) else 0 |
| map_add' f g := by |
| funext a |
| split_ifs with h <;> simp [h] |
| map_smul' r f := by |
| funext a |
| split_ifs with h <;> simp [h] |
| |
| lemma toFixed_self (A : Carrier ι) (f : Sections D A) (a : A.Index) : |
| toFixed D A (A.support a) f a=f a := by |
| change (if ha : A.support a⊆A.support a then (D.res ha).hom (f a) else 0)=f a |
| rw [dite_eq_left (Finset.Subset.refl _),D.res_self] |
| rfl |
|
|
| lemma toFixed_restrict (A : Carrier ι) {S T : Finset ι} (hST : S⊆T) (f : Sections D A) : |
| Agree A (D.obj T) S (toFixed D A T f) ((D.res hST).hom ∘ toFixed D A S f) := by |
| intro a ha |
| change (if ht : A.support a⊆T then _ else _) = |
| (D.res hST).hom (if hs : A.support a⊆S then _ else _) |
| rw [dite_eq_left (ha.trans hST),dite_eq_left ha] |
| exact congrArg (fun g : D.obj (A.support a) ⟶ D.obj T => g.hom (f a)) (D.res_comp ha hST).symm |
|
|
| |
| def lift (P : Op (R:=R) A B) : Sections D A →ₗ[R] Sections D B := |
| LinearMap.pi (fun b => (LinearMap.proj b).comp |
| ((P.app (D.obj (B.support b))).comp (toFixed D A (B.support b)))) |
|
|
| lemma toFixed_lift (P : Op (R:=R) A B) (S : Finset ι) (f : Sections D A) : |
| Agree B (D.obj S) S (toFixed D B S (lift D P f)) (P.app (D.obj S) (toFixed D A S f)) := by |
| intro b hb |
| change (if hb : B.support b⊆S then _ else _) = _ |
| rw [dite_eq_left hb] |
| change (D.res hb).hom (P.app (D.obj (B.support b)) (toFixed D A (B.support b) f) b)=_ |
| have he := P.locality (D.obj S) (B.support b) _ _ (toFixed_restrict D A hb f) b (Finset.Subset.refl _) |
| rw [P.natural] at he |
| exact he.symm |
|
|
| lemma lift_comp (Q : Op (R:=R) B C) (P : Op (R:=R) A B) : |
| lift D (Q.comp P)=(lift D Q).comp (lift D P) := by |
| apply LinearMap.ext |
| intro f |
| funext c |
| exact (Q.locality (D.obj (C.support c)) (C.support c) _ _ (toFixed_lift D P _ f) |
| c (Finset.Subset.refl _)).symm |
|
|
| lemma lift_id (A : Carrier ι) : lift D (Op.id A)=LinearMap.id := by |
| apply LinearMap.ext |
| intro f |
| funext a |
| exact toFixed_self D A f a |
|
|
| lemma lift_add (P Q : Op (R:=R) A B) : lift D (P.add Q)=lift D P+lift D Q := rfl |
| lemma lift_sub (P Q : Op (R:=R) A B) : lift D (P.sub Q)=lift D P-lift D Q := rfl |
|
|
| lemma lift_congr {P Q : Op (R:=R) A B} (h : ∀ M,P.app M=Q.app M) : lift D P=lift D Q := by |
| apply LinearMap.ext |
| intro f |
| funext b |
| change P.app (D.obj (B.support b)) (toFixed D A (B.support b) f) b=_ |
| rw [h] |
| rfl |
| end Lech.CarrierOperators |
|
|
| end |
|
|
| end OAI |
|
|
