RowReduce for symbolic matrices

Question

I'd like to invoke RowReduce on some matrices with a time parameter.

For example consider

A = {{1, 0}, {0, t}}

If t = 0, we have

RowReduce[A /. t -> 0] = {{1, 0}, {0, 0}}

but RowReduce[A] always returns the identity matrix.

How can I tell Mathematica to distinguish cases where there might be division by zero?

Edit: Maybe I need to clarify my problem a bit more. I don't know much about the matrices, except that they contain some time dependence. Now, whatever form the given matrix has, I want to perform some operation to attain a (time-depending) row-echelon form of my matrix that is valid for all $t \in I\subseteq\mathbb{R}$.

Answer 1

This problem is discussed in the "Handbook of Linear Algebra" book:

When standard linear algebra methods are applied to matrices containing symbolic entries, the user must be aware of new mathematical features that can arise. The main feature is the discontinuity of standard matrix functions, such as the reduced row-echelon form and the rank, both of which can be discontinuous. [...] The recommended solution is to use Turing factoring (generalized PLU decomposition) to obtain the reduced row-echelon form with provisos.

I don't think that the "Turing factorization of rectangular matrix" is implemented in Mathematica (it seems to be the case for Maple and Matlab). You can always settle on a upper-triangular form from the plain LU decomposition, which does not make assumptions such as those made by the RowReduce function:

m = {{aa, bb}, {cc, dd}};
n = Length[m] (* == Length[Transpose[m]]*)
{lu, p, c} = LUDecomposition[m];
(u = lu  SparseArray[{i_, j_} /; j >= i -> 1, {n, n}]) // TableForm

(* sanity check *)
l = lu SparseArray[{i_, j_} /; j < i -> 1, {n, n}] + IdentityMatrix[n];
m[[p]] == l.u

NB: a very similar question was already asked here (duplicate?).

Answer 2

I believe this is a case where Mathematica is giving a generic answer: for all t!=0, the proper answer is indeed the 2 by 2 identity, but for the specific value t=0, you get the specific solution. So one way to distinguish these is to do a test of the matrix rank and then proceed accordingly. For the test case,

a = {{1, 0}, {0, t}};
MatrixRank[a]

gives 2 but

MatrixRank[a /. t -> 0]

gives 1. More generally, say the matrix has a function of t:

a = {{1, 0}, {0, f[t]}};

Then one can similarly test using

MatrixRank[a]
MatrixRank[a /. f[t] -> 0]

The first returns 2 and the second gives 1.

Answer 3

If you "don't know much about matrices" the Presentations Application, which I sell through my web site, has a Student's Linear Equation section that allows one to manipulate matrix structures step by step using various basic matrix operations. One can compose matrix structures, operate on them, print them and there is also a palette display from which one can paste positions. One can also display the matrices in equation form. Linear programming operations are allowed as well as the regular operations. There is even a provision for contravariant columns. One of the problems with matrices is that they lack context. How was the original matrix defined? Are you dealing with it, or the transpose, or the inverse, or the inverse transpose? Here the rows and columns are always labeled to give context. So here is a variant of your example:

<< Presentations`
amat = {{1, t}, {-1, 0}};

First we set up the matrix form. The LEWhiteboard is a palette that displays the current structure and allows positions to be pasted into commands.

seExample = LECreate[2, 4];
LEColumnDividers[seExample, {2}]
LEWhiteboard[seExample]
LEPrint[seExample]

Next we fill in the matrix also giving new row and column names.

LEInsertRowNames[seExample, 1, {y1, y2}]
LEInsertColumnNames[seExample, 1, {x1, x2, y1, y2}]
LEInsertMatrix[seExample, {1, 1}, amat]
LEInsertMatrix[seExample, {1, 3}, IdentityMatrix[2]]
LEPrint[seExample]

The following extracts the equations from the matrix structure.

LERowExpression[seExample, #, 3 ;; 4] == 
    LERowExpression[seExample, #, 1 ;; 2] & /@ {1, 2} // Column

The following does a pivot on the first row and column to give upper echelon row form. One can do full pivots or just pivot on select rows.

LEPivot[seExample, {1, 1}, 2 ;; 2]
LEPrint[seExample]

Next we set t to zero and also draw an extra row divider.

seExample = seExample /. t -> 0;
LERowDividers[seExample, {1}]
LEPrint[seExample]

Finally, we display the new row equations. The last equation gives the restraint that must hold among the y's when t = 0.

LERowExpression[seExample, #, 3 ;; 4] == 
    LERowExpression[seExample, #, 1 ;; 2] & /@ {1, 2} // Column

This is useful for learning basic matrix operations and working small problems within a context.