Symmetric matrix checker

This symmetric matrix checker accepts one real n-by-n array, compares each upper-triangle entry a_ij with its counterpart a_ji, and returns a clear true or false verdict. Non-square shapes, jagged rows, empty inputs, and non-numeric cells are rejected with invalid_input instead of a silent false.

What symmetry means and how the checker decides

Write a real square matrix A with n rows and n columns. Its transpose A transpose is the matrix obtained by swapping rows and columns so that the entry in position j,i of the transpose equals the entry in position i,j of A. If every such pair agrees, the matrix is symmetric; the first mismatch proves it is not. Understanding the definition pays off later: real symmetric matrices have real eigenvalues, admit orthogonal diagonalization, and underpin positive-definite models in statistics and mechanics. By definition A is symmetric exactly when A equals A transpose, which is equivalent to the family of scalar identities a_ij equals a_ji for every pair of indices i and j. The main diagonal always matches itself, so a practical algorithm only needs to inspect the strictly upper triangle: for each pair with i less than j, compare a_ij against a_ji. This endpoint implements that textbook test with a stable floating-point tolerance so tiny round-off dust does not false-fail classroom or engineering inputs that are symmetric up to machine epsilon. Indices in the violation report are zero-based to match JSON array indexing used by the matrix field. The checker does not compute eigenvalues or factors; it only answers the boolean question and, when needed, points at the first counterexample pair so you can correct a typo before a heavier routine fails deeper in the stack.

Input contract, response fields, and error behaviour

Missing fields, empty matrices, NaN or Infinity cells, and non-numeric strings are likewise rejected and are not billed. Near-zero float dust is cleaned so goldens and demos stay stable while ordinary reals keep double precision. POST a JSON body with the required field matrix: a non-empty nested array of rows forming an n-by-n grid of finite numbers, with n at most thirty-two. You may also pass aliases a, A, input, or m, and you may send the matrix as a JSON string of the same nested structure when a form only accepts text. Every row must have exactly n entries; unequal lengths and non-square shapes fail with invalid_input and a message that states the expected column count. On success the body includes n, the cleaned matrix, is_symmetric as a boolean, pairs_checked as the number of off-diagonal pairs examined, and a short formula string restating A equals A transpose. When is_symmetric is false, first_violation appears with row, col, entry, and transpose_entry for the earliest mismatch in row-major order over i less than j; when the matrix is symmetric that object is omitted entirely rather than set to null. Example: the matrix with rows one two and two one is symmetric; changing the lower-left entry to three yields is_symmetric false with first_violation at row zero column one showing entry two against transpose_entry three. Pair the response with your own display of the grid if you want to highlight the mismatched cells in a UI; this endpoint solves the decision problem only and does not emit plots or step-by-step prose beyond the formula field.

Where a symmetric matrix API earns its keep

Data-science and finance notebooks often build covariance-style arrays by construction and still want a gate before Cholesky or spectral routines that assume symmetry; calling a tiny parse API avoids pulling a full computer-algebra system for a single structural test. Keep matrices within ordinary floating-range magnitudes, pin is_symmetric and first_violation in tests, and you get reproducible verdicts for LMS plugins, edge workers, and continuous-integration checks without standing up symbolic math infrastructure of your own.