# Constructors

## Generic varieties

The following constructors are available for building generic varieties.

IntersectionTheory.varietyFunction
variety(n::Int, symbols::Vector{String}, degs::Vector{Int})

Construct a generic variety of dimension $n$ with some classes in given degrees.

Return the variety and the list of classes.

source
variety(n::Int, bundles::Vector{Pair{Int, T}}) where T

Construct a generic variety of dimension $n$ with some bundles of given ranks.

Return the variety and the list of bundles.

source
variety(n::Int)

Construct a generic variety of dimension $n$ and define its tangent bundle.

Return the variety.

source

### Examples

julia> X, (h, c1, c2) = variety(2, ["h", "c1", "c2"], [1, 1, 2])
(AbsVariety of dim 2, IntersectionTheory.ChRingElem[h, c1, c2])

julia> Y, (E,) = variety(2, [3 => "c"])
(AbsVariety of dim 2, IntersectionTheory.AbsBundle[AbsBundle of rank 3 on AbsVariety of dim 2])

julia> chern(E)
1 + c₁ + c₂

julia> Z = variety(2)
AbsVariety of dim 2

julia> chern(tangent_bundle(Z))
1 + c₁ + c₂

julia> point()
AbsVariety of dim 0

julia> curve(3)
AbsVariety of dim 1

julia> euler(curve("g"))
-2*g + 2

For all the above constructors, one can use the param argument to introduce parameters. Basically, this will change the coefficient ring of the Chow ring to a Singular's FunctionField. One can also directly pass the function field using the base argument.

julia> C, d = curve("g", param="d")
(AbsVariety of dim 1, d)

julia> chi(OO(C, d*C.point))
-g + d + 1

julia> S, (E,), d = variety(2, [2 => "c"], param="d")
(AbsVariety of dim 2, IntersectionTheory.AbsBundle[AbsBundle of rank 2 on AbsVariety of dim 2], d)

julia> chern(d*E)
1 + d*c₁ + (d^2 - d)//2*c₁^2 + d*c₂

julia> F = base_ring(S)
Function Field over Rational Field with transcendence basis Singular.n_transExt[d]

julia> X = variety(3, base=F)
AbsVariety of dim 3

julia> d*OO(X)
AbsBundle of rank d on AbsVariety of dim 3
Note

The generic varieties are created without any relations by default. There are of course trivial relations due to dimension (i.e., all classes with codimension larger than the dimension of the variety must be zero). Use trim! on the Chow ring will add these relations and make the quotient ring Artinian. Then we will be able to compute basis, betti, and related things.

## Projective spaces, Grassmannians, flag varieties

The following constructors are available.

IntersectionTheory.projMethod
proj(n::Int)

Construct an abstract projective space of dimension $n$, parametrizing 1-dimensional subspaces of a vector space of dimension $n+1$.

source
IntersectionTheory.grassmannianMethod
grassmannian(k::Int, n::Int; bott::Bool=false)

Construct an abstract Grassmannian $\mathrm{Gr}(k, n)$, parametrizing $k$-dimensional subspaces of an $n$-dimensional vector space.

Use the argument bott=true to construct the Grassmannian as a TnVariety for computing integrals using Bott's formula.

source
IntersectionTheory.flagMethod
flag(dims::Int...; bott::Bool=false)
flag(dims::Vector{Int}; bott::Bool=false)

Construct an abstract flag variety $\mathrm{Fl}(d_1,\dots,d_k)$, parametrizing flags of subspaces $V_{d_1}\subset V_{d_2}\subset\cdots\subset V_{d_k}=V$.

Use the argument bott=true to construct the flag variety as a TnVariety for computing integrals using Bott's formula.

source
Note

Mathematically $\mathrm{Fl}(k, n)$ is exactly the same as $\mathrm{Gr}(k, n)$. The difference is that the Chow ring returned by grassmannian uses only $k$ generators instead of $n$.

### Examples

julia> proj(2)
AbsVariety of dim 2

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

julia> grassmannian(2, 4, bott=true)
TnVariety of dim 4

julia> flag(1, 3, 5)
AbsVariety of dim 8

julia> flag([1, 3, 5])
AbsVariety of dim 8

Again one can use the param and base arguments to introduce parameters.

julia> P2, d = proj(2, param="d");

julia> chern(OO(P2, d))
1 + d*h

julia> 1 - euler(complete_intersection(P2, d))//2
(d^2 - 3*d + 2)//2

julia> symmetric_power(d, 2OO(P2))
AbsBundle of rank d + 1 on AbsVariety of dim 2

## Projective bundles, relative flag varieties

In the relative setting, the following constructors are available.

IntersectionTheory.flagMethod
flag(d::Int, F::AbsBundle)
flag(dims::Vector{Int}, F::AbsBundle)

Construct the relative flag variety of a bundle $F$, parametrizing flags of subspaces $V_{d_1}\subset V_{d_2}\subset\cdots\subset V_{d_k}$. The last dimension (i.e., the rank of $F$) can be omitted.

source

## Moduli spaces of matrices, parameter spaces of twisted cubics

IntersectionTheory.matrix_moduliFunction
matrix_moduli(q::Int, m::Int, n::Int)
matrix_moduli(V::AbsBundle, m::Int, n::Int)

Construct the moduli space $N(q;m,n)$ of $n\times m$ matrices of linear forms on a $q$-dimensional vector space, or relative to a rank-$q$ vector bundle $V$.

source
IntersectionTheory.twisted_cubicsFunction
twisted_cubics()
twisted_cubics(V::AbsBundle)

Construct the parameter space $H$ of twisted cubics in $\mathbf P^3$, or relative to a rank-4 vector bundle $V$, as the blowup of the matrix moduli space $X$ along $i:I\hookrightarrow X$.

Return the parameter space $H$ and the exceptional divisor $Y$.

source
IntersectionTheory.twisted_cubics_on_cubic_fourfoldFunction
twisted_cubics_on_cubic_fourfold()

Compute the Euler number of the LLSvS eightfold $Z$ associated to a cubic fourfold.

Use the argument M3=true to return the 10-dimensional parameter space $M_3$ of twisted cubics on a cubic fourfold. The Euler number of $Z$ can then be obtained as $e(Z) = \frac13e(M_3)-81$.

source
Warning

The various twisted_cubics functions produce the same result as Chow, however I cannot reproduce the intersection numbers found by Schubert. More investigation is needed.

### Examples

A general degree-30 K3 surface can be realized as a zero locus on $N(4;2,3)$, by results of Mukai.

julia> X = matrix_moduli(4,2,3)
AbsVariety of dim 12

julia> S = section_zero_locus(2dual(sum(bundles(X))))
AbsVariety of dim 2

julia> chi(OO(S)), euler(S), chern(1, S) # the numerical invariants of a K3 surface
(2, 24, 0)

julia> S.O1 = -basis(1, S)[1]; degree(S)
30

## Others

IntersectionTheory.linear_subspaces_on_hypersurfaceFunction
linear_subspaces_on_hypersurface(k::Int, d::Int)

Compute the number of $k$-dimensional subspaces on a generic degree-$d$ hypersurface in a projective space of dimension $n=\frac1{k+1}\binom{d+k}d+k$.

The computation uses Bott's formula by default. Use the argument bott=false to switch to Schubert calculus.

source

### Examples

julia> IntersectionTheory.linear_subspaces_on_hypersurface(1, 3)
27