Wit-Functions

WIT
Web Intersection Theory
© S. Xambó
⌊ ⌋ ⊕
User's guide

This page (work in progress) provides descriptions of all the functions in the Wit package that are available thorough the interface WIT.

The description of the algorithms on which the Wit functions are based will appear in the Wit manual (under preparation, but to be linked here).

Warning. If the parameters of a function call do not satisfy the specified conditions in its definition, there will be an error at the Wit/Tau level. Debugging this sort of errors may be hard, as the current WIT interface only gives indirect information on them.

INDEX

Introduction
Low level module
Power functions
Data types
Sheaves and bundles
Varieties
Chow rings
Morphisms
Multiple points

Introduction

The Wit functions are grouped into 'modules'. To each of these modules we devote one of the sections below. Each section describes the functions in the module by giving the call forms and the results that these calls produce.

When there are examples indicated at the end of the function descriptions, they always refer to examples that can be inspected and run at the WIT interface. The reader may find it convenient to link this interface to a tab of the window opened to browse this file.

References

  [F] W. Fulton, Intersection Theory, 2nd edition.
       Ergebnisse 2 (3. Folge),
       Springer Verlag, 1997.

  [X] S. Xambó, Using Intersection Theory.
       Aportaciones Matemáticas, Nivel avanzado 7,
       Sociedad Matemática Mexicana, 1996.

» Index

Low level module

rankblock (A: Matrix)

If A has rank r, this function returns a triple {B, I, J} consisting of a non-singular rxr submatrix B of A and the lists I and J of the row and column indices of A corresponding to the rows and columns of B.

Examples: rankblock.wit

wdeg (p: Polynomial, r: Vector | List)

If p is a polynomial in the variables x₁,...,x_n and r₁,...,r_n are positive integers, the value of the expression wdeg(p,[r₁,...,r_n]), or wdeg(p,{r₁,...,r_n}), is the degree of p when x_i has degree (weight) r_i, i = 1,...,n.
Examples: wdeg.wit

strip (R: Relation)

This function selects the relators x->v of R such that v≠0.
Examples: strip.wit

» Index

Power functions

pad (c: Vector | List, r: Nat)

If the length of c is n, and r≤n, the value of this function coincides with take(c,r). Otherwise it appends r−n zeroes to the right of c.

Examples: vectors.wit

dual (c: Vector)

If c=[c₁,...,c_n], dual (c) returns the vector obtained replacing c_i by (−1)ⁱc_i.
Examples: vectors.wit

invert (c: Vector, r: Nat)
invert (c: Vector)

If c=[c₁,...,c_n], invert(c,r) yields the vector s=[s₁,...,s_r] whose components are the first r coefficients of the power series inverse of the polynomial 1+c₁T+···+c_nTⁿ, so that 1/(1+c₁T+···+c_nTⁿ)= 1+s₁T+···+s_rT^r+···. In other words, (1+c₁T+···+c_nTⁿ)· (1+s₁T+···+s_rT^r) ≡ 1 mod T^r+1.
The call invert(c) is equivalent to invert(c,n), with n=length(c).
Examples: vectors.wit

todd_numbers (n: Nat)

Computes the vector invert(dual([u₁,...,u_n])), where u_j=1/(1+j)!.
Examples: vectors.wit

s2n (s: Vector, r: Nat)
n2s (s: Vector, r: Nat)
s2n (c: Vector)
n2s (c: Vector)

If s = [s₁,s₂,...,s_n] are the elementary symmetric polynomials in the variables x₁,x₂,...,x_n, then s2n(s,r) yields the vector n = [n₁,n₂,...,n_r], where n_j = x₁^j+···+x_n^j (the j-th Newton sum on the variables x₁,x₂,...,x_n).
Converely, if n = [n₁,n₂,...,n_m], with n_j the j-th Newton sum on the variables x₁,x₂,...,x_n, and r ≤ m, then n2s(n,r) yields the vector [s₁,...,s_r], where s_j is the j-th symmetric polynomial in the variables x₁,x₂,...,x_n, with the convention that s_j = 0 for j>n.
The call s2n(c) is equivalent to s2n(c,k), where k=length(c), and the call n2s(n) is defined similarly.
Examples: s2n.wit, n2s.wit.

c2p (c: Vector, r: Nat)
p2c (p: Vector, r: Nat)
c2p (c: Vector)
p2c (p: Vector)

If s2n(c,r) = [n₁,...,n_r], the function c2p(c,r) returns the vector [ n₁/1!, ... ,n_r / r! ]. The call c2p(c) is defined as c2p(c,r) with r = length(c). These functions are used to transform the vector of chern classes of a sheaf into the corresponding chern character vector.
If p = [p₁,...,p_m], and r≤m, then p2c(p,r) computes n2s(n,r), where n = [ 1!·p₁, ... ,m!·p_m ], and p2c(p) is defined as p2c(p,r) with r = length(p). These functions are used to transform the chern character vector of a sheaf into the corresponding vector chern of chern classes.
Examples: c2p.wit, p2c.wit.

monomial (X: List | Vector, E: List | Vector)

If X={x₁,...,x_n} and E={e₁,...,e_m} and m≥n, it returns the value of the expression x₁^e₁··· x_n^e_n.
Examples: monomials.wit.

monomial_list (x: Vector | List, d: Vector | List, n: Nat)

Given variables x₁,x₂,...,x_r of positive degrees d={d₁,d₂,...,d_r}, this function returns the list of all monomials x₁^m₁··· x_r^m_r such that m₁d₁+··· +m_rd_r=n.
Examples: monomials.wit.

» Index

Data types

Some of the Wit data types are defined as classes. Functionally a class C is a table that contains one or more entries of the form x:T, where x is an identifier and T is a data type. The identifiers x appearing in the definition of C are called the fields of C. We will describe C in the format C={..., x:T, ...}.

In this section we do not consider how actual instances of a given class are constructed. This is explained in detail in the other sections.

An instance of C (or an object of type C) can be thought as a table c with one entry of the form x = t for each field x of C such that t is an object of type T. We will describe c in the format c={..., x = t, ...}. The extraction of the value t can be done either with the expression c(x) or x \ c.

The expression c(x)=t sets the field x of c to the value t. The value of an undefined field is null.

Sheaf. This class has the form {rk: Alg, ch: Vector}. Thus Sheaf has two fields, rk and ch. They are called the "rank" and "Chern character" fields, respectively. The rank is of type Alg=AlgebraicExpression and the Chern character is a vector. If F is an instance of Sheaf, its rank and Chern character can be obtained with the expressions F(rk) and F(ch), or rk\F and cl\F, respectively.

Variety. This class, also called Manifold, or VAR, is intended to capture the structural details of the algebraic varieties appearing in intersection theory, and it is defined as follows:

  Variety = {                     # Name of field
    dim             : Integer     # dimension 
    kind            : Identifier  
    gcs             : Vector      # generating classes
    degs            : Vector      # degrees of gcs
    monomials       : List        
    monomial_values : Relation    
    pt              : Polynomial  # point
    relations       : Vector
    basis           : List
    dual_basis      : List
    tan_bundle      : Sheaf       # tangent bundle
    todd_class      : Vector      # Todd class
  }

We will see examples in several of the types below. The list of fields is provided by evaluating the expression VAR_fields# at the WIT interface.

A Variety for which the gcs field is defined is said to be a Space. Formally,

    Space(X) := is?(X,Variety) & defined?(X,gcs).

Grassmannian. This class, also called GRAS, is an extension of Variety that allows us to handle Grassmannian varieties. It is defined as follows:

   Grassmannian =
     Variety | {
                 tautological_bundle   : Sheaf
                 tautological_quotient : Sheaf
               }

Thus Grassmannian is a Variety with two additional fields, both of type Sheaf. As suggested by their identifiers, these fields will hold the tautological bundle and the tautological quotient of a given instance of the class.

Morphism. This class, also called MOR, is defined follows:

   Morphism = {

     source        : Variety

     target        : Variety

     dim           : Integer

     upperstardata : Rule

     kind          : Identifier
   }

Projective_bundle. This class, also called PROJ_BUNDLE, is defined follows:

   Projective_Bundle = 
     Variety | {
                 base_variety  : Variety
                 vector_bundle : Sheaf
                 fiber_dim     : Integer
                 base_dim      : Integer
                 lowerdata     : Rule
                 section       : Alg
               }

Thus we see that a Projective_bundle is a Variety with six additional fields.

Blowup. This class, also called BLOWUP, is defined follows:

Blowup =
   Variety | {
              exceptional_class : Alg
              blowup_map        : Morphism
              blowup_locus      : Variety
              locus_inclusion   : Morphism
             }

Thus we see that a Blowup is an extension of the class Variety with four additional fields.

Bundle_section. This class, also called BSECT, is defined follows:

     Bundle_section =
       Variety | {
                   inclusion : Morphism
                   cl        : Alg
                 }

» Index

Sheaves and bundles

Even though this section is devoted to the construction and manipulation of Sheaf, we begin with the most basic constructor of Variety. The more involved contructors, many of which use Sheaf, are considered in the section on Variety. In this section we will only need that a Variety X has a dim field that can be obtained with the expression dim \ X, or X(dim).

variety (d: Nat)
variety (X: Name, d: Nat)

The call variety(d) constructs the Variety {dim = d}. The call variety(X,d) is equivalent to X=variety(d).

Constructors. Now we turn to the Sheaf constructors and related functions.

SH (r: Alg, x: Vector, d: Nat)
SH (r: Alg, x: Vector, X: Variety)
SH (r: Alg, x: Vector)

These functions are the basic constructs of the class Sheaf. The first call, SH(r,x,d), constructs the instance {rk = r, ch=pad(x,d)}. The second call is defined as SH(r,x,d) with d = dim \ X. The third, SH(r,x), is defined as SH(r,x,d) with d equal to the length of x (this means that it constructs the instance {rk = r, ch = x}).
Examples: SH.wit. Note that the displayed form of {rk = r, ch = x} is simply {r,x}.

The preceding constructors would be used only if the Chern character of the sheaf is known. Next round of constructors take care of the cases in which what is known is the vector of Chern classes. They rely on the function c2p(c,r) that transforms the vector of Chern classes into the Chern character vector.

sheaf (r: Alg, c: Vector, d: Nat)
sheaf (r: Alg, c: Vector, X: Variety)
sheaf (r: Alg, c: Vector)

The function sheaf(r,c,d) is defined as SH(r,c2p(c,d)). The other two calls are defined as sheaf(r,c,d) with d=dim \ X if the third parameter is a Variety and d = length(c) if the third parameter is missing.
Examples: sheaf.wit.

bundle (n: Alg, c: Name, d: Nat)
bundle (n: Alg, c: Name, X: Variety)
bundle (n: Alg, c: Name)

These are sheaf constructors that are convenient when we need to deal with a symbolic vector of Chern classes of the form [c1, c2, ... , cd], where 'c' is a stem name. The main call is bundle(n,c,d), which is defined differently according to whether n is a non-negative integer or otherwise.
If n is a non-negative integer, bundle(n,c,d) is defined as sheaf(n,[c1, ... , ck],d), where k = min(n,d) (this ties with the fact that the Chern classes of a vector bundle vanish above its rank).
If n is an algebraic expression that does not evalute to a non-negative integer, bundle(n,c,d) is defined as sheaf(n,[c1, ... , cd]).
The call bundle(n,c,X) is defined as bundle(n,c,dim \ X).
The third function call, bundle(n, c), is defined as bundle(n, c, DIM), where DIM is the current default dimension (see the section Varieties and spaces for the ways in which its value is set).
Examples: bundle.wit.

trivial_bundle(n: Alg, d: Nat)
trivial_bundle(n: Alg, X: Variety)
trivial_bundle(n: Alg)

These functions calls are defined, respectively, as sheaf(n, [0], d), sheaf(n, [0], dim \ X) and sheaf(n, [0], DIM).
Examples: trivial.wit.

o_(d: Alg, k: Nat)
o_(d: Alg, X: Variety)
o_(d: Alg)
O_(d: Nat)
O_(X: Variety)

The o_ function calls are defined, respectively, as sheaf(1, [d], k), sheaf(1, [d], dim \ X) and sheaf(1, [d], DIM) (line bundle associated to a divisor d).
The O_ function calls are defined, respectively, as sheaf(1, [0], d) and sheaf(1, [0], dim \ X) (trivial line bundle).
Examples: o_.wit.

Chern, Segre and Todd classes. Next we will consider a group of functions that provide differents sorts of characteristic classes of a Sheaf.

chern_polynomial (F: Sheaf, T: Identifier)

This function provides the polynomial form, using T, of the representation {rk = r, ch = x} of F, by which we mean r + T * polynomial(x,T). chern_character is a synonym of chern_polynomial.
Examples: chern-polynomial.wit.

chern_vector (F: Sheaf, k: Nat)
chern_vector (F: Sheaf, X: Variety)
chern_vector (F: Sheaf)

The function chern_vector(F,k) yields the vector [c₁, ... , c_n] of Chern classes of F of length n = min(k,lenght(ch \ F)). It is defined as p2c(ch \ F,n). As usual, chern_vector(F, X) is simply chern_vector(F,dim \ X), while chern_vector(F) is chern_vector(F, length(ch \ F)).
Examples: chern-vector.wit.

chern (k: Integer, F: Sheaf, d: Nat)
chern (k: Integer, F: Sheaf, X: Variety)
chern (k: Integer, F: Sheaf)
chern (K: Chain, F: Sheaf, d: Nat)
chern (K: Chain, F: Sheaf, X: Variety)
chern (K: Chain, F: Sheaf).

The function call chern (k, F, d) yields the k-th Chern class of F, interpreting that it is 0 if k < 0 or k > d, and with c₀=1. The other two calls are reduced to the first with d = dim \ X and d = length(ch \ F), respectively.
If in the first three functions we replace the integer k by a list, vector or range of integers K, the corresponding functions yield the vector of values of chern (k, F, d), chern (k, F, X), chern (k, F), respectively, when k ranges in K.
Examples: chern-classes.wit.

segre_vector (F: Sheaf, d: Nat)
segre_vector (F: Sheaf, X: Variety)
segre_vector (F: Sheaf)

The function segre_vector(F,d) yields the vector [s₁, ... , s_d] formed with the first d Segre classes of F. It is defined as invert(chern_vector(F,d)). The call segre_vector(F,X) is defined as segre_vector(F,dim \ X) and the call segre_vector(F) as segre_vector(F,length(ch \ F)).
Examples: segre-vector.wit.

segre (k: Integer, F: Sheaf, d: Nat)
segre (k: Integer, F: Sheaf, X: Variety)
segre (k: Integer, F: Sheaf)
segre (K: Chain, F: Sheaf, d: Nat)
segre (K: Chain, F: Sheaf, X: Variety)
segre (K: Chain, F: Sheaf)

The function call segre (k, F, d) yields the k-th Segre class s_k of F, interpreting that it is 0 if k < 0 or k > d, and with s₀=1. The other two calls are reduced to the first with d = dim \ X and d = length(ch \ F), respectively.
If in the first three functions we replace the integer k by a list, vector or range of integers K, the corresponding functions yield the vector of values of segre (k, F, d), segre (k, F, X), segre (k, F), respectively, when k ranges in K.
Examples: segre-classes.wit.

todd_vector (F: Sheaf, d: Integer)
todd_vector (F: Sheaf, X: Variety)
todd_vector (F: Sheaf)
todd(k: Integer, F: Sheaf)

The function todd_vector(F,d) yields the empty vector [ ] if d ≤ 0 and otherwise the vector [t₁, ... , t_d] formed with the first d Todd classes t_i of F. The call todd_vector(F,X) is defined as todd_vector(F,dim \ X) and the call todd_vector(F) as todd_vector(F,length(ch \ F)).
The k-th Todd class of a sheaf F is obtained with todd(k,F).
Examples: todd-vector.wit.

Operations with sheaves. The functions in the remaining of this section describe several operations with sheaves. Some are monary, like dual or deteminant, and some are binary, like the direct sum or the tensor product.

dual (F: Sheaf)

This function constructs the dual of the Sheaf F. If F = {r, x}, then dual(F) is {r, dual(x)}, or, more formally, SH(rk \ F,dual(ch \ F)).

determinant (F: Sheaf, d: Nat)
determinant (F: Sheaf, X: Variety)
determinant (F: Sheaf)

If F = {r, [x₁,...]}, determinant(F,d) is defined as o_(x₁,d), or, more formally, o_((ch\F).1,d). The calls determinant(F,X) and determinant(F) are defined as determinant(F,d) with d = dim \ X and d = length(ch \F), respectively.
Examples: determinant.wit.

(F: Sheaf) + (G: Sheaf) ≡ osum (F: Sheaf, G: Sheaf)
osum (F: Sheaf, G: Sheaf, k: Nat)
osum (F: Sheaf, G: Sheaf, X: Variety)

The main form here is osum (F,G,k). If F = {r, x} and F = {r', x'}, then osum(F,G,k) is defined as {r+r', x +_k x'}, where x +_k x' denotes pad(x,m)+pad(x',m) with m = min(k,M) and M=max(length(x), length(x')).
The call osum (F,G,X) is defined as osum (F,G,d) with d = dim \ X.
Finally, osum(F,G), which can also be denoted F + G, is defined as osum (F,G,d) with d = max(length(x), length(x')).
Examples: osum.wit.

(F: Sheaf) − (G: Sheaf) ≡ (F: Sheaf) / (G: Sheaf) ≡ odiff (F: Sheaf, G: Sheaf)
odiff (F: Sheaf, G: Sheaf, k: Nat) ≡ quotient(F: Sheaf, G: Sheaf, k: Nat)
odiff (F: Sheaf, G: Sheaf, X: Variety) ≡ quotient(F: Sheaf, G: Sheaf, X: Variety)

The main form here is odiff (F,G,k). If F = {r, x} and F = {r', x'}, then odiff(F,G,k) is defined as {r-r', x −_k x'}, where x −_k x' denotes pad(x,m)−pad(x',m) with m = min(k,M) and M=max(length(x), length(x')).
The call odiff (F,G,X) is defined as odiff (F,G,d) with d = dim \ X.
Finally, odiff(F,G), which can also be denoted F − G, is defined as odiff (F,G,d) with d = max(length(x), length(x')).
Examples: odiff.wit.

(F: Sheaf) * (G: Sheaf) ≡ tensor (F: Sheaf, G: Sheaf)
tensor (F: Sheaf, G: Sheaf, k: Nat)
tensor (F: Sheaf, G: Sheaf, X: Variety)

The main form here is tensor (F,G,k). If F = {r, x} and F = {r', x'}, then tensor(F,G,k) is defined as {r * r', r * pad(x,k) + r' * pad(x',k) + convolution(x,x',1..k) (this is a rephrasing of the fact that the Chern polynomial of a tensor product is the product of the corresponding Chern polynomials).
The call tensor(F,G,X) is defined as tensor (F,G,d) with d = dim \ X.
Finally, tensor(F,G), which can also be denoted F * G, is defined as tensor (F,G,d) with d = max(length(x), length(x')).
Examples: tensor.wit.

hom (F: Sheaf, G: Sheaf)
hom (F: Sheaf, G: Sheaf, k: Nat)
hom (F: Sheaf, G: Sheaf, X: Variety)

The main form here is hom (F,G,k), and it is defined as tensor(dual(F),G,k).
The call hom(F,G,X) is defined as tensor(dual(F),G,d) with d = dim \ X.
Finally, hom(F,G) is defined as dual(F) * G.
Remark. Instead of hom and we can use the synonym Hom.
Examples: hom.wit.

symm (p: Nat, F: Sheaf)

This function computes the p-th symmetric power of the sheaf F.
Examples: symm.wit.

wedge (p: Nat, E: Sheaf, d: Nat)
wedge (p: Nat, E: Sheaf, X: Variety)
wedge (p: Nat, F: Sheaf)

This function computes Λ^pF, the p-th exterior power of the sheaf F.
Examples: symm.wit, sch-1.wit.

» Index

Varieties

This section is devoted to present the main constructors of the type Variety and a number of related functions. The meaning of some of the fields of the class Variety, and of the values assigned to them by the constructors, may be rather obscure at this stage, but it will become clearer as we go forward, and especially in next section (Chow rings).

variety (d: Nat, T: Table)
variety (X: Name, d: Nat, T: Table)

This function constructs a Variety, say V, by first setting V = variety(d) and then setting V(f ) = T(f ) for each of the fields f of Variety that appear in T (the posssible fields f of Variety are dim, kind, gcs, degs, monomials, monomial_values, pt, relations, tan_bundle, todd_class). Cf. Variety in the section Data types).
The second function call, variety (X, d, T), is equivalent to the expression X = variety(d,T).
Examples: variety.wit.

algebraic_curve (g: Nat | Identifier, P: Identifier)
algebraic_curve (C: Name, g: Nat | Identifier, P: Identifier)

The form algebaic_curve(g,P) constructs a Variety whose fields have the following values:
dim = 1 kind = _algebraic_curve_ gcs = [P:Polynomial] degs = [1] relations = [P^2] pt = (P:Polynomial) monomial_values = {P->1} tan_bundle = {rk=1, ch=[(2-2*g)*P]} todd_class = [(1-g)*P]
The second form, algebaic_curve(C,g,P), is equivalent to C = algebaic_curve(g,P).
Examples: curve.wit.

projective_space (n: Nat, h: Name)
projective_space (P: Name, n: Nat, h: Name)

The form projective_space(n,h) constructs a Variety that implements the notion of projective space with hypeplane class h. Its fields have, letting c = [binomial(n+1,j)· h^j with j in 1..n] the following values:
dim = n kind = if n==1 then _projective_line_ elif n==2 then _projective_plane_ else _projective_space_ end gcs = [h:Polynomial] degs = [1] relations = [h^(n+1)] monomials = { {h^j} with j in 1..n} monomial_values = {h^n->1} pt = h^n tan_bundle = sheaf(n,c) todd_class = todd_vector(sheaf(n,c))
The second form, projective_space(P,n,h), is equivalent to P = projective_space(n,h).
Examples: projective-space.wit.

grassmannian (k: Nat, n: Nat, c: Name)
grassmannian (G: Name, k: Nat, n: Nat, c: Name)

The form grassmannian(k, n, c) constructs a Variety that implements the notion of the Grassmannian variety G of k-planes in the n-dimensional projective space and with C = [c1, c2, ... ] = vector(c,k+1) the vector of Chern classes of the tautological bundle on G. Its fields have, letting
S = bundle(k+1,c),
T = trivial_bundle(n+1),
M = { monomial_list ( C, [1..(k+1)], j) with j in 1..(k+1)·(n-k) },
Q = T / dual(S),
the following values:
dim = (k+1)·(n-k) kind = _grassmannian_ gcs = C degs = [1..(k+1)] relations = take(invert(C,n+1),-k-1) pt = (C.(k+1))^(n-k) monomials = M monomial_values = find_monomial_values( (k+1)·(n-k), C, [1..(k+1)], R, pt ) tautological_bundle = S tautological_quotient = dual(S) tan_bundle = hom(Q,dual(S)) todd_class = todd_vector(hom(Q,dual(S)))
The second form, grassmannian(G, k, n, c), is equivalent to G = grassmannian(k, n, c).
Examples: grassmannian.wit.
Remark. The function grassmannian uses the function
find_monomial_values( d:Nat, h:Vector|List, w:Vector, R:Vector|List, P:Polynomial) ,
which assigns numerical values to all monomials of degree d in the variables h={h₁,...,h_m}, or h=[h₁,...,h_m], with weights w=[w₁,...,w_m], assuming the relations R={R₁,...,R_n} (each relation is a homogeneous polynomial in the variables h, taking into account the weights). The numbers assigned are normalized so that the monomial P representing a point has value 1.

cartesian_product (X: variety, Y: Variety)

Returns a variety, say P, with the following values for its fields:
dim = (dim\X) + (dim\Y) kind = _product_ gcs = (gcs\X) | (gcs\Y) degs = (degs\X) | (degs\Y) monomial_values = if defined?(X,monomial_values) & defined?(Y,monomial_values) then {x*y->(monomial_values\X)(x) * (monomial_values\Y)(y) with (x,y) in (last(monomials\X),last(monomials\Y) } end pt = if defined?(X,pt) & defined?(Y,pt) then (pt\X) * (pt\Y) else undefined end tan_bundle = if defined?(X,tan_bundle) & defined?(Y,tan_bundle) then osum(tan_bundle\X,tan_bundle\Y, P) end

Examples: product.wit.

» Index

Chow rings

The cycle classes considered are those that can be represented as polynomials in the generating classes of the current variety, and the product of two such polynomials respresents the intersection product of the corresponding classes.

integral (p: Polynomial, X: Variety) ≡ integral (X: Variety, p: Polynomial)
integral (p: Polynomial, T: Relation, V: Vector) ≡ integral (T: Relation, p: Polynomial, V: Vector)
integral (p: Polynomial, T: Relation) ≡ integral (T: Relation, p: Polynomial)

With this group of functions we implement the homomorphism (cf. [F], p. 13, or [X], p. 25)
∫_{_X} : A₀(X) −> Z
from the Chow group of 0-dimensional cycles to the additive group of the integers Z (it is the unique group homomorphism such that ∫_{_X} [z] = degree(z), where [z] denotes the class in A₀(X) of the 0-dimensional cycle z). In our implementation, the elements of A₀(X) appear as polynomials in the generating classes of X that have homogenous weight dim\X (the weights of the generating classes are given by the vector degs\X).
The function integral(p,X) is defined as integral(p, T, V), with T = monomial_values \ X and V = gcs \ X. This insures that the set of variables appearing on the left sides of the relators in T is contained in the set of variables in the vector V (the relators forming T have the form m −> v, where m is a monomial and v a value).
The value of the form integral(p, T, V) is defined additively on p and hence it is enough to describe its value when p is a monomial. In this case p = m · m', with m a monomial in the variables V and m' a monomial in the variables that are not in V, and we define integral(p, T, V) as T(m) · m'. This value is v · m' if T contains a relator of the form m −> v and 0 otherwise.
The short form integral(p,T) is equivalent to integral(p,T,variables(T)), where variables (T) is the set of variables that appear on the left sides of the relators of T. This form is slower than integral(p, T, V) because it has to go trough all the relators in T to determine variables(T) and this can be costly when T contains many relators.
Finally notice that we obtain equivalent function calls for each of the three function calls that we have just described by interchanging the first two parameters.
Examples: integral.wit, lines.wit, lns-3ic.wit, lns-5ic.wit.

HRR (X: Variety, F: Sheaf)
chi (X: Variety, F: Sheaf)

The function HRR(X,F) computes the integrand ch(F) · td(X)_n of the Hirzebruch-Riemann-Roch theorem, which asserts that if F is a vector bundle on a non-singular complete variety X of dimension n, then the Euler-Poincaré characteristic of F, χ(X,F), is given by (cf. [F], p. 288, or [X], p. 34):
χ(X,F) = ∫_X (ch(F)·td(X))_n,
where ch(F) is the Chern character of F, td(X) the Todd character of the tangent bundle of X and (ch(F) · td(X))_n the term of degree n of the intersection product ch(F) · td(X). In our approach this is defined as
coefficient(collect( Ch(F,T) · Td(X,T), T), n) .
The function call chi(X,F) computes χ(X,F). It is defined as
integral( X, HRR(X,F) ) .
Examples: chi.wit.

» Index

Morphisms

projective_bundle ( X: Variety, E: Sheaf, h: Name)
projective_bundle ( E: Sheaf, h: Name)
lowerstar ( P: Projective_bundle, u: Polynomial)

The function call projective_bundle (X, E, h) returns a Projective_bundle, say P, with the following values for its fields (we set n = dim \ X, r = rk \ E and s = segre_vector(E)):

      dim           = n+r−1
      kind          = _projective_bundle_
      gcs           = [h]
      degs          = [1]
      base_variety  = X
      base_dim      = n
      fiber_dim     = r−1
      vector_bundle = E
      lowerdata     = {h^(r-1)->1} | {h^(i+r-1)->s.i with i in 1..n}
      section       = h^(r-1)
      pt            = h^(r-1)·(pt \ X)

The form projective_bundle (E, h) is defined as projective_bundle (X_, E, h), where X_ is the default variety.

With lowerstar(P,u) we obtain the push-forward of a class u on P to its base variety.

Examples: nu8.wit, conics-5ic.wit.

morphism (X: Variety, Y: Space, e: List|Vector)
compose ( g: Morphism, f: Morphism)

The function call morphism (X, Y, e) returns a Morphism with the following values for its fields:
source = X target = Y dim = (dim\X)−(dim\Y) upperstardata = substitution(gcs\Y,e)
Here substitution([g₁,...,g_r], [e₁,...,e_s]) returns {g₁ ⇒ e₁, ... , g_r ⇒ e_r} (a Rule), provided s ≥ r.
The function call compose(g,f) is defined if target\f=source\g, and in that case it returns a Morphism, defined as morphism(X,Z,e), where X=source\f, Z=target\g and e={U(V(z) with z in gcs\Z}, with U=upperstardata\f and V=upperstardata\g.
Examples: morphism.wit, compose.wit.

blowup (i: Morphism, e: Name, f: Name)
blowup_points (k: Nat, X: Variety, f: Name, e: Name)

If we let X=target(i) and Y=source(i), the function blowup(i,e,f) constructs the blowup, say W, of X along Y in such a way that e is the exceptional class and f : W −> X the projection map.
The call blowup_points (k, X, f, e) constructs the blowup, say W, of k points of X in such a way that e represents the exceptional class and f : W −> X is the projection map.
Examples: blowup.wit, blowuppoints.

» Index

Multiple points

» Index