flagBundle -- make a flag bundle

Synopsis

• Usage:

  flagBundle(r,E)

• Inputs:
  • r, a list, a list $\{r_0, ..., r_{n-1}\}$ of non-negative integers
  • E, an abstract sheaf, whose flag bundle is to be formed. If $E$ is, instead, an abstract variety then a trivial sheaf on it is used. If $E$ is, instead, an integer then a trivial sheaf on point of rank $E$ is used. If $E$ is omitted, then a trivial sheaf on point is used; its rank is the sum of the entries of $r$.
• Optional inputs:
  • VariableNames => a thing, default value null, used for specifying how the generators of the intersection ring of the resulting flag bundle are to be named. If no value is provided, then H_(i,j) = $H_{i,j}$ denotes the j-th Chern class of i-th tautological sheaf. If its value is a symbol, then that symbol is used instead of H. If its value is a list, then for each i, its i-th entry specifies how the Chern classes of the i-th tautological sheaf are to be named. If the i-th entry is omitted (i.e., is null), then the default names are used. If the i-th entry is a symbol, say c, then the names are c_1 .. c_(r_i). If the i-th entry is a string, say c, then the names are c1, c2, c3, ... . If the i-th entry is a list, its entries are used as the names.
  • QuotientBundles => a Boolean value, default value true, whether the additional tautological subquotient bundle, needed to make up the discrepancy between the sum of the rank specified by $r$ and the rank of $E$, should be at the bottom of the filtration.
  • Isotropic => a Boolean value, default value false, whether to produce the isotropic flag bundle; in that case, the vector bundle should have even rank.
• Outputs:
  • F, an abstract flag bundle, the flag bundle over the variety of $E$ parametrizing filtrations $0 = E_0 \subseteq{} E_1 \subseteq{} ... \subseteq{} E_n = E$ of $E$ whose successive subquotients are vector bundles $E_{i+1}/E_i$ of rank $r_i$
• Consequences:

  • The list r of ranks can be obtained later with F.BundleRanks, see BundleRanks. Its sum can be obtained with F.Rank.
  • The list of consecutive quotients in the tautological filtration can be obtained later with bundles F, see bundles. See also SubBundles and QuotientBundles.
  • The (relative) tautological line bundle can be obtained later with OO_F(1).
  • The structure map from F to the variety of E can be obtained later with F.StructureMap, see StructureMap. Abstract sheaves and cycle classes can be pulled back and pushed forward, see AbstractVarietyMap ^* and AbstractVarietyMap _*. Integration will work if it works on the variety of E, see integral. The (relative) tangent bundle can be obtained from it, see tangentBundle(AbstractVarietyMap).

Description

i1 : base(3,Bundle => (E,4,c))

o1 = a variety

o1 : an abstract variety of dimension 3

i2 : F = flagBundle({2,2},E)

o2 = F

o2 : a flag bundle with subquotient ranks {2:2}

i3 : bundles F

o3 = (a sheaf, a sheaf)

o3 : Sequence

i4 : rank \ oo

o4 = (2, 2)

o4 : Sequence

i5 : chern \ ooo

                            2
o5 = (1 + (- H    + c ) + (H    - H    - c H    + c ), 1 + H    + H   )
              2,1    1      2,1    2,2    1 2,1    2        2,1    2,2

o5 : Sequence

i6 : product toList oo

o6 = 1 + c  + c  + c
          1    2    3

                                       QQ[c ..c ][H   ..H   ]
                                           1   3   1,1   2,2
o6 : ------------------------------------------------------------------------------------------
     (- H    - H    + c , - H    - H   H    - H    + c , - H   H    - H   H    + c , -H   H   )
         1,1    2,1    1     1,2    1,1 2,1    2,2    2     1,2 2,1    1,1 2,2    3    1,2 2,2

i7 : intersectionRing flagBundle({2,2},E,VariableNames=>{{a,b},t})

                         QQ[c ..c ][a..b, t ..t ]
                             1   3         1   2
o7 = ----------------------------------------------------------------
     (- a - t  + c , - b - a*t  - t  + c , - b*t  - a*t  + c , -b*t )
             1    1           1    2    2       1      2    3      2

o7 : QuotientRing

See also

• abstractProjectiveSpace -- make a projective space
• projectiveBundle -- make a projective bundle from an abstract sheaf