For evaluators — SANKHYA

Question 1 · two minutes

Is it really not built on another solver?

The problem statement's hard requirement. Three places to look, none of them a README.

1Open the CI runs. The job called provenance prints the full link line of the binary and fails the build if a solver library ever appears in it..github/workflows/ci.yml

2Open docs/PROVENANCE.md. The dependency table has five entries, each with one line on why it is not a solver, and the algorithm table names the paper or textbook each engine was written from.docs/PROVENANCE.md

3Search the source for the name of any solver you know. The only hits are in the comparison harness, which runs HiGHS in a separate process, and in the rule that forbids reading their code.ENGINEERING_RULES.md, the red line

Question 2 · eight minutes

Are the answers right?

Build it, then let a program that shares no code with the solver check what it says. The build is five commands on Windows, Ubuntu or macOS; the Run it page has the toolchain line for each.

Build and run the tests · five minutes

git clone https://github.com/thegoodengineers/SANKHYA && cd SANKHYA
scripts/configure.sh build Release
cmake --build build -j
ctest --test-dir build --output-on-failure

Expect the build to finish with no warnings and ctest to end with 100% tests passed. The suite includes a fuzz test that compares the simplex against an exact rational-arithmetic oracle on random models.

Solve a blending model and check it independently · one minute

./build/sankhya solve demo/crude_blend.mps --write-sol blend.sol --ranging
python tools/verify_solution.py demo/crude_blend.mps blend.sol

The checker reads only the model file and the solution file, re-derives feasibility and optimality in its own arithmetic and prints its verdict with the residuals. Open blend.sol: every row has its shadow price and its range.

Watch an impossible model get a proof, not an excuse · one minute

./build/sankhya solve demo/crude_blend_infeasible.mps --write-sol no.sol
python tools/verify_solution.py demo/crude_blend_infeasible.mps no.sol

The status is infeasible, the solution file carries a Farkas certificate and the smallest conflicting set of constraints, and the checker verifies the certificate against the model. A verdict that has no certificate says so in its message rather than staying silent.

Run a public benchmark through the same checker · one minute

demo/run_demo.sh --list
demo/run_demo.sh share2b

Classic Netlib models, committed in the repository so nothing is downloaded. Each solve prints our objective against the published optimum and ends with the checker's verdict; the benchmark runners in bench/runners/ do the same for the full set and write a CSV with the commit hash and your machine's tag.

Question 3 · three minutes

How does it compare, and what does it not do?

Against HiGHS, the strongest open-source LP code: the same answer on all 50 medium Netlib models, at about twice its wall time, measured with HiGHS in a separate process on the same machine. Against the published Netlib optima: 80 of 89 matched and verified; of the nine others, eight are cases where the published table itself is the outlier and HiGHS agrees with us.

On mixed-integer models it reaches the published optimum on 14 of 30 MIPLIB easy instances and proves it on 9. On the eight smallest Mittelmann LPs it finishes two inside 300 seconds, both with the first-order engine and both verified; the default simplex and the interior point finish none. The GPU backend is written and has never been compiled, because the team has no GPU.

Every number above, with its CSV → The full list of limits →

80 / 89Netlib, matched and verified

50 / 50agree with HiGHS, medium tier

2.0xour wall time over HiGHS's

2 / 8Mittelmann inside 300 s, first-order engine

Glossary

The words on this site, in plain language.

Linear program (LP): Choose quantities to make a cost as small as possible while staying inside limits that are all straight-line rules. "Buy crudes to minimise cost, subject to capacity and quality limits" is one.
Mixed-integer LP (MILP): An LP where some choices must be whole numbers or yes/no: which unit runs this week, how many batches. Much harder, because rounding an LP answer is usually wrong.
Quadratic program (QP): An LP whose cost has a squared term, such as a penalty for deviating from a target blend. Convex means it has one lowest point; a non-convex one can trap a solver at a false bottom, so this solver refuses those rather than guess.
Simplex: The classical method: walk from corner to corner of the feasible region, improving each step. Exact at the end, and it produces a basis, the object that makes warm starts and mixed-integer search possible.
Interior point: A method that moves through the middle of the region instead of along its edges. Fewer, heavier steps; the engine of choice at large size. It does not produce a basis.
First-order method (PDHG): A method that uses only matrix-vector products, the operation a GPU does well. Converges to a tolerance rather than to an exact corner, so here it is finished by the interior point.
Presolve: Simplifications applied before solving: dropping rows that cannot bind, fixing variables that have no choice. Postsolve reverses them, and here the result is re-measured against the original model.
Shadow price: What one more unit of a limit is worth: how much the cost would fall if a tank were one barrel bigger. Ranging says how far that price stays valid.
Certificate: A short proof that can be checked without re-solving. For an impossible model it is a Farkas vector: weights on the rules that, added up, contradict each other. For an unbounded one it is a direction along which the cost never stops improving.
IIS: Irreducible infeasible subsystem: the smallest set of rules that still cannot all hold. What a planner reads to find out which constraint to relax.
Verifier: The Python program in tools/verify_solution.py. It reads the model file and the solution file, nothing else, and decides for itself whether the answer is feasible, optimal and proved.
Netlib, MIPLIB, Mittelmann: Public collections of hard models with published answers, used for decades to test solvers. Netlib is classical LPs, MIPLIB is mixed-integer, Mittelmann is the large LPs used in the standard solver comparisons.