speclogician 0.0.0b1__py3-none-any.whl → 0.0.0.dev1__py3-none-any.whl

speclogician/logic/api/client.py

@@ -1,606 +0,0 @@
-#
-#   Imandra Inc.
-#
-#   speclogician/logic/api/client.py
-#
-
-
-
-import os
-import tempfile
-
-from dataclasses import dataclass
-from typing import Sequence
-
-from imandrax_api_models import InstanceRes, EvalRes
-from imandrax_api_models.client import ImandraXAsyncClient, get_imandrax_async_client
-from iml_query.processing.decomp import DecompReqArgs
-
-from speclogician.utils import IMLValidity
-from speclogician.modeling.scenario import Scenario
-from speclogician.modeling.complement import ScenarioComplement
-from speclogician.modeling.conflict import ScenarioConsumed
-from speclogician.modeling.domain import DomainModel
-from speclogician.data.artifact import (
-    TraceArtifact, 
-    TraceIMLValidity, 
-    TraceScenarioMatchResult
-)
-
-from ..strings import (
-    mk_predicates_only_instance_src,
-    mk_scenario_expr,
-    collect_pred_names,
-    mk_goal_def,
-    mk_spec_disjunction_expr,
-    mk_instance_src_for_expr
-)
-
-import structlog
-structlog.configure(logger_factory=structlog.ReturnLoggerFactory()) # will drop all events
-
-
-try: 
-    from dotenv import load_dotenv, find_dotenv
-    # Will look for .env file in parent dirs
-    load_dotenv(find_dotenv(usecwd=True), override=False)
-except ImportError:
-    pass
-
-@dataclass(frozen=True)
-class ScenarioConsistency:
-    is_consistent : bool
-    model_src: str | None
-    inst_src: str
-
-@dataclass(frozen=True)
-class ScenarioIntersection:
-    scenario1_name : str
-    scenario2_name : str
-    do_they_intersect : bool
-    model_src: str | None
-
-@dataclass(frozen=True)
-class TraceValueValidation:
-    ok: bool
-    errors: Sequence[str]
-    compiled_src: str
-
-@dataclass(frozen=True)
-class TraceScenarioMatch:
-    scenario_name: str
-    matches: bool
-    witness_src: str | None
-    reason: str | None = None
-
-class SpecLogicianImandraX:
-    def __init__(self) -> None:
-        self._client_cm = None
-        self._client: ImandraXAsyncClient | None = None
-
-    async def __aenter__(self) -> "SpecLogicianImandraX":
-        self._client_cm = get_imandrax_async_client(os.getenv('IMANDRA_UNI_KEY'))
-        self._client = await self._client_cm.__aenter__()
-        return self
-
-    async def __aexit__(self, exc_type, exc, tb) -> None:
-        assert self._client_cm is not None
-        await self._client_cm.__aexit__(exc_type, exc, tb)
-        self._client = None
-        self._client_cm = None
-
-    @property
-    def c(self) -> ImandraXAsyncClient:
-        if self._client is None:
-            raise RuntimeError("ImandraX client not initialized")
-        return self._client
-
-    async def load_model(self, iml_src: str) -> EvalRes:
-        return await self.c.eval_model(src=iml_src)
-
-    async def check_scenario_consistent(
-        self,
-        domain_model: DomainModel,
-        scenario: Scenario,
-        check_state_preds : bool,
-        check_action_preds : bool
-    ) -> ScenarioConsistency:
-        
-        if not check_state_preds and not check_action_preds:
-            raise ValueError("At least `check_state_preds` or `check_action_preds` must be True!")
-
-        state_preds = scenario.given if check_state_preds else ()
-        action_preds = scenario.when if check_action_preds else ()
-
-        inst_name = f"__speclogician_{scenario.name}"
-
-        # Fast local validation: better UX than solver/type errors
-        domain_model.assert_has_predicates(given=state_preds, when=action_preds)
-
-        # Build a minimized IML model containing only what this scenario needs
-        d_model = domain_model.make_iml_model(
-            state_pred_names=list(state_preds),
-            action_pred_names=list(action_preds),
-            transition_names=[],
-        )
-
-        eval_res = await self.c.eval_model(src=d_model)
-
-        if bool(getattr(eval_res, "has_errors", False)):
-            errs = getattr(eval_res, "errors", None)
-            if errs:
-                raise ValueError(f"Domain model has errors (e.g. {errs[0]})")
-            raise ValueError("Domain model has errors")
-
-        # Predicates-only instance query in that model context
-        inst_src = mk_predicates_only_instance_src(
-            name=inst_name,
-            given=state_preds,
-            when=action_preds,
-        )
-
-        res: InstanceRes = await self.c.instance_src(src=inst_src)
-
-        return ScenarioConsistency(
-            is_consistent=res.sat is not None,
-            model_src=res.sat.model.src if res.sat is not None and res.sat.model is not None else None,
-            inst_src=inst_src
-        )
-
-    async def check_scenarios_intersect(
-        self,
-        domain_model: DomainModel,
-        sc_a: Scenario,
-        sc_b: Scenario,
-    ) -> ScenarioIntersection:
-        """
-        Check whether two scenarios intersect (predicate-only semantics).
-
-        Intersection exists iff there is a single (state, action) satisfying
-        both scenarios' given/when predicates.
-        """
-
-        inst_name = f"__speclogician_intersect_{sc_a.name}_{sc_b.name}"
-
-        # 1) Fast local validation
-        domain_model.assert_has_predicates(given=sc_a.given, when=sc_a.when)
-        domain_model.assert_has_predicates(given=sc_b.given, when=sc_b.when)
-
-        # 2) Combine predicates
-        given = list(set(list(sc_a.given) + list(sc_b.given)))
-        when  = list(set(list(sc_a.when)  + list(sc_b.when)))
-
-        # 3) Build minimized IML model
-        d_model = domain_model.make_iml_model(
-            state_pred_names=given,
-            action_pred_names=when,
-            transition_names=[],
-        )
-
-        eval_res = await self.c.eval_model(src=d_model)
-        if bool(getattr(eval_res, "has_errors", False)):
-            errs = getattr(eval_res, "errors", None)
-            if errs:
-                raise ValueError(f"Domain model has errors (e.g. {errs[0]})")
-            raise ValueError("Domain model has errors")
-
-        # 4) Predicates-only instance
-        inst_src = mk_predicates_only_instance_src(
-            name=inst_name,
-            given=given,
-            when=when,
-        )
-
-        res: InstanceRes = await self.c.instance_src(src=inst_src)
-
-        return ScenarioIntersection (
-            scenario1_name = sc_a.name,
-            scenario2_name = sc_b.name,
-            do_they_intersect = res.sat is not None,
-            model_src = res.sat.model.src if res.sat is not None and res.sat.model is not None else None
-        )
-    
-    async def decompose_goal_function(
-        self,
-        *,
-        domain_model: DomainModel,
-        goal_name: str,
-        goal_def_src: str,
-        state_pred_names: list[str],
-        action_pred_names: list[str],
-        assuming: str | None = None,
-        rule_specs: list[str] | None = None,
-        ctx_simp: bool | None = None,
-        lift_bool: str | None = None,
-        filter_out_false : bool = True
-    ) -> ScenarioComplement:
-        
-        base_src = domain_model.make_iml_model(
-            state_pred_names=state_pred_names,
-            action_pred_names=action_pred_names,
-            transition_names=[],
-        )
-        full_src = base_src + "\n\n" + goal_def_src
-
-        eval_res = await self.c.eval_model(src=full_src)
-
-        #print ("THE FULL MODEL is ")
-        #print (full_src)
-        #print ("THE FULL MODEL is ")
-
-        if bool(getattr(eval_res, "has_errors", False)):
-            errs = getattr(eval_res, "errors", None)
-            if errs:
-                raise ValueError(f"Domain model has errors (e.g. {errs[0]})")
-            raise ValueError("Domain model has errors")
-
-        req: DecompReqArgs = {
-            "name": goal_name,
-            "assuming": assuming,
-            "rule_specs": rule_specs,
-            "prune": True,
-            "ctx_simp": ctx_simp,
-            "lift_bool": lift_bool,
-        }
-
-        res = await self.c.decompose(**req)
-
-        if res.regions_str:
-            regions_str = list(filter (lambda x: x.model_eval_str != ['true', 'false'][int(filter_out_false)], res.regions_str))
-        else:
-            regions_str = []
-
-        return ScenarioComplement(regions=regions_str)
-    
-
-    async def decompose_intersection (
-        self,
-        *,
-        domain_model: DomainModel,
-        sc1: Scenario,
-        sc2: Scenario,
-        ctx_simp: bool | None = None,
-        lift_bool: str | None = None,
-    ) -> ScenarioComplement:
-        domain_model.assert_has_predicates(given=sc1.given, when=sc1.when)
-        domain_model.assert_has_predicates(given=sc2.given, when=sc2.when)
-
-        state_names, action_names = collect_pred_names([sc1, sc2])
-        needs_action = bool(action_names)
-
-        goal_name = f"__decomp_intersect_{sc1.name}_{sc2.name}"
-        goal_expr = f"({mk_scenario_expr(sc1)}) && ({mk_scenario_expr(sc2)})"
-        goal_def = mk_goal_def(goal_name, goal_expr, needs_action=needs_action)
-
-        res = await self.decompose_goal_function(
-            domain_model=domain_model,
-            goal_name=goal_name,
-            goal_def_src=goal_def,
-            state_pred_names=state_names,
-            action_pred_names=action_names,
-            ctx_simp=ctx_simp,
-            lift_bool=lift_bool,
-            filter_out_false=True
-        )
-
-        return res
-    
-    async def decompose_spec_complement (
-        self,
-        *,
-        domain_model: DomainModel,
-        scenarios: Sequence[Scenario],
-        ctx_simp: bool | None = None,
-        lift_bool: str | None = None,
-    ) -> ScenarioComplement:
-        for sc in scenarios:
-            domain_model.assert_has_predicates(given=sc.given, when=sc.when)
-
-        state_names, action_names = collect_pred_names(scenarios)
-        needs_action = bool(action_names)
-
-        goal_name = "__decomp_spec_complement"
-        spec_expr = mk_spec_disjunction_expr(scenarios)
-        goal_expr = f"not ({spec_expr})"
-        goal_def = mk_goal_def(goal_name, goal_expr, needs_action=needs_action)
-
-        #print ("decomp <><>><>")
-        #print (domain_model)
-        #print ("<><><>")
-        #print ("goal name: " + goal_name)
-        #print ("decomp <><>><>")
-
-        return await self.decompose_goal_function(
-            domain_model=domain_model,
-            goal_name=goal_name,
-            goal_def_src=goal_def,
-            state_pred_names=state_names,
-            action_pred_names=action_names,
-            ctx_simp=True,
-            lift_bool=lift_bool,
-            filter_out_false=True
-        )
-    
-
-    async def check_trace_iml_validity(self, tr: TraceArtifact, model: DomainModel) -> TraceIMLValidity:
-        errs: list[str] = []
-
-        base_src = model.make_iml_model([], [], [])
-
-        bindings: list[str] = []
-        if not tr.given.strip():
-            errs.append("Trace missing `given` state value")
-        else:
-            bindings.append(f"let s : state = {tr.given}")
-
-        if tr.when is not None and tr.when.strip():
-            bindings.append(f"let a : action = {tr.when}")
-
-        if tr.then is not None and tr.then.strip():
-            bindings.append(f"let s_then : state = {tr.then}")
-
-        if errs:
-            return TraceIMLValidity(iml_valid=IMLValidity.INVALID, err="\n".join(errs))
-
-        full_src = base_src + "\n\n" + "\n".join(bindings)
-
-        try:
-            eval_res = await self.c.eval_model(src=full_src)
-        except Exception as e:
-            # Could be network/credentials/etc — we truly don't know IML validity.
-            return TraceIMLValidity(iml_valid=IMLValidity.UNKNOWN, err=str(e))
-
-        if bool(getattr(eval_res, "has_errors", False)):
-            es = getattr(eval_res, "errors", None) or []
-            msg = "\n".join(str(e) for e in es) if es else "ImandraX eval_model: has_errors=True"
-            return TraceIMLValidity(iml_valid=IMLValidity.INVALID, err=msg)
-
-        return TraceIMLValidity(iml_valid=IMLValidity.VALID, err=None)
-
-    async def check_trace_match(self, tr: TraceArtifact, s: Scenario, model: DomainModel) -> TraceScenarioMatchResult:
-        errs: list[str] = []
-
-        # 0) Typecheck everything first (fast fail)
-        v = await self.check_trace_iml_validity(tr, model)
-        if v.iml_valid != IMLValidity.VALID:
-            return TraceScenarioMatchResult(
-                scenario_name=s.name,
-                iml_valid=False,
-                err=v.err,
-                given_matches=False,
-                when_matches=False,
-                transition_matches=False,
-            )
-
-        # 1) Build model with scenario deps
-        dm = model
-        dm.assert_has_predicates(given=s.given, when=s.when)
-        dm.assert_has_transitions(then=s.then)
-
-        base_src = dm.make_iml_model(
-            state_pred_names=list(s.given),
-            action_pred_names=list(s.when),
-            transition_names=list(s.then),
-        )
-
-        bindings: list[str] = [f"let s : state = {tr.given}"]
-        if tr.when is not None and tr.when.strip():
-            bindings.append(f"let a : action = {tr.when}")
-        if tr.then is not None and tr.then.strip():
-            bindings.append(f"let s_then : state = {tr.then}")
-
-        ctx = base_src + "\n\n" + "\n".join(bindings)
-
-        async def eval_bool(expr: str) -> tuple[bool, str | None]:
-            import os
-            import imandrax_api
-            imandrax_api_key = os.getenv("IMANDRA_UNI_KEY")
-            url = imandrax_api.url_prod
-
-            async with imandrax_api.AsyncClient(
-                url=url, auth_token=imandrax_api_key, timeout=300
-            ) as ac:
-                src = ctx + "\n\n" + f"eval({expr})"
-                
-                res = await ac.eval_src(src=src)
-                
-                from imandrax_api.lib import read_artifact_zip
-
-                art_zip = await ac.get_artifact_zip(task=res.tasks[0], kind="eval_res")
-                with tempfile.NamedTemporaryFile(suffix=".zip", delete=True) as f:
-                    f.write(art_zip.art_zip)
-                    f.flush()
-                    eval_res = read_artifact_zip(f.name)
-
-                if str(eval_res.res.v.v) == 'Eval_Value_view_V_true()':
-                    return True, None
-                elif str(eval_res.res.v.v) == 'Eval_Value_view_V_false()':
-                    return False, None
-                else:
-                    return False, f"Result:{eval_res.res.v.v}"
-
-                #print("The result is" + str(eval_res.res.v.v))
-                #
-                #print ("The result is")
-                #print (res)
-
-                #import sys
-                #sys.exit(0)
-
-                #evs = getattr(res, "eval_results", None) or []
-                #if not evs or not getattr(evs[0], "success", False):
-                #    return False, f"eval failed for: {expr}"
-                #v = (getattr(evs[0], "value_as_ocaml", "") or "").strip()
-                #if v == "true":
-                #    return True, None
-                #if v == "false":
-                #    return False, None
-                #return False, f"eval returned non-bool: {v!r} for {expr}"
-
-        # 2) given_matches
-        if list(s.given):
-            given_expr = " && ".join(f"({p} s)" for p in s.given)
-            given_ok, given_err = await eval_bool(given_expr)
-            if given_err:
-                errs.append(given_err)
-        else:
-            given_ok = True
-
-        # 3) when_matches
-        if list(s.when):
-            if not (tr.when is not None and tr.when.strip()):
-                when_ok = False
-                errs.append("Scenario has action predicates but trace has no `when` action value")
-            else:
-                when_expr = " && ".join(f"({p} s a)" for p in s.when)
-                when_ok, when_err = await eval_bool(when_expr)
-                if when_err:
-                    errs.append(when_err)
-        else:
-            when_ok = True
-
-        # 4) transition_matches
-        # Semantics:
-        # - If scenario has no transitions, transition_matches is True (no then required).
-        # - If scenario has transitions, we need:
-        #     - trace has when (single-action mode)
-        #     - trace has then (state) to compare to
-        #     - apply transitions sequentially: s |> t1 a |> t2 a |> ... and compare to s_then
-        if not list(s.then):
-            # Scenario does not specify any transitions: nothing to check.
-            trans_ok = True
-        else:
-            # Scenario specifies transitions: we need action.
-            if not (tr.when is not None and tr.when.strip()):
-                trans_ok = False
-            else:
-                trans_names = list(s.then)
-
-                # Build a sequential application expression.
-                # Example for [t1, t2, t3]:
-                # let s1 = t1 s a in let s2 = t2 s1 a in let s3 = t3 s2 a in ...
-                if len(trans_names) == 1:
-                    final_state_expr = f"({trans_names[0]} s a)"
-                else:
-                    lets: list[str] = []
-                    prev = "s"
-                    for i, t in enumerate(trans_names, 1):
-                        si = f"s{i}"
-                        lets.append(f"let {si} = ({t} {prev} a) in")
-                        prev = si
-                    final_state_expr = " ".join(lets) + f" {prev}"
-
-                if not (tr.then is not None and tr.then.strip()):
-                    # then is optional: skip equality check, but still force typecheck/eval
-                    trans_ok, trans_err = await eval_bool(f"let _ = {final_state_expr} in true")
-                else:
-                    trans_expr = f"({final_state_expr} = s_then)"
-                    trans_ok, trans_err = await eval_bool(trans_expr)
-
-                # IMPORTANT: do NOT append anything when trans_ok is False.
-                if trans_err:
-                    errs.append(trans_err)
-
-        ok_err = "\n".join(errs) if errs else None
-        return TraceScenarioMatchResult(
-            scenario_name=s.name,
-            iml_valid=True,
-            err=ok_err,
-            when_matches=when_ok,
-            given_matches=given_ok,
-            transition_matches=trans_ok,
-        )
-    
-    async def check_scenario_implies(
-        self,
-        domain_model: DomainModel,
-        *,
-        sc_a: Scenario,  # A (more general)
-        sc_b: Scenario,  # B (more specific)
-    ) -> ScenarioConsumed | None:
-        """
-        Return ScenarioConsumed(A,B) iff B ⇒ A (i.e. scenario B is a subset of scenario A).
-        Otherwise return None.
-
-        We check satisfiability of:  (B && not A)
-        - UNSAT (no witness) => B ⇒ A   => consumed(A,B)
-        - SAT (witness)      => not implied => None
-
-        IMPORTANT: ImandraX usage here is:
-        1) eval_model(src=<full model that *defines* the named query>)
-        2) instance_src(src="<query_name>")  # NOT source; just the name
-        """
-
-        # 1) Fast local validation
-        domain_model.assert_has_predicates(given=sc_a.given, when=sc_a.when)
-        domain_model.assert_has_predicates(given=sc_b.given, when=sc_b.when)
-
-        # 2) Build minimal model with union of predicates used by either scenario
-        given = sorted(set(list(sc_a.given) + list(sc_b.given)))
-        when = sorted(set(list(sc_a.when) + list(sc_b.when)))
-
-        d_model = domain_model.make_iml_model(
-            state_pred_names=given,
-            action_pred_names=when,
-            transition_names=[],
-        )
-
-        # 3) Build counterexample expression: B && not(A)
-        a_expr = mk_scenario_expr(sc_a)
-        b_expr = mk_scenario_expr(sc_b)
-        ce_expr = f"({b_expr}) && (not ({a_expr}))"
-        needs_action = bool(when)
-
-        # 4) Define a NAMED boolean query inside the model context
-        # Ensure name is a valid identifier (avoid '-' etc.)
-        qname = f"__speclogician_implies_{sc_a.name}_{sc_b.name}".replace("-", "_")
-
-        # This helper must emit a *function definition*, not an `instance { ... }` block.
-        # Example shapes:
-        #   let q (s: state) : bool = <expr>
-        #   let q (s: state) (a: action) : bool = <expr>
-
-        def mk_bool_query_def(*, name: str, expr: str, needs_action: bool) -> str:
-            if needs_action:
-                return f"""
-        let {name} (s: state) (a: action) : bool =
-        ({expr})
-        """
-            return f"""
-        let {name} (s: state) : bool =
-        ({expr})
-        """
-
-        query_def = mk_bool_query_def(
-            name=qname,
-            expr=ce_expr,
-            needs_action=needs_action,
-        )
-
-        full_src = d_model + "\n\n" + query_def
-
-        # 5) eval_model the full program (model + query)
-        eval_res = await self.c.eval_model(src=full_src)
-        if bool(getattr(eval_res, "has_errors", False)):
-            errs = getattr(eval_res, "errors", None)
-            if errs:
-                raise ValueError(f"Domain model has errors (e.g. {errs[0]})")
-            raise ValueError("Domain model has errors")
-
-        # 6) instance_src just by NAME
-        res: InstanceRes = await self.c.instance_src(src=qname)
-
-        # SAT => counterexample exists => not consumed
-        if res.sat is not None:
-            return None
-
-        # UNSAT => implication holds => consumed
-        details = (
-            "Scenario is consumed: every state/action satisfying scenario2 also satisfies scenario1.\n"
-            "Checked UNSAT of: scenario2 && not(scenario1)."
-        )
-        return ScenarioConsumed(
-            scenario_name1=sc_a.name,  # A (general)
-            scenario_name2=sc_b.name,  # B (specific)
-            details=details,
-        )

speclogician/logic/api/decomp.py

@@ -1,67 +0,0 @@
-#
-#   Imandra Inc.
-#
-#   speclogician/logic/api/complement.py
-#
-
-import asyncio
-from imandrax_api_models import DecomposeRes
-
-from .client import SpecLogicianImandraX
-from speclogician.modeling.spec import Spec
-from speclogician.modeling.scenario import Scenario
-from speclogician.modeling.complement import ScenarioComplement
-
-
-def assert_decomp_ok(
-    res: DecomposeRes,
-    *,
-    ctx: str = "decompose",
-    require_regions: bool = True,
-) -> None:
-    if getattr(res, "errors", None):
-        raise AssertionError(f"{ctx}: decomposition errors: {res.errors}")
-
-    if res.regions_str is None:
-        raise AssertionError(f"{ctx}: decomposition produced no regions (regions_str is None)")
-
-    if require_regions and len(res.regions_str) == 0:
-        raise AssertionError(f"{ctx}: decomposition returned zero regions")
-
-async def decomp_intersection_async(sc1: Scenario, sc2: Scenario, spec: Spec) -> ScenarioComplement:
-    """
-    Decompose intersection of two scenarios and assert it succeeded.
-    """
-    async with SpecLogicianImandraX() as ix:
-        res = await ix.decompose_intersection(
-            domain_model=spec.domain_model,
-            sc1=sc1,
-            sc2=sc2,
-        )
-        return res
-
-def decomp_intersection(sc1: Scenario, sc2: Scenario, spec: Spec) -> ScenarioComplement:
-    """
-    Sync wrapper around decomp_intersection_async.
-    """
-    return asyncio.run(decomp_intersection_async(sc1, sc2, spec))
-
-async def decomp_complement_async(spec: Spec) -> ScenarioComplement:
-    """
-    Decompose complement of all scenarios in the spec and assert it succeeded.
-    """
-    scenarios = list(spec.scenarios)
-
-    async with SpecLogicianImandraX() as ix:
-        res = await ix.decompose_spec_complement(
-            domain_model=spec.domain_model,
-            scenarios=scenarios,
-        )
-        return res
-
-def decomp_complement(spec: Spec) -> ScenarioComplement:
-    """
-    Sync wrapper around decomp_complement_async.
-    """
-    return asyncio.run(decomp_complement_async(spec))
-