Section 3

3.1. Discrete signatures and their varieties

Below is the computation (in Macaulay2) for discrete signatures varieties for some particular cases.

A signature of a matrix \(d \times N\) is an infinite sequence of integers indexed by certain polynomials. By truncating the sequence by the polynomials up to a certain degree \(h\), we obtain a finite sequence of integers called the signature of height \(h\).

Discrete signature varieties are parametrized by three integers \(d\), \(\verb|h|\) and \(N\), and correspond to the variety of all possible signatures of height \(\verb|h|\) arising from a matrix of size \(d \times N\).

We compute the discrete signature variety for the case \(d=1\), \(h=3\) and \(N=3\).

-- d = 1
-- h = 3
-- N = 3
restart
R = QQ[a1,b1,c1,
s00, s01, s10, s11,
Degrees => {3:1,4:1},
MonomialOrder => Eliminate 3];
vrbs = {a1, b1, c1};

Q = QQ[S00, S01, S10, S11,
Degrees => {4:1}];

mapFunction = map(Q, R, {a1 => 0, b1 => 0, c1 => 0, s00 => S00, s01 => S01, s10 => S10, s11 => S11});
varietyName = "V133";

I = ideal(
s00-a1*b1*c1,
s10-a1*a1*b1-a1*a1*c1-b1*b1*c1,
s01-a1*b1*b1-a1*c1*c1-b1*c1*c1,
s11-a1*a1*a1-b1*b1*b1-c1*c1*c1);

-- auxiliary functions
isVar = var -> member(var, vrbs);

hasNoVar = p -> (
        0 == number(support p, isVar)
);

reduceAndMapGenerators = K -> (
        -- reduce the ideal K in the ring R and map it into Q
        g = groebnerBasis I;
        lenGroebnerBasis = numColumns g;
        L = for i from 0 to lenGroebnerBasis-1 list (g_i)_0;
        L = select(L, hasNoVar);
        len_subbasis = length L;
        LNew = for i from 0 to len_subbasis-1 list mapFunction(L_i); -- we map each value of L into the new ring Q
        return LNew;
);

-- main program
gensReducedIdeal = reduceAndMapGenerators(I);
numReducedGenerators = length gensReducedIdeal;
J = ideal(gensReducedIdeal);
dimJ = dim J;
degreeJ = degree J;
smplPoly = toString gensReducedIdeal_(numReducedGenerators - 1);

concatenate {"There are ", toString numReducedGenerators, " generators in ", varietyName}
concatenate {varietyName, " had dimension ", toString dimJ}
concatenate {varietyName, " had degree ", toString degreeJ}
concatenate {"A sample generator of ", varietyName, " is ", smplPoly}

-- There are 1 generators in V133
-- V133 had dimension 3
-- V133 had degree 9
-- A sample generator of V133 is 81*s00^9+162*s00^8*s01+351*s00^7*s01^2+333*s00^6*s01^3+72*s00^5*s01^4-63*s00^4*s01^5-30*s00^3*s01^6+6*s00^2*s01^7+6*s00*s01^8+s01^9+162*s00^8*s10 + ...

Although this variety only has one generator, it is a polynomial of degree 9.

We compute the discrete signature variety for the case \(d=1\), \(h=4\) and \(N=3\).

-- d = 1
-- h = 4
-- N = 3
restart
R = QQ[a1,b1,c1,
s000, s001, s010, s011, s100, s101, s110, s111,
Degrees => {3:1,8:1},
MonomialOrder => Eliminate 3];
vrbs = {a1, b1, c1};

Q = QQ[S000, S001, S010, S011, S100, S101, S110, S111,
Degrees => {8:1}];

mapFunction = map(Q, R, {a1 => 0, b1 => 0, c1 => 0,
        s000 => S000, s001 => S001, s010 => S010, s011 => S011,
        s100 => S100, s101 => S101, s110 => S110, s111 => S111});
varietyName = "V143";


I = ideal(
        s000-0,
        s001-a1*b1*c1*c1,
        s010-a1*b1*b1*c1,
        s011-a1*b1*b1*b1-a1*c1*c1*c1-b1*c1*c1*c1,
        s100-a1*a1*b1*c1,
        s101-a1*a1*b1*b1-a1*a1*c1*c1-b1*b1*c1*c1,
        s110-a1*a1*a1*b1-a1*a1*a1*c1-b1*b1*b1*c1,
        s111-a1*a1*a1*a1-b1*b1*b1*b1-c1*c1*c1*c1
);


-- auxiliary functions
isVar = var -> member(var, vrbs);

hasNoVar = p -> (
        0 == number(support p, isVar)
);

reduceAndMapGenerators = K -> (
        -- reduce the ideal K in the ring R and map it into Q
        g = groebnerBasis I;
        lenGroebnerBasis = numColumns g;
        L = for i from 0 to lenGroebnerBasis-1 list (g_i)_0;
        L = select(L, hasNoVar);
        len_subbasis = length L;
        LNew = for i from 0 to len_subbasis-1 list mapFunction(L_i); -- we map each value of L into the new ring Q
        return LNew;
);

-- main program
gensReducedIdeal = reduceAndMapGenerators(I);
numReducedGenerators = length gensReducedIdeal;
J = ideal(gensReducedIdeal);
dimJ = dim J;
degreeJ = degree J;
smplPoly = toString gensReducedIdeal_(numReducedGenerators - 1);

concatenate {"There are ", toString numReducedGenerators, " generators in ", varietyName}
concatenate {varietyName, " had dimension ", toString dimJ}
concatenate {varietyName, " had degree ", toString degreeJ}
concatenate {"A sample generator of ", varietyName, " is ", smplPoly}

-- There are 20 generators in V143
-- V143 had dimension 3
-- V143 had degree 16
-- A sample generator of V143 is 22050*S001*S100^3+28284*S011*S100^2*S101+257246*S100^3*S101+110804*S001*S010*S101^2+89216*S010^2*S101^2-165868*S001*S011*S101^2-129102*S010*S011*S101^2-75540*S011^2*S101^2-132088*S001*S100*S101^2 + ...

We compute the discrete signature variety for the case \(d=2\), \(h=2\) and \(N=3\).

-- d = 2
-- h = 2
-- N = 3
restart
R = QQ[a1,a2,b1,b2,c1,c2,s11,s12,s21,s22,t11,t22,t12,
Degrees => {6:1,7:1},
MonomialOrder => Eliminate 6];
vrbs = {a1, a1, b1, b2, c1, c2};

Q = QQ[S11, S12, S21, S22, T11, T12, T22,
Degrees => {7:1}];

mapFunction = map(Q, R, {a1 => 0, a2 => 0, b1 => 0, b2 => 0, c1 => 0, c2 => 0,
        s11 => S11, s12 => S12, s21 => S21, s22 => S22,
        t11 => T11, t12 => T12, t22 => T22});
varietyName = "V223";

I = ideal(
a1*b1+a1*c1+b1*c1-s11,
a1*b2+a1*c2+b1*c2-s12,
a2*b1+a2*c1+b2*c1-s21,
a2*b2+a2*c2+b2*c2-s22,
a1*a1+b1*b1+c1*c1-t11,
a2*a2+b2*b2+c2*c2-t22,
a1*a2+b1*b2+c1*c2-t12);



-- auxiliary functions
isVar = var -> member(var, vrbs);

hasNoVar = p -> (
        0 == number(support p, isVar)
);

reduceAndMapGenerators = K -> (
        -- reduce the ideal K in the ring R and map it into Q
        g = groebnerBasis I;
        lenGroebnerBasis = numColumns g;
        L = for i from 0 to lenGroebnerBasis-1 list (g_i)_0;
        L = select(L, hasNoVar);
        len_subbasis = length L;
        LNew = for i from 0 to len_subbasis-1 list mapFunction(L_i); -- we map each value of L into the new ring Q
        return LNew;
);

-- main program
gensReducedIdeal = reduceAndMapGenerators(I);
numReducedGenerators = length gensReducedIdeal;
J = ideal(gensReducedIdeal);
dimJ = dim J;
degreeJ = degree J;
smplPoly = toString gensReducedIdeal_(numReducedGenerators - 1);

concatenate {"There are ", toString numReducedGenerators, " generators in ", varietyName}
concatenate {varietyName, " had dimension ", toString dimJ}
concatenate {varietyName, " had degree ", toString degreeJ}
concatenate {"A sample generator of ", varietyName, " is ", smplPoly}

-- There are 1 generators in V223
-- V223 had dimension 6
-- V223 had degree 2
-- A sample generator of V223 is S12^2+2*S12*S21+S21^2-4*S11*S22-2*S22*T11+2*S12*T12+2*S21*T12+T12^2-2*S11*T22-T11*T22

It can be seen that this variety is a cubic hypersurface in \(\mathbb{P}^6\).

We compute the discrete signature variety for the case \(d=2\), \(h=2\) and \(N=4\).

-- d = 2
-- h = 2
-- N = 4
restart
R = QQ[a1,a2,b1,b2,c1,c2,d1,d2,s11,s12,s21,s22,t11,t22,t12,
Degrees => {8:1,7:1},
MonomialOrder => Eliminate 8];
vrbs = {a1, a1, b1, b2, c1, c2, d1, d2};

Q = QQ[S11, S12, S21, S22, T11, T12, T22,
Degrees => {7:1}];


mapFunction = map(Q, R, {a1 => 0, a2 => 0, b1 => 0, b2 => 0, c1 => 0, c2 => 0, d1 => 0, d2 => 0,
        s11 => S11, s12 => S12, s21 => S21, s22 => S22,
        t11 => T11, t12 => T12, t22 => T22});
varietyName = "V224";


I = ideal(
a1*b1+a1*c1+b1*c1+a1*d1+b1*d1+c1*d1-s11,
a1*b2+a1*c2+b1*c2+a1*d2+b1*d2+c1*d2-s12,
a2*b1+a2*c1+b2*c1+a2*d1+b2*d1+c2*d1-s21,
a2*b2+a2*c2+b2*c2+a2*d2+b2*d2+c2*d2-s22,
a1*a1+b1*b1+c1*c1+d1*d1-t11,
a2*a2+b2*b2+c2*c2+d2*d2-t22,
a1*a2+b1*b2+c1*c2+d1*d2-t12);


-- auxiliary functions
isVar = var -> member(var, vrbs);

hasNoVar = p -> (
        0 == number(support p, isVar)
);

reduceAndMapGenerators = K -> (
        -- reduce the ideal K in the ring R and map it into Q
        g = groebnerBasis I;
        lenGroebnerBasis = numColumns g;
        L = for i from 0 to lenGroebnerBasis-1 list (g_i)_0;
        L = select(L, hasNoVar);
        len_subbasis = length L;
        LNew = for i from 0 to len_subbasis-1 list mapFunction(L_i); -- we map each value of L into the new ring Q
        return LNew;
);

-- main program
gensReducedIdeal = reduceAndMapGenerators(I);
numReducedGenerators = length gensReducedIdeal;
J = ideal(gensReducedIdeal);
dimJ = dim J;
degreeJ = degree J;
smplPoly = toString gensReducedIdeal_(numReducedGenerators - 1);

concatenate {"There are ", toString numReducedGenerators, " generators in ", varietyName}
concatenate {varietyName, " had dimension ", toString dimJ}
concatenate {varietyName, " had degree ", toString degreeJ}
concatenate {"A sample generator of ", varietyName, " is ", smplPoly}

-- There are 1 generators in V224
-- V224 had dimension 6
-- V224 had degree 2
-- A sample generator of V224 is S12^2+2*S12*S21+S21^2-4*S11*S22-2*S22*T11+2*S12*T12+2*S21*T12+T12^2-2*S11*T22-T11*T22

We can see that we obtain the same variety as in the previous case.

We compute the discrete signature variety for the case \(d=2\), \(h=3\) and \(N=2\).

-- d = 2
-- h = 3
-- N = 2
restart
R = QQ[a1,a2,b1,b2,
s111,s112,s121,s122,s211,s212,s221,s222,
t111,t121,t221, t112, t122, t222,
u111, u211, u112, u212, u122, u222,
v111, v112, v122, v222,
Degrees => {4:1,24:1},
MonomialOrder => Eliminate 4];
vrbs = {a1, a1, b1, b2};


Q = QQ[S111,S112,S121,S122,S211,S212,S221,S222,
T111,T121,T221, T112, T122, T222,
U111, U211, U112, U212, U122, U222,
V111, V112, V122, V222,
Degrees => {24:1}];


mapFunction = map(Q, R, {a1 => 0, a2 => 0, b1 => 0, b2 => 0,
        s111 => S111, s112 => S112, s121 => S121, s122 => S122,
        s211 => S211, s212 => S212, s221 => S221, s222 => S222,
        t111 => T111, t121 => T121, t221 => T221,
        t112 => T112, t122 => T122, t222 => T222,
        u111 => U111, u211 => U211, u112 => U112,
        u212 => U212, u122 => U122, u222 => U222,
        v111 => V111, v112 => V112, v122 => V122, v222 => V222
        });
varietyName = "V232";


I = ideal(
0-s111,a1*a1*b1-t111,a1*b1*b1-u111,a1*a1*a1+b1*b1*b1-v111,
0-s112,a1*a2*b1-t121,a2*b1*b1-u211,a1*a1*a2+b1*b1*b2-v112,
0-s121,a2*a2*b1-t221,a1*b1*b2-u112,a1*a2*a2+b1*b2*b2-v122,
0-s122,a1*a1*b2-t112,a2*b1*b2-u212,a2*a2*a2+b2*b2*b2-v222,
0-s211,a1*a2*b2-t122,a1*b2*b2-u122,
0-s212,a2*a2*b2-t222,a2*b2*b2-u222,
0-s221,
0-s222
);



-- auxiliary functions
isVar = var -> member(var, vrbs);

hasNoVar = p -> (
        0 == number(support p, isVar)
);

reduceAndMapGenerators = K -> (
        -- reduce the ideal K in the ring R and map it into Q
        g = groebnerBasis I;
        lenGroebnerBasis = numColumns g;
        L = for i from 0 to lenGroebnerBasis-1 list (g_i)_0;
        L = select(L, hasNoVar);
        len_subbasis = length L;
        LNew = for i from 0 to len_subbasis-1 list mapFunction(L_i); -- we map each value of L into the new ring Q
        return LNew;
);

-- main program
gensReducedIdeal = reduceAndMapGenerators(I);
numReducedGenerators = length gensReducedIdeal;
J = ideal(gensReducedIdeal);
dimJ = dim J;
degreeJ = degree J;
smplPoly = toString gensReducedIdeal_(numReducedGenerators - 1);

concatenate {"There are ", toString numReducedGenerators, " generators in ", varietyName}
concatenate {varietyName, " had dimension ", toString dimJ}
concatenate {varietyName, " had degree ", toString degreeJ}
concatenate {"A sample generator of ", varietyName, " is ", smplPoly}

-- There are 1 generators in V232
-- V232 had dimension 4
-- V232 had degree 27
-- A sample generator of V232 is 4*T111^2*U112*V112^2-T112*V111^2*V112^2+2*U111^2*V112^3-T111*V111*V112^3-4*T111^2*U112*V111*V122+T112*V111^3*V122-2*T111^2*U111*V112*V122-3*U111^2*V111*V112*V122+2*T111*V111^2*V112*V122 + ...

The computation of the discrete signature variety for the case \(d=2\), \(h=3\) and \(N=3\) does not finish in a reasonable time.

We share the code below, but we do not provide the output.

-- d = 2
-- h = 3
-- N = 3
restart
R = QQ[a1,a2,b1,b2,c1,c2,
s111,s112,s121,s122,s211,s212,s221,s222,
t111,t121,t221,t112,t122,t222,
u111,u211,u112,u212,u122,u222,
v111,v112,v122,v222,
Degrees => {6:1,24:1},
MonomialOrder => Eliminate 6];

vrbs = {a1, a1, b1, b2, c1, c2};


Q = QQ[S111,S112,S121,S122,S211,S212,S221,S222,
T111,T121,T221, T112, T122, T222,
U111, U211, U112, U212, U122, U222,
V111, V112, V122, V222,
Degrees => {24:1}];


mapFunction = map(Q, R, {a1 => 0, a2 => 0, b1 => 0, b2 => 0, c1 => 0, c2 => 0,
        s111 => S111, s112 => S112, s121 => S121, s122 => S122,
        s211 => S211, s212 => S212, s221 => S221, s222 => S222,
        t111 => T111, t121 => T121, t221 => T221,
        t112 => T112, t122 => T122, t222 => T222,
        u111 => U111, u211 => U211, u112 => U112,
        u212 => U212, u122 => U122, u222 => U222,
        v111 => V111, v112 => V112, v122 => V122, v222 => V222
        });
varietyName = "V233";

I = ideal(
a1*b1*c1-s111,
a1*b1*c2-s112,
a1*b2*c1-s121,
a1*b2*c2-s122,
a2*b1*c1-s211,
a2*b1*c2-s212,
a2*b2*c1-s221,
a2*b2*c2-s222,
a1*a1*b1+a1*a1*c1+b1*b1*c1-t111,
a1*a1*b2+a1*a1*c2+b1*b1*c2-t112,
a1*a2*b1+a1*a2*c1+b1*b2*c1-t121,
a1*a2*b2+a1*a2*c2+b1*b2*c2-t122,
a2*a2*b1+a2*a2*c1+b2*b2*c1-t221,
a2*a2*b2+a2*a2*c2+b2*b2*c2-t222,
a1*b1*b1+a1*c1*c1+b1*c1*c1-u111,
a1*b1*b2+a1*c1*c2+b1*c1*c2-u112,
a1*b2*b2+a1*c2*c2+b1*c2*c2-u122,
a2*b1*b1+a2*c1*c1+b2*c1*c1-u211,
a2*b1*b2+a2*c1*c2+b2*c1*c2-u212,
a2*b2*b2+a2*c2*c2+b2*c2*c2-u222,
a1*a1*a1+b1*b1*b1+c1*c1*c1-v111,
a1*a1*a2+b1*b1*b2+c1*c1*c2-v112,
a1*a2*a2+b1*b2*b2+c1*c2*c2-v122,
a2*a2*a2+b2*b2*b2+c2*c2*c2-v222
);



-- auxiliary functions
isVar = var -> member(var, vrbs);

hasNoVar = p -> (
        0 == number(support p, isVar)
);

reduceAndMapGenerators = K -> (
        -- reduce the ideal K in the ring R and map it into Q
        g = groebnerBasis I;
        lenGroebnerBasis = numColumns g;
        L = for i from 0 to lenGroebnerBasis-1 list (g_i)_0;
        L = select(L, hasNoVar);
        len_subbasis = length L;
        LNew = for i from 0 to len_subbasis-1 list mapFunction(L_i); -- we map each value of L into the new ring Q
        return LNew;
);

-- main program
gensReducedIdeal = reduceAndMapGenerators(I);
numReducedGenerators = length gensReducedIdeal;
J = ideal(gensReducedIdeal);
dimJ = dim J;
degreeJ = degree J;
smplPoly = toString gensReducedIdeal_(numReducedGenerators - 1);

concatenate {"There are ", toString numReducedGenerators, " generators in ", varietyName}
concatenate {varietyName, " had dimension ", toString dimJ}
concatenate {varietyName, " had degree ", toString degreeJ}
concatenate {"A sample generator of ", varietyName, " is ", smplPoly}

-- There are ? generators in V233
-- V233 had dimension ?
-- V233 had degree ?
-- A sample generator of V233 is ?

We compute the discrete signature variety for the case \(d=3\), \(h=2\) and \(N=2\).

-- d = 3
-- h = 2
-- N = 2
restart
R = QQ[a1,a2,a3,b1,b2,b3,
s11, s12, s13, s21, s22, s23, s31, s32, s33,
t11, t12, t13, t22, t23, t33,
Degrees => {6:1,15:1},
MonomialOrder => Eliminate 6];

vrbs = {a1, a2, a3, b1, b2, b3};


Q = QQ[S11, S12, S13, S21, S22, S23, S31, S32, S33,
T11, T12, T13, T22, T23, T33,
Degrees => {15:1}];



mapFunction = map(Q, R, {a1 => 0, a2 => 0, a3 => 0, b1 => 0, b2 => 0, b3 => 0,
        s11 => S11, s12 => S12, s13 => S13,
        s21 => S21, s22 => S22, s23 => S23,
        s31 => S31, s32 => S32, s33 => S33,
        t11 => T11, t12 => T12, t13 => T13,
        t22 => T22, t23 => T23, t33 => T33
        });
varietyName = "V322";


I = ideal(
t11-a1*a1-b1*b1,
t12-a1*a2-b1*b2,
t13-a1*a3-b1*b3,
t22-a2*a2-b2*b2,
t23-a2*a3-b2*b3,
t33-a3*a3-b3*b3,
s11-a1*b1,
s12-a1*b2,
s13-a1*b3,
s21-a2*b1,
s22-a2*b2,
s23-a2*b3,
s31-a3*b1,
s32-a3*b2,
s33-a3*b3
);


-- auxiliary functions
isVar = var -> member(var, vrbs);

hasNoVar = p -> (
        0 == number(support p, isVar)
);

reduceAndMapGenerators = K -> (
        -- reduce the ideal K in the ring R and map it into Q
        g = groebnerBasis I;
        lenGroebnerBasis = numColumns g;
        L = for i from 0 to lenGroebnerBasis-1 list (g_i)_0;
        L = select(L, hasNoVar);
        len_subbasis = length L;
        LNew = for i from 0 to len_subbasis-1 list mapFunction(L_i); -- we map each value of L into the new ring Q
        return LNew;
);

-- main program
gensReducedIdeal = reduceAndMapGenerators(I);
numReducedGenerators = length gensReducedIdeal;
J = ideal(gensReducedIdeal);
dimJ = dim J;
degreeJ = degree J;
smplPoly = toString gensReducedIdeal_(numReducedGenerators - 1);

concatenate {"There are ", toString numReducedGenerators, " generators in ", varietyName}
concatenate {varietyName, " had dimension ", toString dimJ}
concatenate {varietyName, " had degree ", toString degreeJ}
concatenate {"A sample generator of ", varietyName, " is ", smplPoly}

-- There are 45 generators in V322
-- V322 had dimension 6
-- V322 had degree 32
-- A sample generator of V322 is S21^2*S32^2-S11*S22*S32^2-S21^2*S22*S33+S11*S22^2*S33+S21*S22*T13*T23-S11*S22*T23^2-S21*S22*T12*T33+S11*S22*T22*T33