Matrix Inverse

What an inverse means

For a square matrix A, an inverse A^-1 satisfies A x A^-1 = I3 and A^-1 x A = I3 when the inverse exists. I3 is the 3x3 identity matrix with ones on the main diagonal and zeros elsewhere. The inverse is therefore an operator that undoes the action of A under ordinary matrix multiplication. It is not a reciprocal applied independently to every entry. Off-diagonal interactions and row-column products determine its entries.

Not every matrix has an inverse. A singular matrix maps some nonzero direction to zero or otherwise lacks three independent pivot directions. In exact arithmetic its determinant is zero. A numerically unstable matrix can have a determinant that is nonzero in floating-point arithmetic but too small relative to the scale of its entries for division to be trustworthy under this contract. The handler rejects both cases before attempting to form divided inverse entries.

• An inverse is defined through two identity products.
• Entrywise reciprocals are not a matrix inverse.
• Singular and unstable cases need a rejection path before division.

The fixed input and field order

The matrix is entered as [[a11, a12, a13], [a21, a22, a23], [a31, a32, a33]]. The first digit in a key is its row and the second is its column. A field swap can change the determinant, cofactor signs, and every inverse entry, so the row-major labels are part of the mathematical contract rather than mere interface decoration. Write the complete grid before calculating if the source values come from a table or a larger system.

Each source entry must be a finite number between -1000 and 1000 inclusive. The direct handler rejects strings, missing values, NaN, infinity, and out-of-range entries. These bounds keep the source arithmetic predictable, but they do not guarantee that every valid matrix is well-conditioned. The separate determinant guard is required because finite input alone does not make division by a small determinant numerically safe.

• Use all nine fixed row-major entries.
• A small determinant is a stability concern even with valid fields.
• Input validation occurs before cofactors and determinant are used for division.

Determinant and cofactor identity

For the 3x3 matrix, form each signed cofactor Cij from a 2x2 minor. Expanding along the first row gives det(A) = a11 C11 + a12 C12 + a13 C13. The cofactor matrix C is then transposed to form the adjugate: adj(A) = C^T. The classical inverse formula is A^-1 = adj(A)/det(A). The implementation follows these stages directly so the source of each inverse entry is visible rather than hidden inside a generic parser.

The transpose is essential. The cofactor at position 12 becomes an adjugate entry at position 21, and the same exchange applies to all off-diagonal positions. Omitting this step can produce a finite matrix that is not an inverse. The handler computes the determinant and all cofactors with finite checks, tests the determinant against the scale-relative threshold, then divides the transposed cofactor entries.

• Build signed 2x2 cofactors first.
• Transpose the cofactor matrix to get the adjugate.
• Divide the adjugate by a guarded determinant.

A worked inverse example

For A = [[1, 2, 3], [0, 1, 4], [5, 6, 0]], the cofactor matrix is [[-24, 20, -5], [18, -15, 4], [5, -4, 1]]. Its determinant from the first row is 1x(-24) + 2x20 + 3x(-5) = 1. The adjugate is the transpose [[-24, 18, 5], [20, -15, -4], [-5, 4, 1]]. Because the determinant is one, division leaves the adjugate unchanged.

The returned inverse is [[-24, 18, 5], [20, -15, -4], [-5, 4, 1]]. An independent check multiplies A by this matrix. The first row of the product is [1, 0, 0], the second is [0, 1, 0], and the third is [0, 0, 1]. Checking both product orders is stronger than checking only the determinant, because it tests the transpose placement and all row-column arithmetic in the inverse result.

• The example determinant is 1.
• The adjugate and inverse are identical in this example.
• Both product orders should reproduce I3.

Singular matrices and rejection

A matrix with a zero determinant has no ordinary inverse. For example, [[1, 2, 3], [2, 4, 6], [0, 1, 1]] has a second row equal to twice the first, so its rows cannot supply three independent directions. The cofactor matrix may still be defined, but dividing its adjugate by zero is not. The inverse handler rejects the matrix before any inverse entry is formed and reports that it is singular or numerically unstable.

The determinant test is not a license to divide by an almost-zero value. A determinant can be nonzero as a floating-point number while being too small relative to the scale of the matrix for the classical division to be a reliable bounded result. The guard compares absolute determinant magnitude with 1e-12 times S^3, where S is the largest absolute input entry. Values at or below that threshold are rejected before division.

• Exact zero determinant is rejected.
• A nonzero but too-small determinant is also rejected under the declared guard.
• Cofactor construction and inverse existence are separate questions.

Why the tolerance is scale-relative

The determinant has cubic scale: if every matrix entry is multiplied by t, the determinant is multiplied by t^3. Comparing the determinant with a fixed absolute number would therefore treat a large matrix and a uniformly scaled small matrix inconsistently. The guard uses 1e-12*S^3 so the threshold follows the largest entry scale. This is a conservative numerical policy for this bounded calculator, not a full condition-number estimate or a proof of application-level accuracy.

A matrix with a determinant just above the threshold is accepted, but acceptance means only that the declared division guard passed. The result can still be sensitive to measurement error, rounding, or a different norm-based conditioning requirement. A matrix with a determinant just below the threshold is rejected even if an arbitrary precision system could compute an inverse. Record the threshold with any result so another reviewer does not mistake the policy for a universal definition of invertibility.

• Determinant scale grows as the cube of uniform entry scale.
• The threshold is 1e-12 times S cubed.
• Passing the guard is not a complete condition-number analysis.

Finite output and deterministic matrix text

Every product, minor, cofactor, determinant tolerance, and divided inverse entry is checked for finiteness. The guard runs before the first division. If an inverse entry would leave the conservative arithmetic range, the handler throws rather than returning a partially valid matrix. Numeric values are normalized away from negative zero before the final formatter creates the bracketed row-major text result.

The output is a text matrix because the inverse is a structured 3x3 result. The steps remain nonempty and state the determinant, tolerance, adjugate operation, and final matrix. JSON serialization therefore produces a stable object containing ordinary strings and finite numeric fields where numeric metrics are used internally in steps only. Preserve the original named inputs and stability policy with the formatted inverse for reproducible review.

• No division occurs before the stability check.
• Every inverse entry is finite-checked and normalized.
• The matrix text uses stable row-major punctuation.

Inverse versus transpose and other shortcuts

The transpose changes positions and exists for every finite matrix, while the inverse requires nonsingularity and guarded division. A symmetric orthogonal matrix can have an inverse equal to its transpose, but that is a special structural fact, not the general rule. Likewise, reciprocal diagonal entries give the inverse of a nonsingular diagonal matrix, but applying reciprocals to a non-diagonal matrix is not valid. The calculator uses cofactors and the adjugate so the general 3x3 identity remains explicit.

Solving a linear system with an inverse is also different from deciding whether an inverse can be displayed. An inverse may amplify errors, and a practical solver may use factorization or a condition-aware method instead of forming the inverse explicitly. This page provides the requested bounded algebraic matrix and its guards; it does not choose a numerical strategy for a larger or higher-consequence system.

• Transpose exists without a determinant condition; inverse does not.
• Entrywise reciprocals work only in special structures such as diagonal matrices.
• A displayed inverse is not automatically the best way to solve a system.

Verification and responsible use

To verify an inverse, start with I3, a diagonal matrix, the worked nonsingular example, and a singular repeated-row matrix. Multiply the returned inverse on both sides by the source and compare with I3 within a stated numerical tolerance. Test a near-singular matrix on both sides of the determinant guard and confirm that rejection happens before division. Also inspect the cofactor signs independently, because a sign error can survive a superficial determinant check while corrupting the off-diagonal inverse entries.

The calculator does not infer units, uncertainty, measurement quality, or whether a matrix represents a safe or valid system. Do not put private identifiers or sensitive records in the numeric fields. If the inverse feeds engineering, finance, science, control, or another consequential decision, use an appropriate numerical method, condition analysis, precision policy, and qualified review. The returned matrix is a finite result for the exact bounded inputs and declared tolerance; it is not a universal guarantee about an external system.

• Check both A x A^-1 and A^-1 x A against I3.
• Exercise singular and near-threshold rejection explicitly.
• Keep conditioning, units, uncertainty, and downstream review outside the handler.

Two-sided identity verification

For a valid inverse, both multiplication orders should produce I3: A x A^-1 and A^-1 x A. Checking only one side can miss a misplaced transpose or an order-specific implementation error. Recompute all nine product cells with structured numeric values and compare diagonal cells with one and off-diagonal cells with zero under a declared tolerance. The formatted inverse text is useful for display, but it should not be parsed as the sole source for a verification calculation.

The residual matrix from either product can be inspected separately from the identity claim. A finite residual that is small under one tolerance may be large under a stricter policy. Keep the source scale, determinant, inverse values, and comparison tolerance in the audit record. The handler returns the bounded inverse for the entered numbers; it does not choose how much residual an external application may accept.

• Verify both multiplication orders.
• Compare every identity cell with an explicit tolerance.
• Keep residuals separate from the displayed inverse matrix.

Determinant scale and the stability guard

The guard uses S, the largest absolute input entry, and rejects when absolute determinant is at or below 1e-12 times S cubed. The cubic scale follows the fact that a 3x3 determinant contains products of three entries. For the default matrix S is 6 and the threshold is 2.16e-10, while determinant one is comfortably above it. The exact numeric threshold is included in the steps so a reviewer can reproduce the decision rather than seeing only an accepted or rejected label.

Uniformly scaling every entry by t scales the determinant by t cubed and the threshold by the same absolute scale cubed. This makes the guard a relative policy for a fixed matrix shape, not a universal condition-number estimate. Nonuniform changes, rounding, and cancellation can change the determinant relationship in ways that require a new review. Do not compare acceptance states without retaining the scale and input precision.

• S is the largest absolute input entry.
• The determinant threshold uses 1e-12 times S cubed.
• Guard passage is relative policy, not complete conditioning analysis.

Near-singular examples

A repeated-row matrix is an exact singular fixture and should be rejected before any division. A near-singular fixture can use a diagonal entry such as 1e-13 while the other diagonal entries are one; its determinant is nonzero in ordinary arithmetic but falls below the declared threshold for S equal to one. Testing both cases confirms that the rejection message covers exact zero and numerically unstable division rather than relying on a single determinant equality check.

A matrix just above the threshold can be accepted, but the resulting entries may be large because division magnifies the cofactors. Acceptance only means the handler's declared guard passed and all returned entries remained within the arithmetic limit. If a workflow needs a stronger margin, it should apply a stricter external policy or a condition-aware method. It should not reinterpret the page's acceptance as a guarantee of stable real-world behavior.

• Use exact singular and near-singular fixtures.
• Test both sides of the determinant threshold.
• Accepted does not mean insensitive to measurement error.

Structured matrices and expected inverses

A nonsingular diagonal matrix has a diagonal inverse whose entries are the reciprocals of the source diagonal values. This is a useful fixture for the general cofactor and adjugate path, but it should not justify an entrywise reciprocal implementation because non-diagonal matrices require off-diagonal interactions. A triangular matrix has a triangular inverse when it is nonsingular, providing another structural check for zero placement and cofactor transposition.

The identity matrix is its own inverse and is valuable for checking determinant one, cofactor signs, adjugate placement, and formatting. A signed diagonal matrix checks that negative reciprocals remain negative. A nonsymmetric distinct-entry matrix remains necessary because symmetric and diagonal cases can hide an omitted transpose or an accidental shortcut. Use several fixtures before accepting a change to the inverse code.

• Diagonal inverses provide an exact reciprocal fixture.
• Triangular structure can check zero placement.
• Identity, signed, and nonsymmetric matrices expose different defects.

Inverse versus solving a system

Displaying A^-1 is not the same as solving A x = b for a supplied vector. A solution workflow would need vector fields, a multiplication convention, residual checks, and a policy for whether forming the inverse is numerically appropriate. This page intentionally returns only the 3x3 inverse text and does not accept b. A caller should not imply that an inverse result has solved a system when no right-hand side was entered.

For larger or sensitive systems, factorization methods can avoid explicitly forming an inverse and can expose pivot or conditioning information more directly. The M1 contract is a bounded educational and software-checking operation for a fixed 3x3 input. If a product uses the displayed inverse later, retain the original matrix and verify the downstream residual rather than treating the formatted result as a universal solver artifact.

• No right-hand side vector is solved here.
• An inverse display and a system solution are different contracts.
• Larger systems may require methods other than explicit inversion.

Error propagation and displayed precision

An inverse can amplify small changes in the source matrix, especially near the stability boundary. Two source matrices that differ in a few low-order digits can produce visibly different inverse entries even when both pass the guard. Preserve the full input values used by the handler and state any comparison tolerance. The formatter uses compact deterministic numbers for display; those strings should not be copied back as if they preserved every source digit.

Rounding an inverse before multiplying it back by the source can create a residual that was not present in the structured result. Perform identity checks with structured numeric values and round only at the presentation boundary. If a report needs a fixed number of decimal places, state that as display policy and retain the unrounded result under appropriate controls.

• Near-singular inverses can amplify input changes.
• Use structured numbers for residual checks.
• Display rounding is not a stability or precision guarantee.

Cross-tool audit and provenance

An end-to-end audit can obtain the cofactor matrix from the cofactor handler, transpose it, compute the determinant from a separate expansion, divide the adjugate in a test-only reference, and compare all nine cells with the inverse handler. Then multiply both orders and inspect identity residuals. This sequence isolates source mapping, checkerboard signs, determinant scale, transpose placement, division, and formatting. It is stronger than checking only the known default string.

A durable inverse record should include the named source matrix, determinant, largest absolute entry, threshold, acceptance state, inverse values, display representation, and verification tolerance. Include the source labels and units when they exist, but keep private identifiers out of the calculator fields. This provenance lets a later reviewer distinguish a changed input, a changed threshold, and a changed implementation.

• Audit cofactors, determinant, adjugate, division, and products in stages.
• Record scale, threshold, determinant, and verification policy.
• Preserve source mapping without putting private context in numeric fields.

Final inverse acceptance criteria

An inverse result is ready for handoff when all nine finite bounded entries are mapped correctly, the cofactor determinant is finite, absolute determinant exceeds the documented scale-relative threshold, every divided entry remains finite and within the arithmetic guard, and both identity products pass the declared external tolerance. The output should contain stable row-major matrix text and steps that expose determinant, tolerance, adjugate, and final result. A nonempty matrix string alone is not evidence that the matrix is an inverse.

The remaining interpretation questions concern units, uncertainty, conditioning, model validity, privacy, and the consequence of using the result. Keep those questions with the surrounding application and qualified review. The pure handler should remain a narrow, deterministic implementation of A^-1 = transpose(C(A))/det(A) for a bounded 3x3 real matrix, with explicit rejection before unstable division.

A final handoff should state whether the inverse was accepted by the scale-relative guard and whether an independent identity check was performed. If no check was performed, do not imply that the text matrix has been validated beyond the handler's finite arithmetic and determinant policy. Keep the original matrix, determinant, threshold, inverse, and residual evidence together so a later change in display precision does not erase the basis for the result.

• Confirm mapping, determinant guard, finite division, and identity products.
• Retain threshold and verification metadata with the inverse.
• Separate algebraic completion from downstream system decisions.