
5.1.90 minor
Syntax:
minor ( matrix_expression M, int_expression mSize,
[ ideal_expression I],
[ int_expression k],
[ string_expression algorithm],
[ int_expression cachedP],
[ int_expression cachedM])
Type:
 ideal
Purpose:
 returns the specified set of (mSize x mSize)minors (= subdeterminants)
of the given matrix M. These minors form the list of generators of the
returned ideal.
If the optional ideal I is given, it is assumed to capture a standard
basis. In this case, all computations will be performed modulo I.
If k is not given, all minors will be computed. Otherwise, if k > 0,
the first k nonzero minors will be computed; for k < 0, the first k
minors will be computed regardless whether they are zero or not. Here,
"first k minors" is with respect to a fixed ordering among all
minors. (To understand the ordering, run the below example, type
minor(m,2,i,18); and inspect the ordering among the returned 18
minors. Note that this ordering is only enforced
when some k <> 0 is provided. Otherwise, no ordering among the returned
minors can be guaranteed. This is due to the fact that in this case,
minor may call a specially tuned implementation of Bareiss's
algorithm.)
If no algorithm is given, a heuristic will pick the bestsuited algorithm
among Bareiss's algorithm (which is only applicable over integral domains),
Laplace's algorithm, and Laplace's algorithm combined with caching of
subdeterminantes. In the heuristic setting, cacheP and cacheM must also be
absent.
If the argument algorithm is present it must be one of B/bareiss ,
L/laplace , and C/cache . For, B/bareiss and
L/laplace the optional arguments cacheP and cacheM must again
be absent, whereas for C/cache , they may be provided: cachedP
determines the maximum number of cached subdeterminantes (=polynomials),
and cachedM the total number of cached monomials (counted over all cached
polynomials). If, for algorithm = C/cache cachedP and cachedM are
not provided by the user, the values 200 and 100000, respectively, will
be used as defaults.
Note:
 If
mSize is larger than the given matrix, minor returns 0,
if mSize is smaller than 1, minor returns 1.
Example:
 ring r=0,(a,b,c,d,e,f,g,h,s,t,u,v),ds;
matrix m[3][4]=a,b,c,d,e,f,g,h,s,t,u,v;
print(m);
==> a,b,c,d,
==> e,f,g,h,
==> s,t,u,v
// let's compute all nonzero minors;
// here we do not guarantee any ordering:
minor(m,2);
==> _[1]=hu+gv
==> _[2]=ht+fv
==> _[3]=hs+ev
==> _[4]=du+cv
==> _[5]=dt+bv
==> _[6]=ds+av
==> _[7]=gtfu
==> _[8]=gseu
==> _[9]=ctbu
==> _[10]=csau
==> _[11]=fs+et
==> _[12]=bs+at
==> _[13]=dg+ch
==> _[14]=df+bh
==> _[15]=de+ah
==> _[16]=cfbg
==> _[17]=ceag
==> _[18]=be+af
ideal i=a,c; i=std(i);
// here come the first 4 nonzero minors mod I;
// this time, a fixed ordering is guaranteed:
minor(m,2,i,4);
==> _[1]=be
==> _[2]=bg
==> _[3]=de
==> _[4]=df+bh
// and here the first 4 minors mod I (possibly zero)
// using Laplace's algorithm,
// again, the fixed ordering is guaranteed:
minor(m,2,i,4,"Laplace");
==> _[1]=be
==> _[2]=0
==> _[3]=bg
==> _[4]=de

See
det.
