CoCoA » CoCoALib

Here is a simple failing case:

ZZ6 ::= ZZ/(6);
M := IdentityMat(ZZ6,6);
det(M);  --> ERROR (not sparse poly ring !??!)
M^(-1);  --> ERROR (not int.dom.)

Inverse always fails, but det succeeds up to size 5x5 because small matrices are handled specially.

I'm now wondering what is the difference between ConstMatrixViewBase::myDet and DenseMatImpl::myDet...

Now det of a matrix over ZZ/(6) work also for larger matrices, but it is horribly slow :-(

ZZ6 ::= ZZ/(6);
M := IdentityMat(ZZ6,11);
det(M); --> takes 22s

Why does it not recognise that M is an identity matrix?
In this case we could "speculatively" try gauss (it will work), or alternatively compute det over ZZ and then reduce mod 6...

Here are some more examples which should work, but which do not:

/**/ ZZ15 ::= ZZ/(15);
/**/ M := mat(ZZ15, [[5,3],[3,5]]);
/**/ inverse(M);
--> ERROR: Ring is not an integral domain
--> [CoCoALib] InverseByGauss(Mat)  over non-integral domain
--> inverse(M);
--> ^^^^^^^^^^
/**/ det(M);
1
/**/ M := mat(ZZ15, [[5,3,3],[3,5,3],[3,3,5]]);
/**/ det(M);
-1
/**/ inverse(M);
--> ERROR: Ring is not an integral domain

Note that det works here but inverse does not. As observed earlier, it could be tricky deciding how to compute the inverse since all entries are zero-divisors.

Here is a way of making test cases for computing determinant:
take a unimodular matrix, and multiply it by a nzzd (which is not nilpotent).
So every entry is a zero-divisor, and all linear combinations of rows/cols contain only zero-divisors.

One possible approach is to represent the determinant as a sum of two other determinants,
by representing the [1,1]-element as a sum of two non-zero-divisors; compute recursively
the dets of the two matrices obtained by substituting the two summands in posn [1,1].
A problem is that we would have to repeat this process for each row/col; there would
have to be about 2^n low-level det computations.

I wonder if there is some clever "fraction-free" method.

Another (daft?) idea: if all entries are zero-divisors then try multiplying the matrix
by a random unimodular one. Maybe we will be lucky and get a matrix some of whose entries
are "nice" (i.e. not zero-divisors).

Two concrete examples:

UniMod := matrix(ZZ, [[1, 1, 3],  [2, 1, 4],  [1, 1, 2]]);
M := 3*matrix(ZZ15, UniMod); // all entries are nzzds

Here is a "lucky" multiplication by a unimodular mat:

N := mat(ZZ15, [[5,3,3],[3,5,3],[3,3,5]]);
N*mat(ZZ15, UniMod); // UniMod from example above
matrix( ZZ15, 
 [[-1, -4, 3],
  [1, -4, 5],
  [-1, -4, 1]])