‣ EliminateIfRowObsoleteForUnimodularityAsRightInverse( row ) | ( operation ) |
Returns: a list
For the given row row, check whether all but one elements in the right inverse generate the unit ideal. It returns a list [ V, VI ] such that row * V = [ 1 0 0 ... 0 ] and the first row of VI is the given row.
‣ EliminateUnitInAColumnAsRightInverse( row ) | ( operation ) |
Returns: a list
For the given row row, check whether the right inverse contains a unit. It returns a list [ V, VI ] such that row * V = [ 1 0 0 ... 0 ] and the first row of VI is the given row.
‣ EliminateUnimodularPairPositionPerColumnAsRightInverse( row ) | ( operation ) |
Returns: a list
For the given row row, check whether any two elements in the right inverse are coprime. It returns a list [ V, VI ] such that row * V = [ 1 0 0 ... 0 ] and the first row of VI is the given row.
‣ GetFirstMonicOfSmallestDegreeInRow( row, o ) | ( operation ) |
Returns: a positive integer
Checks whether there is any other monic of smaller degree than o-th position element. If found, returns the position of new monic, else returns o. It returns the position of the monic.
‣ CleanRowUsingMonicUptoUnit( row, o ) | ( operation ) |
Returns: a list
Cleans row using a monic at o-th position. It returns a list with the modified row and the transformation matrices.
‣ GetObsoleteColumnForUnimodularity( row, unclean_cols ) | ( operation ) |
Returns: a list
Checks whether any \((n-1)\) elements among the \(n\) unclean_cols positions of row generate a unit ideal. It returns a list [ j, r, h ] where
j = Except j-th entry, all other elements generate \(1\)
r = list of positions of entries that generate \(1\)
h = the right inverse of r-subrow
‣ GetObsoleteColumnForUnimodularity( M, unclean_rows, unclean_cols ) | ( operation ) |
Returns: a list
Checks whether any \((n-1)\) elements among the \(n\) unclean_cols positions of one of the rows among unclean_rows generate a unit ideal. It returns a list [ j, r, h, i ] where
j = Except j-th entry, all other elements of the i-th row generate \(1\)
r = list of positions of entries that generate \(1\)
h = the right inverse of r-subrow
i = i-th row
‣ GetObsoleteColumnForUnimodularity( M ) | ( operation ) |
Returns: a list
Checks whether any \((n-1)\) elements of some row of M generate a unit ideal. It returns a list [ j, r, h, i ] where
j = Except j-th entry, all other elements of the i-th row generate \(1\)
r = list of positions of entries that generate \(1\)
h = the right inverse of r-subcolumn
i = i-th row
‣ EliminateIfColumnObsoleteForUnimodularity( row ) | ( operation ) |
Returns: a list
If any \((n-1)\) elements of the row generate \(1\), then this function cleans the row and returns the transformation matrix and its inverse. It returns a list of two matrices V and VI such that row * V = [ 1 0 0 ... 0 ] and the first row of VI is the given row.
gap> Q := HomalgFieldOfRationalsInSingular( );; gap> R := Q * "x1..5"; Q[x1,x2,x3,x4,x5] gap> row := HomalgMatrix( "[ \ > 120*x1^2-96*x1*x2+12*x2^2-96*x1*x3+60*x2*x3+18*x3^2+176*x1*x4\ > -32*x2*x4-108*x3*x4+20*x4^2-128*x1*x5+80*x2*x5+48*x3*x5-144*x4*x5\ > +32*x5^2+40*x1-4*x2+20*x4+15,\ > -48*x1^2+24*x1*x2-12*x2^2+60*x1*x3-24*x2*x3-18*x3^2-32*x1*x4\ > +32*x2*x4+36*x3*x4-20*x4^2+80*x1*x5\-32*x2*x5-48*x3*x5+48*x4*x5\ > -32*x5^2-4*x1-14*x2+22*x4+1,\ > -48*x1^2+60*x1*x2-12*x2^2+36*x1*x3-36*x2*x3-108*x1*x4+36*x2*x4\ > +72*x3*x4-24*x4^2+48*x1*x5-48*x2*x5+96*x4*x5-2,\ > 88*x1^2-32*x1*x2+16*x2^2-108*x1*x3+36*x2*x3+36*x3^2+40*x1*x4\ > -40*x2*x4-48*x3*x4+24*x4^2-144*x1*x5+48*x2*x5+96*x3*x5-64*x4*x5\ > +64*x5^2+20*x1+22*x2-30*x4+7,\ > -64*x1^2+80*x1*x2-16*x2^2+48*x1*x3-48*x2*x3-144*x1*x4+48*x2*x4\ > +96*x3*x4-32*x4^2+64*x1*x5-64*x2*x5+128*x4*x5-2\ > ]", 1, 5, R ); <A 1 x 5 matrix over an external ring> gap> EliminateIfColumnObsoleteForUnimodularity( row ); [ <An unevaluated 5 x 5 matrix over an external ring>, <An unevaluated 5 x 5 matrix over an external ring> ] gap> n := NrColumns( row );; gap> Assert( 4, row * l[1] = CertainRows( HomalgIdentityMatrix( n, R ), [ 1 ] ) ); gap> Assert( 4, CertainRows( l[2], [ 1 ] ) = row );
‣ GetUnimodularPairPositionPerRow( row ) | ( operation ) |
Returns: a list
Checks whether any two elements of row are coprime. It returns a list [ l, [ i, j ] ] where
i and j-th elements are coprime with each other
l is the syzygy of these two elements.
‣ EliminateUnimodularPairPositionPerRow( row ) | ( operation ) |
Returns: a list
If any two elements of row are coprime, then this function cleans the row and returns the transformation matrix and its inverse. It returns a list of two matrices V and VI such that row * V = [ 1 0 0 ... 0 ] and the first row of VI is the given row.
gap> Q := HomalgFieldOfRationalsInSingular( );; gap> R := Q * "x1..5"; Q[x1,x2,x3,x4,x5] gap> row := HomalgMatrix( "[ \ > 4*x1+4*x2-8*x3-8*x4-4*x5+17, 4*x1+4*x2-8*x3-8*x4-4*x5+12, \ > -8*x1-8*x2+16*x3+16*x4+8*x5-27, -8*x1-8*x2+16*x3+16*x4+8*x5-28,\ > -4*x1-4*x2+8*x3+8*x4+4*x5-16 \ > ]", 1, 5, R ); <A 1 x 5 matrix over an external ring> gap> l := EliminateUnimodularPairPositionPerRow( row ); [ <An unevaluated 5 x 5 matrix over an external ring>, <An unevaluated 5 x 5 matrix over an external ring> ] gap> n := NrColumns( row );; gap> Assert( 4, row * l[1] = CertainRows( HomalgIdentityMatrix( n, R ), [ 1 ] ) ); gap> Assert( 4, CertainRows( l[2], [ 1 ] ) = row );
‣ EliminateUnitInARow( row ) | ( operation ) |
Returns: a list
The row contains a unit, then this function cleans the row using this unit and return the transformation matrices. It returns a list of two matrices V and VI such that row * V = [ 1 0 0 ... 0 ] and the first row of VI is the given row.
‣ GetFirstMonicOfSmallestDegreeInColumn( col, o ) | ( operation ) |
Returns: a positive integer
Checks whether there is any other monic of smaller degree than o-th position element. If found, returns the position of new monic, else returns o. It returns the position of the monic.
‣ CleanColumnUsingMonicUptoUnit( col, o ) | ( operation ) |
Returns: a list
Cleans col using a monic at o-th position. It returns a list with the modified column and transformation matrices.
‣ GetObsoleteRowForUnimodularity( col, unclean_rows ) | ( operation ) |
Returns: a list
Checks whether any \((n-1)\) elements among the \(n\) unclean_rows positions of col generate a unit ideal. It returns a list [ j, r, h ] where
j = Except j-th entry, all other elements generate \(1\)
r = list of positions of entries that generate \(1\)
h = the left inverse of r-subcolumn
‣ GetObsoleteRowForUnimodularity( M, unclean_cols, unclean_rows ) | ( operation ) |
Returns: a list
Checks whether any \((n-1)\) elements among the \(n\) unclean_rows positions of one of the columns among unclean_cols generate a unit ideal. It returns a list [ j, r, h, i ] where
j = Except j-th entry, all other elements of the i-th column generate \(1\)
r = list of positions of entries that generate \(1\)
h = the left inverse of r-subcolumn
i = i-th column
‣ GetObsoleteRowForUnimodularity( M ) | ( operation ) |
Returns: a list
Checks whether any \((n-1)\) elements of some column of M generate a unit ideal. It returns a list [ j, r, h, i ] where
j = Except j-th entry, all other elements of the i-th column generate \(1\)
r = list of positions of entries that generate \(1\)
h = the right inverse of r-subcolumn
i = i-th column
‣ EliminateIfRowObsoleteForUnimodularity( col ) | ( operation ) |
Returns: a list
If any \((n-1)\) elements of the column generate \(1\), then this function cleans the col and returns the transformation matrix and its inverse. It returns a list of two matrices U and UI such that U * col = Column( [ 1 0 0 ... 0 ] ) and the first column of UI is the given column.
gap> Q := HomalgFieldOfRationalsInSingular( );; gap> R := Q * "x1..5"; Q[x1,x2,x3,x4,x5] gap> col := HomalgMatrix( "[ \ > 120*x1^2-96*x1*x2+12*x2^2-96*x1*x3+60*x2*x3+18*x3^2+176*x1*x4\ > -32*x2*x4-108*x3*x4+20*x4^2-128*x1*x5+80*x2*x5+48*x3*x5-144*x4*x5\ > +32*x5^2+40*x1-4*x2+20*x4+15,\ > -48*x1^2+24*x1*x2-12*x2^2+60*x1*x3-24*x2*x3-18*x3^2-32*x1*x4\ > +32*x2*x4+36*x3*x4-20*x4^2+80*x1*x5\-32*x2*x5-48*x3*x5+48*x4*x5\ > -32*x5^2-4*x1-14*x2+22*x4+1,\ > -48*x1^2+60*x1*x2-12*x2^2+36*x1*x3-36*x2*x3-108*x1*x4+36*x2*x4\ > +72*x3*x4-24*x4^2+48*x1*x5-48*x2*x5+96*x4*x5-2,\ > 88*x1^2-32*x1*x2+16*x2^2-108*x1*x3+36*x2*x3+36*x3^2+40*x1*x4\ > -40*x2*x4-48*x3*x4+24*x4^2-144*x1*x5+48*x2*x5+96*x3*x5-64*x4*x5\ > +64*x5^2+20*x1+22*x2-30*x4+7,\ > -64*x1^2+80*x1*x2-16*x2^2+48*x1*x3-48*x2*x3-144*x1*x4+48*x2*x4\ > +96*x3*x4-32*x4^2+64*x1*x5-64*x2*x5+128*x4*x5-2\ > ]", 5, 1, R ); <A 5 x 1 matrix over an external ring> gap> l := EliminateIfRowObsoleteForUnimodularity( col ); [ <An unevaluated 5 x 5 matrix over an external ring>, <An unevaluated 5 x 5 matrix over an external ring> ] gap> n := NrRows( col );; gap> Assert( 4, l[1] * col = CertainColumns( HomalgIdentityMatrix( n, R ), [ 1 ] ) ); gap> Assert( 4, CertainColumns( l[2], [ 1 ] ) = col );
‣ GetUnimodularPairPositionPerColumn( col ) | ( operation ) |
Returns: a list
Checks whether any two elements of col are coprime. It returns a list [ l, [ i, j ] ] where
i and j-th elements are coprime with each other
l is the syzygy of these two elements.
‣ EliminateUnimodularPairPositionPerColumn( col ) | ( operation ) |
Returns: a list
If any two elements of col are coprime, then this function cleans the col and returns the transformation matrix and its inverse. It returns a list of two matrices U and UI such that U * col = Column( [ 1 0 0 ... 0 ] ) and the first column of UI is the given column.
gap> Q := HomalgFieldOfRationalsInSingular( );; gap> R := Q * "x1..5"; Q[x1,x2,x3,x4,x5] gap> col := HomalgMatrix( "[ \ > 4*x1+4*x2-8*x3-8*x4-4*x5+17, 4*x1+4*x2-8*x3-8*x4-4*x5+12, \ > -8*x1-8*x2+16*x3+16*x4+8*x5-27, -8*x1-8*x2+16*x3+16*x4+8*x5-28,\ > -4*x1-4*x2+8*x3+8*x4+4*x5-16 \ > ]", 5, 1, R ); <A 5 x 1 matrix over an external ring> gap> l := EliminateUnimodularPairPositionPerColumn( col ); [ <An unevaluated 5 x 5 matrix over an external ring>, <An unevaluated 5 x 5 matrix over an external ring> ] gap> n := NrRows( col );; gap> Assert( 4, l[1] * col = CertainColumns( HomalgIdentityMatrix( n, R ), [ 1 ] ) ); gap> Assert( 4, CertainColumns( l[2], [ 1 ] ) = col );
‣ EliminateUnitInAColumn( col ) | ( operation ) |
Returns: a list
The col contains a unit, then this function cleans the col using this unit and return the transformation matrices. It returns a list of two matrices U and UI such that U * col = Column( [ 1 0 0 ... 0 ] ) and the first column of UI is the given column.
generated by GAPDoc2HTML