ci: harden solver fallback chain and guard precision-sensitive tests

LMI solvers (hinf, h2, lyap, lipschitz):
- Replace bare prob.solve() fallback with explicit MOSEK → CLARABEL → default
  chain so geotorch _right_inverse initialisations always get a high-accuracy
  solution; SCS is only reached as a last resort

tests/conftest.py:
- Detect best available solver (MOSEK / CLARABEL / SCS) once per session
- Add 'needs_mosek' marker: auto-skipped when only SCS is available
  (CLARABEL counts as high-precision; ships with cvxpy >= 1.5)
- Add lmi_atol fixture (1e-7 / 1e-5 / 1e-2) for parametrised tolerance checks
- Extend data guard to tests/models/linear/test_h2linear (imports pendulum)

tests/models/linear/test_hinflinear.py:
- Mark the two _right_inverse accuracy tests that assert < 1e-3 / 1e-4
  tolerances with @pytest.mark.needs_mosek

https://claude.ai/code/session_017mH337zq1P8SP5zCakWnn8

Author: claude

ctrlnmod/lmis/h2.py

@@ -88,7 +88,10 @@ def solve(cls, A: Tensor, B: Tensor, C: Tensor, solver="MOSEK", epsilon=1e-5) ->
         try:
             prob.solve(solver)
         except SolverError:
-            prob.solve()  # If MOSEK is not installed then try SCS by default
+            try:
+                prob.solve("CLARABEL")
+            except SolverError:
+                prob.solve()
         if prob.status not in ["infeasible", "unbounded"]:
             gamma2_lmi = np.sqrt(np.trace(B.T @ P.value @ B))
         else:
@@ -181,7 +184,10 @@ def solve(cls, A: Tensor, B: Tensor, C: Tensor, solver="MOSEK", epsilon=1e-6) ->
         try:
             prob.solve(solver)
         except SolverError:
-            prob.solve()  # If MOSEK is not installed then try SCS by default
+            try:
+                prob.solve("CLARABEL")
+            except SolverError:
+                prob.solve()
 
         if prob.status not in ["infeasible", "unbounded"]:
             gamma2_lmi = np.sqrt(np.trace(B.T @ P.value @ B))

ctrlnmod/lmis/hinf.py

@@ -63,7 +63,10 @@ def solve(cls, A: Tensor, B: Tensor, C: Tensor, D: Optional[Tensor]=None, alpha:
         try:
             prob.solve(solver)
         except SolverError:
-            prob.solve()
+            try:
+                prob.solve("CLARABEL")
+            except SolverError:
+                prob.solve()
 
         if prob.status in ["infeasible", "unbounded"]:
             raise ValueError("SDP problem is infeasible or unbounded")
@@ -148,7 +151,10 @@ def solve(cls, A: Tensor, B: Tensor, C: Tensor, D: Tensor, alpha: Tensor,
         try:
             prob.solve(solver)
         except SolverError:
-            prob.solve()
+            try:
+                prob.solve("CLARABEL")
+            except SolverError:
+                prob.solve()
 
         if prob.status in ["infeasible", "unbounded"]:
             raise ValueError("SDP problem is infeasible or unbounded")

ctrlnmod/lmis/lipschitz.py

@@ -170,7 +170,10 @@ def solve(cls, A: Tensor, B: Tensor, C: Tensor,
         try:
             prob.solve(solver)
         except SolverError:
-            prob.solve()  # If MOSEK is not installed then try SCS by default
+            try:
+                prob.solve("CLARABEL")
+            except SolverError:
+                prob.solve()
 
         if prob.status not in ["infeasible", "unbounded"]:
             assert lip.value is not None

ctrlnmod/lmis/lyap.py

@@ -60,7 +60,10 @@ def solve(cls, A: Tensor, alpha: float, tol: float = 1e-9, solver: str = 'MOSEK'
         try:
             prob.solve(solver)
         except cp.SolverError:
-            prob.solve()  # If MOSEK is not installed then try SCS by default
+            try:
+                prob.solve("CLARABEL")
+            except cp.SolverError:
+                prob.solve()
 
         if prob.status not in ["infeasible", "unbounded"]:
             P_value = torch.tensor(P.value)
@@ -134,7 +137,10 @@ def solve(cls, A: Tensor, alpha: float, tol: float = 1e-9, solver: str = 'MOSEK'
         try:
             prob.solve(solver)
         except cp.SolverError:
-            prob.solve()  # If MOSEK is not installed then try SCS by default
+            try:
+                prob.solve("CLARABEL")
+            except cp.SolverError:
+                prob.solve()
 
         if prob.status not in ["infeasible", "unbounded"]:
             P_value = torch.tensor(P.value)

tests/conftest.py

@@ -7,6 +7,12 @@
     Tests that require external data files or long training loops.
     Excluded from the default CI run; opt-in with:  pytest -m slow
 
+needs_mosek
+    Tests that verify tight LMI tolerances or geotorch constraint
+    feasibility after _right_inverse initialisation.  They pass reliably
+    with MOSEK; they are skipped automatically when only CLARABEL/SCS is
+    available (solver precision is then at best ~1e-6 instead of ~1e-9).
+
 Collection guards
 -----------------
 Any test file that imports a module unavailable in the current environment
@@ -15,10 +21,29 @@
 """
 
 import importlib
-
 import pytest
 
 
+# ---------------------------------------------------------------------------
+# Solver detection  (session-level, computed once)
+# ---------------------------------------------------------------------------
+
+def _best_available_solver() -> str:
+    """Return the most accurate CVXPY solver that is installed."""
+    for solver in ("MOSEK", "CLARABEL", "SCS"):
+        try:
+            mod = "mosek" if solver == "MOSEK" else solver.lower()
+            importlib.import_module(mod)
+            return solver
+        except ImportError:
+            continue
+    return "SCS"  # SCS ships with cvxpy, always present
+
+
+_SOLVER = _best_available_solver()
+_HIGH_PRECISION = _SOLVER in ("MOSEK", "CLARABEL")
+
+
 # ---------------------------------------------------------------------------
 # Custom markers
 # ---------------------------------------------------------------------------
@@ -28,25 +53,70 @@ def pytest_configure(config):
         "markers",
         "slow: mark test as requiring external data or heavy compute (skipped in CI)",
     )
+    config.addinivalue_line(
+        "markers",
+        (
+            "needs_mosek: mark test as requiring high-precision LMI solving "
+            "(MOSEK or CLARABEL); skipped automatically when only SCS is available"
+        ),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Auto-skip needs_mosek tests when solver precision is insufficient
+# ---------------------------------------------------------------------------
+
+def pytest_collection_modifyitems(config, items):
+    skip_low_precision = pytest.mark.skip(
+        reason=f"Requires MOSEK or CLARABEL for geotorch init precision "
+               f"(available solver: {_SOLVER})"
+    )
+    for item in items:
+        if item.get_closest_marker("needs_mosek") and not _HIGH_PRECISION:
+            item.add_marker(skip_low_precision)
 
 
 # ---------------------------------------------------------------------------
 # Skip collection of test files whose data dependencies are missing
 # ---------------------------------------------------------------------------
 
-_DATA_GUARDED_MODULES = [
-    # module string that must be importable for the tests in that file
-    ("tests.train.test_train", "data.pendulum.load_pendulum"),
+_DATA_GUARDED_FILES = [
+    # (substring in path,  required importable module)
+    ("tests/train/test_train",   "data.pendulum.load_pendulum"),
+    ("tests/models/linear/test_h2linear", "data.pendulum.load_pendulum"),
 ]
 
 
 def pytest_ignore_collect(collection_path, config):
     """Skip a test file when its external data module cannot be imported."""
-    path_str = str(collection_path)
-    for _test_module, data_module in _DATA_GUARDED_MODULES:
-        if _test_module.replace(".", "/") in path_str.replace("\\", "/"):
+    path_str = str(collection_path).replace("\\", "/")
+    for path_fragment, data_module in _DATA_GUARDED_FILES:
+        if path_fragment in path_str:
             try:
                 importlib.import_module(data_module)
             except ImportError:
-                return True  # silently skip
+                return True   # silently skip the whole file
     return None
+
+
+# ---------------------------------------------------------------------------
+# Shared fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture(scope="session")
+def cvxpy_solver() -> str:
+    """Best available CVXPY solver for this session."""
+    return _SOLVER
+
+
+@pytest.fixture(scope="session")
+def lmi_atol() -> float:
+    """
+    Absolute tolerance appropriate for LMI residual checks, scaled to the
+    precision of the available solver.
+
+    MOSEK    → 1e-7
+    CLARABEL → 1e-5
+    SCS      → 1e-2  (rarely reached; most precision tests are skipped)
+    """
+    return {"MOSEK": 1e-7, "CLARABEL": 1e-5, "SCS": 1e-2}[_SOLVER]

tests/models/linear/test_hinflinear.py

@@ -233,17 +233,18 @@ def test_initialization_accuracy_sqrtm(self, dims, stable_tensors):
         assert torch.norm(B_recon - B_orig) < 10.0, "B reconstruction too far from original"
         assert torch.norm(C_recon - C_orig) < 10.0, "C reconstruction too far from original"
 
+    @pytest.mark.needs_mosek
     def test_initialization_accuracy_riccati(self, dims, stable_tensors):
         """Test that right_inverse produces accurate reconstruction for riccati"""
         A_orig, B_orig, C_orig = stable_tensors
         gamma = 1.0
-        
+
         model = L2BoundedLinear(dims["nu"], dims["ny"], dims["nx"], gamma, 0.0, param='riccati', epsilon=1e-6)
-        
+
         # Try initialization with progressively higher gamma until it works
         gammas_to_try = [1.0, 15.0, 30.0, 50.0, 100.0]
         initialized = False
-        
+
         for g in gammas_to_try:
             try:
                 model.gamma = g
@@ -252,22 +253,17 @@ def test_initialization_accuracy_riccati(self, dims, stable_tensors):
                 break
             except ValueError:
                 continue
-        
+
         assert initialized, "Could not initialize with any gamma value"
-        
+
         # Get reconstructed matrices
         A_recon, B_recon, C_recon = model._frame()
-        
-        # Check that reconstruction is reasonably close
-        print(f"A difference norm: {torch.norm(A_recon - A_orig)}")
-        print(f"B difference norm: {torch.norm(B_recon - B_orig)}")
-        print(f"C difference norm: {torch.norm(C_recon - C_orig)}")
-        
-        # The reconstruction should be reasonable
+
         assert torch.norm(A_recon - A_orig) < 0.1, "A reconstruction too far from original"
         assert torch.norm(B_recon - B_orig) < 1e-3, "B reconstruction too far from original"
         assert torch.norm(C_recon - C_orig) < 1e-3, "C reconstruction too far from original"
-    
+
+    @pytest.mark.needs_mosek
     def test_perfect_reconstruction_identity_system(self, dims):
         """Test reconstruction with a simple identity-like system"""
         # Create a very simple, well-conditioned system
@@ -591,17 +587,17 @@ def test_initialization_accuracy_sqrtm(self, dims, stable_tensors_exo):
             assert torch.norm(B_recon - B_orig) < 10.0, "B reconstruction too far from original"
             assert torch.norm(C_recon - C_orig) < 10.0, "C reconstruction too far from original"
 
+    @pytest.mark.needs_mosek
     def test_initialization_accuracy_riccati(self, dims, stable_tensors):
         """Test that right_inverse produces accurate reconstruction for riccati"""
         A_orig, B_orig, C_orig = stable_tensors
         gamma = 1.0
-        
+
         model = L2BoundedLinear(dims["nu"], dims["ny"], dims["nx"], gamma, 0.0, param='riccati', epsilon=1e-6)
-        
-        # Try initialization with progressively higher gamma until it works
+
         gammas_to_try = [1.0, 15.0, 30.0, 50.0, 100.0]
         initialized = False
-        
+
         for g in gammas_to_try:
             try:
                 model.gamma = g
@@ -610,18 +606,11 @@ def test_initialization_accuracy_riccati(self, dims, stable_tensors):
                 break
             except ValueError:
                 continue
-        
+
         assert initialized, "Could not initialize with any gamma value"
-        
-        # Get reconstructed matrices
+
         A_recon, B_recon, C_recon = model._frame()
-        
-        # Check that reconstruction is reasonably close
-        print(f"A difference norm: {torch.norm(A_recon - A_orig)}")
-        print(f"B difference norm: {torch.norm(B_recon - B_orig)}")
-        print(f"C difference norm: {torch.norm(C_recon - C_orig)}")
-        
-        # The reconstruction should be reasonable
+
         assert torch.norm(A_recon - A_orig) < 0.1, "A reconstruction too far from original"
         assert torch.norm(B_recon - B_orig) < 1e-3, "B reconstruction too far from original"
         assert torch.norm(C_recon - C_orig) < 1e-3, "C reconstruction too far from original"