# Varieties

## Basic invariants

IntersectionTheory.hilbert_polynomialFunction
hilbert_polynomial(F::AbsBundle)
hilbert_polynomial(X::AbsVariety)

Compute the Hilbert polynomial of a bundle $F$ or the Hilbert polynomial of $X$ itself, with respect to the polarization $\mathcal O_X(1)$ on $X$.

source

### Examples

julia> degree(grassmannian(2, 4))
2

julia> euler(grassmannian(2, 4))
6

julia> hilbert_polynomial(proj(3))
1//6*t^3 + t^2 + 11//6*t + 1

## Characteristic classes

By common abuse of notations, the Chern/Todd/... class of a variety will mean the Chern/Todd/... class of its tangent bundle.

IntersectionTheory.chern_numberFunction
chern_number(X::Variety, λ::Int...)
chern_number(X::Variety, λ::AbstractVector)

Compute the Chern number $c_\lambda (X):=\int_X c_{\lambda_1}(X)\cdots c_{\lambda_k}(X)$, where $\lambda:=(\lambda_1,\dots,\lambda_k)$ is a partition of the dimension of $X$.

source
IntersectionTheory.chern_numbersMethod
chern_numbers(X::Variety)
chern_numbers(X::Variety, P::Vector{<:Partition})

Compute all the Chern numbers of $X$ as a dictionary of $\lambda\Rightarrow c_\lambda(X)$, or only those corresponding to partitions in a given vector.

source

We also have the following functions for producing generic formulae.

### Examples

julia> chern(proj(2))
1 + 3*h + 3*h^2

julia> todd(proj(2))
1 + 3//2*h + h^2

julia> pontryagin(proj(2))
1 + 3*h^2

julia> chern_number(proj(3), [2,1])
24

julia> chern_numbers(proj(3))
Dict{AbstractAlgebra.Generic.Partition{Int64}, Nemo.fmpq} with 3 entries:
1₃   => 64
2₁1₁ => 24
3₁   => 4

julia> a_hat_genus(proj(2))
-1//8

julia> signature(proj(2))
1

julia> signature(complete_intersection(proj(3), 4)) # signature of a K3 surface
-16
julia> todd(2)
1 + 1//2*c₁ + 1//12*c₁^2 + 1//12*c₂

julia> a_hat_genus(2)
1 - 1//24*p₁ + 7//5760*p₁^2 - 1//1440*p₂

julia> l_genus(2)
1 + 1//3*p₁ - 1//45*p₁^2 + 7//45*p₂

## Chow ring

AbstractAlgebra.Generic.basisFunction
basis(X::AbsVariety)

Return an additive basis of the Chow ring of $X$, grouped by increasing degree (i.e., increasing codimension).

source
basis(k::Int, X::AbsVariety)

Return an additive basis of the Chow ring of $X$ in codimension $k$.

source
Singular.bettiFunction
betti(X::AbsVariety)

Return the Betti numbers of the Chow ring of $X$. Note that these are not necessarily equal to the usual Betti numbers, i.e., the dimensions of (co)homologies.

source
AbstractAlgebra.integralMethod
integral(x::ChRingElem)

Compute the integral of a Chow ring element.

If the variety $X$ has a (unique) point class X.point, the integral will be a number (an fmpq or a function field element). Otherwise the 0-dimensional part of $x$ is returned.

source
IntersectionTheory.dual_basisFunction
dual_basis(k::Int, X::AbsVariety)

Compute the dual basis of the additive basis in codimension $k$ given by basis(k, X) (the returned elements are therefore in codimension $\dim X-k$).

source
dual_basis(X::AbsVariety)

Compute the dual basis with respect to the additive basis given by basis(X), grouped by decreasing degree (i.e., decreasing codimension).

source
IntersectionTheory.intersection_matrixFunction
intersection_matrix(a::Vector)
intersection_matrix(a::Vector, b::Vector)
intersection_matrix(X::AbsVariety)

Compute the intersection matrix among entries of a vector $a$ of Chow ring elements, or between two vectors $a$ and $b$. For a variety $X$, this computes the intersection matrix of the additive basis given by basis(X).

source

Methods for Grassmannians.

IntersectionTheory.schubert_classMethod
schubert_class(G::AbsVariety, λ::Int...)
schubert_class(G::AbsVariety, λ::AbstractVector)

Return the Schubert class $\sigma_\lambda$ on a (relative) Grassmannian $G$.

source

### Examples

julia> basis(proj(2))
3-element Vector{Vector{IntersectionTheory.ChRingElem}}:

[h]
[h^2]

julia> G = grassmannian(2, 4)
AbsVariety of dim 4

julia> basis(G)
5-element Vector{Vector{IntersectionTheory.ChRingElem}}:

[c₁]
[c₂, c₁^2]
[c₁*c₂]
[c₂^2]

julia> dual_basis(G)
5-element Vector{Vector{IntersectionTheory.ChRingElem}}:
[c₂^2]
[c₁*c₂]
[-c₁^2 + 2*c₂, c₁^2 - c₂]
[c₁]


julia> betti(G)
5-element Vector{Int64}:
1
1
2
1
1

julia> basis(2, G)
2-element Vector{IntersectionTheory.ChRingElem}:
c₂
c₁^2

julia> intersection_matrix(basis(2, G))
[1   1]
[1   2]

julia> intersection_matrix(basis(2, G), dual_basis(2, G))
[1   0]
[0   1]

julia> intersection_matrix(G)
[0   0   0   0   0   1]
[0   0   0   0   1   0]
[0   0   1   1   0   0]
[0   0   1   2   0   0]
[0   1   0   0   0   0]
[1   0   0   0   0   0]

julia> schubert_class(G, [1,1])
c₂

julia> schubert_classes(2, G)
2-element Vector{IntersectionTheory.ChRingElem}:
c₁^2 - c₂
c₂

Notice that intersection_matrix(X) contains a lot of redundant information: intersection numbers that are not in complementary codimensions are always 0. So usually it is better to separate the components in different codimensions.

## Construct new varieties

Base.:*Method
*(X::AbsVariety, Y::AbsVariety)

Construct the product variety $X\times Y$. If both $X$ and $Y$ have a polarization, $X\times Y$ will be endowed with the polarization of the Segre embedding.

source
IntersectionTheory.complete_intersectionFunction
complete_intersection(X::AbsVariety, degs::Int...)
complete_intersection(X::AbsVariety, degs::Vector{Int})

Construct the complete intersection in $X$ of general hypersurfaces with degrees $d_1,\dots,d_k$.

source
IntersectionTheory.section_zero_locusFunction
section_zero_locus(F::AbsBundle)

Construct the zero locus of a general section of a bundle $F$.

Use the argument class=true to only compute the class of the zero locus (same as ctop(F)).

source
IntersectionTheory.degeneracy_locusFunction
degeneracy_locus(k::Int, F::AbsBundle, G::AbsBundle)

Construct the $k$-degeneracy locus for a general bundle map from $F$ to $G$.

Use the argument class=true to only compute the class of the degeneracy locus.

source

### Examples

julia> proj(1) * proj(1)
AbsVariety of dim 2

julia> complete_intersection(proj(3), 4)
AbsVariety of dim 2

julia> section_zero_locus(OO(proj(3), 4))
AbsVariety of dim 2

julia> X, (A, B) = variety(2, [3=>"a", 4=>"b"]);

julia> D = degeneracy_locus(2, A, B)
AbsVariety of dim 0

julia> pushforward(D → X, D(1))
a₁^2 - a₁*b₁ - a₂ + b₂

julia> degeneracy_locus(2, A, B, class=true)
a₁^2 - a₁*b₁ - a₂ + b₂