solverpilot 0.1__py3-none-any.whl

solverpilot/model/sets.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class LessThan:
+    upper: float = 0.0
+
+
+@dataclass(frozen=True, slots=True)
+class GreaterThan:
+    lower: float = 0.0
+
+
+@dataclass(frozen=True, slots=True)
+class EqualTo:
+    value: float = 0.0
+
+
+@dataclass(frozen=True, slots=True)
+class Interval:
+    lower: float
+    upper: float
+
+
+ScalarSet = LessThan | GreaterThan | EqualTo | Interval
+
+
+@dataclass(frozen=True, slots=True)
+class SecondOrderCone:
+    dimension: int
+
+    def __post_init__(self) -> None:
+        if int(self.dimension) < 2:
+            raise ValueError("SecondOrderCone dimension must be >= 2")
+        object.__setattr__(self, "dimension", int(self.dimension))
+
+
+@dataclass(frozen=True, slots=True)
+class RotatedSecondOrderCone:
+    dimension: int
+
+    def __post_init__(self) -> None:
+        if int(self.dimension) < 3:
+            raise ValueError("RotatedSecondOrderCone dimension must be >= 3")
+        object.__setattr__(self, "dimension", int(self.dimension))
+
+
+@dataclass(frozen=True, slots=True)
+class PositiveSemidefiniteCone:
+    dimension: int
+
+    def __post_init__(self) -> None:
+        if int(self.dimension) < 1:
+            raise ValueError("PositiveSemidefiniteCone dimension must be >= 1")
+        object.__setattr__(self, "dimension", int(self.dimension))
+
+
+ConstraintSet = ScalarSet | SecondOrderCone | RotatedSecondOrderCone | PositiveSemidefiniteCone

solverpilot/model/types.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+@dataclass(frozen=True, slots=True, order=True)
+class EntityId:
+    value: str
+    namespace: str = ""
+
+    def __str__(self) -> str:
+        return self.value
+
+    @property
+    def qualified(self) -> str:
+        return f"{self.namespace}:{self.value}" if self.namespace else self.value
+
+
+class SignDomain(str, Enum):
+    UNKNOWN = "unknown"
+    ZERO = "zero"
+    NONNEGATIVE = "nonnegative"
+    NONPOSITIVE = "nonpositive"
+
+
+class Curvature(str, Enum):
+    CONSTANT = "constant"
+    AFFINE = "affine"
+    UNKNOWN = "unknown"
+
+
+class NumericType(str, Enum):
+    REAL = "real"
+    INTEGER = "integer"
+    BINARY = "binary"

solverpilot/nlp/__init__.py

@@ -0,0 +1,7 @@
+from .ir import NLPConstraintBlock, NLPProblem
+from .ad import NLPDerivativeEngine, evaluate_node
+from .compiler import compile_nlp_model
+from .validation import NLPValidationReport, validate_nlp_solution
+from .backend import CasadiIpoptBackend, NLPSolveResult
+from .conformance import NLPConformanceCheck, NLPConformanceReport, conform_casadi_ipopt_backend
+__all__=['NLPConstraintBlock','NLPProblem','NLPDerivativeEngine','evaluate_node','compile_nlp_model','NLPValidationReport','validate_nlp_solution','CasadiIpoptBackend','NLPSolveResult','NLPConformanceCheck','NLPConformanceReport','conform_casadi_ipopt_backend']

solverpilot/nlp/ad.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+import numpy as np
+
+from solverpilot.model.expression import ExprNode
+from .ir import NLPProblem
+
+
+def _reshape_row_major_ca(ca, vec, shape):
+    if shape == ():
+        return vec[0] if hasattr(vec, '__len__') else vec
+    if len(shape) == 1:
+        return ca.reshape(vec, shape[0], 1)
+    if len(shape) == 2:
+        r, c = shape
+        return ca.reshape(vec, c, r).T
+    raise ValueError("P7 supports at most 2-D expressions")
+
+
+def _flatten_row_major_ca(ca, expr, shape):
+    if shape == ():
+        return ca.vertcat(expr)
+    if len(shape) == 1:
+        return ca.reshape(expr, shape[0], 1)
+    if len(shape) == 2:
+        return ca.reshape(expr.T, shape[0]*shape[1], 1)
+    raise ValueError("P7 supports at most 2-D expressions")
+
+
+def _eval_np(node: ExprNode, x: np.ndarray, problem: NLPProblem):
+    kind = node.kind
+    if kind == 'constant': return np.asarray(node.payload, dtype=float)
+    if kind == 'parameter': return np.asarray(problem.parameter_values[str(node.payload)], dtype=float)
+    if kind == 'variable':
+        off, shape = problem.variable_layout[str(node.payload)]
+        size = int(np.prod(shape)) if shape else 1
+        arr = np.asarray(x[off:off+size], dtype=float)
+        return arr.reshape(shape if shape else ())
+    args = [_eval_np(a, x, problem) for a in node.args]
+    if kind == 'index': return args[0][node.payload]
+    if kind == 'transpose': return np.asarray(args[0]).T
+    if kind == 'sum': return np.sum(args[0], axis=node.payload)
+    if kind == 'neg': return -args[0]
+    if kind == 'add': return args[0] + args[1]
+    if kind == 'mul': return args[0] * args[1]
+    if kind == 'div': return args[0] / args[1]
+    if kind == 'matmul': return args[0] @ args[1]
+    if kind == 'pow': return np.power(args[0], int(node.payload))
+    if kind == 'sin': return np.sin(args[0])
+    if kind == 'cos': return np.cos(args[0])
+    if kind == 'exp': return np.exp(args[0])
+    if kind == 'log': return np.log(args[0])
+    if kind == 'sqrt': return np.sqrt(args[0])
+    if kind == 'tanh': return np.tanh(args[0])
+    raise ValueError(f'unsupported P7 expression kind {kind!r}')
+
+
+def evaluate_node(problem: NLPProblem, node: ExprNode, x: np.ndarray):
+    with np.errstate(all='ignore'):
+        return _eval_np(node, np.asarray(x, dtype=float).reshape(-1), problem)
+
+
+def _to_ca(ca, node: ExprNode, x, problem: NLPProblem, cache: dict[int, Any]):
+    key = id(node)
+    if key in cache: return cache[key]
+    kind = node.kind
+    if kind == 'constant':
+        arr = np.asarray(node.payload, dtype=float)
+        out = ca.DM(float(arr)) if arr.shape == () else ca.DM(arr if arr.ndim == 2 else arr.reshape(-1,1))
+    elif kind == 'parameter':
+        arr = np.asarray(problem.parameter_values[str(node.payload)], dtype=float)
+        out = ca.DM(float(arr)) if arr.shape == () else ca.DM(arr if arr.ndim == 2 else arr.reshape(-1,1))
+    elif kind == 'variable':
+        off, shape = problem.variable_layout[str(node.payload)]
+        size = int(np.prod(shape)) if shape else 1
+        out = _reshape_row_major_ca(ca, x[off:off+size], shape)
+    else:
+        args = [_to_ca(ca, a, x, problem, cache) for a in node.args]
+        if kind == 'index':
+            out = args[0][node.payload]
+        elif kind == 'transpose': out = args[0].T
+        elif kind == 'sum':
+            if node.payload is None: out = ca.sum1(ca.sum2(args[0]))
+            elif int(node.payload) == 0: out = ca.sum1(args[0])
+            elif int(node.payload) == 1: out = ca.sum2(args[0])
+            else: raise ValueError('P7 sum supports axes 0/1')
+        elif kind == 'neg': out = -args[0]
+        elif kind == 'add': out = args[0] + args[1]
+        elif kind == 'mul': out = args[0] * args[1]
+        elif kind == 'div': out = args[0] / args[1]
+        elif kind == 'matmul':
+            a0, a1 = node.args
+            left = args[0].T if len(a0.shape) == 1 and len(a1.shape) == 2 else args[0]
+            out = ca.mtimes(left, args[1])
+        elif kind == 'pow': out = ca.power(args[0], int(node.payload))
+        elif kind == 'sin': out = ca.sin(args[0])
+        elif kind == 'cos': out = ca.cos(args[0])
+        elif kind == 'exp': out = ca.exp(args[0])
+        elif kind == 'log': out = ca.log(args[0])
+        elif kind == 'sqrt': out = ca.sqrt(args[0])
+        elif kind == 'tanh': out = ca.tanh(args[0])
+        else: raise ValueError(f'unsupported P7 expression kind {kind!r}')
+    cache[key] = out
+    return out
+
+
+@dataclass
+class NLPDerivativeEngine:
+    problem: NLPProblem
+
+    def __post_init__(self) -> None:
+        import casadi as ca
+        self.ca = ca
+        self.x = ca.MX.sym('x', self.problem.n_variables)
+        cache: dict[int, Any] = {}
+        f_raw = _to_ca(ca, self.problem.objective_node, self.x, self.problem, cache)
+        obj_size = int(np.prod(self.problem.objective_node.shape)) if self.problem.objective_node.shape else 1
+        if obj_size != 1:
+            raise ValueError('NLP objective must be scalar')
+        self.f = ca.reshape(f_raw, 1, 1)[0]
+        g_parts = []
+        for block in self.problem.constraints:
+            e = _to_ca(ca, block.node, self.x, self.problem, cache)
+            g_parts.append(_flatten_row_major_ca(ca, e, block.shape))
+        self.g = ca.vertcat(*g_parts) if g_parts else ca.MX.zeros(0,1)
+        self.grad = ca.gradient(self.f, self.x)
+        self.jac = ca.jacobian(self.g, self.x)
+        self.lam = ca.MX.sym('lam', self.problem.n_constraints)
+        lag = self.f + ca.dot(self.lam, self.g) if self.problem.n_constraints else self.f
+        self.hess = ca.hessian(lag, self.x)[0]
+        self._fun = ca.Function('solverpilot_p7_eval', [self.x], [self.f, self.g, self.grad, self.jac])
+        self._hfun = ca.Function('solverpilot_p7_hess', [self.x, self.lam], [self.hess])
+
+    def evaluate(self, x):
+        out = self._fun(np.asarray(x,dtype=float).reshape(-1))
+        return (float(out[0]), np.asarray(out[1],dtype=float).reshape(-1), np.asarray(out[2],dtype=float).reshape(-1), np.asarray(out[3],dtype=float))
+
+    def objective(self, x) -> float:
+        return self.evaluate(x)[0]
+    def constraints(self, x) -> np.ndarray:
+        return self.evaluate(x)[1]
+    def gradient(self, x) -> np.ndarray:
+        return self.evaluate(x)[2]
+    def jacobian(self, x) -> np.ndarray:
+        return self.evaluate(x)[3]
+    def lagrangian_hessian(self, x, multipliers=None) -> np.ndarray:
+        lam = np.zeros(self.problem.n_constraints) if multipliers is None else np.asarray(multipliers,dtype=float).reshape(-1)
+        return np.asarray(self._hfun(np.asarray(x,dtype=float).reshape(-1), lam), dtype=float)
+    def jacobian_sparsity(self) -> tuple[tuple[int,int], ...]:
+        sp = self.jac.sparsity(); rows, cols = sp.get_triplet()[0:2]
+        return tuple(zip(map(int, rows), map(int, cols)))
+    def hessian_sparsity(self) -> tuple[tuple[int,int], ...]:
+        sp = self.hess.sparsity(); rows, cols = sp.get_triplet()[0:2]
+        return tuple(zip(map(int, rows), map(int, cols)))
+    def jvp(self, x, v) -> np.ndarray:
+        import casadi as ca
+        v_sym = ca.MX.sym('v', self.problem.n_variables)
+        fun = ca.Function('solverpilot_p7_jvp', [self.x, v_sym], [ca.jtimes(self.g, self.x, v_sym)])
+        return np.asarray(fun(np.asarray(x,float), np.asarray(v,float)), dtype=float).reshape(-1)
+    def vjp(self, x, w) -> np.ndarray:
+        import casadi as ca
+        w_sym = ca.MX.sym('w', self.problem.n_constraints)
+        fun = ca.Function('solverpilot_p7_vjp', [self.x, w_sym], [ca.jtimes(self.g, self.x, w_sym, True)])
+        return np.asarray(fun(np.asarray(x,float), np.asarray(w,float)), dtype=float).reshape(-1)

solverpilot/nlp/backend.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+import importlib.util
+import numpy as np
+from .ad import NLPDerivativeEngine, evaluate_node
+from .ir import NLPProblem
+from .validation import NLPValidationReport, validate_nlp_solution
+
+@dataclass(frozen=True, slots=True)
+class NLPSolveResult:
+    backend:str
+    backend_status:str
+    x:np.ndarray|None
+    objective_reported:float|None
+    validation:NLPValidationReport
+    local_optimal_candidate:bool
+    globally_proven:bool
+    multipliers_g:np.ndarray|None
+    multipliers_x:np.ndarray|None
+    kkt_stationarity_inf:float|None
+    raw_statistics:dict[str,Any]
+
+@dataclass(slots=True)
+class CasadiIpoptBackend:
+    max_iter:int=3000
+    tol:float=1e-9
+    print_level:int=0
+    linear_solver:str|None=None
+    @property
+    def name(self): return 'casadi-ipopt-nlp-bridge'
+    @property
+    def binding_version(self):
+        try:
+            import casadi as ca; return ca.__version__
+        except Exception: return None
+    def is_available(self):
+        if importlib.util.find_spec('casadi') is None: return False
+        try:
+            import casadi as ca; return bool(ca.has_nlpsol('ipopt'))
+        except Exception: return False
+    @property
+    def capability_manifest_v2(self):
+        from solverpilot import __version__
+        from solverpilot.capabilities.v2 import BackendCapabilityManifestV2,CapabilityClaim,CapabilityEvidence,CapabilityKey,CapabilityMode,CapabilityStatus,VerificationLevel
+        bv=f'bundled-with-casadi-{self.binding_version or "unknown"}'
+        ev=CapabilityEvidence('p7-casadi-ipopt-conformance-v1','runtime-conformance',(bv,),(() if self.binding_version is None else (self.binding_version,)),(__version__,),'2026-09-06',('Ipopt local NLP solve + SolverPilot independent validation + derivative cross-check',))
+        def v(restr=None):
+            restr={} if restr is None else restr
+            return CapabilityClaim(CapabilityStatus.RESTRICTED if restr else CapabilityStatus.SUPPORTED,CapabilityMode.EMULATED_SAFE,VerificationLevel.VERIFIED,restr,(ev,))
+        claims={CapabilityKey.PROBLEM_NLP:v({'continuous_only':True,'local_solver':True,'global_optimality_not_claimed':True}),CapabilityKey.CONSTRAINT_NONLINEAR:v(),CapabilityKey.DERIVATIVE_GRADIENT:v(),CapabilityKey.DERIVATIVE_JACOBIAN:v(),CapabilityKey.DERIVATIVE_HESSIAN:v(),CapabilityKey.RESULT_PRIMAL:v(),CapabilityKey.RESULT_OBJECTIVE:v(),CapabilityKey.RESULT_DUAL:v({'backend_multiplier_sign_convention':'Ipopt/CasADi'}),CapabilityKey.START_PRIMAL:v()}
+        return BackendCapabilityManifestV2(self.name,bv,'casadi',self.binding_version,__version__,claims=claims,metadata={'plugin':'ipopt','local_nlp':True})
+    def solve(self,problem:NLPProblem,*,x0=None):
+        if not self.is_available(): raise RuntimeError('CasADi Ipopt plugin unavailable')
+        import casadi as ca
+        eng=NLPDerivativeEngine(problem)
+        nlp={'x':eng.x,'f':eng.f}
+        if problem.n_constraints: nlp['g']=eng.g
+        opts={'print_time':False,'ipopt.print_level':int(self.print_level),'ipopt.max_iter':int(self.max_iter),'ipopt.tol':float(self.tol)}
+        if self.linear_solver: opts['ipopt.linear_solver']=self.linear_solver
+        solver=ca.nlpsol('solverpilot_p7_ipopt','ipopt',nlp,opts)
+        initial_search_attempts=0
+        if x0 is None:
+            lo,hi=problem.variable_lower,problem.variable_upper
+            midpoint=np.where(np.isfinite(lo)&np.isfinite(hi),0.5*(lo+hi),np.where(np.isfinite(lo),np.maximum(lo,0),np.where(np.isfinite(hi),np.minimum(hi,0),0.0)))
+            candidates=[midpoint]
+            # Deterministic interior-biased alternatives. They are only a starting-point
+            # strategy; final validity still comes from independent original-space validation.
+            for frac in (0.25,0.75):
+                cand=np.where(np.isfinite(lo)&np.isfinite(hi),lo+frac*(hi-lo),midpoint)
+                candidates.append(cand)
+            candidates.append(np.clip(np.ones(problem.n_variables),lo,hi))
+            candidates.append(np.clip(-np.ones(problem.n_variables),lo,hi))
+            x0=midpoint
+            for cand in candidates:
+                initial_search_attempts += 1
+                try:
+                    f=evaluate_node(problem,problem.objective_node,cand)
+                    gs=[evaluate_node(problem,b.node,cand) for b in problem.constraints]
+                    if np.isfinite(np.asarray(f,dtype=float)).all() and all(np.isfinite(np.asarray(g,dtype=float)).all() for g in gs):
+                        x0=np.asarray(cand,dtype=float); break
+                except (FloatingPointError,ValueError,TypeError,OverflowError):
+                    continue
+        kw={'x0':np.asarray(x0,float),'lbx':problem.variable_lower,'ubx':problem.variable_upper}
+        if problem.n_constraints: kw.update(lbg=problem.constraint_lower,ubg=problem.constraint_upper)
+        result=None; err=None
+        try: result=solver(**kw)
+        except Exception as e: err=f'{type(e).__name__}: {e}'
+        try: stats=dict(solver.stats())
+        except Exception: stats={}
+        x=None; obj=None; lg=None; lx=None
+        if result is not None:
+            if 'x' in result:
+                arr=np.asarray(result['x'],dtype=float).reshape(-1)
+                if arr.shape==(problem.n_variables,) and np.all(np.isfinite(arr)): x=arr
+            if 'f' in result:
+                try: obj=float(result['f'])
+                except Exception: pass
+            if 'lam_g' in result: lg=np.asarray(result['lam_g'],dtype=float).reshape(-1)
+            if 'lam_x' in result: lx=np.asarray(result['lam_x'],dtype=float).reshape(-1)
+        validation=validate_nlp_solution(problem,x,objective_reported=obj,atol=max(1e-7,self.tol*100),rtol=max(1e-7,self.tol*100))
+        raw=str(stats.get('return_status',''))
+        stationarity=None
+        if x is not None and lg is not None and lx is not None:
+            try:
+                grad=eng.gradient(x); jac=eng.jacobian(x)
+                stationarity=float(np.max(np.abs(grad + jac.T @ lg + lx)))
+            except Exception:
+                stationarity=None
+        kkt_tol=max(1e-6,self.tol*1000)
+        success=bool(stats.get('success')) and validation.valid and stationarity is not None and stationarity <= kkt_tol
+        stats.update({'error':err,'initial_point_domain_search_attempts':initial_search_attempts,'domain_hazards':list(problem.metadata.get('domain_hazards',())),'casadi_version':self.binding_version,'nlpsol_plugin':'ipopt','global_optimality_claimed':False,'kkt_stationarity_inf':stationarity,'kkt_stationarity_tolerance':kkt_tol})
+        return NLPSolveResult(self.name,raw,x,obj,validation,success,False,lg,lx,stationarity,stats)

solverpilot/nlp/compiler.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+from dataclasses import replace
+import numpy as np
+from solverpilot.model.errors import CompileError
+from solverpilot.model.sets import LessThan, GreaterThan, EqualTo, Interval
+from solverpilot.problem import ObjectiveSense, VariableDomain
+from solverpilot.model.compiler import CompiledModel, CompilationReport, _variable_layout
+from .ir import NLPConstraintBlock, NLPProblem
+
+
+def _broadcast_bound(value, size):
+    arr=np.asarray(value,dtype=float)
+    try: return np.broadcast_to(arr,(size,)).astype(float,copy=True)
+    except Exception as e: raise CompileError('NLP set bound cannot broadcast to expression size') from e
+
+
+def _node_interval(node, *, variable_layout, variable_lower, variable_upper, parameter_values):
+    """Conservative scalar interval over all elements of an expression node.
+
+    ``None`` means the compiler cannot prove a safe range from declared variable
+    bounds and frozen parameter values. The analysis is intentionally fail-closed.
+    """
+    kind=node.kind
+    if kind=='constant':
+        a=np.asarray(node.payload,dtype=float); return (float(np.min(a)),float(np.max(a)))
+    if kind=='parameter':
+        a=np.asarray(parameter_values[str(node.payload)],dtype=float); return (float(np.min(a)),float(np.max(a)))
+    if kind=='variable':
+        off,shape=variable_layout[str(node.payload)]; size=int(np.prod(shape)) if shape else 1
+        return (float(np.min(variable_lower[off:off+size])),float(np.max(variable_upper[off:off+size])))
+    if kind in {'index','transpose'}:
+        return _node_interval(node.args[0],variable_layout=variable_layout,variable_lower=variable_lower,variable_upper=variable_upper,parameter_values=parameter_values)
+    if kind=='sum':
+        child=_node_interval(node.args[0],variable_layout=variable_layout,variable_lower=variable_lower,variable_upper=variable_upper,parameter_values=parameter_values)
+        if child is None: return None
+        count=int(np.prod(node.args[0].shape)) if node.payload is None else node.args[0].shape[int(node.payload)]
+        lo,hi=child
+        if lo>=0 or hi<=0: return (lo*count,hi*count)
+        return None
+    vals=[_node_interval(a,variable_layout=variable_layout,variable_lower=variable_lower,variable_upper=variable_upper,parameter_values=parameter_values) for a in node.args]
+    if any(v is None for v in vals): return None
+    if kind=='neg': return (-vals[0][1],-vals[0][0])
+    if kind=='add': return (vals[0][0]+vals[1][0],vals[0][1]+vals[1][1])
+    if kind=='mul':
+        a,b=vals; c=[a[0]*b[0],a[0]*b[1],a[1]*b[0],a[1]*b[1]]; return (min(c),max(c))
+    if kind=='div':
+        a,b=vals
+        if b[0] <= 0 <= b[1]: return None
+        c=[a[0]/b[0],a[0]/b[1],a[1]/b[0],a[1]/b[1]]; return (min(c),max(c))
+    if kind=='pow':
+        exponent=int(node.payload); a=vals[0]
+        if exponent%2==0:
+            hi=max(abs(a[0]),abs(a[1]))**exponent
+            lo=0.0 if a[0] <= 0 <= a[1] else min(abs(a[0]),abs(a[1]))**exponent
+            return (lo,hi)
+        return (a[0]**exponent,a[1]**exponent)
+    if kind=='exp': return (float(np.exp(vals[0][0])),float(np.exp(vals[0][1])))
+    if kind=='log':
+        if vals[0][0] <= 0: return None
+        return (float(np.log(vals[0][0])),float(np.log(vals[0][1])))
+    if kind=='sqrt':
+        if vals[0][0] < 0: return None
+        return (float(np.sqrt(vals[0][0])),float(np.sqrt(vals[0][1])))
+    if kind=='tanh': return (float(np.tanh(vals[0][0])),float(np.tanh(vals[0][1])))
+    return None
+
+def _collect_domain_hazards(node, *, variable_layout, variable_lower, variable_upper, parameter_values, where):
+    hazards=[]
+    for child in node.args:
+        hazards.extend(_collect_domain_hazards(child,variable_layout=variable_layout,variable_lower=variable_lower,variable_upper=variable_upper,parameter_values=parameter_values,where=where))
+    if node.kind not in {'log','sqrt','div'}:
+        return hazards
+    target=node.args[0] if node.kind in {'log','sqrt'} else node.args[1]
+    interval=_node_interval(target,variable_layout=variable_layout,variable_lower=variable_lower,variable_upper=variable_upper,parameter_values=parameter_values)
+    safe=False
+    if interval is not None:
+        lo,hi=interval
+        safe=(node.kind=='log' and lo>0) or (node.kind=='sqrt' and lo>=0) or (node.kind=='div' and not (lo<=0<=hi))
+    if not safe:
+        hazards.append({'where':where,'kind':node.kind,'interval':None if interval is None else [float(interval[0]),float(interval[1])],'status':'not_proven_safe_from_declared_bounds'})
+    return hazards
+
+def compile_nlp_model(model, *, use_cache=True):
+    if model.objective is None: raise CompileError('model has no objective')
+    if model.objective.sense is not ObjectiveSense.MINIMIZE: raise CompileError('P7 NLP compiler currently supports minimization only')
+    if model.objective.expression.shape != (): raise CompileError('P7 NLP objective must be scalar')
+    if any(d.domain is not VariableDomain.CONTINUOUS for d in model._variables.values()): raise CompileError('P7 NLP supports continuous variables only; MINLP is P8')
+    offsets,n,vl,vu,domains,source_vars=_variable_layout(model)
+    layout={vid:(offsets[vid][0],data.shape) for vid,data in model._variables.items()}
+    pvals={pid:data.value.copy() for pid,data in model._parameters.items()}
+    domain_hazards=_collect_domain_hazards(
+        model.objective.expression._node, variable_layout=layout, variable_lower=vl, variable_upper=vu,
+        parameter_values=pvals, where='NLP objective'
+    )
+    blocks=[]; source_constraints={}
+    for c in model.constraints:
+        if not hasattr(c,'set') or c.__class__.__name__=='IndicatorConstraint': raise CompileError('P7 NLP compiler does not lower indicator constraints; compile through P4/P8 orchestration')
+        if not isinstance(c.set,(LessThan,GreaterThan,EqualTo,Interval)): raise CompileError(f'P7 NLP supports scalar-set constraints only, got {type(c.set).__name__}')
+        domain_hazards.extend(_collect_domain_hazards(
+            c.function._node, variable_layout=layout, variable_lower=vl, variable_upper=vu,
+            parameter_values=pvals, where=f'NLP constraint {c.entity_id.value}'
+        ))
+        size=int(np.prod(c.function.shape)) if c.function.shape else 1
+        if isinstance(c.set,LessThan): lo=np.full(size,-np.inf); hi=_broadcast_bound(c.set.upper,size)
+        elif isinstance(c.set,GreaterThan): lo=_broadcast_bound(c.set.lower,size); hi=np.full(size,np.inf)
+        elif isinstance(c.set,EqualTo): lo=hi=_broadcast_bound(c.set.value,size)
+        else: lo=_broadcast_bound(c.set.lower,size); hi=_broadcast_bound(c.set.upper,size)
+        blocks.append(NLPConstraintBlock(c.entity_id.value,c.function._node,lo,hi,c.function.shape,tuple(sorted(c.function.parameter_dependencies))))
+        source_constraints[c.entity_id.value]={'semantic_kind':'nonlinear_function_in_set','nlp_rows':size,'shape':list(c.function.shape)}
+    problem=NLPProblem(n,vl,vu,layout,pvals,model.objective.expression._node,tuple(blocks),model.objective.sense.value,model.name,{'semantic_hash':model.semantic_hash,'compiled_by':'solverpilot-p7','domain_hazards':tuple(domain_hazards),'domain_safety_proven':not bool(domain_hazards)})
+    import hashlib,json
+    payload={'semantic_hash':model.semantic_hash,'target':'nlp-ir-v1','policy':'p7-smooth-core-v1','objective_degree':model.objective.expression.polynomial_degree,'constraint_kinds':[c.function._node.kind for c in model.constraints]}
+    ch=hashlib.sha256(json.dumps(payload,sort_keys=True,separators=(',',':')).encode()).hexdigest()
+    pmap={pid:{'shape':list(data.shape),'patchable':False,'parameter_compile_class':'p7_full_nlp_relower','plan_sensitive':bool(pid in model.objective.expression.parameter_dependencies or any(pid in c.function.parameter_dependencies for c in model.constraints))} for pid,data in model._parameters.items()}
+    report=CompilationReport(target='nlp-ir-v1',semantic_analysis_s=0.0,lowering_s=0.0,total_s=0.0,n_semantic_variables=len(model._variables),n_execution_variables=n,n_semantic_constraints=len(model._constraints),n_execution_constraints=problem.n_constraints,cache_status='disabled' if not use_cache else 'p7_rebuild',changed_parameters=(),reused_execution_rows=0,recompiled_execution_rows=problem.n_constraints,objective_recompiled=True,execution_mutations=(),n_transformations=0)
+    return CompiledModel(execution_ir=problem,semantic_hash=model.semantic_hash,data_hash=model.data_hash,compilation_hash=ch,parameter_map=pmap,source_map={'variables':source_vars,'constraints':source_constraints,'objective':{model.objective.entity_id.value:{'execution_objective':True}}},transformation_tape=(),capability_signature='p7-nlp-smooth-core-casadi-ad-v1',mutation_plan={'mode':'p7_full_nlp_relower','backend_session_patch':False},plan_sensitive_dependencies=tuple(sorted(set().union(*[set(c.function.parameter_dependencies) for c in model.constraints],set(model.objective.expression.parameter_dependencies)))),precondition_certificate_hashes=(),compilation_report=report,reconstruction_contract={'primal':'identity_by_source_map','dual':'backend_specific','original_space_validation':'solverpilot.nlp.validate_nlp_solution'},schema_version='solverpilot.compiled-model.p7.v1')

solverpilot/nlp/conformance.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import numpy as np
+
+from solverpilot.model import Model, sin, exp
+from .backend import CasadiIpoptBackend
+from .compiler import compile_nlp_model
+from .ad import NLPDerivativeEngine
+
+
+@dataclass(frozen=True, slots=True)
+class NLPConformanceCheck:
+    name: str
+    passed: bool
+    detail: str
+
+
+@dataclass(frozen=True, slots=True)
+class NLPConformanceReport:
+    backend: str
+    available: bool
+    passed: bool
+    checks: tuple[NLPConformanceCheck, ...]
+
+
+def conform_casadi_ipopt_backend(backend: CasadiIpoptBackend | None = None) -> NLPConformanceReport:
+    backend = CasadiIpoptBackend(tol=1e-10, max_iter=2000) if backend is None else backend
+    checks: list[NLPConformanceCheck] = []
+    if not backend.is_available():
+        return NLPConformanceReport(backend.name, False, False, (NLPConformanceCheck('availability', False, 'CasADi Ipopt plugin unavailable'),))
+
+    # Local nonlinear objective with known minimizer.
+    m=Model(); x=m.variable(2,lower=-3,upper=3); c=np.array([0.4,-0.7])
+    m.minimize((x[0]-c[0])**4+(x[1]-c[1])**4+0.2*((x[0]-c[0])**2+(x[1]-c[1])**2))
+    p=compile_nlp_model(m).execution_ir; r=backend.solve(p,x0=[0,0])
+    ok=bool(r.validation.valid and r.local_optimal_candidate and not r.globally_proven and np.max(np.abs(r.x-c))<2e-5)
+    checks.append(NLPConformanceCheck('local_nlp_solve',ok,f'x_error={np.max(np.abs(r.x-c)) if r.x is not None else None}, status={r.backend_status}'))
+
+    # Nonlinear inequality with analytic projection.
+    m=Model(); x=m.variable(2,lower=0,upper=2); m.minimize((x[0]-1)**2+(x[1]-1)**2); m.add(x[0]**2+x[1]**2<=1)
+    p=compile_nlp_model(m).execution_ir; r=backend.solve(p,x0=[0.2,0.3]); target=np.array([1/np.sqrt(2)]*2)
+    ok=bool(r.validation.valid and r.local_optimal_candidate and not r.globally_proven and np.max(np.abs(r.x-target))<5e-5)
+    checks.append(NLPConformanceCheck('nonlinear_constraint',ok,f'x_error={np.max(np.abs(r.x-target)) if r.x is not None else None}, violation={r.validation.max_constraint_violation}'))
+
+    # AD correctness at a deterministic point.
+    m=Model(); x=m.variable(2,lower=[0.2,-2],upper=[2,2]); m.minimize(exp(0.2*x[0])+sin(x[0]*x[1])+x[0]/(1+x[1]**2)); m.add(sin(x[0])+x[1]**3<=2)
+    ad=NLPDerivativeEngine(compile_nlp_model(m).execution_ir); z=np.array([1.1,-0.25]); h=1e-6
+    gfd=np.zeros(2); Jfd=np.zeros((1,2))
+    for i in range(2):
+        zp=z.copy(); zm=z.copy(); zp[i]+=h; zm[i]-=h
+        gfd[i]=(ad.objective(zp)-ad.objective(zm))/(2*h)
+        Jfd[:,i]=(ad.constraints(zp)-ad.constraints(zm))/(2*h)
+    ge=float(np.max(np.abs(ad.gradient(z)-gfd))); je=float(np.max(np.abs(ad.jacobian(z)-Jfd)))
+    ok=ge<3e-6 and je<3e-6
+    checks.append(NLPConformanceCheck('automatic_differentiation',ok,f'gradient_error={ge}, jacobian_error={je}'))
+
+    return NLPConformanceReport(backend.name, True, all(c.passed for c in checks), tuple(checks))

solverpilot/nlp/ir.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Any, Mapping
+
+import numpy as np
+
+from solverpilot.model.expression import ExprNode
+
+
+@dataclass(frozen=True, slots=True)
+class NLPConstraintBlock:
+    source_id: str
+    node: ExprNode
+    lower: np.ndarray
+    upper: np.ndarray
+    shape: tuple[int, ...]
+    parameter_dependencies: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        lo = np.asarray(self.lower, dtype=float).reshape(-1).copy()
+        hi = np.asarray(self.upper, dtype=float).reshape(-1).copy()
+        if lo.shape != hi.shape:
+            raise ValueError("constraint lower/upper shape mismatch")
+        lo.flags.writeable = False; hi.flags.writeable = False
+        object.__setattr__(self, "lower", lo); object.__setattr__(self, "upper", hi)
+
+
+@dataclass(frozen=True, slots=True)
+class NLPProblem:
+    n_variables: int
+    variable_lower: np.ndarray
+    variable_upper: np.ndarray
+    variable_layout: Mapping[str, tuple[int, tuple[int, ...]]]
+    parameter_values: Mapping[str, np.ndarray]
+    objective_node: ExprNode
+    constraints: tuple[NLPConstraintBlock, ...]
+    objective_sense: str
+    name: str | None = None
+    metadata: Mapping[str, Any] = MappingProxyType({})
+
+    def __post_init__(self) -> None:
+        vl = np.asarray(self.variable_lower, dtype=float).reshape(-1).copy()
+        vu = np.asarray(self.variable_upper, dtype=float).reshape(-1).copy()
+        if vl.shape != (self.n_variables,) or vu.shape != (self.n_variables,):
+            raise ValueError("variable bound shape mismatch")
+        if np.any(vl > vu):
+            raise ValueError("variable lower bound exceeds upper bound")
+        vl.flags.writeable = False; vu.flags.writeable = False
+        object.__setattr__(self, "variable_lower", vl); object.__setattr__(self, "variable_upper", vu)
+        object.__setattr__(self, "variable_layout", MappingProxyType(dict(self.variable_layout)))
+        pv = {k: np.asarray(v, dtype=float).copy() for k, v in self.parameter_values.items()}
+        for v in pv.values(): v.flags.writeable = False
+        object.__setattr__(self, "parameter_values", MappingProxyType(pv))
+        object.__setattr__(self, "metadata", MappingProxyType(dict(self.metadata)))
+
+    @property
+    def n_constraints(self) -> int:
+        return int(sum(c.lower.size for c in self.constraints))
+
+    @property
+    def constraint_lower(self) -> np.ndarray:
+        if not self.constraints: return np.empty(0, dtype=float)
+        return np.concatenate([c.lower for c in self.constraints])
+
+    @property
+    def constraint_upper(self) -> np.ndarray:
+        if not self.constraints: return np.empty(0, dtype=float)
+        return np.concatenate([c.upper for c in self.constraints])

solverpilot/nlp/nlp-ir-v1.schema.json

@@ -0,0 +1 @@
+{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"solverpilot.nlp-ir-v1","type":"object","required":["schema_version","n_variables","n_constraints","derivatives"],"properties":{"schema_version":{"const":"solverpilot.nlp-ir.v1"},"n_variables":{"type":"integer","minimum":0},"n_constraints":{"type":"integer","minimum":0},"derivatives":{"type":"object","required":["gradient","jacobian","lagrangian_hessian"],"properties":{"gradient":{"const":"automatic_differentiation"},"jacobian":{"const":"automatic_differentiation_sparse"},"lagrangian_hessian":{"const":"automatic_differentiation_sparse"}}}}}