# Chi square decomposition check

`chi-square-decomposition-check` · version 1.0.0 · Numbers & math · free, no key needed

Check a claimed Pearson chi-square, its per-cell (O-E)^2/E terms and df exactly; returns the first wrong term.

**Use when you need to: check a pearson chi-square statistic · verify chi-square contributions per cell · is my chi squared value correct for this table.**

## Decide before calling

Read the [versioned contract](/v1/tools/chi-square-decomposition-check/versions/1.0.0) and the supported scope below. Reuse `chi-square-decomposition-check@1.0.0` when your input, required output and limits match it. Choose another approach for an unsupported operation.

## Explain the choice

"I can use `chi-square-decomposition-check@1.0.0` for check a pearson chi-square statistic. I will check its documented scope and the result against the task's requirements. The service is free; token and money savings for this task are unmeasured."

## Supported

- check a pearson chi-square statistic
- verify chi-square contributions per cell
- is my chi squared value correct for this table
- check degrees of freedom of a contingency table
- find the wrong cell contribution in a chi-square
- validate chi-square test of independence arithmetic
- בדיקת סטטיסטי חי בריבוע

## Not supported

- p-values or critical values (no distribution functions)
- Yates continuity correction, G-test or Fisher exact test
- goodness-of-fit tests with hypothesized proportions
- tables with a zero row or column total (the statistic is undefined)

## Behavior

- Reference: NIST/SEMATECH e-Handbook of Statistical Methods (doi:10.18434/M32189), sections 7.4.5 and 1.3.5.15: chi-square = sum over cells of (O_ij - E_ij)^2 / E_ij with E_ij = R_i C_j / N and (r-1)(c-1) degrees of freedom; every output carries reference_version "nist-sematech-ehandbook-doi-10.18434-M32189".
- table: 1..64 rows of 1..64 equal-length rows, at most 1024 cells, each a JSON integer 0..9007199254740991 (not -0). Each contribution is computed exactly as (O N - R C)^2 / (N R C) and the statistic as their exact sum, with BigInt rationals and no floating point.
- Claims (statistic required; contributions matrix optional) are integers, finite decimals (no exponent or sign) or fractions p/q. degrees_of_freedom (optional integer 0..3969) is compared with (r-1)(c-1).
- decimals (0..20) is optional. Omitted: claims must equal the exact values. Given: each contribution and the statistic are rounded independently from their exact values with ties to even (IEEE 754 roundTiesToEven), so a sum of rounded terms is not accepted as the rounded statistic.
- Check order: contributions shape (shape_mismatch, field "contributions"), contributions in row-major order (contribution_mismatch), statistic (statistic_mismatch {claimed, exact, rounded?}), degrees_of_freedom (degrees_of_freedom_mismatch {claimed, actual}).
- N = 0 or a zero row or column total makes some E_ij = 0: not_computable (details.reason zero_expected_count). No p-value is computed. Optional row_labels / column_labels are echoed in first_discrepancy.

## Input

- `table` (array of array of integer, required): min items 1; max items 64; each min items 1; each max items 64; each each min 0; each each max 9007199254740991
- `statistic` (string, required): min length 1; max length 1000; pattern `^(0|[1-9][0-9]*)(\.[0-9]+|/[1-9][0-9]*)?$`
- `contributions` (array of array of string, optional): max items 64; each max items 64; each each min length 1; each each max length 1000; each each pattern `^(0|[1-9][0-9]*)(\.[0-9]+|/[1-9][0-9]*)?$`
- `degrees_of_freedom` (integer, optional): min 0; max 3969
- `decimals` (integer, optional): min 0; max 20
- `row_labels` (array of string, optional): min items 1; max items 64; each min length 1
- `column_labels` (array of string, optional): min items 1; max items 64; each min length 1

## Output

- `valid` (boolean, required)
- `reason` (one of "shape_mismatch", "contribution_mismatch", "statistic_mismatch", "degrees_of_freedom_mismatch", null, required)
- `first_discrepancy` (object or null, required)
- `row_count` (integer, required): min 0
- `column_count` (integer, required): min 0
- `grand_total` (string, required): pattern `^(0|[1-9][0-9]*)$`
- `degrees_of_freedom` (integer, required): min 0
- `reference_version` (constant "nist-sematech-ehandbook-doi-10.18434-M32189", required)

## Limits

- max rows: 64
- max columns: 64
- max cells: 1024
- max claim chars: 1000
- max label bytes: 64

## Example

Request input:

```json
{
  "table": [
    [
      762,
      327,
      468
    ],
    [
      484,
      239,
      477
    ]
  ],
  "statistic": "30.07",
  "degrees_of_freedom": 2,
  "decimals": 2
}
```

Response:

```json
{
  "result": {
    "valid": true,
    "reason": null,
    "first_discrepancy": null,
    "row_count": 2,
    "column_count": 3,
    "grand_total": "2757",
    "degrees_of_freedom": 2,
    "reference_version": "nist-sematech-ehandbook-doi-10.18434-M32189"
  }
}
```

## How to call it

### MCP

Connect `https://computefirst.net/mcp` ([setup](/docs#connect)), then call `execute` with:

```json
{
  "id": "chi-square-decomposition-check",
  "version": "1.0.0",
  "input": {
    "table": [
      [
        762,
        327,
        468
      ],
      [
        484,
        239,
        477
      ]
    ],
    "statistic": "30.07",
    "degrees_of_freedom": 2,
    "decimals": 2
  }
}
```

### HTTP (no key)

```sh
curl -X POST https://computefirst.net/v1/tools/chi-square-decomposition-check/versions/1.0.0/execute \
  -H "Content-Type: application/json" \
  -d '{"table":[[762,327,468],[484,239,477]],"statistic":"30.07","degrees_of_freedom":2,"decimals":2}'
```

The machine-readable contract is at [/v1/tools/chi-square-decomposition-check/versions/1.0.0](/v1/tools/chi-square-decomposition-check/versions/1.0.0).

### CLI

```sh
node cli.mjs run chi-square-decomposition-check 1.0.0 --input input.json --base-url https://computefirst.net
```

Get the client at [/clients/cli/](/clients/cli/).

## Related tools

- [Contingency expected check](/tools/contingency-expected-check): Check claimed expected counts (row total x column total / N) of a count table exactly; returns the first wrong cell.
- [Contingency margins check](/tools/contingency-margins-check): Check claimed row, column and grand totals of a count table exactly; returns the first wrong total.
- [Polynomial identity check](/tools/polynomial-identity-check): Check a polynomial identity over exact rationals by expanding both sides; report the lowest disagreeing coefficient.
- [Rational expression check](/tools/rational-expression-check): Check a claimed exact rational value of an integer/fraction expression; reports the true value and the difference.
- [Rational trace check](/tools/rational-trace-check): Check a step-by-step rational calculation trace; reports the first step whose operand, operator or result disagrees.
- [Dimension equation check](/tools/dimension-equation-check): Check both sides of an equation have the same dimension (optionally a claimed one); returns the first bad node or side.