---
profile: elgora_markdown_bounty_challenge_v0
escrow_amount: "1000000"
submission_deadline: 1791632400
payout_policy: winner_take_all
constraints:
  max_extracted_bytes: 1000000
  allowed_extensions: [.csv, .txt]
---

# The Seeded Instance

## Summary
Solve a sparse linear system of 10,000 equations in 10,000 unknowns whose
full construction recipe is published in this page, to a relative residual of
at most 1e-8. The instance files are pinned by SHA-256 and are authoritative;
a Solver may reproduce them locally from the recipe as a cross-check before
solving. Solving the wrong instance (an off-by-one seed, a mis-implemented
recipe) fails the residual check, so reproducibility discipline pays.

## Challenge details
The instance is a sparse, nonsymmetric, nonsingular real matrix C of size
10000 x 10000 in MatrixMarket coordinate format, and a right-hand-side vector
b of length 10000 in CSV. Both are linked under Inputs, Materials and
References, and each file is pinned by a SHA-256 hash that identifies its
authoritative bytes. The recipe below documents exactly how the instance was
constructed. Reproducing the instance locally from the recipe is permitted as
a cross-check and is neither required nor evaluated: only the submitted
solution vector is judged.

**Recipe.** Build the matrix C with numpy and scipy as follows:
- Use `numpy.random.default_rng(20261009)`.
- The diagonal is 8.0 for all 10,000 rows.
- For each k in -3, -2, -1, 1, 2, 3 (in this order), draw
  `v = rng.uniform(-1.5, 1.5, 10000 - abs(k))` and place v at the offsets:
  for k > 0 place v in rows 0..9999-k, columns k..9999; for k < 0 place v in
  rows abs(k)..9999, columns 0..9999-abs(k). Also place the same vector v at
  the transposed position (rows and columns swapped).
- The resulting 10000 x 10000 matrix C has exactly 69988 nonzeros. Assemble
  from the coordinate triplets (row, col, value) in the order generated above,
  with the 10000 diagonal triplets appended last, summing duplicate
  coordinates.
- Draw `x_true = rng.uniform(-2.0, 2.0, 10000)` and set `b = C @ x_true` in
  binary64 (scipy.sparse CSR product).

The pinned files under Inputs, Materials and References are the
authoritative instance for every acceptance check; the recipe explains their
construction and serves any Solver who prefers to regenerate and compare
before solving.

Produce any vector x of length 10000 such that the relative residual defined
under Acceptance Criteria is at most 1e-8. C is strictly diagonally dominant
and well-conditioned; the bound is comfortably attainable with standard
sparse linear algebra in double precision. The method is the Solver's choice
and is not evaluated.

## What you need to submit (Deliverables)

| File | Required or optional | Required content | Format | Purpose |
|---|---|---|---|---|
| `solution.csv` | required | The solution vector, one entry per unknown | UTF-8 text, CSV with the single header line `index,value`, then exactly 10000 data rows, row i carrying the value of x_i in the row with index i (indices 1 through 10000, ascending, no gaps or duplicates) | The deliverable being judged |
| `checksum.txt` | required | Exactly one line containing one real number in plain decimal or scientific notation: the sum of the 10000 values in `solution.csv` | UTF-8 text, one line | An independent arithmetic anchor for the vector |

Both files must be present as bytes in the Submission; a Submission missing
either file fails Acceptance Criteria 1 and 2. Extra files are permitted and
are not evaluated, and no submitted content other than these two deliverables
affects eligibility.

## Inputs, Materials and References

The two files below are the authoritative and complete instance, pinned by
SHA-256; the recipe in Challenge details reconstructs them.

| File | Purpose | Required input or background | Link | SHA-256 |
|---|---|---|---|---|
| `C_matrix.mtx` | The matrix C in MatrixMarket coordinate format (10000 x 10000, 69988 nonzeros, general, real) | required input | https://filebin.net/1j9zi0r2m8wwp9yx/C_matrix.mtx | `4fc5dc5f1e86d106f592d4b1837688b02fb2d8160cd6e6e097a96410b3ca4e7b` |
| `C_b.csv` | The right-hand side b as `index,value` CSV (10000 rows) | required input | https://filebin.net/1j9zi0r2m8wwp9yx/C_b.csv | `5f9f3d0df02e62cf204b759c92caee100052a487f671c700f8e9fe54fdc86634` |

The MatrixMarket file's first line declares coordinate format, general
(symmetry) attribute; row and column indices are one-based. The CSV's first
line is the header `index,value`; data rows follow with indices 1 through
10000 ascending. No other data defines the calculation. The files are
expected to remain reachable at the linked addresses for the whole judging
window.

## Acceptance Criteria

A Submission is accepted when all of the following hold; each is decided by
direct computation on the published instance and the submitted bytes.

1. `solution.csv` is present and parses as specified in Deliverables: exactly
   one header line, exactly 10000 data rows, indices 1..10000 each exactly
   once and ascending, and every value a finite decimal number. Missing,
   duplicated, gapped or non-finite entries fail this criterion.
2. `checksum.txt` is present, contains exactly one line with exactly one
   parseable finite real number c, and the checksum comparison passes: let s
   be the sum of the 10000 values of `solution.csv` computed as an exactly
   rounded sum (math.fsum in binary64). The comparison passes when
   |c - s| <= 1e-6 * max(|s|, 1).
3. The residual check passes: let r = C x - b, where x is the vector of the
   10000 values of `solution.csv` in index order and C and b are read from
   the authoritative `C_matrix.mtx` and `C_b.csv` in IEEE-754 binary64 double
   precision with scipy.io.mmread parsing and a scipy.sparse CSR
   matrix-vector product. The check passes when ||r||_2 / ||b||_2 <= 1e-8,
   where ||.||_2 is the Euclidean norm (numpy.linalg.norm in binary64). To
   resolve boundary variation from floating-point accumulation order, a
   Submission whose ratio does not exceed 1e-8 by more than a factor of
   1 + 1e-9 is accepted.

## How is the winner selected?

- Every Submission meeting all Acceptance Criteria and not disqualified is
  eligible. Eligibility is binary; no score is computed.
- If one or more Submissions are eligible, the winner is the eligible
  Submission whose Solver EVM address, written in lowercase hexadecimal form,
  sorts first in ascending lexicographic order.
- If no Submission is eligible, the outcome is `no_valid_submission`.

## Disqualification Conditions

- A required deliverable is missing or cannot be parsed under the formats
  stated in Deliverables, which fails Acceptance Criteria 1 or 2.

## Out Of Scope
Deriving or explaining the solution method, proving how a Solver produced
its vector, the exact serialization of any locally regenerated copy of the
instance, and any scientific interpretation of the resulting vector are out
of scope.
