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

matchingFieldFromPermutation -- matching field parametrised by permutations

Synopsis

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

Ways to use matchingFieldFromPermutation :

For the programmer

The object matchingFieldFromPermutation is a method function with options.

Menu