File size: 4,805 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
import OAI.ArithmeticGeometry.OrdinaryLocus.Openness.TensorSectionRestriction
import OAI.AlgebraicGeometry.SheafCohomology.Projective.AdditiveCoproductSections

/-! # Base Open Sections -/

namespace OAI.ArithmeticGeometry.OrdinaryLocus.Openness.BaseOpenSections.Construction

noncomputable section

/-! Actual sections on an open subset, with scalars from the global sections of the base. -/

open _root_.CategoryTheory _root_.AlgebraicGeometry MonoidalCategory
open OAI.AlgebraicGeometry.SheafCohomology.Projective.AdditiveCoproductSections

universe u

def baseOpenScalarMap {X S : Scheme.{u}} (Ļ€ : X ⟶ S) (U : X.Opens) :
    Ī“(S, ⊤) →+* Ī“(X, U) :=
  (Ļ€.appLE ⊤ U (by simp)).hom

theorem baseOpenScalarMap_eq {X S : Scheme.{u}} (Ļ€ : X ⟶ S) (U : X.Opens) :
    baseOpenScalarMap π U =
      (X.presheaf.map (homOfLE le_top : U ⟶ ⊤).op).hom.comp Ļ€.appTop.hom := rfl

@[instance_reducible]
def baseOpenSectionsAlgebra {X S : Scheme.{u}} (Ļ€ : X ⟶ S) (U : X.Opens) :
    Algebra Ī“(S, ⊤) Ī“(X, U) := (baseOpenScalarMap Ļ€ U).toAlgebra

@[instance_reducible]
def baseOpenSectionsModule {X S : Scheme.{u}} (Ļ€ : X ⟶ S) (M : X.Modules) (U : X.Opens) :
    Module Ī“(S, ⊤) Ī“(M, U) := Module.compHom Ī“(M, U) (baseOpenScalarMap Ļ€ U)

def baseOpenSectionsFunctor {X S : Scheme.{u}} (Ļ€ : X ⟶ S) (U : X.Opens) :
    X.Modules ℤ ModuleCat.{u} Ī“(S, ⊤) where
  obj M := letI := baseOpenSectionsModule Ļ€ M U; ModuleCat.of Ī“(S, ⊤) Ī“(M, U)
  map {M N} q := by
    letI := baseOpenSectionsModule π M U
    letI := baseOpenSectionsModule π N U
    exact ModuleCat.ofHom
      { (q.val.app (.op U)).hom.toAddMonoidHom with
        map_smul' := fun r x => (q.val.app (.op U)).hom.map_smul (baseOpenScalarMap π U r) x }
  map_id _ := by ext; rfl
  map_comp _ _ := by ext; rfl

def baseOpenSectionsRestriction {X S : Scheme.{u}} (Ļ€ : X ⟶ S) (M : X.Modules) (U : X.Opens) :
    (AlgebraicGeometry.SheafCohomology.Projective.AdditiveCoproductSections.baseGlobalSectionsFunctor Ļ€).obj M →ₗ[Ī“(S, ⊤)] (baseOpenSectionsFunctor Ļ€ U).obj M where
  toFun := M.presheaf.map (homOfLE (le_top : U ≤ ⊤)).op
  map_add' := (M.presheaf.map (homOfLE (le_top : U ≤ ⊤)).op).hom.map_add
  map_smul' r x := (M.val.map (homOfLE (le_top : U ≤ ⊤)).op).hom.map_smul (Ļ€.appTop r) x

theorem baseOpenScalarMap_pullback {X Y S : Scheme.{u}}
    (f : X ⟶ Y) (Ļ€ : Y ⟶ S) (U : Y.Opens) :
    (f.app U).hom.comp (baseOpenScalarMap π U) =
      baseOpenScalarMap (f ≫ Ļ€) (f ⁻¹ᵁ U) := by
  have h := Scheme.Hom.appLE_comp_appLE f Ļ€ ⊤ U (f ⁻¹ᵁ U) (by simp) le_rfl
  rw [Scheme.Hom.appLE_eq_app] at h
  exact congrArg CommRingCat.Hom.hom h

def baseOpenSectionsPullbackAlgHom {X Y S : Scheme.{u}}
    (f : X ⟶ Y) (Ļ€ : Y ⟶ S) (U : Y.Opens) :
    letI := baseOpenSectionsAlgebra π U
    letI := baseOpenSectionsAlgebra (f ≫ Ļ€) (f ⁻¹ᵁ U)
    Ī“(Y, U) →ₐ[Ī“(S, ⊤)] Ī“(X, f ⁻¹ᵁ U) :=
  letI := baseOpenSectionsAlgebra π U
  letI := baseOpenSectionsAlgebra (f ≫ Ļ€) (f ⁻¹ᵁ U)
  { (f.app U).hom with
    commutes' r := RingHom.congr_fun (baseOpenScalarMap_pullback f π U) r }

local instance baseOpenSectionTensor (X : Scheme.{u}) :
    MonoidalCategory X.Modules := AlgebraicGeometry.SheafCohomology.Projective.Monoidal.Scheme.Modules.monoidalCategory X

def tensorSectionGlobalCoefficientLinear {X S : Scheme.{u}} (Ļ€ : X ⟶ S)
    (M : X.Modules) {P : X.Modules} (a : šŸ™_ X.Modules ⟶ P) (U : X.Opens)
    [IsIso ((Scheme.Modules.pullback U.ι).map a)] :
    (AlgebraicGeometry.SheafCohomology.Projective.AdditiveCoproductSections.baseGlobalSectionsFunctor Ļ€).obj (M āŠ— P) →ₗ[Ī“(S, ⊤)]
      (baseOpenSectionsFunctor π U).obj M := by
  letI := baseOpenSectionsModule π M U
  letI := baseOpenSectionsModule Ļ€ (M āŠ— P) U
  let e : (baseOpenSectionsFunctor Ļ€ U).obj (M āŠ— P) ā‰ƒā‚—[Ī“(S, ⊤)]
      (baseOpenSectionsFunctor π U).obj M :=
    { (TensorSectionFrame.Construction.tensorSectionFrameAppEquiv M a U).symm.toAddEquiv with
      map_smul' := fun r x => (TensorSectionFrame.Construction.tensorSectionFrameAppEquiv M a U).symm.map_smul
        (baseOpenScalarMap π U r) x }
  exact e.toLinearMap.comp (baseOpenSectionsRestriction Ļ€ (M āŠ— P) U)

theorem tensorSectionGlobalCoefficientLinear_apply {X S : Scheme.{u}} (Ļ€ : X ⟶ S)
    (M : X.Modules) {P : X.Modules} (a : šŸ™_ X.Modules ⟶ P) (U : X.Opens)
    [IsIso ((Scheme.Modules.pullback U.ι).map a)]
    (x : (AlgebraicGeometry.SheafCohomology.Projective.AdditiveCoproductSections.baseGlobalSectionsFunctor Ļ€).obj (M āŠ— P)) :
    tensorSectionGlobalCoefficientLinear π M a U x = TensorSectionRestriction.Construction.tensorSectionGlobalCoefficient M a U x := rfl

end

end OAI.ArithmeticGeometry.OrdinaryLocus.Openness.BaseOpenSections.Construction