Macaulay2 » Documentation
Packages » MatchingFields » flMatchingField
next | previous | forward | backward | up | index | toc

# flMatchingField -- Construct a matching field for a partial flag variety

- Usage:
    `L = flMatchingField(kList, weightMatrix)`
    `L = flMatchingField(kList, n, tuples)`
    `L = flMatchingField(weightMatrix)`
- Inputs:
  - kList, a list, positive integers; the sizes of the tuples of the flag matching field
  - n, an integer, positive integer; the tuples have entries in 1 .. n
  - weightMatrix, a matrix, induces the flag matching field
- Outputs:
  - L, an instance of the type FlMatchingField,

## Description

This function is the basic constructor for matching fields for partial flag varieties, which we simply call flag matching fields. The function outputs an instance of type FlMatchingField, which represents the flag matching field and stores all data related and computed about it.

There are three basic ways to define a flag matching field. The first way is to supply a weight matrix that induces the flag matching field. This produces a flag matching field for the full flag variety.

    i1 : M = matrix {{0,0,0,0}, {4,2,3,1}, {10, 40, 30, 20}}

    o1 = | 0  0  0  0  |
         | 4  2  3  1  |
         | 10 40 30 20 |

                  3       4
    o1 : Matrix ZZ  <-- ZZ

    i2 : L1 = flMatchingField M

    o2 = Flag Matching Field for Fl(1, 2, 3; 4)

    o2 : FlMatchingField

    i3 : netList getTuples L1

         +---------+---------+---------+---------+------+------+
    o3 = |{1}      |{2}      |{3}      |{4}      |      |      |
         +---------+---------+---------+---------+------+------+
         |{1, 2}   |{1, 3}   |{3, 2}   |{1, 4}   |{2, 4}|{3, 4}|
         +---------+---------+---------+---------+------+------+
         |{3, 2, 1}|{2, 4, 1}|{3, 4, 1}|{3, 2, 4}|      |      |
         +---------+---------+---------+---------+------+------+

    i4 : isToricDegeneration L1

    o4 = true

In the above example, we construct the flag matching field for the full flag variety induced by the given weight matrix. The tuples for the flag matching field are listed by their size. Similarly to Grassmannian matching fields: GrMatchingField, the function isToricDegeneration checks the equality of the matchingFieldIdeal and the initial ideal of the plueckerIdeal with respect to the weight of the matching field.

The second way to define a flag matching field is to supply a weight matrix and specify the size of the sets or, in other words, specify the dimensions of the vector spaces in the flags.

    i5 : L2 = flMatchingField({1,2}, M)

    o5 = Flag Matching Field for Fl(1, 2; 4)

    o5 : FlMatchingField

    i6 : netList getTuples L2

         +------+------+------+------+------+------+
    o6 = |{1}   |{2}   |{3}   |{4}   |      |      |
         +------+------+------+------+------+------+
         |{1, 2}|{1, 3}|{3, 2}|{1, 4}|{2, 4}|{3, 4}|
         +------+------+------+------+------+------+

The third way to define a flag matching field is by listing out its tuples.

    i7 : T = getTuples L1

    o7 = {{{1}, {2}, {3}, {4}}, {{1, 2}, {1, 3}, {3, 2}, {1, 4}, {2, 4}, {3, 4}},
         ------------------------------------------------------------------------
         {{3, 2, 1}, {2, 4, 1}, {3, 4, 1}, {3, 2, 4}}}

    o7 : List

    i8 : L3 = flMatchingField({1,3}, 4, {T_0, T_2})

    o8 = Flag Matching Field for Fl(1, 3; 4)

    o8 : FlMatchingField

    i9 : getTuples L3

    o9 = {{{1}, {2}, {3}, {4}}, {{3, 2, 1}, {2, 4, 1}, {3, 4, 1}, {3, 2, 4}}}

    o9 : List

    i10 : isCoherent L3

    o10 = true

    i11 : getWeightMatrix L3

    o11 = | 0 0 0 0  |
          | 0 0 1 -1 |
          | 0 2 2 0  |

                   3       4
    o11 : Matrix ZZ  <-- ZZ

As shown in the example above, the first argument "kList" specifies the size of the sets. The third argument is a list whose i-th entry is a list of tuples of size "kList_i". In this example, the size of the sets are 1 and 3, which correspond to "T_0" and "T_2". When a flag matching field is constructed in this way, it is not guaranteed to be coherent, i.e., it may not be induced by a weight matrix. Similarly to Grassmannian matching fields, the function isCoherent checks whether the matching field is coherent and the function getWeightMatrix returns a weight matrix that induces the matching field, if it exists. If the matching field is not coherent, then these methods produce an error.

A note of caution. Two different weight matrices may induce the same matching field so the function getWeightMatrix may return a weight matrix that is different to what may be expected. However, if a matching field is defined by a weight matrix, then that weight matrix will be returned.

## See also

- FlMatchingField -- the class of matching fields for partial flag varieties
- GrMatchingField -- the class of Grassmannian matching fields
- grMatchingField -- Construct a matching field for the Grassmannian variety
- isToricDegeneration -- Does the matching field give rise to a toric degeneration
- plueckerIdeal -- The Pluecker ideal of a matching field
- matchingFieldIdeal -- The toric ideal of a matching field
- isCoherent -- Is the matching field coherent
- getWeightMatrix -- weight matrix that induces the matching field

### Menu

## Ways to use flMatchingField:

- `flMatchingField(List,Matrix)`
- `flMatchingField(List,ZZ,List)`
- `flMatchingField(Matrix)`

## For the programmer

The object flMatchingField is a method function.

The source of this document is in /build/macaulay2-88fgJW/macaulay2-1.25.11+ds/M2/Macaulay2/packages/MatchingFields.m2:1802:0.