Wolfram Language & System Documentation Center

SymmetricMatrixQ

gives True if m is explicitly symmetric, and False otherwise.

Details and Options

A matrix m is symmetric if m==Transpose[m].
SymmetricMatrixQ works for symbolic as well as numerical matrices.
The following options can be given:
SameTest Automatic function to test equality of expressions

Tolerance Automatic tolerance for approximate numbers
For exact and symbolic matrices, the option SameTest->f indicates that two entries m_ij and m_kl are taken to be equal if f[m_ij,m_kl] gives True.
For approximate matrices, the option Tolerance->t can be used to indicate that all entries Abs[m_ij]≤t are taken to be zero.
For matrix entries Abs[m_ij]>t, equality comparison is done except for the last bits, where is $MachineEpsilon for MachinePrecision matrices and for matrices of Precision .

Examples

open all close all

Basic Examples (2)

Test if a 2×2 numeric matrix is explicitly symmetric:

Wolfram Language code:

SymmetricMatrixQ[(⁠|   |   |
| - | - |
| 1 | 2 |
| 2 | 3 |⁠)]

Test if a 3×3 symbolic matrix is explicitly symmetric:

Wolfram Language code:

SymmetricMatrixQ[(⁠|   |   |   |
| - | - | - |
| a | b | c |
| b | d | e |
| c | e | f |⁠)]

Scope (10)

Basic Uses (6)

Test if a real machine-precision matrix is symmetric:

Wolfram Language code: m = {{1, 2.3}, {2.3, 2}};

Wolfram Language code: SymmetricMatrixQ[m]

A real symmetric matrix is also Hermitian:

Wolfram Language code: HermitianMatrixQ[m]

Test if a complex matrix is symmetric:

Wolfram Language code: m = {{1 + I, 2 - 3I}, {2 - 3I, 2 - 3I}};

Wolfram Language code: SymmetricMatrixQ[m]

A complex symmetric matrix has symmetric real and imaginary parts:

Wolfram Language code: {SymmetricMatrixQ[Re[m]], SymmetricMatrixQ[Im[m]]}

Test if an exact matrix is symmetric:

Wolfram Language code:

m = (⁠|   |    |    |
| - | -- | -- |
| 4 | -5 | 2  |
| 3 | -3 | -3 |
| 5 | 5  | 5  |⁠);

Wolfram Language code: SymmetricMatrixQ[m]

Make the matrix symmetric:

Wolfram Language code: SymmetricMatrixQ[(m + m^/2)]

Use SymmetricMatrixQ with an arbitrary-precision matrix:

Wolfram Language code: m = RandomReal[5, {3, 3}, WorkingPrecision -> 15]

A random matrix is typically not symmetric:

Wolfram Language code: SymmetricMatrixQ[m]

Use SymmetricMatrixQ with a symbolic matrix:

Wolfram Language code: SymmetricMatrixQ[{{a, b}, {c, d}}]

The matrix becomes symmetric when :

Wolfram Language code: Block[{c = b}, SymmetricMatrixQ[{{a, b}, {c, d}}]]

SymmetricMatrixQ works efficiently with large numerical matrices:

Wolfram Language code: m = RandomReal[1, {1000, 1000}];

Wolfram Language code: AbsoluteTiming[SymmetricMatrixQ[m]]

Wolfram Language code:

a = m + m^;
AbsoluteTiming[SymmetricMatrixQ[a]]

Special Matrices (4)

Use SymmetricMatrixQ with sparse matrices:

Wolfram Language code: SparseArray[{i_, j_} -> (i - j)^2 / (i + j)^2, {5, 5}]

Wolfram Language code: SymmetricMatrixQ[%]

Use SymmetricMatrixQ with structured matrices:

Wolfram Language code: SymmetrizedArray[{{1, 2} -> a, {2, 3} -> b}, {3, 3}, Symmetric[{1, 2}]]

Wolfram Language code: SymmetricMatrixQ[%]

Use with a QuantityArray structured matrix:

Wolfram Language code: QuantityArray[{{1, 2}, {3, 4}}, "Meters"]

Wolfram Language code: SymmetricMatrixQ[%]

The identity matrix is symmetric:

Wolfram Language code: SymmetricMatrixQ[IdentityMatrix[5]]

HilbertMatrix is symmetric:

Wolfram Language code: SymmetricMatrixQ[HilbertMatrix[5]]

Options (2)

SameTest (1)

This matrix is symmetric for a positive real , but SymmetricMatrixQ gives False:

Wolfram Language code: m = {{1, Log[x ^ 2]}, {2 Log[x], 2}};

Wolfram Language code: SymmetricMatrixQ[m]

Use the option SameTest to get the correct answer:

Wolfram Language code: SymmetricMatrixQ[m, SameTest -> (Simplify[#1 - #2, x > 0] == 0&)]

Tolerance (1)

Generate a real-valued symmetric matrix with some random perturbation of order 10^-14:

Wolfram Language code:

SeedRandom[123];
m = Block[{a = RandomReal[1, {3, 3}]}, a + a^];
m = m + 10^-14 RandomReal[10, {3, 3}];

Wolfram Language code: SymmetricMatrixQ[m]

Adjust the option Tolerance to accept this matrix as symmetric:

Wolfram Language code: SymmetricMatrixQ[m, Tolerance -> 10 ^ -12]

The norm of the difference between the matrix and its transpose:

Wolfram Language code: m - m^//Norm

Applications (13)

Generating Symmetric Matrices (4)

Any matrix generated from a symmetric function is symmetric:

Wolfram Language code: f[i_, j_] := i j

The function is symmetric:

Wolfram Language code: f[i, j] == f[j, i]

Using Table generates a symmetric matrix:

Wolfram Language code: SymmetricMatrixQ[Table[f[i, j], {i, 5}, {j, 5}]]

SymmetrizedArray can generate matrices (and general arrays) with symmetries:

Wolfram Language code: SymmetrizedArray[{{1, 2} -> a, {2, 3} -> b}, {3, 3}, Symmetric[{1, 2}]]

Wolfram Language code: SymmetricMatrixQ[%]

Convert back to an ordinary matrix using Normal:

Wolfram Language code:

Normal[SymmetrizedArray[StructuredArray`StructuredData[{3, 3}, {{{1, 2} -> a, {2, 3} -> b}, 
   Symmetric[{1, 2}]}]]]

Check that matrices drawn from GaussianOrthogonalMatrixDistribution are symmetric:

Wolfram Language code: SymmetricMatrixQ /@ RandomVariate[GaussianOrthogonalMatrixDistribution[3], 10]

Matrices drawn from CircularOrthogonalMatrixDistribution are symmetric and unitary:

Wolfram Language code: (mat |-> SymmetricMatrixQ[mat]∧UnitaryMatrixQ[mat] ) /@ RandomVariate[CircularOrthogonalMatrixDistribution[3], 10]

Every Jordan matrix is similar to a symmetric matrix. Since any square matrix is similar to its Jordan form, this means that any square matrix is similar to a symmetric matrix. Define a function for generating an Jordan block for eigenvalue :

Wolfram Language code: j[λ_, n_] := λ IdentityMatrix[n] + SparseArray[{Band[{1, 2}] -> 1}, {n, n}]

For example, here is the Jordan matrix of dimension 4 for the eigenvalue :

Wolfram Language code: j[λ, 4]//MatrixForm

Define a function for generating a corresponding complex similarity transformation:

Wolfram Language code: s[n_] := (1/Sqrt[2]) (IdentityMatrix[n] + SparseArray[{Band[{1, n}, {n, 1}, {1, -1}] -> I}, {n, n}])

The matrix is a sum of times the identity matrix and times the backward identity matrix:

Wolfram Language code: s[4]//MatrixForm

Then is symmetric, which shows that the Jordan matrix is similar to a symmetric matrix:

Wolfram Language code: s[4].j[λ, 4].Inverse[s[4]]//Simplify//MatrixForm

Confirm the matrix is symmetric:

Wolfram Language code: SymmetricMatrixQ[%]

Examples of Symmetric Matrices (5)

The Hessian matrix of a function is symmetric:

Wolfram Language code: f[x_, y_] := Log[Cos[x] ^ 2 + Sin[y]];

Wolfram Language code: hessian = D[f[x, y], {{x, y}, 2}]

Wolfram Language code: SymmetricMatrixQ[hessian]

Many special matrices are symmetric, including FourierMatrix:

Wolfram Language code: SymmetricMatrixQ[FourierMatrix[2 ^ 7]]

HadamardMatrix:

Wolfram Language code: SymmetricMatrixQ[HadamardMatrix[2 ^ 7]]

HankelMatrix:

Wolfram Language code: SymmetricMatrixQ[HankelMatrix[Range[100], Range[100, 1, -1]]]

And HilbertMatrix:

Wolfram Language code: SymmetricMatrixQ[HilbertMatrix[100]]

Visualize the matrix types:

Wolfram Language code:

Table[MatrixPlot[g, FrameTicks -> None], {g, {FourierMatrix[2 ^ 7], HadamardMatrix[2 ^ 7], HankelMatrix[Range[100], Range[100, 1, -1]], HilbertMatrix[100]}}]

Many filter kernel matrices are symmetric, including DiskMatrix:

Wolfram Language code: SymmetricMatrixQ[DiskMatrix[7]]

CrossMatrix:

Wolfram Language code: SymmetricMatrixQ[CrossMatrix[1]]

DiamondMatrix:

Wolfram Language code: SymmetricMatrixQ[DiamondMatrix[10]]

Visualize the matrices:

Wolfram Language code: {ArrayPlot[DiskMatrix[7]], ArrayPlot[CrossMatrix[1]], ArrayPlot[DiamondMatrix[10]]}

AdjacencyMatrix of an undirected graph is symmetric:

Wolfram Language code: AdjacencyMatrix[[image]]

Wolfram Language code: SymmetricMatrixQ[%]

As is KirchhoffMatrix:

Wolfram Language code: KirchhoffMatrix[[image]]

Wolfram Language code: SymmetricMatrixQ[%]

Visualize adjacency and Kirchhoff matrices for different graphs:

Wolfram Language code:

{Table[MatrixPlot[AdjacencyMatrix[g], FrameTicks -> None], {g, {CirculantGraph[12, {2, 4}], HypercubeGraph[6], PetersenGraph[10, 8]}}], Table[MatrixPlot[KirchhoffMatrix[g], FrameTicks -> None], {g, {CirculantGraph[12, {2, 4}], HypercubeGraph[6], PetersenGraph[10, 8]}}]}

Several statistical measures are symmetric matrices, including Covariance:

Wolfram Language code: data = RandomVariate[DirichletDistribution[Range[5]], 10^3];

Wolfram Language code: SymmetricMatrixQ[Covariance[data]]

Correlation:

Wolfram Language code: SymmetricMatrixQ[Correlation[data]]

AbsoluteCorrelation:

Wolfram Language code: SymmetricMatrixQ[AbsoluteCorrelation[data]]

Uses of Symmetric Matrices (4)

A positive-definite, real symmetric matrix or metric defines an inner product by :

Wolfram Language code: (g = {{7, 2, 0}, {2, 6, -2}, {0, -2, 5}})//MatrixForm

Wolfram Language code: ip[u_, v_] := u.g.v

Verify that is in fact symmetric and positive definite:

Wolfram Language code: SymmetricMatrixQ[g] && PositiveDefiniteMatrixQ[g]

Orthogonalize the standard basis of $TemplateBox[{}, Reals]^n$ to find an orthonormal basis:

Wolfram Language code: {Subscript[e, 1], Subscript[e, 2], Subscript[e, 3]} = Orthogonalize[IdentityMatrix[3], ip]

Confirm that this basis is orthonormal with respect to the inner product :

Wolfram Language code: Table[ip[Subscript[e, i], Subscript[e, j]], {i, 3}, {j, 3}]//Simplify

The moment of inertia tensor is the equivalent of mass for rotational motion. For example, kinetic energy is , with taking the place of the mass and angular velocity taking the place of linear velocity in the formula . can be represented by a positive-definite symmetric matrix. Compute the moment of inertia for a tetrahedron with endpoints at the origin and positive coordinate axes:

Wolfram Language code:

MomentOfInertia[Tetrahedron[{{0, 0, 0}, {a, 0, 0}, {0, b, 0}, {0, 0, c}}], Assumptions -> {a, b, c}∈PositiveReals]//MatrixForm

Verify that the matrix is symmetric:

Wolfram Language code: SymmetricMatrixQ[%]

Compute the kinetic energy if its angular velocity is :

Wolfram Language code:

(1/2){Subscript[ω, x], Subscript[ω, y], Subscript[ω, z]}.%%.{Subscript[ω, x], Subscript[ω, y], Subscript[ω, z]}//FullSimplify

The kinetic energy is positive as long as is nonzero, showing the matrix was positive definite:

Wolfram Language code:

Resolve[Subscript[∀, {Subscript[ω, x], Subscript[ω, y], Subscript[ω, z], a, b, c}, {a, b, c}∈PositiveReals && {Subscript[ω, x], Subscript[ω, y], Subscript[ω, z]} ≠ {0, 0, 0}]% > 0]

Determine if a sparse matrix is structurally symmetric:

Wolfram Language code: ArrayPlot[m = SparseArray[{Band[{1, 2}] -> 1, Band[{2, 1}] -> -1}, {25, 25}]]

The matrix is not symmetric:

Wolfram Language code: SymmetricMatrixQ[m]

But it is structurally symmetric:

Wolfram Language code: SymmetricMatrixQ[Unitize[m]]

Use a different method for symmetric matrices, with failover to a general method:

Wolfram Language code:

myLS[m_, b_] := Module[{x}, 
	If[SymmetricMatrixQ[m], 
	(* "Cholesky" works for positive definite matrices only *)Quiet[x = LinearSolve[m, b, Method -> "Cholesky"]]];
	If[!VectorQ[x], x = LinearSolve[m, b]];
	x]

Construct real-valued matrices for testing:

Wolfram Language code:

With[{n = 1000}, 
m = RandomReal[NormalDistribution[], {n, n}];
b = N[Range[n]];]

For a non-symmetric matrix m, the function myLS just uses Gaussian elimination:

Wolfram Language code: Timing[myLS[m, b];]

For a symmetric indefinite matrix ms, try Cholesky and continue with Gaussian elimination:

Wolfram Language code: ms = m + Transpose[m];

Wolfram Language code: Timing[myLS[ms, b];]

For a symmetric positive-definite matrix mpd, try Cholesky, which succeeds:

Wolfram Language code: mpd = m.Transpose[m];

Wolfram Language code: SymmetricMatrixQ[mpd]

Wolfram Language code: Timing[myLS[mpd, b];]

Properties & Relations (14)

SymmetricMatrixQ[x] trivially returns False for any x that is not a matrix:

Wolfram Language code: SymmetricMatrixQ[Sqrt[3]]

A matrix is symmetric if mTranspose[m]:

Wolfram Language code:

m = (⁠|         |         |
| ------- | ------- |
| 1 + I   | 2 + 2 I |
| 2 + 2 I | 3 + 3 I |⁠);

Wolfram Language code: {m == Transpose[m], SymmetricMatrixQ[m]}

A real-valued symmetric matrix is Hermitian:

Wolfram Language code:

m = (⁠|   |   |
| - | - |
| 1 | 2 |
| 2 | 3 |⁠);

Wolfram Language code: {SymmetricMatrixQ[m], HermitianMatrixQ[m]}

But a complex-valued symmetric matrix may not be:

Wolfram Language code:

m = (⁠|         |         |
| ------- | ------- |
| 1 + I   | 2 + 2 I |
| 2 + 2 I | 3 + 3 I |⁠);

Wolfram Language code: {SymmetricMatrixQ[m], HermitianMatrixQ[m]}

Use Symmetrize to compute the symmetric part of a matrix:

Wolfram Language code: m = RandomReal[1, {3, 3}];

Wolfram Language code: Symmetrize[m]

This equals the average of m and Transpose[m]:

Wolfram Language code: % == (m + m/2)

Any matrix can be represented as the sum of its symmetric and antisymmetric parts:

Wolfram Language code:

m = RandomComplex[1 + I, {3, 3}];
{sym, asym} = {(m + m) / 2, (m - m) / 2};

Wolfram Language code: m == sym + asym

Use AntisymmetricMatrixQ to test whether a matrix is antisymmetric:

Wolfram Language code: {SymmetricMatrixQ[sym], AntisymmetricMatrixQ[asym]}

If is a symmetric matrix with real entries, then is antihermitian:

Wolfram Language code: m = Block[{a = RandomReal[1, {5, 5}]}, a + a^];

Wolfram Language code: {SymmetricMatrixQ[m], AntihermitianMatrixQ[I m]}

MatrixExp[I m] for real symmetric m is unitary:

Wolfram Language code: m = Symmetrize[RandomReal[1, {5, 5}]];

Wolfram Language code: UnitaryMatrixQ[MatrixExp[I m]]

A real-valued symmetric matrix is always a normal matrix:

Wolfram Language code: m = Block[{a = RandomReal[1, {10, 10}]}, a + a];

Wolfram Language code: {SymmetricMatrixQ[m], NormalMatrixQ[m]}

A complex-valued symmetric matrix need not be normal:

Wolfram Language code:

c = (⁠|   |   |   |
| - | - | - |
| I | 0 | 1 |
| 0 | I | I |
| 1 | I | I |⁠);

Wolfram Language code: {SymmetricMatrixQ[c], NormalMatrixQ[c]}

Real-valued symmetric matrices have all real eigenvalues:

Wolfram Language code: m = Block[{a = RandomReal[1, {5, 5}]}, a + a];

Wolfram Language code: SymmetricMatrixQ[m]

Use Eigenvalues to find eigenvalues:

Wolfram Language code: Eigenvalues[m]

Note that a complex-valued symmetric matrix may have both real and complex eigenvalues:

Wolfram Language code:

Eigenvalues[(⁠|   |   |   |
| - | - | - |
| I | 0 | 1 |
| 0 | I | I |
| 1 | I | I |⁠)]

CharacteristicPolynomial[m,x] for real symmetric m can be factored into linear terms:

Wolfram Language code: m = Block[{a = RandomReal[1, {3, 3}]}, a + a];

Wolfram Language code: Factor[CharacteristicPolynomial[m, x]]

Real-valued symmetric matrices have a complete set of eigenvectors:

Wolfram Language code: m = Block[{a = RandomReal[1, {3, 3}]}, a + a];

Wolfram Language code: SymmetricMatrixQ[m]

As a consequence, they must be diagonalizable:

Wolfram Language code: DiagonalizableMatrixQ[m]

Use Eigenvectors to find eigenvectors:

Wolfram Language code: Eigenvectors[m]//MatrixForm

Note that a complex-valued symmetric matrix need not have these properties:

Wolfram Language code:

c = (⁠|   |   |   |
| - | - | - |
| I | 0 | 1 |
| 0 | I | I |
| 1 | I | I |⁠);

Wolfram Language code: {SymmetricMatrixQ[c], DiagonalizableMatrixQ[c]}

The inverse of a symmetric matrix is symmetric:

Wolfram Language code: m = Block[{a = RandomComplex[1 + I, {3, 3}]}, a + a];

Wolfram Language code: SymmetricMatrixQ[Inverse[m]]

Matrix functions of symmetric matrices are symmetric, including MatrixPower:

Wolfram Language code: m = Block[{a = RandomReal[1, {3, 3}]}, a + a];

Wolfram Language code: SymmetricMatrixQ[MatrixPower[m, n]]

MatrixExp:

Wolfram Language code: SymmetricMatrixQ[MatrixExp[m]]

And any univariate function representable using MatrixFunction:

Wolfram Language code: SymmetricMatrixQ[MatrixFunction[Sin, m]]

SymmetricMatrix can be used to explicitly construct symmetric matrices:

Wolfram Language code: SymmetricMatrix[RandomVariate[GaussianOrthogonalMatrixDistribution[3]]]

These satisfy SymmetricMatrixQ:

Wolfram Language code: SymmetricMatrixQ[%]

Possible Issues (1)

SymmetricMatrixQ uses the definition for both real- and complex-valued matrices:

Wolfram Language code:

c = (⁠|   |   |   |
| - | - | - |
| I | 0 | 1 |
| 0 | I | I |
| 1 | I | I |⁠);

Wolfram Language code: {SymmetricMatrixQ[c] , c == c}

These complex matrices need not be normal or possess many properties of self-adjoint (real symmetric) matrices:

Wolfram Language code: NormalMatrixQ[c]

HermitianMatrixQ tests the condition for self-adjoint matrices:

Wolfram Language code: HermitianMatrixQ[c]

Alternatively, test if the entries are real to restrict to real symmetric matrices:

Wolfram Language code: symmetricMatrixQ[m_] := SymmetricMatrixQ[m] && Element[m, Reals]

Wolfram Language code: symmetricMatrixQ[c]

Neat Examples (1)

Images of symmetric matrices including FourierMatrix:

Wolfram Language code: m = FourierMatrix[45];

Wolfram Language code: SymmetricMatrixQ[m]

Wolfram Language code: MatrixPlot[N[m, 20]]

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

SymmetricMatrixQ

Details and Options

Examples

Basic Examples (2)

Scope (10)

Basic Uses (6)

Special Matrices (4)

Options (2)

SameTest (1)

Tolerance (1)

Applications (13)

Generating Symmetric Matrices (4)

Examples of Symmetric Matrices (5)

Uses of Symmetric Matrices (4)

Properties & Relations (14)

Possible Issues (1)

Neat Examples (1)

Text

CMS

APA

BibTeX

BibLaTeX

	SameTest	Automatic	function to test equality of expressions
	Tolerance	Automatic	tolerance for approximate numbers

SymmetricMatrixQ

Details and Options

Examples

Basic Examples (2)

Scope (10)

Basic Uses (6)

Special Matrices (4)

Options (2)

SameTest (1)

Tolerance (1)

Applications (13)

Generating Symmetric Matrices (4)

Examples of Symmetric Matrices (5)

Uses of Symmetric Matrices (4)

Properties & Relations (14)

Possible Issues (1)

Neat Examples (1)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX