File size: 6,146 Bytes
a72760f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
import OAI.NumberTheory.PiExponent.Approximation.ClosedImmersionSerreTransfer
import OAI.NumberTheory.PiExponent.Cohomology.EulerExact

namespace OAI

namespace PiExponent.ClosedImmersionSerreTransfer

noncomputable section
open AlgebraicGeometry CategoryTheory CategoryTheory.Limits CategoryTheory.Abelian
open TopologicalSpace Opposite PiExponentSeshadri.Geometry

variable {X Y : Scheme.{0}} (f : X ⟶ Y)
local instance closedPushforwardLinearSourceHasExt : HasExt.{1} X.Modules := schemeHasExt
local instance closedPushforwardLinearTargetHasExt : HasExt.{1} Y.Modules := schemeHasExt

lemma baseScalars_comp_actual (p : Y ⟶ Spec (CommRingCat.of ℂ)) :
    baseScalars (f ≫ p) = f.appTop.hom.comp (baseScalars p) := by
  ext c
  simp only [baseScalars, Scheme.Hom.comp_appTop, CommRingCat.hom_comp,
    RingHom.comp_apply]

lemma scalar_naturality (p : Y ⟶ Spec (CommRingCat.of ℂ)) (U : Y.Opens) (r : ℂ) :
    restrictScalar X (f ⁻¹ᵁ U) (baseScalars (f ≫ p) r) =
      f.app U (restrictScalar Y U (baseScalars p r)) := by
  rw [baseScalars_comp_actual]
  change X.presheaf.map (homOfLE le_top).op (f.appTop (baseScalars p r)) = _
  exact (CategoryTheory.congr_fun (f.naturality (homOfLE le_top).op) (baseScalars p r)).symm

theorem complexLinearPushforward (p : Y ⟶ Spec (CommRingCat.of ℂ)) :
    letI := sheafComplexLinear (f ≫ p)
    letI := sheafComplexLinear p
    (Scheme.Modules.pushforward f).Linear ℂ := by
  let := sheafComplexLinear (f ≫ p)
  let := sheafComplexLinear p
  constructor
  intro M N g r
  ext U m
  let y : Γ(N, f ⁻¹ᵁ U) := g.val.app (op (f ⁻¹ᵁ U)) m
  change restrictScalar X (f ⁻¹ᵁ U) (baseScalars (f ≫ p) r) • y =
    f.app U (restrictScalar Y U (baseScalars p r)) • y
  rw [scalar_naturality]

variable [IsClosedImmersion f]

lemma cohomologyMap_comp {M N : X.Modules} {n m k : ℕ}
    (x : cohomology M n) (y : Ext.{1} M N m) (h : n + m = k) :
    cohomologyMap f N k (x.comp y h) =
      (cohomologyMap f M n x).comp (y.mapExactFunctor (Scheme.Modules.pushforward f)) h :=
  PiExponentSeshadri.ExtSectionComparison.mapFrom_comp
    (Scheme.Modules.pushforward f) (structureMap f) x y h

def typedCohomologyMap (M : X.Modules) (n : ℕ) :
    cohomology M n →+ cohomology ((Scheme.Modules.pushforward f).obj M) n :=
  cohomologyMap f M n

lemma typedCohomologyMap_comp {M N : X.Modules} {n m k : ℕ}
    (x : cohomology M n) (y : Ext.{1} M N m) (h : n + m = k) :
    typedCohomologyMap f N k (x.comp y h) =
      (typedCohomologyMap f M n x).comp
        (y.mapExactFunctor (Scheme.Modules.pushforward f)) h :=
  cohomologyMap_comp f x y h

lemma typedCohomologyMap_bijective (M : X.Modules) (n : ℕ) :
    Function.Bijective (typedCohomologyMap f M n) :=
  cohomologyMap_bijective f M n

def cohomologyLinearMap (p : Y ⟶ Spec (CommRingCat.of ℂ)) (M : X.Modules) (n : ℕ) :
    letI := Module.compHom (cohomology M n) (baseScalars (f ≫ p))
    letI := Module.compHom (cohomology ((Scheme.Modules.pushforward f).obj M) n) (baseScalars p)
    cohomology M n →ₗ[ℂ] cohomology ((Scheme.Modules.pushforward f).obj M) n := by
  letI := Module.compHom (cohomology M n) (baseScalars (f ≫ p))
  letI := Module.compHom (cohomology ((Scheme.Modules.pushforward f).obj M) n) (baseScalars p)
  exact { toFun := typedCohomologyMap f M n
          map_add' := (typedCohomologyMap f M n).map_add
          map_smul' := by
            intro r x
            change typedCohomologyMap f M n ((baseScalars (f ≫ p) r) • x) =
              (baseScalars p r) • (typedCohomologyMap f M n x)
            rw [Ext.smul_eq_comp_mk₀, typedCohomologyMap_comp, Ext.smul_eq_comp_mk₀,
              Ext.mapExactFunctor_mk₀]
            congr 2
            ext U m
            change Γ(M, f ⁻¹ᵁ U) at m
            change restrictScalar X (f ⁻¹ᵁ U) (baseScalars (f ≫ p) r) • m =
              f.app U (restrictScalar Y U (baseScalars p r)) • m
            rw [scalar_naturality] }

lemma cohomologyLinearMap_eq (p : Y ⟶ Spec (CommRingCat.of ℂ)) (M : X.Modules) (n : ℕ) :
    ⇑(cohomologyLinearMap f p M n) = typedCohomologyMap f M n := rfl

def cohomologyLinearEquiv (p : Y ⟶ Spec (CommRingCat.of ℂ)) (M : X.Modules) (n : ℕ) :
    letI := Module.compHom (cohomology M n) (baseScalars (f ≫ p))
    letI := Module.compHom (cohomology ((Scheme.Modules.pushforward f).obj M) n) (baseScalars p)
    cohomology M n ≃ₗ[ℂ] cohomology ((Scheme.Modules.pushforward f).obj M) n := by
  exact LinearEquiv.ofBijective (cohomologyLinearMap f p M n)
    (by rw [cohomologyLinearMap_eq]; exact typedCohomologyMap_bijective f M n)

theorem finiteDimensional_of_pushforward
    (p : Y ⟶ Spec (CommRingCat.of ℂ)) (M : X.Modules) (n : ℕ)
    (hfinite : letI := Module.compHom (cohomology ((Scheme.Modules.pushforward f).obj M) n) (baseScalars p)
      FiniteDimensional ℂ (cohomology ((Scheme.Modules.pushforward f).obj M) n)) :
    letI := Module.compHom (cohomology M n) (baseScalars (f ≫ p))
    FiniteDimensional ℂ (cohomology M n) := by
  let := Module.compHom (cohomology M n) (baseScalars (f ≫ p))
  let := Module.compHom (cohomology ((Scheme.Modules.pushforward f).obj M) n) (baseScalars p)
  have := hfinite
  exact FiniteDimensional.of_injective (cohomologyLinearEquiv f p M n).toLinearMap
    (cohomologyLinearEquiv f p M n).injective

lemma cohomologyDimension_pushforward
    (p : Y ⟶ Spec (CommRingCat.of ℂ)) (M : X.Modules) (n : ℕ) :
    cohomologyDimension p ((Scheme.Modules.pushforward f).obj M) n =
      cohomologyDimension (f ≫ p) M n := by
  let := Module.compHom (cohomology M n) (baseScalars (f ≫ p))
  let := Module.compHom (cohomology ((Scheme.Modules.pushforward f).obj M) n) (baseScalars p)
  exact (cohomologyLinearEquiv f p M n).finrank_eq.symm

theorem euler_pushforward (p : Y ⟶ Spec (CommRingCat.of ℂ)) (M : X.Modules) (d : ℕ) :
    eulerCharacteristic p d ((Scheme.Modules.pushforward f).obj M) =
      eulerCharacteristic (f ≫ p) d M := by
  apply Finset.sum_congr rfl
  intro n hn
  rw [cohomologyDimension_pushforward]

end
end PiExponent.ClosedImmersionSerreTransfer

end OAI