Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Frames of modules on the small étale site

Definition
AlgebraicGeometry_EtaleFramePresentations

by tomasz · Nov 18, 2026 · Mathlib 0df444a (Lean v4.33.1)

algebraic-geometryetale-cohomology

Local frames are isomorphisms from the structure sheaf to the pullback of a module. Restriction uses the canonical isomorphism for composite pullback. A presentation identifies these frames with sections of a units torsor wherever a frame exists. Tensoring frames uses the canonical tensor comparison for pullback.

Definition code
import Mathlib
import Definitions.Def_AlgebraicGeometry_ModulesPullbackMonoidalV2
import Definitions.Def_AlgebraicGeometry_RelativePicardFunctor
import Definitions.Def_AlgebraicGeometry_SmallEtaleUnits
import Definitions.Def_AlgebraicGeometry_AbelianSheafTorsors
import Definitions.Def_AlgebraicGeometry_ModulesPullbackMonoidalV2

section
set_option autoImplicit false
set_option maxHeartbeats 900000
set_option backward.isDefEq.respectTransparency.types false
set_option backward.isDefEq.respectTransparency false
noncomputable section

open AlgebraicGeometry CategoryTheory Opposite TopologicalSpace

namespace PhilipponFrameUnits
universe u

/-- The trivial line bundle on a scheme. -/
abbrev trivial (X : Scheme.{u}) : X.Modules := SheafOfModules.unit X.ringCatSheaf

/-- A compatible family of sections on all opens is determined by its
section on the whole scheme. -/
def globalSections (X : Scheme.{u}) (M : X.Modules) :
    SheafOfModules.sections M ≃ Γ(M, ⊤) where
  toFun s := s.val (op ⊤)
  invFun s := M.val.sectionsMk
    (fun U => M.val.map (homOfLE (le_top : U.unop ≤ ⊤)).op s)
    (by
      intro U V f
      rw [← M.val.map_comp_apply]
      congr 2)
  left_inv s := by
    apply PresheafOfModules.sections_ext
    intro U
    exact PresheafOfModules.sections_property s (homOfLE (le_top : U.unop ≤ ⊤)).op
  right_inv s := by
    change M.val.map (homOfLE (le_top : (⊤ : X.Opens) ≤ ⊤)).op s = s
    rw [show (homOfLE (le_top : (⊤ : X.Opens) ≤ ⊤)).op = 𝟙 (op ⊤) from Subsingleton.elim _ _]
    change M.val.map (𝟙 _) s = s
    simp

/-- Endomorphisms of the actual tensor unit are multiplication by global
sections of the structure sheaf. -/
def unitEnd (X : Scheme.{u}) : End (trivial X) ≃* Γ(X, ⊤) := by
  let O : X.Modules := SheafOfModules.unit X.ringCatSheaf
  let e : End (trivial X) ≃ Γ(X, ⊤) :=
    (SheafOfModules.unitHomEquiv O).trans (globalSections X O)
  refine { toEquiv := e, map_mul' := ?_ }
  intro f g
  let f' : SheafOfModules.unit X.ringCatSheaf ⟶ SheafOfModules.unit X.ringCatSheaf := f
  let g' : SheafOfModules.unit X.ringCatSheaf ⟶ SheafOfModules.unit X.ringCatSheaf := g
  let F : Γ(X, ⊤) →ₗ[Γ(X, ⊤)] Γ(X, ⊤) := (f'.val.app (op (⊤ : X.Opens))).hom
  let G : Γ(X, ⊤) →ₗ[Γ(X, ⊤)] Γ(X, ⊤) := (g'.val.app (op (⊤ : X.Opens))).hom
  change F (G (1 : Γ(X, ⊤))) = F 1 * G 1
  have h := F.map_smul (G (1 : Γ(X, ⊤))) (1 : Γ(X, ⊤))
  change F (G 1 * 1) = G 1 * F 1 at h
  simpa only [mul_one] using h.trans (mul_comm (G 1) (F 1))

/-- Scalar units are exactly automorphisms of the tensor unit. -/
def unitAut (X : Scheme.{u}) : Aut (trivial X) ≃* (Γ(X, ⊤))ˣ :=
  (Aut.unitsEndEquivAut _).symm.trans (Units.mapEquiv (unitEnd X))

/-- Taking differences from a fixed frame gives a bijection with the
global units on the scheme. -/
def differenceEquiv (X : Scheme.{u}) {M : X.Modules} (q : (trivial X) ≅ M) :
    ((trivial X) ≅ M) ≃ (Γ(X, ⊤))ˣ :=
  (Equiv.mk (fun p => p ≪≫ q.symm) (fun a => a ≪≫ q)
    (by intro p; simp) (by intro a; simp)).trans (unitAut X).toEquiv

/-- The scalars measuring two successive changes of frame multiply to
the scalar for the composite change of frame. -/
theorem difference_mul (X : Scheme.{u}) {M : X.Modules} (p q r : (trivial X) ≅ M) :
    differenceEquiv X q p * differenceEquiv X r q = differenceEquiv X r p := by
  change unitAut X (p ≪≫ q.symm) * unitAut X (q ≪≫ r.symm) = unitAut X (p ≪≫ r.symm)
  rw [mul_comm, ← map_mul]
  congr 1
  apply Aut.ext
  change (p.hom ≫ q.inv) ≫ (q.hom ≫ r.inv) = p.hom ≫ r.inv
  simp

end PhilipponFrameUnits
end
end

section
set_option autoImplicit false
set_option maxHeartbeats 900000
set_option backward.isDefEq.respectTransparency.types false
set_option backward.isDefEq.respectTransparency false
noncomputable section

open AlgebraicGeometry CategoryTheory Opposite PhilipponFrameUnits

namespace PhilipponFramePullback
universe u
variable {X Y : Scheme.{u}} (f : X ⟶ Y)

/-- The canonical comparison of the pulled-back tensor unit with the
tensor unit on the domain. -/
abbrev unitIso : (Scheme.Modules.pullback f).obj (trivial Y) ≅ trivial X :=
  Scheme.Modules.pullbackUnitIso f

theorem pullback_scalar_square (a : End (trivial Y)) :
    (Scheme.Modules.pullback f).map a ≫ (unitIso f).hom =
      (unitIso f).hom ≫ (PhilipponFrameUnits.unitEnd X).symm
        (f.appTop (PhilipponFrameUnits.unitEnd Y a)) := by
  let b := (PhilipponFrameUnits.unitEnd X).symm (f.appTop (PhilipponFrameUnits.unitEnd Y a))
  let OX : X.Modules := trivial X
  let OY : Y.Modules := trivial Y
  let N := (Scheme.Modules.pushforward f).obj OX
  let adj := Scheme.Modules.pullbackPushforwardAdjunction f
  let m : OY ⟶ N := SheafOfModules.unitToPushforwardObjUnit f.toRingCatSheafHom
  have he : adj.homEquiv OY OX (unitIso f).hom = m :=
    SheafOfModules.pullbackPushforwardAdjunction_homEquiv_pullbackObjUnitToUnit _
  change (Scheme.Modules.pullback f).map a ≫ (unitIso f).hom = (unitIso f).hom ≫ b
  apply (adj.homEquiv OY OX).injective
  rw [adj.homEquiv_naturality_left, adj.homEquiv_naturality_right, he]
  let eval : (OY ⟶ N) ≃ Γ(N, ⊤) := (SheafOfModules.unitHomEquiv N).trans
    (PhilipponFrameUnits.globalSections Y N)
  apply eval.injective
  let b' : SheafOfModules.unit X.ringCatSheaf ⟶ SheafOfModules.unit X.ringCatSheaf := b
  change f.appTop (PhilipponFrameUnits.unitEnd Y a) =
    b'.val.app (op (⊤ : X.Opens)) (f.appTop (1 : Γ(Y, ⊤)))
  rw [map_one]
  exact ((PhilipponFrameUnits.unitEnd X).apply_symm_apply _).symm

/-- Pulling back an automorphism of the trivial line bundle restricts the
unit that represents it. -/
theorem unitAut_pullback (a : Aut (trivial Y)) :
    PhilipponFrameUnits.unitAut X ((unitIso f).symm ≪≫
      (Scheme.Modules.pullback f).mapIso a ≪≫ unitIso f) =
      Units.map f.appTop.hom.toMonoidHom (PhilipponFrameUnits.unitAut Y a) := by
  apply Units.ext
  change PhilipponFrameUnits.unitEnd X
    ((unitIso f).inv ≫ (Scheme.Modules.pullback f).map a.hom ≫ (unitIso f).hom) =
    f.appTop (PhilipponFrameUnits.unitEnd Y a.hom)
  have h := pullback_scalar_square f (End.of a.hom)
  rw [h, Iso.inv_hom_id_assoc, MulEquiv.apply_symm_apply]

def pullFrame {M : Y.Modules} (p : trivial Y ≅ M) :
    trivial X ≅ (Scheme.Modules.pullback f).obj M :=
  (unitIso f).symm ≪≫ (Scheme.Modules.pullback f).mapIso p

theorem difference_pullback {M : Y.Modules} (p q : trivial Y ≅ M) :
    PhilipponFrameUnits.differenceEquiv X (pullFrame f q) (pullFrame f p) =
      Units.map f.appTop.hom.toMonoidHom (PhilipponFrameUnits.differenceEquiv Y q p) := by
  change PhilipponFrameUnits.unitAut X (pullFrame f p ≪≫ (pullFrame f q).symm) =
    Units.map f.appTop.hom.toMonoidHom (PhilipponFrameUnits.unitAut Y (p ≪≫ q.symm))
  rw [← unitAut_pullback f (p ≪≫ q.symm)]
  congr 1
  apply Aut.ext
  simp [pullFrame]

theorem difference_postcompose {M N : X.Modules} (p q : trivial X ≅ M) (e : M ≅ N) :
    PhilipponFrameUnits.differenceEquiv X (q ≪≫ e) (p ≪≫ e) =
      PhilipponFrameUnits.differenceEquiv X q p := by
  change PhilipponFrameUnits.unitAut X ((p ≪≫ e) ≪≫ (q ≪≫ e).symm) =
    PhilipponFrameUnits.unitAut X (p ≪≫ q.symm)
  congr 1
  apply Aut.ext
  simp

end PhilipponFramePullback
end
end

section
set_option autoImplicit false
set_option maxHeartbeats 900000
set_option backward.isDefEq.respectTransparency.types false
set_option backward.isDefEq.respectTransparency false
noncomputable section

open AlgebraicGeometry CategoryTheory Opposite
open PhilipponFrameUnits PhilipponFramePullback

namespace PhilipponEtaleFrameSections
universe u
variable {X : Scheme.{u}} (M : X.Modules)

/-- A local frame of a module on a small étale object over the scheme. -/
def Frame (U : X.Etale) := trivial U.left ≅ (Scheme.Modules.pullback U.hom).obj M

/-- Restriction pulls back the frame and uses the comparison between
iterated pullback and pullback along the composite. -/
def restrict {U V : X.Etale} (f : V ⟶ U) (p : Frame M U) : Frame M V :=
  pullFrame f.left p ≪≫
    (Scheme.Modules.pullbackComp f.left U.hom).app M ≪≫
    (Scheme.Modules.pullbackCongr (MorphismProperty.Over.w f)).app M

/-- The change of local frame is a section of the published units sheaf. -/
def diff (U : X.Etale) (p q : Frame M U) :
    (PhilipponKummerSequence.units X).obj.obj (op U) :=
  Additive.ofMul (differenceEquiv U.left q p)

theorem diff_add (U : X.Etale) (p q r : Frame M U) :
    diff M U p q + diff M U q r = diff M U p r :=
  congrArg Additive.ofMul (difference_mul U.left p q r)

theorem diff_restrict {U V : X.Etale} (f : V ⟶ U) (p q : Frame M U) :
    (PhilipponKummerSequence.units X).obj.map f.op (diff M U p q) =
      diff M V (restrict M f p) (restrict M f q) := by
  let e := (Scheme.Modules.pullbackComp f.left U.hom).app M ≪≫
    (Scheme.Modules.pullbackCongr (MorphismProperty.Over.w f)).app M
  change Additive.ofMul (Units.map f.left.appTop.hom.toMonoidHom (differenceEquiv U.left q p)) =
    Additive.ofMul (differenceEquiv V.left (pullFrame f.left q ≪≫ e) (pullFrame f.left p ≪≫ e))
  apply congrArg Additive.ofMul
  rw [difference_postcompose, difference_pullback]

theorem diff_bijective (U : X.Etale) (q : Frame M U) : Function.Bijective (fun p => diff M U p q) :=
  (Additive.ofMul.bijective.comp (differenceEquiv U.left q).bijective)

end PhilipponEtaleFrameSections
end
end

section
set_option autoImplicit false
set_option maxHeartbeats 1200000
set_option backward.isDefEq.respectTransparency.types false
set_option backward.isDefEq.respectTransparency false
noncomputable section

open AlgebraicGeometry CategoryTheory Opposite
open PhilipponFramePullback PhilipponFrameUnits

namespace PhilipponFrameUnitCoherence
universe u v w t

private theorem homEquiv_precompose_conjugate
    {C : Type u} {D : Type v} [Category.{w} C] [Category.{t} D]
    {L₁ L₂ : C ⥤ D} {R₁ R₂ : D ⥤ C} (adj₁ : L₁ ⊣ R₁) (adj₂ : L₂ ⊣ R₂)
    (m : L₂ ⟶ L₁) {A : C} {B : D} (k : L₁.obj A ⟶ B) :
    adj₂.homEquiv A B (m.app A ≫ k) =
      adj₁.homEquiv A B k ≫ (conjugateEquiv adj₁ adj₂ m).app B := by
  rw [adj₂.homEquiv_unit, adj₁.homEquiv_unit, Functor.map_comp, ← Category.assoc,
    ← unit_conjugateEquiv adj₁ adj₂ m, Category.assoc,
    ← (conjugateEquiv adj₁ adj₂ m).naturality k, Category.assoc]

variable {X Y Z : Scheme.{u}}

private abbrev adj {A B : Scheme.{u}} (f : A ⟶ B) := Scheme.Modules.pullbackPushforwardAdjunction f

private abbrev toDirectImage {A B : Scheme.{u}} (f : A ⟶ B) :
    trivial B ⟶ (Scheme.Modules.pushforward f).obj (trivial A) :=
  SheafOfModules.unitToPushforwardObjUnit f.toRingCatSheafHom

private theorem adj_unit {A B : Scheme.{u}} (f : A ⟶ B) :
    (adj f).homEquiv (trivial B) (trivial A) (unitIso f).hom = toDirectImage f :=
  SheafOfModules.pullbackPushforwardAdjunction_homEquiv_pullbackObjUnitToUnit _

@[simp]
theorem unitIso_id (X : Scheme.{u}) :
    unitIso (𝟙 X) = (Scheme.Modules.pullbackId X).app (trivial X) := by
  apply Iso.ext
  apply ((adj (𝟙 X)).homEquiv (trivial X) (trivial X)).injective
  rw [adj_unit]
  have h := homEquiv_precompose_conjugate (Adjunction.id (C := X.Modules)) (adj (𝟙 X))
    (Scheme.Modules.pullbackId X).hom (A := trivial X) (B := trivial X) (𝟙 (trivial X))
  rw [Scheme.Modules.conjugateEquiv_pullbackId_hom] at h
  change ((adj (𝟙 X)).homEquiv _ _)
    ((Scheme.Modules.pullbackId X).hom.app (trivial X) ≫ 𝟙 (trivial X)) =
    𝟙 (trivial X) ≫ (Scheme.Modules.pushforwardId X).inv.app (trivial X) at h
  calc
    toDirectImage (𝟙 X) = (Scheme.Modules.pushforwardId X).inv.app (trivial X) := by
      apply Scheme.Modules.hom_ext
      intro U
      rfl
    _ = 𝟙 (trivial X) ≫ (Scheme.Modules.pushforwardId X).inv.app (trivial X) :=
      (Category.id_comp _).symm
    _ = _ := h.symm
    _ = _ := congrArg ((adj (𝟙 X)).homEquiv (trivial X) (trivial X)) (Category.comp_id _)

/-- Unit comparisons commute with composition of scheme pullbacks. -/
theorem unitIso_comp (f : X ⟶ Y) (g : Y ⟶ Z) :
    unitIso (f ≫ g) = ((Scheme.Modules.pullbackComp f g).app (trivial Z)).symm ≪≫
      (Scheme.Modules.pullback f).mapIso (unitIso g) ≪≫ unitIso f := by
  apply Iso.ext
  apply ((adj (f ≫ g)).homEquiv (trivial Z) (trivial X)).injective
  rw [adj_unit]
  let m := (Scheme.Modules.pullbackComp f g).inv
  let k := (Scheme.Modules.pullback f).map (unitIso g).hom ≫ (unitIso f).hom
  change toDirectImage (f ≫ g) = (adj (f ≫ g)).homEquiv _ _ (m.app _ ≫ k)
  rw [homEquiv_precompose_conjugate ((adj g).comp (adj f)) (adj (f ≫ g)),
    Scheme.Modules.conjugateEquiv_pullbackComp_inv]
  change toDirectImage (f ≫ g) = ((adj g).comp (adj f)).homEquiv _ _
    ((Scheme.Modules.pullback f).map (unitIso g).hom ≫ (unitIso f).hom) ≫
    (Scheme.Modules.pushforwardComp f g).hom.app (trivial X)
  rw [Adjunction.comp_homEquiv]
  change toDirectImage (f ≫ g) = (adj g).homEquiv _ _
    ((adj f).homEquiv _ _ ((Scheme.Modules.pullback f).map (unitIso g).hom ≫ (unitIso f).hom)) ≫ _
  rw [(adj f).homEquiv_naturality_left, adj_unit,
    (adj g).homEquiv_naturality_right, adj_unit]
  apply Scheme.Modules.hom_ext
  intro U
  simp only [Scheme.Modules.Hom.comp_app, Scheme.Modules.pushforward_map_app,
    Scheme.Modules.pushforwardComp_hom_app_app]
  rfl

end PhilipponFrameUnitCoherence
end
end

section
set_option autoImplicit false
set_option maxHeartbeats 1500000
set_option backward.isDefEq.respectTransparency.types false
set_option backward.isDefEq.respectTransparency false
noncomputable section

open AlgebraicGeometry CategoryTheory
open PhilipponFrameUnits PhilipponFramePullback PhilipponFrameUnitCoherence

namespace PhilipponFrameRestrictionCoherence
universe u
variable {S U V W : Scheme.{u}} (M : S.Modules)

def alongComposite (f : V ⟶ U) (i : U ⟶ S)
    (q : trivial U ≅ (Scheme.Modules.pullback i).obj M) :
    trivial V ≅ (Scheme.Modules.pullback (f ≫ i)).obj M :=
  pullFrame f q ≪≫ (Scheme.Modules.pullbackComp f i).app M

private theorem comparison_assoc (g : W ⟶ V) (f : V ⟶ U) (i : U ⟶ S) :
    ((Scheme.Modules.pullbackComp g f).app ((Scheme.Modules.pullback i).obj M)).hom ≫
      ((Scheme.Modules.pullbackComp (g ≫ f) i).app M).hom ≫
      ((Scheme.Modules.pullbackCongr (Category.assoc g f i)).app M).hom =
    (Scheme.Modules.pullback g).map (((Scheme.Modules.pullbackComp f i).app M).hom) ≫
      ((Scheme.Modules.pullbackComp g (f ≫ i)).app M).hom := by
  let a := (Scheme.Modules.pullbackComp g (f ≫ i)).app M
  let b := (Scheme.Modules.pullback g).mapIso ((Scheme.Modules.pullbackComp f i).app M)
  let c := (Scheme.Modules.pullbackComp g f).app ((Scheme.Modules.pullback i).obj M) ≪≫
    (Scheme.Modules.pullbackComp (g ≫ f) i).app M
  let e := (Scheme.Modules.pullbackCongr (Category.assoc g f i)).app M
  have he := NatTrans.congr_app (Scheme.Modules.pseudofunctor_associativity g f i) M
  change a.inv ≫ b.inv ≫ 𝟙 _ ≫ c.hom = e.inv at he
  rw [Category.id_comp] at he
  have h := congrArg (fun k => k ≫ e.hom) he
  change (a.inv ≫ b.inv ≫ c.hom) ≫ e.hom = e.inv ≫ e.hom at h
  simp only [Category.assoc, Iso.inv_hom_id] at h
  have hc : c.hom ≫ e.hom = b.hom ≫ a.hom := by
    apply (cancel_epi (a.inv ≫ b.inv)).mp
    simpa only [Category.assoc, Iso.inv_hom_id_assoc, Iso.inv_hom_id] using h
  simpa only [c, e, a, b, Iso.trans_hom, Functor.mapIso_hom, Category.assoc] using hc

theorem alongComposite_assoc (g : W ⟶ V) (f : V ⟶ U) (i : U ⟶ S)
    (q : trivial U ≅ (Scheme.Modules.pullback i).obj M) :
    alongComposite M g (f ≫ i) (alongComposite M f i q) =
      alongComposite M (g ≫ f) i q ≪≫
        (Scheme.Modules.pullbackCongr (Category.assoc g f i)).app M := by
  apply Iso.ext
  have hn := (Scheme.Modules.pullbackComp g f).hom.naturality q.hom
  change (Scheme.Modules.pullback g).map ((Scheme.Modules.pullback f).map q.hom) ≫
      ((Scheme.Modules.pullbackComp g f).app ((Scheme.Modules.pullback i).obj M)).hom =
    ((Scheme.Modules.pullbackComp g f).app (trivial U)).hom ≫
      (Scheme.Modules.pullback (g ≫ f)).map q.hom at hn
  simp only [alongComposite, pullFrame, unitIso_comp g f, Iso.trans_hom, Iso.trans_inv,
    Iso.symm_hom, Iso.symm_inv, Functor.mapIso_hom, Functor.mapIso_inv, Functor.map_comp,
    Category.assoc]
  rw [← reassoc_of% hn, comparison_assoc]

theorem alongComposite_id (i : U ⟶ S)
    (q : trivial U ≅ (Scheme.Modules.pullback i).obj M) :
    alongComposite M (𝟙 U) i q ≪≫
      (Scheme.Modules.pullbackCongr (Category.id_comp i)).app M = q := by
  apply Iso.ext
  let I := (Scheme.Modules.pullbackId U).app ((Scheme.Modules.pullback i).obj M)
  let C := (Scheme.Modules.pullbackComp (𝟙 U) i).app M
  let E := (Scheme.Modules.pullbackCongr (Category.id_comp i)).app M
  have he := NatTrans.congr_app (Scheme.Modules.pseudofunctor_right_unitality i) M
  change C.inv ≫ I.hom ≫ 𝟙 _ = E.hom at he
  rw [Category.comp_id] at he
  have hn := (Scheme.Modules.pullbackId U).inv.naturality q.hom
  change q.hom ≫ I.inv = ((Scheme.Modules.pullbackId U).app (trivial U)).inv ≫
    (Scheme.Modules.pullback (𝟙 U)).map q.hom at hn
  change (unitIso (𝟙 U)).inv ≫ (Scheme.Modules.pullback (𝟙 U)).map q.hom ≫ C.hom ≫ E.hom = q.hom
  rw [unitIso_id, ← reassoc_of% hn, ← he]
  simp [I, C]

end PhilipponFrameRestrictionCoherence
end
end

section
set_option autoImplicit false
set_option maxHeartbeats 1200000
set_option backward.isDefEq.respectTransparency.types false
set_option backward.isDefEq.respectTransparency false
noncomputable section

open AlgebraicGeometry CategoryTheory Opposite
open PhilipponFrameUnits PhilipponEtaleFrameSections PhilipponFrameRestrictionCoherence
open PhilipponTorsorPresheafDifference PhilipponTorsorInvariantDescent

namespace PhilipponEtaleFramePresheaf
universe u
variable {X : Scheme.{u}} (M : X.Modules)

private theorem pullbackCongr_app_trans {U : Scheme.{u}} {a b c : U ⟶ X}
    (h : a = b) (k : b = c) :
    (Scheme.Modules.pullbackCongr h).app M ≪≫ (Scheme.Modules.pullbackCongr k).app M =
      (Scheme.Modules.pullbackCongr (h.trans k)).app M := by
  subst b
  subst c
  change Iso.refl ((Scheme.Modules.pullback a).obj M) ≪≫ Iso.refl _ = Iso.refl _
  simp

private theorem alongComposite_congr {U V : Scheme.{u}} {a b : U ⟶ X} (f : V ⟶ U)
    (h : a = b) (q : trivial U ≅ (Scheme.Modules.pullback a).obj M) :
    alongComposite M f b (q ≪≫ (Scheme.Modules.pullbackCongr h).app M) =
      alongComposite M f a q ≪≫ (Scheme.Modules.pullbackCongr (congrArg (f ≫ ·) h)).app M := by
  subst b
  change alongComposite M f a (q ≪≫ Iso.refl _) = alongComposite M f a q ≪≫ Iso.refl _
  simp

theorem restrict_id (U : X.Etale) (p : Frame M U) : restrict M (𝟙 U) p = p := by
  change alongComposite M (𝟙 U.left) U.hom p ≪≫
    (Scheme.Modules.pullbackCongr (Category.id_comp U.hom)).app M = p
  exact alongComposite_id M U.hom p

theorem restrict_comp {U V W : X.Etale} (f : V ⟶ U) (g : W ⟶ V) (p : Frame M U) :
    restrict M g (restrict M f p) = restrict M (g ≫ f) p := by
  change alongComposite M g.left V.hom
    (alongComposite M f.left U.hom p ≪≫
      (Scheme.Modules.pullbackCongr (MorphismProperty.Over.w f)).app M) ≪≫
      (Scheme.Modules.pullbackCongr (MorphismProperty.Over.w g)).app M =
    alongComposite M (g.left ≫ f.left) U.hom p ≪≫
      (Scheme.Modules.pullbackCongr (MorphismProperty.Over.w (g ≫ f))).app M
  rw [alongComposite_congr, alongComposite_assoc]
  simp only [Iso.trans_assoc, pullbackCongr_app_trans]

/-- The presheaf of frames of a module on the small étale site. -/
def presheaf : X.Etaleᵒᵖ ⥤ Type u where
  obj U := Frame M U.unop
  map f := ↾(restrict M f.unop)
  map_id U := by
    apply ConcreteCategory.hom_ext
    intro p
    exact restrict_id M U.unop p
  map_comp f g := by
    apply ConcreteCategory.hom_ext
    intro p
    exact (restrict_comp M f.unop g.unop p).symm

def difference : Difference (PhilipponKummerSequence.units X).obj where
  P := presheaf M
  diff U := diff M U.unop
  diff_add_diff U := diff_add M U.unop
  map_diff f := diff_restrict M f.unop

end PhilipponEtaleFramePresheaf
end
end

section
set_option autoImplicit false
set_option maxHeartbeats 1000000
set_option backward.isDefEq.respectTransparency.types false
set_option backward.isDefEq.respectTransparency false
noncomputable section

open AlgebraicGeometry CategoryTheory CategoryTheory.Limits Opposite
open PhilipponTorsorSectionFibers PhilipponEtaleFramePresheaf PhilipponEtaleFrameSections

namespace PhilipponEtaleFrameTorsor
universe u
variable {X : Scheme.{u}}

/-- A sheaf torsor equipped with its comparison from actual frames. -/
structure Presentation (M : X.Modules) where
  torsor : Torsor (PhilipponKummerSequence.units X)
  frames : presheaf M ⟶ torsor.D.P
  diff_eq (U : X.Etaleᵒᵖ) (p q : Frame M U.unop) :
    torsor.D.diff U (frames.app U p) (frames.app U q) = diff M U.unop p q
  bijective (U : X.Etaleᵒᵖ) : Nonempty (Frame M U.unop) → Function.Bijective (frames.app U)

end PhilipponEtaleFrameTorsor
end
end

section
set_option autoImplicit false
set_option maxHeartbeats 1200000
set_option backward.isDefEq.respectTransparency.types false
set_option backward.isDefEq.respectTransparency false
noncomputable section

open AlgebraicGeometry CategoryTheory MonoidalCategory
open PhilipponFrameUnits

namespace PhilipponTensorFrames
universe u v

def tensorFrame (X : Scheme.{u}) {M N : X.Modules} (p : trivial X ≅ M) (q : trivial X ≅ N) :
    trivial X ≅ M ⊗ N :=
  (λ_ (𝟙_ X.Modules)).symm ≪≫ (p ⊗ᵢ q)


/-- Tensor two frames and transport along the given module isomorphism. -/
def tensorOn {X : Scheme.{u}} {M N L : X.Modules} (e : M ⊗ N ≅ L)
    (U : X.Etale) (p : PhilipponEtaleFrameSections.Frame M U)
    (q : PhilipponEtaleFrameSections.Frame N U) : PhilipponEtaleFrameSections.Frame L U :=
  tensorFrame U.left p q ≪≫ (Functor.Monoidal.μIso (Scheme.Modules.pullback U.hom) M N) ≪≫
    (Scheme.Modules.pullback U.hom).mapIso e

end PhilipponTensorFrames
end
end
Source
Stacks Project, Section 59.24, https://stacks.math.columbia.edu/tag/03P8.

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me