solverpilot 0.1__py3-none-any.whl

solverpilot/io/source.py

@@ -0,0 +1,104 @@
+"""Fail-closed helpers for local file and declared-bundle ingestion."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path, PurePosixPath
+
+from .errors import DataIOSourceError
+
+
+def _absolute_without_resolving(path: Path) -> Path:
+    return Path(os.path.abspath(os.fspath(path)))
+
+
+def _reject_symlink_components(path: Path) -> None:
+    absolute = _absolute_without_resolving(path)
+    current = Path(absolute.anchor)
+    for part in absolute.parts[1:]:
+        current = current / part
+        try:
+            if current.is_symlink():
+                raise DataIOSourceError("Symbolic links are rejected in data source paths.")
+        except OSError as exc:
+            raise DataIOSourceError("Local source path components cannot be inspected safely.") from exc
+
+
+def validate_local_path(
+    path: str | Path,
+    *,
+    expect_directory: bool | None,
+    reject_symlinks: bool = True,
+) -> Path:
+    if not isinstance(path, (str, os.PathLike)):
+        raise DataIOSourceError("Local source path must be path-like.")
+    if isinstance(path, str) and not path.strip():
+        raise DataIOSourceError("Local source path must be non-empty.")
+    candidate = Path(path)
+    if reject_symlinks:
+        _reject_symlink_components(candidate)
+    try:
+        exists = candidate.exists()
+    except OSError as exc:
+        raise DataIOSourceError("Local source path cannot be inspected safely.") from exc
+    if not exists:
+        raise DataIOSourceError(f"Local source does not exist: {candidate.name or 'source'}.")
+    try:
+        is_directory = candidate.is_dir()
+        is_file = candidate.is_file()
+    except OSError as exc:
+        raise DataIOSourceError("Local source type cannot be inspected safely.") from exc
+    if expect_directory is True and not is_directory:
+        raise DataIOSourceError("Data source must be a directory bundle.")
+    if expect_directory is False and not is_file:
+        raise DataIOSourceError("Data source must be a regular file.")
+    if expect_directory is None and not (is_file or is_directory):
+        raise DataIOSourceError("Data source must be a regular file or directory bundle.")
+    return candidate
+
+
+def safe_bundle_child(
+    bundle: Path,
+    file_name: str,
+    *,
+    reject_symlinks: bool = True,
+) -> Path:
+    if not isinstance(file_name, str) or not file_name.strip():
+        raise DataIOSourceError("Bundle file name must be a non-empty string.")
+    posix = PurePosixPath(file_name.strip().replace("\\", "/"))
+    if posix.is_absolute() or not posix.parts or any(
+        part in {"", ".", ".."} or ":" in part for part in posix.parts
+    ):
+        raise DataIOSourceError("Bundle file name must be a safe relative path.")
+    child = bundle.joinpath(*posix.parts)
+    if reject_symlinks:
+        _reject_symlink_components(bundle)
+        _reject_symlink_components(child)
+    try:
+        bundle_resolved = bundle.resolve(strict=True)
+        child_resolved = child.resolve(strict=True)
+    except FileNotFoundError as exc:
+        raise DataIOSourceError(f"Declared bundle file is missing: {posix.as_posix()}.") from exc
+    except OSError as exc:
+        raise DataIOSourceError("Bundle paths cannot be resolved safely.") from exc
+    if bundle_resolved != child_resolved.parent and bundle_resolved not in child_resolved.parents:
+        raise DataIOSourceError("Declared bundle file escapes the bundle directory.")
+    if not child_resolved.is_file():
+        raise DataIOSourceError(f"Declared bundle entry is not a file: {posix.as_posix()}.")
+    return child_resolved
+
+
+def read_limited_bytes(path: Path, *, max_bytes: int) -> bytes:
+    """Read at most ``max_bytes`` and detect growth without trusting a prior stat."""
+    if type(max_bytes) is not int or max_bytes <= 0:
+        raise DataIOSourceError("Maximum source size must be a positive integer.")
+    try:
+        with path.open("rb") as handle:
+            data = handle.read(max_bytes + 1)
+    except OSError as exc:
+        raise DataIOSourceError("Source bytes could not be read.") from exc
+    if len(data) > max_bytes:
+        raise DataIOSourceError(
+            f"Source exceeds the configured maximum size of {max_bytes} bytes."
+        )
+    return data

solverpilot/io/strict_json.py

@@ -0,0 +1,133 @@
+"""Strict JSON parser shared by file ingestion and JSON-valued mapping fields."""
+
+from __future__ import annotations
+
+import json
+import math
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from .binary64 import Binary64ConversionError, decimal_token_to_binary64
+from .errors import DataIOParseError
+
+DEFAULT_MAX_JSON_DEPTH = 256
+DEFAULT_MAX_INTEGER_DIGITS = 1000
+
+
+class _DuplicateKey(ValueError):
+    pass
+
+
+class _NonFiniteConstant(ValueError):
+    pass
+
+
+class _IntegerTooLarge(ValueError):
+    pass
+
+
+def _object_pairs_no_duplicates(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for key, value in pairs:
+        if key in result:
+            raise _DuplicateKey("duplicate object key")
+        result[key] = value
+    return result
+
+
+def _reject_constant(value: str) -> None:
+    raise _NonFiniteConstant(value)
+
+
+def _parse_bounded_int(value: str) -> int:
+    if len(value.lstrip("-")) > DEFAULT_MAX_INTEGER_DIGITS:
+        raise _IntegerTooLarge("integer digit limit exceeded")
+    return int(value, 10)
+
+
+def _validate_tree(value: Any, *, max_depth: int, context: str) -> None:
+    stack: list[tuple[Any, int]] = [(value, 0)]
+    while stack:
+        current, depth = stack.pop()
+        if depth > max_depth:
+            raise DataIOParseError(f"{context} exceeds the maximum nesting depth of {max_depth}.")
+        if current is None or isinstance(current, (bool, int)):
+            continue
+        if isinstance(current, float):
+            if not math.isfinite(current):
+                raise DataIOParseError(f"{context} contains a non-finite number.")
+            continue
+        if isinstance(current, str):
+            try:
+                current.encode("utf-8")
+            except UnicodeEncodeError as exc:
+                raise DataIOParseError(f"{context} contains an invalid Unicode surrogate.") from exc
+            continue
+        if isinstance(current, Mapping):
+            for key, item in current.items():
+                if not isinstance(key, str):
+                    raise DataIOParseError(f"{context} object keys must be strings.")
+                try:
+                    key.encode("utf-8")
+                except UnicodeEncodeError as exc:
+                    raise DataIOParseError(
+                        f"{context} contains an invalid Unicode surrogate in an object key."
+                    ) from exc
+                stack.append((item, depth + 1))
+            continue
+        if isinstance(current, Sequence) and not isinstance(current, (str, bytes, bytearray)):
+            stack.extend((item, depth + 1) for item in current)
+            continue
+        raise DataIOParseError(f"{context} contains an unsupported parsed value type.")
+
+
+def loads_strict_json(
+    text: str,
+    *,
+    context: str = "JSON input",
+    max_depth: int = DEFAULT_MAX_JSON_DEPTH,
+    strict_numbers: bool = True,
+) -> Any:
+    """Parse standards-compliant JSON with deterministic resource and numeric gates."""
+    if not isinstance(text, str):
+        raise DataIOParseError(f"{context} must be text.")
+    if type(max_depth) is not int or max_depth < 0:
+        raise DataIOParseError("max_depth must be a non-negative integer.")
+    if type(strict_numbers) is not bool:
+        raise DataIOParseError("strict_numbers must be a boolean.")
+
+    def parse_float(token: str) -> float:
+        try:
+            return decimal_token_to_binary64(token, exact_decimal=strict_numbers)
+        except Binary64ConversionError as exc:
+            raise Binary64ConversionError(str(exc)) from exc
+
+    try:
+        parsed = json.loads(
+            text,
+            object_pairs_hook=_object_pairs_no_duplicates,
+            parse_constant=_reject_constant,
+            parse_int=_parse_bounded_int,
+            parse_float=parse_float,
+        )
+    except _DuplicateKey as exc:
+        raise DataIOParseError(f"{context} contains a duplicate object key.") from exc
+    except _NonFiniteConstant as exc:
+        raise DataIOParseError(f"{context} contains a non-finite JSON constant.") from exc
+    except _IntegerTooLarge as exc:
+        raise DataIOParseError(
+            f"{context} contains an integer exceeding {DEFAULT_MAX_INTEGER_DIGITS} digits."
+        ) from exc
+    except Binary64ConversionError as exc:
+        raise DataIOParseError(
+            f"{context} contains a decimal number rejected by the binary64 ingestion policy."
+        ) from exc
+    except json.JSONDecodeError as exc:
+        raise DataIOParseError(f"{context} is malformed at line {exc.lineno}, column {exc.colno}.") from exc
+    except RecursionError as exc:
+        raise DataIOParseError(f"{context} exceeds the supported nesting depth.") from exc
+    except (ValueError, OverflowError, UnicodeError) as exc:
+        raise DataIOParseError(f"{context} cannot be parsed safely.") from exc
+
+    _validate_tree(parsed, max_depth=max_depth, context=context)
+    return parsed

solverpilot/minlp/__init__.py

@@ -0,0 +1,6 @@
+from .ir import MINLPProblem, ConvexityCertificate
+from .compiler import compile_minlp_model
+from .orchestrator import MINLPSolveResult, MINLPIteration, solve_binary_enumeration, solve_outer_approximation, solve_minlp
+from .validation import MINLPValidationReport, validate_minlp_solution
+from .conformance import MINLPConformanceCheck, MINLPConformanceReport, conform_minlp_orchestrator
+__all__=['MINLPProblem','ConvexityCertificate','compile_minlp_model','MINLPSolveResult','MINLPIteration','solve_binary_enumeration','solve_outer_approximation','solve_minlp','MINLPValidationReport','validate_minlp_solution','MINLPConformanceCheck','MINLPConformanceReport','conform_minlp_orchestrator']

solverpilot/minlp/compiler.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+import hashlib, json
+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 solverpilot.nlp.ir import NLPConstraintBlock, NLPProblem
+from .ir import MINLPProblem, ConvexityCertificate
+from .convexity import prove_curvature
+
+
+def _broadcast(value,size):
+    try: return np.broadcast_to(np.asarray(value,dtype=float),(size,)).astype(float,copy=True)
+    except Exception as e: raise CompileError('MINLP set bound cannot broadcast') from e
+
+
+def compile_minlp_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('P8 MINLP v1 supports minimization only')
+    if model.objective.expression.shape != (): raise CompileError('P8 MINLP objective must be scalar')
+    if any(c.__class__.__name__=='IndicatorConstraint' for c in model.constraints):
+        raise CompileError('P8 MINLP v1 does not combine indicator bridges with nonlinear orchestration')
+    offsets,n,vl,vu,domains,source_vars=_variable_layout(model)
+    dom_objs=tuple(VariableDomain(d) for d in domains)
+    integer=tuple(i for i,d in enumerate(dom_objs) if d in {VariableDomain.INTEGER,VariableDomain.BINARY})
+    binary=tuple(i for i,d in enumerate(dom_objs) if d is VariableDomain.BINARY)
+    if not integer: raise CompileError('compile_minlp_model requires at least one discrete variable')
+    if integer != binary:
+        raise CompileError('P8 OA v1 supports binary discrete variables only; general integer MINLP is fail-closed')
+    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()}
+    blocks=[]; source_constraints={}; ccurv=[]
+    for c in model.constraints:
+        if not isinstance(c.set,(LessThan,GreaterThan,EqualTo,Interval)):
+            raise CompileError(f'P8 supports scalar-set algebraic constraints only, got {type(c.set).__name__}')
+        size=int(np.prod(c.function.shape)) if c.function.shape else 1
+        if size != 1 and (c.function.polynomial_degree is None or c.function.polynomial_degree>1):
+            raise CompileError('P8 nonlinear constraints must be scalar in v1')
+        if isinstance(c.set,LessThan): lo=np.full(size,-np.inf); hi=_broadcast(c.set.upper,size)
+        elif isinstance(c.set,GreaterThan): lo=_broadcast(c.set.lower,size); hi=np.full(size,np.inf)
+        elif isinstance(c.set,EqualTo): lo=hi=_broadcast(c.set.value,size)
+        else: lo=_broadcast(c.set.lower,size); hi=_broadcast(c.set.upper,size)
+        proof=prove_curvature(c.function._node,pvals)
+        nonlinear=not (c.function.polynomial_degree is not None and c.function.polynomial_degree<=1)
+        if nonlinear:
+            if isinstance(c.set,LessThan) and proof.curvature not in {'convex','affine'}:
+                raise CompileError(f'P8 cannot certify convex upper-bounded constraint {c.entity_id.value}: {proof.reason}')
+            if isinstance(c.set,GreaterThan) and proof.curvature not in {'concave','affine'}:
+                raise CompileError(f'P8 cannot certify concave lower-bounded constraint {c.entity_id.value}: {proof.reason}')
+            if isinstance(c.set,(EqualTo,Interval)):
+                raise CompileError('P8 nonlinear equality/two-sided constraints are outside exact OA v1 scope')
+        ccurv.append(proof.curvature)
+        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':'minlp_function_in_set','nlp_rows':size,'shape':list(c.function.shape),'curvature':proof.curvature}
+    op=prove_curvature(model.objective.expression._node,pvals)
+    if op.curvature not in {'convex','affine'}:
+        raise CompileError(f'P8 exact OA requires certified convex objective: {op.reason}')
+    relax=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-p8'})
+    cert=ConvexityCertificate('solverpilot.minlp.convexity-certificate.v1',op.curvature,tuple(ccurv),'p8-affine-square-exp-v1',model.data_hash,('binary-discrete-only','nonlinear equalities rejected'))
+    problem=MINLPProblem(relax,tuple(d.value for d in dom_objs),integer,binary,cert,model.semantic_hash,model.data_hash,{'global_proof_scope':'certified-convex-binary-minlp'})
+    payload={'semantic_hash':model.semantic_hash,'data_hash':model.data_hash,'target':'minlp-ir-v1','policy':'p8-certified-convex-binary-oa-v1','convexity':cert.objective_curvature,'constraints':cert.constraint_curvatures}
+    ch=hashlib.sha256(json.dumps(payload,sort_keys=True,separators=(',',':')).encode()).hexdigest()
+    pmap={pid:{'shape':list(data.shape),'patchable':False,'parameter_compile_class':'p8_full_minlp_recertificate','plan_sensitive':True} for pid,data in model._parameters.items()}
+    report=CompilationReport(target='minlp-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=relax.n_constraints,cache_status='disabled' if not use_cache else 'p8_rebuild',changed_parameters=(),reused_execution_rows=0,recompiled_execution_rows=relax.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,'curvature':op.curvature}}},transformation_tape=(),capability_signature='p8-certified-convex-binary-minlp-v1',mutation_plan={'mode':'p8_full_recertificate','backend_session_patch':False},plan_sensitive_dependencies=tuple(sorted(model._parameters)),precondition_certificate_hashes=(hashlib.sha256(json.dumps({'schema':cert.schema,'objective_curvature':cert.objective_curvature,'constraint_curvatures':cert.constraint_curvatures,'supported_atom_policy':cert.supported_atom_policy,'data_hash':cert.data_hash,'notes':cert.notes},sort_keys=True,default=list).encode()).hexdigest(),),compilation_report=report,reconstruction_contract={'primal':'identity_by_source_map','global_proof':'only_if_orchestrator_proved','original_space_validation':'solverpilot.nlp.validate_nlp_solution'},schema_version='solverpilot.compiled-model.p8.v1')

solverpilot/minlp/conformance.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+from dataclasses import dataclass
+import numpy as np
+
+@dataclass(frozen=True, slots=True)
+class MINLPConformanceCheck:
+    name: str
+    passed: bool
+    detail: str
+
+@dataclass(frozen=True, slots=True)
+class MINLPConformanceReport:
+    schema: str
+    checks: tuple[MINLPConformanceCheck, ...]
+    passed: bool
+
+
+def conform_minlp_orchestrator() -> MINLPConformanceReport:
+    import solverpilot as om
+    from .orchestrator import solve_binary_enumeration, solve_outer_approximation
+    checks=[]
+    m=om.Model('p8-conformance')
+    x=m.variable(lower=-2,upper=2); z=m.binary()
+    m.minimize((x-0.2)**2 + (z-0.4)**2)
+    p=m.compile().execution_ir
+    enum=solve_binary_enumeration(p); oa=solve_outer_approximation(p)
+    checks.append(MINLPConformanceCheck('enumeration_global_proof',bool(enum.globally_proven),str(enum.status)))
+    checks.append(MINLPConformanceCheck('oa_global_proof',bool(oa.globally_proven),str(oa.status)))
+    agree=bool(enum.objective is not None and oa.objective is not None and abs(enum.objective-oa.objective)<=2e-6)
+    checks.append(MINLPConformanceCheck('oa_matches_enumeration',agree,f'{enum.objective} vs {oa.objective}'))
+    bound=bool(oa.lower_bound is not None and oa.objective is not None and oa.lower_bound <= oa.objective + 2e-6)
+    checks.append(MINLPConformanceCheck('bound_consistency',bound,f'lb={oa.lower_bound}, ub={oa.objective}'))
+    checks.append(MINLPConformanceCheck('no_global_claim_from_nlp_status_alone',all('global_subproblem_by_convexity_certificate' not in i.nlp_status for i in oa.iterations), 'global proof comes from convexity+bound closure'))
+    return MINLPConformanceReport('solverpilot.minlp.conformance.v1',tuple(checks),all(c.passed for c in checks))

solverpilot/minlp/convexity.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+from dataclasses import dataclass
+import numpy as np
+from solverpilot.model.expression import ExprNode
+from solverpilot.model.types import Curvature
+
+_AFFINE_KINDS={'constant','parameter','variable','index','transpose','sum','concat','matmul'}
+
+@dataclass(frozen=True, slots=True)
+class CurvatureProof:
+    curvature: str
+    reason: str
+
+
+def _fixed_scalar(node: ExprNode, parameter_values: dict[str,np.ndarray]):
+    if node.variable_dependencies:
+        return None
+    k=node.kind
+    if k=='constant':
+        a=np.asarray(node.payload,dtype=float)
+    elif k=='parameter':
+        a=np.asarray(parameter_values[str(node.payload)],dtype=float)
+    elif k=='neg':
+        v=_fixed_scalar(node.args[0],parameter_values); return None if v is None else -v
+    elif k in {'add','mul','div'}:
+        a0=_fixed_scalar(node.args[0],parameter_values); a1=_fixed_scalar(node.args[1],parameter_values)
+        if a0 is None or a1 is None: return None
+        if k=='add': return a0+a1
+        if k=='mul': return a0*a1
+        if np.any(np.asarray(a1)==0): return None
+        return a0/a1
+    elif k=='pow':
+        a0=_fixed_scalar(node.args[0],parameter_values)
+        return None if a0 is None else np.power(a0,int(node.payload))
+    else:
+        return None
+    if np.asarray(a).size != 1: return None
+    return float(np.asarray(a).reshape(-1)[0])
+
+
+def _same_node(a: ExprNode,b: ExprNode) -> bool:
+    return a is b or a == b
+
+
+def prove_curvature(node: ExprNode, parameter_values: dict[str,np.ndarray]) -> CurvatureProof:
+    if node.degree is not None and node.degree <= 1:
+        return CurvatureProof('affine','polynomial degree <= 1')
+    k=node.kind
+    if k=='neg':
+        p=prove_curvature(node.args[0],parameter_values)
+        return CurvatureProof({'convex':'concave','concave':'convex'}.get(p.curvature,p.curvature),f'neg({p.reason})')
+    if k=='add':
+        a=prove_curvature(node.args[0],parameter_values); b=prove_curvature(node.args[1],parameter_values)
+        if a.curvature=='affine': return CurvatureProof(b.curvature,f'affine + {b.reason}')
+        if b.curvature=='affine': return CurvatureProof(a.curvature,f'{a.reason} + affine')
+        if a.curvature==b.curvature and a.curvature in {'convex','concave'}:
+            return CurvatureProof(a.curvature,f'sum of {a.curvature} terms')
+        return CurvatureProof('unknown','sum composition not certified')
+    if k=='mul':
+        a,b=node.args
+        ca=_fixed_scalar(a,parameter_values); cb=_fixed_scalar(b,parameter_values)
+        if ca is not None:
+            p=prove_curvature(b,parameter_values)
+            if ca==0: return CurvatureProof('affine','zero scaling')
+            if ca>0: return CurvatureProof(p.curvature,f'positive scaling {ca:g}')
+            return CurvatureProof({'convex':'concave','concave':'convex'}.get(p.curvature,p.curvature),f'negative scaling {ca:g}')
+        if cb is not None:
+            p=prove_curvature(a,parameter_values)
+            if cb==0: return CurvatureProof('affine','zero scaling')
+            if cb>0: return CurvatureProof(p.curvature,f'positive scaling {cb:g}')
+            return CurvatureProof({'convex':'concave','concave':'convex'}.get(p.curvature,p.curvature),f'negative scaling {cb:g}')
+        pa=prove_curvature(a,parameter_values)
+        if _same_node(a,b) and pa.curvature=='affine' and a.shape==():
+            return CurvatureProof('convex','square of scalar affine expression')
+        return CurvatureProof('unknown','bilinear/product term not certified')
+    if k=='exp':
+        p=prove_curvature(node.args[0],parameter_values)
+        if p.curvature=='affine': return CurvatureProof('convex','exp of affine')
+        return CurvatureProof('unknown','exp composition outside P8 certificate policy')
+    if k=='pow':
+        p=prove_curvature(node.args[0],parameter_values); e=int(node.payload)
+        if p.curvature=='affine' and e>=2 and e%2==0 and node.shape==():
+            return CurvatureProof('convex',f'even power {e} of scalar affine')
+        return CurvatureProof('unknown','power outside P8 certificate policy')
+    return CurvatureProof('unknown',f'atom {k!r} outside P8 convexity certificate policy')

solverpilot/minlp/ir.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Any, Mapping
+import numpy as np
+from solverpilot.nlp.ir import NLPProblem
+
+@dataclass(frozen=True, slots=True)
+class ConvexityCertificate:
+    schema: str
+    objective_curvature: str
+    constraint_curvatures: tuple[str, ...]
+    supported_atom_policy: str
+    data_hash: str
+    notes: tuple[str, ...] = ()
+
+@dataclass(frozen=True, slots=True)
+class MINLPProblem:
+    relaxation: NLPProblem
+    domains: tuple[str, ...]
+    integer_indices: tuple[int, ...]
+    binary_indices: tuple[int, ...]
+    convexity_certificate: ConvexityCertificate
+    semantic_hash: str
+    data_hash: str
+    metadata: Mapping[str, Any] = MappingProxyType({})
+
+    def __post_init__(self) -> None:
+        if len(self.domains) != self.relaxation.n_variables:
+            raise ValueError('domain vector length mismatch')
+        object.__setattr__(self, 'metadata', MappingProxyType(dict(self.metadata)))
+
+    @property
+    def n_variables(self) -> int:
+        return self.relaxation.n_variables

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

@@ -0,0 +1 @@
+{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://solverpilot.dev/schema/minlp-ir-v1.json","title":"SolverPilot MINLP IR v1","type":"object","required":["schema","semantic_hash","data_hash","domains","binary_indices","convexity_certificate"],"properties":{"schema":{"const":"solverpilot.minlp-ir.v1"},"semantic_hash":{"type":"string"},"data_hash":{"type":"string"},"domains":{"type":"array","items":{"type":"string"}},"binary_indices":{"type":"array","items":{"type":"integer","minimum":0}},"convexity_certificate":{"type":"object"}}}