Matrix minor calculator
For the matrix with rows 1, 2, 3; 0, 4, 5; 1, 0, 6, crossing out row 1 and column 1 leaves rows 4, 5 and 0, 6, whose determinant 24 is the minor. Rows and columns are counted from 1. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Runs in your browser. Free, unlimited — your data never leaves this page.
A matrix minor is the scalar you get when you strike out one row and one column of a square matrix and take the determinant of whatever is left. That single number is the building block of cofactor expansion, the adjugate, Cramer's rule, and every classical formula for the inverse of a small matrix. This calculator accepts a square nested array of finite real numbers together with one-based row and column indices, deletes that row and column, evaluates the determinant of the remaining block with the same closed formulas and LU path used by sibling linear-algebra tools, and returns the cleaned minor along with the submatrix, the original entry, the method used, and a short formula string. Non-square inputs, one-by-one matrices, out-of-range indices, empty grids, NaN, Infinity, and oversized arrays are rejected with a clear validation error.
What a matrix minor is and how it is computed
Fix a square matrix A of order n at least two and pick integers i and j between one and n inclusive. The minor M_ij is defined as the determinant of the (n minus one) by (n minus one) matrix obtained by deleting row i and column j of A. That definition does not multiply by a sign: the signed quantity that appears in Laplace expansion is the cofactor C_ij equals minus one to the power i plus j times M_ij.
This capability returns the unsigned minor itself, which is exactly what textbooks ask for when they write find M_23 or list all minors of a three-by-three matrix. Internally the engine first validates that the input is a true square array of finite numbers with n between two and thirty-two, then checks that row and col are integers in range, builds the submatrix by skipping the chosen row and column, and finally computes its determinant. For a one-by-one remainder the minor is simply the surviving entry.
For a two-by-two remainder the closed form ad minus bc is used. For a three-by-three remainder Laplace expansion along the first row is applied. For larger remainders an LU factorization with partial pivoting multiplies the diagonal of U by the permutation sign.
Classic checks include the three-by-three matrix with rows one two three, zero four five, and one zero six whose minor at row one column one is twenty-four from the two-by-two block four five over zero six.
Where matrix minors show up in real work
Secondary-school and college linear algebra courses constantly assign cofactor tables, expansion along a chosen row, and hand calculation of two-by-two minors cut from three-by-three matrices; a single trusted oracle that returns the submatrix and the minor speeds grading and demo setup. Programming contest problems and interview warm-ups often ask for one specific minor before asking for the full determinant or inverse, and engineers need a numeric M_ij rather than a silent wrong product from an off-by-one delete.
Computer graphics and robotics libraries that implement classical adjoint-based inversion for small blocks rely on a complete set of minors; verifying one entry against this calculator catches row-column index bugs early. Statistics and numerical linear algebra courses use minors when discussing principal minors and positive-definiteness criteria for symmetric matrices. Pair it with the matrix determinant landing when students need det of the full matrix, and with rank or inverse landings when the next step is invertibility rather than a single deleted-row determinant.
What you can do with it
Homework cofactor tables
Generate M_ij and the deleted-row submatrix for textbook 2×2, 3×3, and small n×n drills so teachers and auto-graders share one ground truth before students multiply by the cofactor sign.
Laplace expansion checks
Verify each minor that appears when expanding det(A) along a chosen row or column, catching off-by-one deletions before the full determinant is assembled.
Adjoint and inverse prep
Compute individual minors used to build the adjugate matrix for classical inversion of small dense blocks in graphics, robotics, and numerical recipes.
FAQ
What is the difference between a minor and a cofactor?
The minor M_ij is the determinant of the matrix after deleting row i and column j. The cofactor is C_ij = (−1)^(i+j) · M_ij. This tool returns the minor only; apply the sign yourself if you need the cofactor.
Are row and col zero-based or one-based?
One-based, matching textbook notation M_11, M_23, and so on. For an n×n matrix both indices must be integers from 1 through n.
Why is a 1×1 matrix rejected?
Deleting the only row and column leaves a 0×0 matrix whose determinant is a convention (often 1) that confuses beginners. Require n ≥ 2 so every minor is a well-defined positive-order determinant.
What methods compute the remaining determinant?
Closed 1×1 and 2×2 formulas, Laplace cofactor expansion for 3×3 remainders, and LU with partial pivoting for larger blocks. The response includes a method field naming the path used.
What does it cost?
The browser tool is free and runs locally.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/algebra/matrix-minor \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"matrix":[[1,2,3],[0,4,5],[1,0,6]],"row":1,"col":1}'const res = await fetch("https://api.kit.forhosting.com/algebra/matrix-minor", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"matrix": [
[
1,
2,
3
],
[
0,
4,
5
],
[
1,
0,
6
]
],
"row": 1,
"col": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/algebra/matrix-minor",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"matrix": [
[
1,
2,
3
],
[
0,
4,
5
],
[
1,
0,
6
]
],
"row": 1,
"col": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/algebra/matrix-minor", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"matrix":[[1,2,3],[0,4,5],[1,0,6]],"row":1,"col":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"matrix":[[1,2,3],[0,4,5],[1,0,6]],"row":1,"col":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/algebra/matrix-minor", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"matrix": [
[
1,
2,
3
],
[
0,
4,
5
],
[
1,
0,
6
]
],
"row": 1,
"col": 1
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "algebra.matrix_minor",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
What a matrix minor is and how it is computed
All arithmetic is deterministic floating-point code with stable twelve-significant-digit cleaning, no random seeds, no wall-clock timestamps, and no network calls, so identical inputs always produce identical JSON.
What you send and what you get back
Send three required fields. Every row must have the same length, that length must equal the number of rows, and n must be at least two because a one-by-one matrix has no proper minor after its only row and column are removed. The fields row and col are one-based integers naming the entry whose minor you want; they are also the row and column that will be deleted. If you later need the signed cofactor, the full determinant of A, the adjugate, or the inverse, treat those as separate search intents rather than overloading this minor calculator page. The field matrix is either a nested JSON array of rows of finite numbers, such as one comma two comma three then zero comma four comma five then one comma zero comma six, or a JSON string encoding the same nested array. Missing matrix, non-array shapes, jagged rows, non-numeric cells, NaN, Infinity, empty grids, dimensions larger than thirty-two, and indices outside one through n fail with invalid_input and are not charged. On success the response reports dimension n, the echoed row and col, the original entry a_ij at that position, the cleaned submatrix, the scalar minor, the determinant method used on the submatrix, and a short formula string of the form M_ij equals det of A without that row and column. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance.
Where matrix minors show up in real work
Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance.