solverpilot 0.1__py3-none-any.whl

solverpilot/cp/reference.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any
+import itertools, math
+from solverpilot._immutability import deep_freeze
+from .ir import *
+from .validate import validate_cp_solution, complete_assignment
+
+@dataclass(frozen=True, slots=True)
+class CPSolveResult:
+    status:str
+    assignment:Mapping[int,int]|None
+    objective:int|None
+    validation:object
+    optimality_proven:bool
+    backend:str
+    raw_statistics:Mapping[str,Any]
+
+    def __post_init__(self):
+        if self.assignment is not None:
+            object.__setattr__(self, 'assignment', deep_freeze(dict(self.assignment)))
+        object.__setattr__(self, 'raw_statistics', deep_freeze(dict(self.raw_statistics)))
+
+class ReferenceCPBackend:
+    name='reference-cp-enumeration'
+    verification_only=True
+    def __init__(self,max_states=1_000_000): self.max_states=int(max_states)
+    def is_available(self): return True
+    def solve(self,problem:CPProblem,*,max_states=None):
+        limit=self.max_states if max_states is None else int(max_states)
+        base=problem.base_variables
+        states=math.prod(len(v.domain) for v in base)
+        if states>limit:
+            return CPSolveResult('unknown_state_limit',None,None,validate_cp_solution(problem,{}),False,self.name,{'states_total':states,'states_examined':0,'limit':limit})
+        best=None; best_obj=None; examined=0; feasible=0
+        for values in itertools.product(*(v.domain for v in base)):
+            examined+=1; a={v.var_id:int(x) for v,x in zip(base,values)}; a=complete_assignment(problem,a)
+            rep=validate_cp_solution(problem,a)
+            if not rep.valid: continue
+            feasible+=1; obj=rep.objective_recomputed
+            if problem.objective is None:
+                best=a; best_obj=None; break
+            if best is None or (problem.objective_sense is CPObjectiveSense.MINIMIZE and obj<best_obj) or (problem.objective_sense is CPObjectiveSense.MAXIMIZE and obj>best_obj):
+                best=a.copy(); best_obj=obj
+        if best is None:
+            # If objective-free search stops at first feasible only when found; no feasible means full enumeration.
+            return CPSolveResult('infeasible',None,None,validate_cp_solution(problem,{}),True,self.name,{'states_total':states,'states_examined':examined,'feasible_seen':feasible})
+        rep=validate_cp_solution(problem,best,best_obj)
+        proof = problem.objective is None or examined==states
+        return CPSolveResult('optimal' if problem.objective is not None and proof else 'feasible',best,best_obj,rep,proof,self.name,{'states_total':states,'states_examined':examined,'feasible_seen':feasible})

solverpilot/cp/serialization.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from .ir import (
+    CPAllDifferentIR,
+    CPCircuitIR,
+    CPCumulativeIR,
+    CPElementIR,
+    CPExactlyOneIR,
+    CPIntVarIR,
+    CPIntervalIR,
+    CPLinearConstraintIR,
+    CPLinearExprIR,
+    CPNoOverlapIR,
+    CPObjectiveSense,
+    CPProblem,
+    CPTableIR,
+)
+
+
+def _expr_from_dict(payload: Mapping[str, Any]) -> CPLinearExprIR:
+    return CPLinearExprIR(
+        terms=tuple((int(v), int(c)) for v, c in payload.get("terms", ())),
+        constant=int(payload.get("constant", 0)),
+    )
+
+
+def problem_from_canonical_dict(payload: Mapping[str, Any]) -> CPProblem:
+    """Reconstruct canonical CP IR from :meth:`CPProblem.canonical_dict` output.
+
+    This deliberately accepts only the closed P9 schema families. It is used by
+    the isolated CP-SAT worker so no pickle/arbitrary-code serialization crosses
+    the process boundary.
+    """
+    variables = tuple(
+        CPIntVarIR(
+            var_id=int(v["id"]),
+            name=str(v["name"]),
+            domain=tuple(int(x) for x in v["domain"]),
+            kind=str(v.get("kind", "int")),
+            derived_from=None
+            if v.get("derived_from") is None
+            else (int(v["derived_from"][0]), int(v["derived_from"][1])),
+        )
+        for v in payload.get("variables", ())
+    )
+    intervals = tuple(
+        CPIntervalIR(
+            interval_id=int(i["id"]),
+            name=str(i["name"]),
+            start_var=int(i["start_var"]),
+            size=int(i["size"]),
+            end_var=int(i["end_var"]),
+        )
+        for i in payload.get("intervals", ())
+    )
+
+    constraints = []
+    for c in payload.get("constraints", ()):
+        kind = c["kind"]
+        if kind == "linear":
+            constraints.append(
+                CPLinearConstraintIR(
+                    _expr_from_dict(c["expr"]),
+                    None if c.get("lower") is None else int(c["lower"]),
+                    None if c.get("upper") is None else int(c["upper"]),
+                )
+            )
+        elif kind == "all_different":
+            constraints.append(CPAllDifferentIR(tuple(int(x) for x in c["var_ids"])))
+        elif kind == "exactly_one":
+            constraints.append(CPExactlyOneIR(tuple(int(x) for x in c["literal_ids"])))
+        elif kind == "table":
+            constraints.append(
+                CPTableIR(
+                    tuple(int(x) for x in c["var_ids"]),
+                    tuple(tuple(int(x) for x in row) for row in c["allowed_tuples"]),
+                )
+            )
+        elif kind == "element":
+            constraints.append(
+                CPElementIR(
+                    int(c["index_var"]),
+                    tuple(int(x) for x in c["values"]),
+                    int(c["target_var"]),
+                )
+            )
+        elif kind == "circuit":
+            constraints.append(
+                CPCircuitIR(tuple(tuple(int(x) for x in arc) for arc in c["arcs"]))
+            )
+        elif kind == "no_overlap":
+            constraints.append(CPNoOverlapIR(tuple(int(x) for x in c["interval_ids"])))
+        elif kind == "cumulative":
+            constraints.append(
+                CPCumulativeIR(
+                    tuple(int(x) for x in c["interval_ids"]),
+                    tuple(int(x) for x in c["demands"]),
+                    int(c["capacity"]),
+                )
+            )
+        else:
+            raise ValueError(f"unsupported CP constraint kind in isolated payload: {kind!r}")
+
+    objective_payload = payload.get("objective")
+    objective = None if objective_payload is None else _expr_from_dict(objective_payload)
+    return CPProblem(
+        variables=variables,
+        intervals=intervals,
+        constraints=tuple(constraints),
+        objective=objective,
+        objective_sense=CPObjectiveSense(payload.get("objective_sense", "minimize")),
+        name=payload.get("name"),
+        metadata=dict(payload.get("metadata", {})),
+        schema_version=str(payload.get("schema_version", "solverpilot.cp-ir.v1")),
+    )

solverpilot/cp/validate.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Mapping
+import math
+from .ir import *
+
+@dataclass(frozen=True, slots=True)
+class CPValidationReport:
+    valid:bool
+    domain_violations:tuple[int,...]
+    constraint_violations:tuple[int,...]
+    derived_violations:tuple[int,...]
+    objective_recomputed:int|None
+    objective_reported:int|None
+    objective_consistent:bool|None
+
+def _expr(e, a): return e.constant + sum(c*a[v] for v,c in e.terms)
+
+def complete_assignment(problem,assignment):
+    a={int(k):int(v) for k,v in dict(assignment).items()}
+    pending=True
+    while pending:
+        pending=False
+        for v in problem.variables:
+            if v.var_id in a: continue
+            if v.derived_from is not None:
+                s,size=v.derived_from
+                if s in a: a[v.var_id]=a[s]+size; pending=True
+    return a
+
+def _circuit_ok(c,a):
+    nodes=set(); selected=[]
+    for t,h,l in c.arcs:
+        nodes.add(t); nodes.add(h)
+        if a[l]==1: selected.append((t,h))
+    # CP-SAT semantics: incident nodes exactly one selected incoming/outgoing.
+    for n in nodes:
+        if sum(1 for t,h in selected if t==n)!=1: return False
+        if sum(1 for t,h in selected if h==n)!=1: return False
+    nonself=[e for e in selected if e[0]!=e[1]]
+    if not nonself: return True
+    active=set(x for e in nonself for x in e)
+    start=next(iter(active)); seen={start}; cur=start
+    for _ in range(len(active)):
+        nxts=[h for t,h in nonself if t==cur]
+        if len(nxts)!=1: return False
+        cur=nxts[0]
+        if cur==start: break
+        if cur in seen: return False
+        seen.add(cur)
+    return cur==start and seen==active
+
+def validate_cp_solution(problem:CPProblem,assignment:Mapping[int,int],objective_reported=None):
+    a=complete_assignment(problem,assignment); dviol=[]; derived=[]; cviol=[]
+    for v in problem.variables:
+        if v.var_id not in a or a[v.var_id] not in v.domain: dviol.append(v.var_id)
+        if v.derived_from is not None and v.var_id in a:
+            s,size=v.derived_from
+            if s not in a or a[v.var_id] != a[s]+size: derived.append(v.var_id)
+    imap=problem.interval_map
+    for idx,c in enumerate(problem.constraints):
+        ok=True
+        try:
+            if isinstance(c,CPLinearConstraintIR):
+                val=_expr(c.expr,a); ok=(c.lower is None or val>=c.lower) and (c.upper is None or val<=c.upper)
+            elif isinstance(c,CPAllDifferentIR): ok=len({a[v] for v in c.var_ids})==len(c.var_ids)
+            elif isinstance(c,CPExactlyOneIR): ok=sum(a[v] for v in c.literal_ids)==1
+            elif isinstance(c,CPTableIR): ok=tuple(a[v] for v in c.var_ids) in set(c.allowed_tuples)
+            elif isinstance(c,CPElementIR):
+                ix=a[c.index_var]; ok=0<=ix<len(c.values) and a[c.target_var]==c.values[ix]
+            elif isinstance(c,CPCircuitIR): ok=_circuit_ok(c,a)
+            elif isinstance(c,CPNoOverlapIR):
+                spans=[(a[imap[i].start_var],a[imap[i].end_var]) for i in c.interval_ids]
+                ok=all(e1<=s2 or e2<=s1 for j,(s1,e1) in enumerate(spans) for s2,e2 in spans[j+1:])
+            elif isinstance(c,CPCumulativeIR):
+                items=[(a[imap[i].start_var],a[imap[i].end_var],d) for i,d in zip(c.interval_ids,c.demands)]
+                points=sorted({s for s,e,d in items if s<e})
+                ok=c.capacity>=0 and all(sum(d for s,e,d in items if s<=t<e)<=c.capacity for t in points)
+        except KeyError: ok=False
+        if not ok: cviol.append(idx)
+    obj=None if problem.objective is None or any(v not in a for v,c in problem.objective.terms) else _expr(problem.objective,a)
+    consistent=None if objective_reported is None or obj is None else int(objective_reported)==int(obj)
+    return CPValidationReport(not dviol and not derived and not cviol and consistent is not False,tuple(dviol),tuple(cviol),tuple(derived),obj,None if objective_reported is None else int(objective_reported),consistent)

solverpilot/diagnose/__init__.py

@@ -0,0 +1,33 @@
+from .infeasibility import (
+    deletion_filter_conflict,
+    diagnose_infeasibility,
+    elastic_relaxation,
+    find_static_infeasibility,
+)
+from .model import (
+    ConflictAtom,
+    ConflictSetResult,
+    DiagnosticIssue,
+    ElasticRelaxationResult,
+    EvidenceKind,
+    InfeasibilityReport,
+    NormalizedIISEvidence,
+    RelaxationViolation,
+    ViolationKind,
+)
+
+__all__ = [
+    "ConflictAtom",
+    "ConflictSetResult",
+    "DiagnosticIssue",
+    "ElasticRelaxationResult",
+    "EvidenceKind",
+    "InfeasibilityReport",
+    "NormalizedIISEvidence",
+    "RelaxationViolation",
+    "ViolationKind",
+    "deletion_filter_conflict",
+    "diagnose_infeasibility",
+    "elastic_relaxation",
+    "find_static_infeasibility",
+]