base -- make an abstract variety from nothing, equipped with some parameters and some bundles

Synopsis

Usage:

X = base()

X = base(p)

X = base(d,p)

X = base(d,p,...,Bundle=>(B,r,b),...)
Inputs:
- d, an integer, if omitted, the value $0$ is used
- p, a symbol,
- B, a symbol,
- r, an integer,
- b, either a symbol, a string, a list of symbols, indexed variables, or Chern class variables
Outputs:
- an abstract variety, a variety of dimension $d$ with an intersection ring containing specified variables and specified Chern classes of abstract sheaves
Consequences:
- Variables $p$, ..., of degree 0 are in the intersection ring of the variety. They are usable as (integer) variables (auxiliary parameters) in intersection ring computations.
- For each option Bundle=>(B,r,b), an abstract sheaf of rank r is created and assigned to the variable B. If b is a symbol, then the Chern classes of $B$ are assigned to the indexed variables b_1, ..., b_k, where $k = min(r,d)$. If b is a string, "d", say, then the Chern classes of $B$ are assigned to the variables whose names are d1, d2, d3, ... . If b is a list of length $k$, then the Chern classes are assigned to its elements.
- A default method for integration of elements of the intersection ring is installed, which returns a formal expression representing the integral of the degree $d$ part of the element when $d$ is greater than zero, and simply returns the degree 0 part of the element when $d$ is zero.

Description

First we make a base variety and illustrate a computation with its two abstract sheaves:

i1 : S = base(2,p,q, Bundle =>(A,1,a), Bundle => (B,2,"b"))

o1 = S

o1 : an abstract variety of dimension 2

i2 : intersectionRing S

o2 = QQ[p..q, a , b1, b2]
               1

o2 : PolynomialRing

i3 : degrees oo

o3 = {{0}, {0}, {1}, {1}, {2}}

o3 : List

i4 : chern (A*B)

                        2
o4 = 1 + (2a  + b1) + (a  + a b1 + b2)
            1           1    1

o4 : QQ[p..q, a , b1, b2]
               1

i5 : integral oo

               2
o5 = integral(a  + a b1 + b2)
               1    1

o5 : Expression of class Adjacent

Then we make a projective space over it and use the auxiliary parameters p and q in a computation that checks the projection formula.

i6 : X = abstractProjectiveSpace'(3,S,VariableName => H)
warning: clearing value of symbol H to allow access to subscripted variables based on it
       : debug with expression   debug 204   or with command line option   --debug 204

o6 = X

o6 : a flag bundle with subquotient ranks {3, 1}

i7 : intersectionRing X

              QQ[p..q, a , b1, b2][H   ..H   , H]
                        1           1,1   1,3
o7 = ----------------------------------------------------
     (- H    - H, - H    - H   H, - H    - H   H, -H   H)
         1,1         1,2    1,1      1,3    1,2     1,3

o7 : QuotientRing

i8 : f = X.StructureMap

o8 = f

o8 : a map to S from X

i9 : x = chern f_* (f^* OO_S(p*a_1) * OO_X(q*H))

          1   3        2     11                   1 2 6 2   1 2 5 2  
o9 = 1 + (-p*q a  + p*q a  + --p*q*a  + p*a ) + (--p q a  + -p q a  +
          6     1        1    6     1      1     72     1   6     1  
     ------------------------------------------------------------------------
     29 2 4 2   23 2 3 2   157 2 2 2   11 2   2
     --p q a  + --p q a  + ---p q a  + --p q*a )
     36     1   12     1    72     1   12     1

o9 : QQ[p..q, a , b1, b2]
               1

i10 : y = chern f_* OO_X((f^*(p*a_1))+q*H)

           1   3        2     11                   1 2 6 2   1 2 5 2  
o10 = 1 + (-p*q a  + p*q a  + --p*q*a  + p*a ) + (--p q a  + -p q a  +
           6     1        1    6     1      1     72     1   6     1  
      -----------------------------------------------------------------------
      29 2 4 2   23 2 3 2   157 2 2 2   11 2   2
      --p q a  + --p q a  + ---p q a  + --p q*a )
      36     1   12     1    72     1   12     1

o10 : QQ[p..q, a , b1, b2]
                1

i11 : x == y

o11 = true

Ways to use base:

base(Sequence)
base(Thing)

For the programmer

The object base is a method function with a single argument.

base -- make an abstract variety from nothing, equipped with some parameters and some bundles

Synopsis

Description

See also

Ways to use base:

For the programmer