fix: stop reading rounding as proof of infeasibility

[tschm]

Summary

solve_qp rejected feasible problems at degenerate vertices, where the reference C
implementation returns the minimiser.

Closes #36

Stacked on #37. Base is hypothesis_35, not main, because this removes the strict
xfail that #37 adds and touches the same lines. Merge #37 first and GitHub retargets this
to main automatically.

The defect

The dual method calls a problem infeasible when the entering constraint's normal already
lies in the span of the active set and no active multiplier can be reduced. That argument
assumes the constraint is genuinely violated.

The Householder deviation makes the other case reachable. At a vertex where all four
constraints are tight and the three nonzero normals span two dimensions:

	residual on the fourth constraint	vs. the 6.43 * eps VSMALL snap
reference C (Givens chain)	4.68 · eps	below → snapped to zero → returns
this port (Householder)	8.00 · eps	above → reads as a violation → raised

Above the snap it reads as violated, the primal cannot move, no multiplier can fall, and
_step_choice declares the dual unbounded.

Why guard the conclusion rather than raise VSMALL

Bumping the constant was the obvious alternative and is worse on two counts:

1. It changes which constraints get selected, and test_against_c.py pins that against
   the reference iteration for iteration across 867 comparisons.
2. It puts the burden on a threshold separating "rounding" from "violated but tiny" — a
   distinction with no safe margin, since a real violation can be arbitrarily small.

The infeasibility test only has to separate "rounding" from "provably infeasible", and
infeasibility is macroscopic: the violation is set by the geometry, not the arithmetic.
Any threshold in the ~13 orders between them works, so _NOISE_MARGIN is loose on purpose
and there is nothing to tune.

Nothing that solved before can change — the guard is reachable only on the path that
previously raised.

Changes

• _is_spurious_violation — scales the bound by ||c|| ||x|| + |b| rather than testing an
  absolute number, because the slack inherits the error in xv, not merely the error of its
  own dot product. For a constraint x already sits on, the terms that formed it are
  themselves at the noise floor and say nothing.
• solve_qp — a constraint judged spurious goes into ignored and the outer loop takes the
  next candidate. The set is cleared whenever xv moves, so nothing stays masked on a stale
  iterate. The insertion moved inside the inner loop so the new exit needs no flag.
• tests/test_structure.py — seven unit tests for the new helper.
• README.md — records the one resulting divergence (below).
• docs/development/MUTATION.md, .github/workflows/mutation.yml — baseline 12 → 14, see below.

Verification

• Differential suite unchanged — 867 comparisons still match the reference's iteration
  counts exactly; the three infeasibility cases still raise.
• 30000 randomized Hypothesis examples at caps wider than committed
  (max_n=6, max_m=8, max_meq=3): 60000 solves, zero false infeasibility, zero
  certificate failures. The same setting produced ~10 per 6000 before.
• 1013 passed, 100% statement and branch coverage.
• Complexity — solve_qp stays B (10), package average unchanged at A (3.71).
• Performance — one Python call per inner iteration: +2% at n ≤ 100, within noise from
  n = 200 up, measured A/B interleaved against a pre-fix build rather than against earlier
  numbers, since this repo has been bitten by machine drift before.

Mutation testing

Seven survivors appeared in the new function, all tolerance mutants. All seven are killed by
the new unit tests, which derive their bounds from _NOISE_MARGIN and VSMALL instead of
restating them — the margin is documented as deliberately loose, and a test that froze it
would contradict that.

The baseline still moves 12 → 14, for two survivors that are not from this change:
_drop_constraint 24 and 25 survive on main too, verified by applying both to the pre-fix
source and running the full suite, which passes. They write to the slot past the shrunken
active set, only ever read as [:nact].

They were missing from the old baseline because mutmut caches per-mutant verdicts and a run
that changes only tests reuses them — it reported the seven above as un-killed until the
cache was cleared, at which point all seven died and the killed count moved by 77. Now
documented in MUTATION.md.

Divergence this introduces

A problem whose infeasibility is itself at the rounding floor may now be solved here and
rejected by the reference. Recorded under README → Deliberate deviations.

Testing

• make test passes locally — 1013 passed, 100% coverage
• make fmt has been run
• New tests added
• make mutation re-run from a cleared cache

Checklist

• Commit messages follow the Conventional Commits format
• CHANGELOG.md entry — generated from the commit by git-cliff
• Documentation updated if behaviour changed — README and MUTATION.md
• make deps passes (no unused or missing dependencies)

🤖 Generated with Claude Code

[Copilot]

Pull request overview

This PR fixes a false infeasibility verdict in solve_qp that can occur at maximally degenerate vertices when rounding pushes a slack just above the existing VSMALL snap threshold, causing the dual method’s “stuck ⇒ infeasible” inference to trigger incorrectly.

Changes:

• Add _is_spurious_violation and use it in solve_qp to set aside rounding-scale “violations” on the specific stuck path that previously raised infeasibility.
• Remove the strict xfail / rejection logic around issue #36 and make the regression test and properties assert on the real solver result.
• Add unit tests for the new spurious-violation rule and update documentation/mutation-testing baseline to reflect the new behavior and tests.

Reviewed changes

Copilot reviewed 6 out of 6 changed files in this pull request and generated 1 comment.

Show a summary per file

File	Description
src/cvx/quadprog/_solve.py	Adds _NOISE_MARGIN, _is_spurious_violation, and an ignored mechanism to avoid concluding infeasibility from rounding-scale slacks.
tests/test_structure.py	Adds unit tests that pin the shape/scale behavior of _is_spurious_violation.
tests/test_properties.py	Removes the xfail/reject shim and asserts the solver no longer rejects the known-feasible degenerate case.
README.md	Documents the new “infeasibility only concluded above rounding floor” behavior and its deliberate divergence edge case.
docs/development/MUTATION.md	Updates mutmut baseline counts and documents cache behavior and the new helper’s mutants.
.github/workflows/mutation.yml	Bumps mutation baseline from 12 to 14.

Suppressed comments (1)

src/cvx/quadprog/_solve.py:310

• ignored is only cleared when xv moves (ztn is not None). But the active set can also change without moving xv (the ztn is None / dual-only branch drops constraints). In that case, a constraint previously marked ignored may become enforceable under the new active-set span, yet it will remain masked until xv moves, which can let the solver terminate without reconsidering it.

            if ztn is not None:
                xv += step * zv
                obj += step * ztn * (step / 2.0 + u)
                # xv moved, so every slack set aside against the old one is
                # stale and must be measured again.
                nign = 0

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.