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

# matchingFieldFromPermutation -- matching field parametrised by permutations

- Usage:
    `Lgr = matchingFieldFromPermutation(k, n, S)`
    `Lfl = matchingFieldFromPermutation(kList, n, S)`
- Inputs:
  - k, an integer, positive integer; the size of the tuples of the Grassmannian matching field
  - 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
- Optional inputs:
  - RowNum => an integer, default value 2, which row of the digonal weight matrix to permute
  - UsePrimePowers => a Boolean value, default value false, use multiples of prime power used for the entries of the diagonal weight matrix
  - PowerValue => an integer, default value 0, use multiples of powers this value in the diagonal weight matrix
  - ScalingCoefficient => an integer, default value 1, the value by which to scale the permuted row of the diagonal weight matrix
- Outputs:
  - Lgr, an instance of the type GrMatchingField,
  - Lfl, an instance of the type FlMatchingField,

## Description

Let $M_0 \in \RR^{k \times n}$ be a matrix that induced the diagonal matching field. Usually, we take this matrix to be $(m_{i,j})$ with $m_{i,j} = (n-j)n^(i-2)$ if $i > 1$ and $m_{i,j} = 0$ if $i = 1$. Note that this matrix is different to the weight matrix of the matching field produced by the function diagonalMatchingField, however the matching fields are the same. Given a permutation $\sigma \in S_n$, the matching field associated to $\sigma$ has weight matrix $M_\sigma$, which is the same as $M_0$ except in the second row, which is given by $\sigma(1), \sigma(2), \dots, \sigma(n)$. If $\sigma = (n, n-1, \dots, 1) \in S_n$ is the permutation written in single-line notation, then the matching field induced by $M_\sigma$ is the diagonal matching field.

    i1 : L0 = diagonalMatchingField(3, 6)

    o1 = Grassmannian Matching Field for Gr(3, 6)

    o1 : GrMatchingField

    i2 : getWeightMatrix L0

    o2 = | 0  0  0 0 0 0 |
         | 6  5  4 3 2 1 |
         | 12 10 8 6 4 2 |

                  3       6
    o2 : Matrix ZZ  <-- ZZ

    i3 : L1 = matchingFieldFromPermutation(3, 6, {6,5,4,3,2,1})

    o3 = Grassmannian Matching Field for Gr(3, 6)

    o3 : GrMatchingField

    i4 : getWeightMatrix L1

    o4 = | 0  0  0  0  0 0 |
         | 6  5  4  3  2 1 |
         | 30 24 18 12 6 0 |

                  3       6
    o4 : Matrix ZZ  <-- ZZ

    i5 : L0 == L1

    o5 = true

    i6 : L2 = matchingFieldFromPermutation(3, 6, {1,3,2,6,4,5})

    o6 = Grassmannian Matching Field for Gr(3, 6)

    o6 : GrMatchingField

    i7 : getWeightMatrix L2

    o7 = | 0  0  0  0  0 0 |
         | 1  3  2  6  4 5 |
         | 30 24 18 12 6 0 |

                  3       6
    o7 : Matrix ZZ  <-- ZZ

    i8 : L3 = matchingFieldFromPermutation({1,2,3}, 6, {1,4,2,3,6,5})

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

    o8 : FlMatchingField

    i9 : getWeightMatrix L3

    o9 = | 0  0  0  0  0 0 |
         | 1  4  2  3  6 5 |
         | 30 24 18 12 6 0 |

                  3       6
    o9 : Matrix ZZ  <-- ZZ

The optional argument RowNum is used to change which row of $M_0$ is permuted.

    i10 : L4 = matchingFieldFromPermutation(3, 6, {1,4,2,3,6,5}, RowNum => 3)

    o10 = Grassmannian Matching Field for Gr(3, 6)

    o10 : GrMatchingField

    i11 : getWeightMatrix L4

    o11 = | 0 0  0  0  0  0  |
          | 5 4  3  2  1  0  |
          | 6 24 12 18 36 30 |

                   3       6
    o11 : Matrix ZZ  <-- ZZ

The optional argument UsePrimePowers is used to modify the original diagonal weight matrix $M_0$. If the option is set to true then we use the matrix with entries $m_{i,j} = (n-j) p^(i-2)$ if $i>1$ and $m_{i,j} = 0$ if $i = 1$, where $p \ge n$ is the smallest prime number greater than or equal to $n$.

    i12 : L5 = matchingFieldFromPermutation(3, 6, {1,3,2,4,6,5}, UsePrimePowers => true)

    o12 = Grassmannian Matching Field for Gr(3, 6)

    o12 : GrMatchingField

    i13 : getWeightMatrix L5

    o13 = | 0  0  0  0  0 0 |
          | 1  3  2  4  6 5 |
          | 35 28 21 14 7 0 |

                   3       6
    o13 : Matrix ZZ  <-- ZZ

The optional argument PowerValue is used to give a specific value to $p$ in the diagonal weight matrix as described above. If the value is not positive, then the argument is ignored. This option should be used carefully. If the power value is set incorrectly (typically by setting a value that is too low) then the weight matrix may not be generic, i.e., it does not define a matching field. However, in such a case, the function produces a matching field without error, as shown in the example $L7$ below. Working with such matching fields may lead to unexpected behaviours.

    i14 : L6 = matchingFieldFromPermutation(3, 6, {1,3,2,4,6,5}, PowerValue => 10)

    o14 = Grassmannian Matching Field for Gr(3, 6)

    o14 : GrMatchingField

    i15 : getWeightMatrix L6

    o15 = | 0  0  0  0  0  0 |
          | 1  3  2  4  6  5 |
          | 50 40 30 20 10 0 |

                   3       6
    o15 : Matrix ZZ  <-- ZZ

    i16 : L7 = matchingFieldFromPermutation(3, 6, {5,4,3,2,1,0}, PowerValue => 1)

    o16 = Grassmannian Matching Field for Gr(3, 6)

    o16 : GrMatchingField

    i17 : getWeightMatrix L7

    o17 = | 0 0 0 0 0 0 |
          | 5 4 3 2 1 0 |
          | 5 4 3 2 1 0 |

                   3       6
    o17 : Matrix ZZ  <-- ZZ

Any positive integer supplied to the argument PowerValue takes precedence over UsePrimePowers. The optional argument ScalingCoefficient is used to scale the entries of the row that is permuted by the permutation. If UsePrimePowers is set to true, and $p \ge n$ is the smallest prime number less than $n$, then the scaling coefficient can be set to any $c \in \{1, 2, \dots, p-1\}$ and the resulting weight matrix is guaranteed to be generic.

    i18 : L8 = matchingFieldFromPermutation(3, 6, {6,1,5,2,3,4}, UsePrimePowers => true, ScalingCoefficient => 3)

    o18 = Grassmannian Matching Field for Gr(3, 6)

    o18 : GrMatchingField

    i19 : getWeightMatrix L8

    o19 = | 0  0  0  0  0 0  |
          | 18 3  15 6  9 12 |
          | 35 28 21 14 7 0  |

                   3       6
    o19 : Matrix ZZ  <-- ZZ

    i20 : isToricDegeneration L8

    o20 = false

The above is an example of a hexagonal matching field, which does not give rise to a toric degeneration of the Grassmannian Gr$(3, 6)$.

## See also

- RowNum -- the row of the diagonal weight matrix to permute
- UsePrimePowers -- use a diagonal weight matrix with multiples of certain powers
- PowerValue -- use a diagonal weight matrix with multiples of certain powers
- ScalingCoefficient -- scale the permuted row of the weight matrix

### Menu

- RowNum -- the row of the diagonal weight matrix to permute
- UsePrimePowers -- use a diagonal weight matrix with multiples of certain powers
- ScalingCoefficient -- scale the permuted row of the weight matrix

## Ways to use matchingFieldFromPermutation:

- `matchingFieldFromPermutation(List,ZZ,List)`
- `matchingFieldFromPermutation(ZZ,ZZ,List)`

## For the programmer

The object matchingFieldFromPermutation is a method function with options.

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