SNMesh.is_same_phase_space is vacuous at d≥3 (None is None ⟹ different 3-D problems compare equal) and false for same-data from_axes builds at d≤2

[deOliveira-R]

The defect

SNMesh.is_same_phase_space (orpheus/sn/mesh/augmented_mesh.py:545-596) is the Problem's identity predicate — the pairing guard Solution.compare (orpheus/sn/solution.py, its only production caller) uses to refuse combining fields from two different discrete problems. It is spelled as CONSTITUENT identity: self.mesh is other.mesh and self.quad is other.quad and <per-material Mixture is> and type(scheme) is type(scheme).

[M] 2026-09-08 (explorer census scratch/_consumers/explorer_problem_solution_census.md §4, probe run at HEAD 7e9b6210), the predicate is wrong in BOTH directions:

• d ≥ 3 — vacuously TRUE for DIFFERENT problems. Axis-native carriers carry mesh = None (SNMesh.from_axes synthesizes a legacy adapter only at d ≤ 2), so self.mesh is other.mesh reads None is None and two 3-D meshes with DIFFERENT edges (volumes unequal, bulk_space unequal) compare as the same phase space. Solution.compare therefore accepts comparing two different 3-D problems.
• d ≤ 2 — FALSE for the SAME data. Two from_axes calls with the same edges, the same Quadrature object and the same materials read False, because each call mints a fresh legacy Mesh1D adapter. A saved-and-reloaded Problem can never be "the same phase space" as its original — which defeats the save-state concept the consumers campaign is about to build (.claude/plans/cs4c_binding_design.md §22.5 addendum).

The docstring rules the constituent tier deliberately ("never relax an invariant to a weaker downstream check", L29). The d ≥ 3 arm is not a strong tier, it is no tier: None is None proves nothing. The d ≤ 2 arm compares a per-construction ADAPTER (inbound provenance) rather than the generating datum it adapts (the axes: edges + BC tags; mat_map).

The fix (the consumers campaign's FIRST item — identity is the Problem's first question)

The honest identity is the identity of the GENERATING DATA: axes (edges + boundary-law tags) × mat_map × quadrature × materials × scheme × closure class — content equality where the datum is a value (edges, tags, mat_map), object identity where it is a shared constituent (Quadrature, each Mixture). Comparing axes by content is STRONGER than mesh is, not weaker, so L29 is honoured. Design the predicate together with __eq__/__hash__ of the future SNProblem (structural identity of FunctionSpace landed at CS4c step 6 and is the template: the metric is part of the identity). Gate: a positive control (same data, two constructions → True at d = 1, 2, 3), a negative control per generating datum (edges / a BC tag / mat_map / quadrature / a mixture / the scheme type each flipped → False), and the d = 3 case that reads True today MUST read False.

Blast radius to census (plan-authoring §6b): is_same_phase_space [M] 3 production sites / 1 file + 0 tests?? — re-measure; Solution.compare's callers; the adjoint-weighted collapse (#281) that relies on the guard.

Provenance

Found by the consumers-campaign opener census (2026-09-08), filed after gh issue list --search "is_same_phase_space" → 0 hits. Not fixed inline because the honest predicate IS the campaign's first design question (Problem identity), ruled by the user at the opener; the interim hazard is confined to Solution.compare on d ≥ 3 problems and on d ≤ 2 problems built by two from_axes calls.

[deOliveira-R]

Two more measurements from the consumers-campaign opener (cross-domain attack, scratch/_consumers/attacker_problem_solution_frames.md), both verified by the main agent at HEAD 7e9b6210 on 2026-09-08:

(a) The truncation order is invisible to the pairing guard — a live exposure. [M] scattering_order has 0 occurrences under orpheus/sn/mesh/; it is clamped inside SNSolver.__init__ (sn/solver.py:1469-1473) and is_same_phase_space compares mesh / quad / materials / scheme-TYPE only. So a P0 forward solve and a P3 adjoint solve compare as the SAME phase space and Solution.condense(adjoint=…) (sn/solution.py:1045) proceeds on fields that were not produced by the same operator. The addendum (§22.5) names the truncation orders as GENERATING data of the Problem; the identity predicate must see them. Its single source today sits on the wrong side: ScatteringOperator.legendre_order (transport/operators/transfer.py:551-560), cached on the solver.

(b) The sibling hub's identity is undefined too, and it RAISES. HomogeneousProblem (C1 5caad3d6) is @dataclass(frozen=True) over a Mixture whose own generated __eq__ compares ndarray fields:

hash(HomogeneousProblem(mix))                              → TypeError: unhashable type: 'Mixture'
HomogeneousProblem(mix_a) == HomogeneousProblem(mix_b)     → ValueError: The truth value of an array … is ambiguous
mix_a == mix_b   (two equal-data Mixture objects)          → the same ValueError — Mixture's own dataclass __eq__ is broken over arrays

(same-object mixtures compare True only because tuple comparison short-circuits on is). So the identity carve has THREE members: SNMesh.is_same_phase_space (this issue's headline), HomogeneousProblem.__eq__/__hash__, and Mixture.__eq__ — one ruling on what a Problem's (and a datum's) identity IS, then three fixes from one definition. The interim for the hub (constituent tier: mixture is other.mixture, hashable) lands with the coda's close-out so the class stops raising; the honest content identity is this issue's.

[deOliveira-R]

Interim landed at 6f6545eb: HomogeneousProblem no longer raises on ==/hash — constituent-tier identity (same Mixture object ⟹ same problem), gated by test_H2b_the_hubs_identity_is_the_mixtures_and_never_raises. The content tier (this issue) still owes ONE definition for the three members (SNMesh.is_same_phase_space, the hub, Mixture.__eq__), and the truncation order must enter it.

[deOliveira-R]

RULED 2026-09-08 (the consumers campaign's opening checkpoint): a Problem's identity is the CONTENT of its generating data — axes (edges + BC tags), mat_map, quadrature, materials, scheme, closure class, the truncation orders — hashable, so a saved-and-reloaded Problem compares equal. One definition, three fixes (SNMesh.is_same_phase_space, HomogeneousProblem, Mixture.__eq__), and scattering_order moves onto the Problem so the guard sees it. This is the campaign's FIRST step (plan .claude/plans/cs4c_binding_design.md §27, R-cc3/R-cc4); test-architect verification plan before the carve.