2.4. Successions of blow-ups and functors
Lean names in this section are shown relative to AlgebraicGeometry.Scheme.IdealSheafData, AlgebraicGeometry.Scheme, AlgebraicGeometry, CategoryTheory.
A resolution is in general not one blow-up with a non-singular centre but a finite succession of
them. This chapter describes the library's successions of blow-ups of schemes (Kollár's blow-up
sequences), the transforms of ideal sheaves and divisors along them, Kollár's divisor families and
simple normal crossings, the operations of pulling back a succession, deleting its empty blow-ups
and pushing it forward, and the blow-up sequence functors in which the functorial theorems are
stated. What a main theorem asserts of its successions or of its functor, and the inputs particular
to a functorial theorem, are stated with the theorem (Algebraic schemes).
The declarations are in AlgebraicGeometry.Scheme (successions, divisor families) and
AlgebraicGeometry (functors).
2.4.1. Finite successions of blow-ups
A finite succession of blow-ups [Kol07, Definition 29] is a chain
X_r \xrightarrow{\ \pi_{r-1}\ } X_{r-1} \to \cdots \to X_1 \xrightarrow{\ \pi_0\ } X_0 = X, \qquad \pi_i \colon X_{i+1} = \mathrm{Bl}_{Z_i} X_i \to X_i,
with a centre Z_i \subseteq X_i chosen at each stage. The centres are part of the data: two
successions with the same composite but different centres are different successions.
-
BlowUpSequence[complete] -
BlowUpSequence.length[complete] -
BlowUpSequence.stage[complete] -
BlowUpSequence.center[complete] -
BlowUpSequence.stageMap[complete] -
BlowUpSequence.last[complete] -
BlowUpSequence.composite[complete]
A BlowUpSequence X is a finite succession of monoidal transformations starting at X,
defined inductively: nil X is the empty succession, and cons X D S' is the blow-up of X with
centre D followed by a succession S' starting at D.blowUp. From it one reads off
-
the length
r(length), -
the stages
X_0 = X, X_1, \dots, X_r(stage i, indexed byFin (r + 1)), -
the centres
D_i \subseteq X_ifori < r(center i, an ideal sheaf on stagei.castSucc), -
the partial composites
\Pi_i \colon X_i \to X(stageMap i), -
the last stage
X_r(last) and the composite\Pi \colon X_r \to X(composite).
The centres are arbitrary closed subschemes: empty and trivial centres are allowed
[Kol07, Warning 20], and the main theorems state the conditions they ask of the centres.
Because the stages are defined by recursion, a centre lives on a stage whose type depends on the
succession; the statements index the stages by Fin (S.length + 1) and the centres by
Fin S.length, with i.castSucc the stage on which the i-th centre lies and Fin.last S.length
the last stage.
Lean code for Definition2.4.1.1●7 definitions
Associated Lean declarations
-
BlowUpSequence[complete]
-
BlowUpSequence.length[complete]
-
BlowUpSequence.stage[complete]
-
BlowUpSequence.center[complete]
-
BlowUpSequence.stageMap[complete]
-
BlowUpSequence.last[complete]
-
BlowUpSequence.composite[complete]
-
BlowUpSequence[complete] -
BlowUpSequence.length[complete] -
BlowUpSequence.stage[complete] -
BlowUpSequence.center[complete] -
BlowUpSequence.stageMap[complete] -
BlowUpSequence.last[complete] -
BlowUpSequence.composite[complete]
-
inductivedefined in Hironaka/Scheme/BlowUpSequence/Defs.leancomplete
A finite succession of monoidal transformations starting at
X[Hir64, Main Theorem I, p. 132]; [Kol07, Definition 29]:nil Xis the empty succession, andcons X D S'is the blow-up ofXwith centreDfollowed by the successionS'starting atD.blowUp. Stages, centres and composites are recovered byBlowUpSequence.stage,center,stageMap,composite. Empty and trivial centres are allowed [Kol07, Warning 20].Constructors
AlgebraicGeometry.Scheme.BlowUpSequence.nil.{u} (X : Scheme) : X.BlowUpSequence
AlgebraicGeometry.Scheme.BlowUpSequence.cons.{u} (X : Scheme) (D : X.IdealSheafData) (rest : D.blowUp.BlowUpSequence) : X.BlowUpSequence
-
defdefined in Hironaka/Scheme/BlowUpSequence/Defs.leancomplete
def BlowUpSequence.length {X : Scheme} : X.BlowUpSequence → ℕ := BlowUpSequence.brecOn x✝ BlowUpSequence.length._f
def BlowUpSequence.length {X : Scheme} : X.BlowUpSequence → ℕ := BlowUpSequence.brecOn x✝ BlowUpSequence.length._f
The number
rof monoidal transformations in the succession. -
defdefined in Hironaka/Scheme/BlowUpSequence/Defs.leancomplete
The stage
X_i,0 ≤ i ≤ r, withX_0 = X. -
defdefined in Hironaka/Scheme/BlowUpSequence/Defs.leancomplete
def BlowUpSequence.center {X : Scheme} (S : X.BlowUpSequence) (i : Fin S.length) : (S.stage i.castSucc).IdealSheafData := BlowUpSequence.brecOn (motive := fun x x_1 => (x_2 : Fin x_1.length) → (x_1.stage x_2.castSucc).IdealSheafData) x✝¹ BlowUpSequence.center._f x✝
def BlowUpSequence.center {X : Scheme} (S : X.BlowUpSequence) (i : Fin S.length) : (S.stage i.castSucc).IdealSheafData := BlowUpSequence.brecOn (motive := fun x x_1 => (x_2 : Fin x_1.length) → (x_1.stage x_2.castSucc).IdealSheafData) x✝¹ BlowUpSequence.center._f x✝
The centre
D_i ⊆ X_iof thei-th monoidal transformation,0 ≤ i < r. -
defdefined in Hironaka/Scheme/BlowUpSequence/Defs.leancomplete
The partial composite
Π_i = f_0 ∘ ⋯ ∘ f_{i-1} : X_i ⟶ X(Kollár'sΠ_{i0}). -
-
defdefined in Hironaka/Scheme/BlowUpSequence/Defs.leancomplete
The composite
Π = f_0 ∘ ⋯ ∘ f_{r-1} : X_r ⟶ Xof the whole succession (Hironaka'sf).
-
BlowUpSequence.weakTransformSeq[complete] -
BlowUpSequence.boundarySeq[complete] -
BlowUpSequence.strictTransformSeq[complete]
Along a succession S, by recursion on the stages:
-
S.weakTransformSeq J iis Hironaka's sequence of weak transforms:J_0 = JandJ_{i+1}the weak transform ofJ_ialong thei-th blow-up (Definition 2.2.5.2); -
S.boundarySeq E iis Hironaka's sequence of boundaries:E_0 = EandE_{i+1} = \mathrm{red}(f_i^{-1}(E_i) \cup f_i^{-1}(D_i)); -
S.strictTransformSeq Y iis the strict transformY_iof a closed subschemeY[Kol07, Definition 30.2]; Włodarczyk'sY_i[Wlo05, Theorem 1.0.2 (b)].
Lean code for Definition2.4.1.2●3 definitions
Associated Lean declarations
-
BlowUpSequence.weakTransformSeq[complete]
-
BlowUpSequence.boundarySeq[complete]
-
BlowUpSequence.strictTransformSeq[complete]
-
BlowUpSequence.weakTransformSeq[complete] -
BlowUpSequence.boundarySeq[complete] -
BlowUpSequence.strictTransformSeq[complete]
-
defdefined in Hironaka/Scheme/BlowUpSequence/Defs.leancomplete
def BlowUpSequence.weakTransformSeq {X : Scheme} (S : X.BlowUpSequence) : X.IdealSheafData → (i : Fin (S.length + 1)) → (S.stage i).IdealSheafData := BlowUpSequence.brecOn (motive := fun x x_1 => x.IdealSheafData → (x_3 : Fin (x_1.length + 1)) → (x_1.stage x_3).IdealSheafData) x✝² BlowUpSequence.weakTransformSeq._f x✝¹ x✝
def BlowUpSequence.weakTransformSeq {X : Scheme} (S : X.BlowUpSequence) : X.IdealSheafData → (i : Fin (S.length + 1)) → (S.stage i).IdealSheafData := BlowUpSequence.brecOn (motive := fun x x_1 => x.IdealSheafData → (x_3 : Fin (x_1.length + 1)) → (x_1.stage x_3).IdealSheafData) x✝² BlowUpSequence.weakTransformSeq._f x✝¹ x✝
Hironaka's sequence of weak transforms:
J_0 = JandJ_{i+1}the weak transform ofJ_ibyf_i[Hir64, Main Theorem II (ii)]. -
defdefined in Hironaka/Scheme/BlowUpSequence/Defs.leancomplete
def BlowUpSequence.boundarySeq {X : Scheme} (S : X.BlowUpSequence) : X.IdealSheafData → (i : Fin (S.length + 1)) → (S.stage i).IdealSheafData := BlowUpSequence.brecOn (motive := fun x x_1 => x.IdealSheafData → (x_3 : Fin (x_1.length + 1)) → (x_1.stage x_3).IdealSheafData) x✝² BlowUpSequence.boundarySeq._f x✝¹ x✝
def BlowUpSequence.boundarySeq {X : Scheme} (S : X.BlowUpSequence) : X.IdealSheafData → (i : Fin (S.length + 1)) → (S.stage i).IdealSheafData := BlowUpSequence.brecOn (motive := fun x x_1 => x.IdealSheafData → (x_3 : Fin (x_1.length + 1)) → (x_1.stage x_3).IdealSheafData) x✝² BlowUpSequence.boundarySeq._f x✝¹ x✝
Hironaka's sequence of boundaries:
E_0 = EandE_{i+1} = red(f_i⁻¹(E_i) ∪ f_i⁻¹(D_i))[Hir64, Main Theorem II (iii); Main Theorem II(N) (3)] (II(N) writesred(f_i⁻¹(E_i ∪ D_i)), the same reduced subscheme: both are the reduced structure onf_i⁻¹(|E_i| ∪ |D_i|)). -
defdefined in Hironaka/Scheme/BlowUpSequence/Defs.leancomplete
def BlowUpSequence.strictTransformSeq {X : Scheme} (S : X.BlowUpSequence) : X.IdealSheafData → (i : Fin (S.length + 1)) → (S.stage i).IdealSheafData := BlowUpSequence.brecOn (motive := fun x x_1 => x.IdealSheafData → (x_3 : Fin (x_1.length + 1)) → (x_1.stage x_3).IdealSheafData) x✝² BlowUpSequence.strictTransformSeq._f x✝¹ x✝
def BlowUpSequence.strictTransformSeq {X : Scheme} (S : X.BlowUpSequence) : X.IdealSheafData → (i : Fin (S.length + 1)) → (S.stage i).IdealSheafData := BlowUpSequence.brecOn (motive := fun x x_1 => x.IdealSheafData → (x_3 : Fin (x_1.length + 1)) → (x_1.stage x_3).IdealSheafData) x✝² BlowUpSequence.strictTransformSeq._f x✝¹ x✝
The strict transform
Y_i ⊆ X_iof a closed subschemeY ⊆ Xalong the succession [Kol07, Definition 30.2]; Włodarczyk'sY_i[Wlo05, Theorem 1.0.2 (b)].
2.4.2. Divisor families and simple normal crossings
-
DivisorFamily[complete] -
DivisorFamily.ι[complete] -
DivisorFamily.component[complete] -
DivisorFamily.fintype[complete] -
DivisorFamily.linearOrder[complete] -
DivisorFamily.empty[complete] -
DivisorFamily.support[complete] -
DivisorFamily.singularLocus[complete] -
DivisorFamily.comap[complete]
Kollár's divisor E = \sum E^i with an ordered index set: a DivisorFamily X is a finite linearly
ordered index type ι (with its fintype and linearOrder) and a closed subscheme
component i for each index, given by its ideal sheaf. The order matters to Kollár's algorithm, in
which new exceptional divisors come after old ones. DivisorFamily.empty X is the empty divisor;
support is the set of points on at least one component and singularLocus
(\operatorname{Sing} E) the set of points on at least two; E.comap h is the inverse image
family h^{-1}(E) [Kol07, 34.1].
Lean code for Definition2.4.2.1●9 definitions
Associated Lean declarations
-
DivisorFamily[complete]
-
DivisorFamily.ι[complete]
-
DivisorFamily.component[complete]
-
DivisorFamily.fintype[complete]
-
DivisorFamily.linearOrder[complete]
-
DivisorFamily.empty[complete]
-
DivisorFamily.support[complete]
-
DivisorFamily.singularLocus[complete]
-
DivisorFamily.comap[complete]
-
DivisorFamily[complete] -
DivisorFamily.ι[complete] -
DivisorFamily.component[complete] -
DivisorFamily.fintype[complete] -
DivisorFamily.linearOrder[complete] -
DivisorFamily.empty[complete] -
DivisorFamily.support[complete] -
DivisorFamily.singularLocus[complete] -
DivisorFamily.comap[complete]
-
structuredefined in Hironaka/Scheme/Snc/Defs.leancomplete
structure DivisorFamily (X : Scheme) : Type (u + 1)
structure DivisorFamily (X : Scheme) : Type (u + 1)
Kollár's divisor
E = ∑ E^iwith ordered index set [Kol07, Definition 31]: a finite linearly ordered family of closed subschemesE^i ⊆ X, each given by its ideal sheaf.Fields
ι : Type u
The (finite, linearly ordered) index set.
fintype : Fintype self.ι
linearOrder : LinearOrder self.ι
component : self.ι → X.IdealSheafData
The ideal sheaf of the component
E^i. -
abbrevdefined in Hironaka/Scheme/Snc/Defs.leancomplete
abbrev DivisorFamily.ι {X : Scheme} (self : X.DivisorFamily) : Type u := self.1
abbrev DivisorFamily.ι {X : Scheme} (self : X.DivisorFamily) : Type u := self.1
The (finite, linearly ordered) index set.
-
abbrevdefined in Hironaka/Scheme/Snc/Defs.leancomplete
abbrev DivisorFamily.component {X : Scheme} (self : X.DivisorFamily) : self.ι → X.IdealSheafData := self.4
abbrev DivisorFamily.component {X : Scheme} (self : X.DivisorFamily) : self.ι → X.IdealSheafData := self.4
The ideal sheaf of the component
E^i. -
abbrevdefined in Hironaka/Scheme/Snc/Defs.leancomplete
abbrev DivisorFamily.fintype {X : Scheme} (self : X.DivisorFamily) : Fintype self.ι
abbrev DivisorFamily.fintype {X : Scheme} (self : X.DivisorFamily) : Fintype self.ι
-
abbrevdefined in Hironaka/Scheme/Snc/Defs.leancomplete
abbrev DivisorFamily.linearOrder {X : Scheme} (self : X.DivisorFamily) : LinearOrder self.ι
abbrev DivisorFamily.linearOrder {X : Scheme} (self : X.DivisorFamily) : LinearOrder self.ι
-
defdefined in Hironaka/Scheme/Snc/Defs.leancomplete
def DivisorFamily.empty (X : Scheme) : X.DivisorFamily := { ι := PEmpty.{u + 1}, fintype := Fintype.instPEmpty, linearOrder := instLinearOrderPEmpty, component := fun i => i.elim }
def DivisorFamily.empty (X : Scheme) : X.DivisorFamily := { ι := PEmpty.{u + 1}, fintype := Fintype.instPEmpty, linearOrder := instLinearOrderPEmpty, component := fun i => i.elim }
The empty divisor
E = ∅. -
defdefined in Hironaka/Scheme/Snc/Defs.leancomplete
def DivisorFamily.support {X : Scheme} (E : X.DivisorFamily) : TopologicalSpace.Closeds ↥X := ⨆ i, (E.component i).support
def DivisorFamily.support {X : Scheme} (E : X.DivisorFamily) : TopologicalSpace.Closeds ↥X := ⨆ i, (E.component i).support
The set of points lying on at least one component.
-
defdefined in Hironaka/Scheme/Snc/Defs.leancomplete
def DivisorFamily.singularLocus {X : Scheme} (E : X.DivisorFamily) : TopologicalSpace.Closeds ↥X := ⨆ i, ⨆ j, ⨆ (_ : i ≠ j), (E.component i).support ⊓ (E.component j).support
def DivisorFamily.singularLocus {X : Scheme} (E : X.DivisorFamily) : TopologicalSpace.Closeds ↥X := ⨆ i, ⨆ j, ⨆ (_ : i ≠ j), (E.component i).support ⊓ (E.component j).support
The singular locus
Sing Eof the divisor∑ E^i: the points lying on at least two components (where a simple normal crossing divisor is singular). The principalization of Theorem 35 is an isomorphism over the complement ofcosupp I ∪ Sing E(AlgebraicGeometry.exists_functorial_principalization). -
defdefined in Hironaka/Scheme/Snc/Defs.leancomplete
def DivisorFamily.comap {X Y : Scheme} (E : X.DivisorFamily) (h : Y ⟶ X) : Y.DivisorFamily := { ι := E.ι, fintype := E.fintype, linearOrder := E.linearOrder, component := fun i => (E.component i).comap h }
def DivisorFamily.comap {X Y : Scheme} (E : X.DivisorFamily) (h : Y ⟶ X) : Y.DivisorFamily := { ι := E.ι, fintype := E.fintype, linearOrder := E.linearOrder, component := fun i => (E.component i).comap h }
The inverse image family
h⁻¹(E)of [Kol07, 34.1].
-
DivisorFamily.IsSncAt[complete] -
DivisorFamily.IsSnc[complete] -
DivisorFamily.HasSncWith[complete]
Kollár's simple normal crossings, illustrated with Hironaka's notion in
Normal crossings. At a point x, E.IsSncAt x z says that
z_1, \dots, z_n is a regular system of parameters of \mathcal{O}_{X,x} and each component of
E through x is cut out near x by its own coordinate z_{c(i)}, distinct components by
distinct coordinates. E.IsSnc asks every component to be smooth and such coordinates to exist at
every point [Kol07, Definition 24 (1)–(3)]; since the coordinates are asked for also at the
points on no component, E.IsSnc makes X itself regular. E.HasSncWith Z says that at every
point of Z the coordinates can be chosen so that in addition Z is cut out by some of them
[Kol07, Definition 24 (4)]; some components may contain Z.
Lean code for Definition2.4.2.2●3 definitions
Associated Lean declarations
-
DivisorFamily.IsSncAt[complete]
-
DivisorFamily.IsSnc[complete]
-
DivisorFamily.HasSncWith[complete]
-
DivisorFamily.IsSncAt[complete] -
DivisorFamily.IsSnc[complete] -
DivisorFamily.HasSncWith[complete]
-
defdefined in Hironaka/Scheme/Snc/Defs.leancomplete
def DivisorFamily.IsSncAt {X : Scheme} (E : X.DivisorFamily) (x : ↥X) {n : ℕ} (z : Fin n → ↑(X.presheaf.stalk x)) : Prop := IsLocalRing.IsRegularSystemOfParameters z ∧ ∃ c, Function.Injective c ∧ ∀ (i : { i // x ∈ (E.component i).support }), (E.component ↑i).stalkIdeal x = Ideal.span {z (c i)}
def DivisorFamily.IsSncAt {X : Scheme} (E : X.DivisorFamily) (x : ↥X) {n : ℕ} (z : Fin n → ↑(X.presheaf.stalk x)) : Prop := IsLocalRing.IsRegularSystemOfParameters z ∧ ∃ c, Function.Injective c ∧ ∀ (i : { i // x ∈ (E.component i).support }), (E.component ↑i).stalkIdeal x = Ideal.span {z (c i)}
The simple normal crossing condition of [Kol07, Definition 24] at one point: the coordinates
z : Fin n → 𝒪_{X,x}form a regular system of parameters, and there is an injective assignmentcof a coordinate index to each component throughx(and only to those) withE^i = (z_{c(i)} = 0)nearx, that is(E^i)_x = (z_{c(i)}). -
defdefined in Hironaka/Scheme/Snc/Defs.leancomplete
def DivisorFamily.IsSnc {X : Scheme} (E : X.DivisorFamily) : Prop := (∀ (i : E.ι), AlgebraicGeometry.IsRegular (E.component i).subscheme) ∧ ∀ (x : ↥X), ∃ n z, E.IsSncAt x z
def DivisorFamily.IsSnc {X : Scheme} (E : X.DivisorFamily) : Prop := (∀ (i : E.ι), AlgebraicGeometry.IsRegular (E.component i).subscheme) ∧ ∀ (x : ↥X), ∃ n z, E.IsSncAt x z
Kollár's simple normal crossing divisor [Kol07, Definition 24 (1)–(3)]: each
E^iis smooth, and at each pointxthere are local coordinatesz_1, …, z_n ∈ 𝔪_x(a regular system of parameters of𝒪_{X,x}) such that every component throughxis(z_{c(i)} = 0)nearx, withc(i) ≠ c(i')for distinct components throughx(IsSncAt). -
defdefined in Hironaka/Scheme/Snc/Defs.leancomplete
def DivisorFamily.HasSncWith {X : Scheme} (E : X.DivisorFamily) (Z : X.IdealSheafData) : Prop := ∀ x ∈ Z.support, ∃ n z, E.IsSncAt x z ∧ ∃ s, Z.stalkIdeal x = Ideal.span (z '' ↑s)
def DivisorFamily.HasSncWith {X : Scheme} (E : X.DivisorFamily) (Z : X.IdealSheafData) : Prop := ∀ x ∈ Z.support, ∃ n z, E.IsSncAt x z ∧ ∃ s, Z.stalkIdeal x = Ideal.span (z '' ↑s)
[Kol07, Definition 24 (4)]: the closed subscheme
Zhas simple normal crossings withEif at each pointxofZone can choose the coordinatesz_1, …, z_nas inIsSncsuch that in additionZ = (z_{j_1} = ⋯ = z_{j_s} = 0)nearx.
Divisors with simple normal crossings, as ideal sheaves and as sets. IsIdealOfSncDivisor I says
that I is the ideal sheaf of an effective divisor \sum a_j F_j supported on a simple normal
crossings family F (Definition 2.4.2.2); Kollár's principalization makes the pull-back of an
ideal sheaf of this form [Kol07, Theorem 35 (2)]. IsSncDivisor Z says that the set Z is
the support of a simple normal crossings divisor family [Kol07, Definition 24], with its reduced
structure; a strong resolution asks this of the preimage of the singular locus [Kol07, (3)].
Lean code for Definition2.4.2.3●2 definitions
Associated Lean declarations
-
IsIdealOfSncDivisor[complete]
-
IsSncDivisor[complete]
-
IsIdealOfSncDivisor[complete] -
IsSncDivisor[complete]
-
defdefined in Hironaka/Scheme/Snc/Defs.leancomplete
Iis the ideal sheaf of an effective divisor∑ a_j F_jsupported on a simple normal crossing familyF[Kol07, Theorem 35 (2) and its proof in 72]. -
defdefined in Hironaka/Scheme/Resolution/Defs.leancomplete
Zis the support of a simple normal crossing divisor onX[Kol07, Definition 24].
-
DivisorFamily.totalTransform[complete] -
BlowUpSequence.totalTransformSeq[complete]
Kollár's total transform of a divisor family under one blow-up with centre D is the family of the
birational transforms of the components of E, followed by the exceptional divisor f^{-1}(D)
with the largest index (DivisorFamily.totalTransform, [Kol07, Definitions 25 and 65]).
Along a succession it gives
E_i = (\pi_0 \cdots \pi_{i-1})^{-1}_*(E) + \mathrm{Ex}_{tot}(\pi_0 \cdots \pi_{i-1})
(BlowUpSequence.totalTransformSeq); starting from the empty family it is the family of
exceptional divisors, as in the embedded desingularization theorem (Theorem 4.2.10.4).
Lean code for Definition2.4.2.4●2 definitions
Associated Lean declarations
-
DivisorFamily.totalTransform[complete]
-
BlowUpSequence.totalTransformSeq[complete]
-
DivisorFamily.totalTransform[complete] -
BlowUpSequence.totalTransformSeq[complete]
-
defdefined in Hironaka/Scheme/Snc/Defs.leancomplete
def DivisorFamily.totalTransform {X : Scheme} (E : X.DivisorFamily) (D : X.IdealSheafData) : D.blowUp.DivisorFamily := { ι := E.ι ⊕ₗ PUnit.{u + 1}, fintype := Lex.fintype (E.ι ⊕ PUnit.{u + 1}), linearOrder := Sum.Lex.linearOrder, component := fun i => Sum.elim (fun j => (E.component j).strictTransform D) (fun x => D.exceptionalDivisor) (ofLex i) }
def DivisorFamily.totalTransform {X : Scheme} (E : X.DivisorFamily) (D : X.IdealSheafData) : D.blowUp.DivisorFamily := { ι := E.ι ⊕ₗ PUnit.{u + 1}, fintype := Lex.fintype (E.ι ⊕ PUnit.{u + 1}), linearOrder := Sum.Lex.linearOrder, component := fun i => Sum.elim (fun j => (E.component j).strictTransform D) (fun x => D.exceptionalDivisor) (ofLex i) }
The total transform of [Kol07, Definition 25] under one blow-up with centre
D: the birational transforms of the components ofE, followed by the exceptional divisorf⁻¹(D), which receives the largest index (new divisors come after old ones, [Kol07, Definition 65]). -
defdefined in Hironaka/Scheme/BlowUpSequence/Defs.leancomplete
def BlowUpSequence.totalTransformSeq {X : Scheme} (S : X.BlowUpSequence) : X.DivisorFamily → (i : Fin (S.length + 1)) → (S.stage i).DivisorFamily := BlowUpSequence.brecOn (motive := fun x x_1 => x.DivisorFamily → (x_3 : Fin (x_1.length + 1)) → (x_1.stage x_3).DivisorFamily) x✝² BlowUpSequence.totalTransformSeq._f x✝¹ x✝
def BlowUpSequence.totalTransformSeq {X : Scheme} (S : X.BlowUpSequence) : X.DivisorFamily → (i : Fin (S.length + 1)) → (S.stage i).DivisorFamily := BlowUpSequence.brecOn (motive := fun x x_1 => x.DivisorFamily → (x_3 : Fin (x_1.length + 1)) → (x_1.stage x_3).DivisorFamily) x✝² BlowUpSequence.totalTransformSeq._f x✝¹ x✝
Kollár's total transform
E_i = (π_0 ⋯ π_{i-1})⁻¹_*(E) + Ex_tot(π_0 ⋯ π_{i-1})of a divisor family at stageiof the succession [Kol07, Definition 25].
2.4.3. Operations on successions
For a succession S of X and a morphism h \colon Y \to X, the pull-back h^* S blows
up, at each stage, the inverse image of the corresponding centre (S.pullback h). For smooth
h its stages are the fibre products X_i \times_X Y
(The universal property): it does on Y what S does on X. For a
projection X \times \mathbb{A}^1 \to X the pull-back is S \times \mathbb{A}^1; for an open
immersion U \hookrightarrow X it is the restriction of S to U, in which a centre disjoint
from U becomes the empty centre.
-
BlowUpSequence.pullback[complete] -
BlowUpSequence.eraseEmpty[complete] -
BlowUpSequence.pushforward[complete]
These operations compare successions on different schemes:
-
S.pullback his the pull-backh^* Salongh \colon Y \to X[Kol07, Definition 30.1]: blow up the inverse images of the centres, using the induced morphisms of blow-ups (Definition 2.2.3.1); for smooth (more generally flat)hthe stages areX_i \times_X Y; -
S.eraseEmptydeletes every blow-up whose centre is empty and reindexes the rest [Kol07, 32 and 34.1], carrying the tail back along the isomorphism of the empty blow-up; -
S.pushforward jis the push-forwardj_* Sof a succession on a closed subscheme along the closed immersionj[Kol07, Definition 30.3]: the centres viewed in the ambient stages (Scheme.Hom.pushforwardBlowUp, Definition 2.2.5.1).
A pulled-back succession may have empty centres where the image of h misses a centre, which is
why, for a non-surjective h, the functorial theorems compare with (S.pullback h).eraseEmpty.
Lean code for Definition2.4.3.1●3 definitions
Associated Lean declarations
-
BlowUpSequence.pullback[complete]
-
BlowUpSequence.eraseEmpty[complete]
-
BlowUpSequence.pushforward[complete]
-
BlowUpSequence.pullback[complete] -
BlowUpSequence.eraseEmpty[complete] -
BlowUpSequence.pushforward[complete]
-
defdefined in Hironaka/Scheme/BlowUpSequence/Defs.leancomplete
def BlowUpSequence.pullback {X : Scheme} : X.BlowUpSequence → {Y : Scheme} → (Y ⟶ X) → Y.BlowUpSequence := BlowUpSequence.brecOn (motive := fun x x_1 => (x_2 : Scheme) → (x_2 ⟶ x) → x_2.BlowUpSequence) x✝² BlowUpSequence.pullback._f x✝¹ x✝
def BlowUpSequence.pullback {X : Scheme} : X.BlowUpSequence → {Y : Scheme} → (Y ⟶ X) → Y.BlowUpSequence := BlowUpSequence.brecOn (motive := fun x x_1 => (x_2 : Scheme) → (x_2 ⟶ x) → x_2.BlowUpSequence) x✝² BlowUpSequence.pullback._f x✝¹ x✝
The pull-back
h^* Bof a succession alongh : Y ⟶ X[Kol07, Definition 30.1]: blow up the inverse image centresh⁻¹(Z_i); for smooth (more generally flat)hthe stages areX_i ×_X Y. -
defdefined in Hironaka/Scheme/BlowUpSequence/Defs.leancomplete
def BlowUpSequence.eraseEmpty {X : Scheme} : X.BlowUpSequence → X.BlowUpSequence := BlowUpSequence.brecOn x✝ BlowUpSequence.eraseEmpty._f
def BlowUpSequence.eraseEmpty {X : Scheme} : X.BlowUpSequence → X.BlowUpSequence := BlowUpSequence.brecOn x✝ BlowUpSequence.eraseEmpty._f
Delete every blow-up whose centre is empty (the unit ideal sheaf
⊤) and reindex the remaining ones [Kol07, 32 and 34.1]. The empty blow-upcons X ⊤ restis removed by carrying its tailrest, a succession onblowUp X ⊤, back toXalong the inverse of the isomorphismblowUpπ X ⊤(the empty blow-up is trivial, [Kol07, Warning 20]:isInvertible_top,blowUp.isIso_π_of_isInvertible), which ispullbackalong that inverse. -
defdefined in Hironaka/Scheme/BlowUpSequence/Defs.leancomplete
def BlowUpSequence.pushforward {Y : Scheme} : Y.BlowUpSequence → {X : Scheme} → (j : Y ⟶ X) → [IsClosedImmersion j] → X.BlowUpSequence := BlowUpSequence.brecOn (motive := fun x x_1 => (x_2 : Scheme) → (x_3 : x ⟶ x_2) → IsClosedImmersion x_3 → x_2.BlowUpSequence) x✝³ BlowUpSequence.pushforward._f x✝² x✝¹ x✝
def BlowUpSequence.pushforward {Y : Scheme} : Y.BlowUpSequence → {X : Scheme} → (j : Y ⟶ X) → [IsClosedImmersion j] → X.BlowUpSequence := BlowUpSequence.brecOn (motive := fun x x_1 => (x_2 : Scheme) → (x_3 : x ⟶ x_2) → IsClosedImmersion x_3 → x_2.BlowUpSequence) x✝³ BlowUpSequence.pushforward._f x✝² x✝¹ x✝
The push-forward
j_* B(S)of a succession on a closed subschemeS ⊆ Xalong the closed immersionj : S ⟶ X[Kol07, Definition 30.3]: the centresZ_i^Sviewed inX_i,Z_i^X := (j_i)_* Z_i^Salong the inclusionsj_i : S_i ↪ X_i(pushforwardBlowUp). The instance argument[IsClosedImmersion j]is what makes the recursion well defined:pushforwardBlowUpexists only for closed immersions.
2.4.4. Blow-up sequence functors
Hironaka's theorems assert that, for each input, a succession of blow-ups with the required
properties exists. Kollár's and Włodarczyk's assert more: one rule, a blow-up sequence functor
B, assigns a succession B(X) to every input X at once [Kol07, 31 and 34]. The inputs
form a category, which differs from theorem to theorem (triples, disjoint unions of varieties,
embedded pairs), and each input has an underlying algebraic k-scheme. As defined, B is data
on objects only; its compatibility with smooth morphisms and with change of the base field is a
property that the theorems assert, explained with functorial principalization
(Functorial principalization).
-
HasUnderlyingScheme[complete] -
HasUnderlyingScheme.forget[complete] -
HasUnderlyingScheme.scheme[complete] -
HasUnderlyingScheme.hom[complete] -
BlowUpSequenceFunctor[complete]
HasUnderlyingScheme C k equips a category of inputs C with a functor forget to
AlgScheme k; scheme X is the underlying scheme of an input and hom h the underlying morphism
of schemes of a morphism of inputs. A blow-up sequence functor BlowUpSequenceFunctor C assigns
to every input X a succession of blow-ups B X : BlowUpSequence (scheme X) of its underlying
scheme [Kol07, Definition 31]. It carries no conditions: the conditions on the values, and the
compatibility with smooth morphisms (Definition 4.2.4.3), are asserted by the main
theorems, which quantify over the input so that a single functor works for all inputs, and over the
field so that a single family of functors works for all fields.
Lean code for Definition2.4.4.1●5 definitions
Associated Lean declarations
-
HasUnderlyingScheme[complete]
-
HasUnderlyingScheme.forget[complete]
-
HasUnderlyingScheme.scheme[complete]
-
HasUnderlyingScheme.hom[complete]
-
BlowUpSequenceFunctor[complete]
-
HasUnderlyingScheme[complete] -
HasUnderlyingScheme.forget[complete] -
HasUnderlyingScheme.scheme[complete] -
HasUnderlyingScheme.hom[complete] -
BlowUpSequenceFunctor[complete]
-
classdefined in Hironaka/Scheme/Resolution/Defs.leancomplete
class HasUnderlyingScheme (C : Type u_1) [Category.{u, u_1} C] (k : outParam (Type u)) [Field k] : Type (max (u + 1) u_1)
class HasUnderlyingScheme (C : Type u_1) [Category.{u, u_1} C] (k : outParam (Type u)) [Field k] : Type (max (u + 1) u_1)
-
abbrevdefined in Hironaka/Scheme/Resolution/Defs.leancomplete
abbrev HasUnderlyingScheme.forget {C : Type u_1} {inst✝ : Category.{u, u_1} C} {k : outParam (Type u)} {inst✝¹ : Field k} [self : HasUnderlyingScheme C k] : C ⥤ AlgScheme k := self.1
abbrev HasUnderlyingScheme.forget {C : Type u_1} {inst✝ : Category.{u, u_1} C} {k : outParam (Type u)} {inst✝¹ : Field k} [self : HasUnderlyingScheme C k] : C ⥤ AlgScheme k := self.1
The underlying algebraic
k-scheme. -
abbrevdefined in Hironaka/Scheme/Resolution/Defs.leancomplete
abbrev HasUnderlyingScheme.scheme {C : Type u_1} [Category.{u, u_1} C] {k : Type u} [Field k] [HasUnderlyingScheme C k] (X : C) : Scheme := (HasUnderlyingScheme.forget.obj X).left
abbrev HasUnderlyingScheme.scheme {C : Type u_1} [Category.{u, u_1} C] {k : Type u} [Field k] [HasUnderlyingScheme C k] (X : C) : Scheme := (HasUnderlyingScheme.forget.obj X).left
The underlying scheme of an input.
-
abbrevdefined in Hironaka/Scheme/Resolution/Defs.leancomplete
abbrev HasUnderlyingScheme.hom {C : Type u_1} [Category.{u, u_1} C] {k : Type u} [Field k] [HasUnderlyingScheme C k] {X Y : C} (h : X ⟶ Y) : HasUnderlyingScheme.scheme X ⟶ HasUnderlyingScheme.scheme Y := (HasUnderlyingScheme.forget.map h).left
abbrev HasUnderlyingScheme.hom {C : Type u_1} [Category.{u, u_1} C] {k : Type u} [Field k] [HasUnderlyingScheme C k] {X Y : C} (h : X ⟶ Y) : HasUnderlyingScheme.scheme X ⟶ HasUnderlyingScheme.scheme Y := (HasUnderlyingScheme.forget.map h).left
The underlying morphism of schemes of a morphism of inputs.
-
abbrevdefined in Hironaka/Scheme/Resolution/Defs.leancomplete
abbrev BlowUpSequenceFunctor (C : Type u_1) [Category.{u, u_1} C] {k : Type u} [Field k] [HasUnderlyingScheme C k] : Type (max (u + 1) u_1) := (X : C) → (HasUnderlyingScheme.scheme X).BlowUpSequence
abbrev BlowUpSequenceFunctor (C : Type u_1) [Category.{u, u_1} C] {k : Type u} [Field k] [HasUnderlyingScheme C k] : Type (max (u + 1) u_1) := (X : C) → (HasUnderlyingScheme.scheme X).BlowUpSequence
A blow-up sequence functor on the inputs
C[Kol07, Definition 31]: a succession of blow-ups of the underlying scheme of every input. Kollár's inputs are triples(X, I, E); for Theorem 36 they are schemes.