speclogician 0.0.0b1__py3-none-any.whl

speclogician/logic/main.py

@@ -0,0 +1,246 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/logic/main.py
+#
+
+from __future__ import annotations
+
+from ..modeling.spec import Spec
+from ..data.container import ArtifactContainer
+from ..data.mapping import ArtifactMap
+
+from ..state.change import (
+    StateChange,
+    DomainModelBaseEdit,
+    PredicateAdd,
+    PredicateEdit,
+    PredicateRemove,
+    TransitionAdd,
+    TransitionEdit,
+    TransitionRemove,
+    ScenarioAdd,
+    ScenarioEdit,
+    ScenarioRemove,
+    AddTestTrace,
+    EditTestTrace,
+    AddLogTrace,
+    EditLogTrace
+)
+
+from .lib.domain_model import check_domain_model
+from .lib.predicates import check_predicates
+from .lib.transitions import check_transitions
+from .lib.scenarios import check_scenarios
+from .lib.traces import check_traces
+from .lib.complement import maybe_update_spec_complement
+
+from ..utils import console
+
+
+def _hdr(title: str, subtitle: str | None = None, json_only: bool = False) -> None:
+    if json_only:
+        return
+    from rich.panel import Panel
+    from rich.text import Text
+
+    console.print(
+        Panel(
+            Text(subtitle or ""),
+            title=f"[bold]Logician[/bold] · {title}",
+            border_style="cyan",
+        )
+    )
+
+
+def _note(msg: str, json_only: bool = False) -> None:
+    if not json_only:
+        console.print(msg)
+
+def analyze_change(
+    spec: Spec,
+    art_cont: ArtifactContainer,
+    art_map: ArtifactMap,
+    change: StateChange,
+    json_only: bool = False,
+) -> None:
+    """
+    Top-level entry for logical analysis post-change event.
+
+    Only performs logic checks when relevant.
+    All other change types are treated as no-ops here.
+    """
+
+    # ----------------------------
+    # Domain base model changed
+    # ----------------------------
+    if isinstance(change, DomainModelBaseEdit):
+        _hdr("DomainModelBaseEdit", "Rechecking domain model and all dependent logic", json_only=json_only)
+        check_domain_model(spec, json_only=json_only)
+        check_predicates(spec, json_only=json_only)
+        check_transitions(spec, json_only=json_only)
+        check_scenarios(spec, json_only=json_only)
+        check_traces(spec, art_cont=art_cont, art_map=art_map, traces=[], json_only=json_only)
+
+        try:
+            maybe_update_spec_complement(spec)
+        except Exception as e:
+            _note(f"[yellow]⚠[/yellow] Complement update failed (non-fatal): {type(e).__name__}: {e}", json_only=json_only)
+
+        _note("[green]✓[/green] Domain analysis complete", json_only=json_only)
+        return
+
+    # ----------------------------
+    # Predicates changed
+    # ----------------------------
+    if isinstance(change, (PredicateAdd, PredicateEdit)):
+        _hdr("Predicate change", f"Predicate: [bold]{change.pred_name}[/bold]", json_only=json_only)
+        check_predicates(spec, names=[change.pred_name], json_only=json_only)
+        check_scenarios(spec, predicates=[change.pred_name], json_only=json_only)
+        check_traces(spec, art_cont=art_cont, art_map=art_map, traces=[], json_only=json_only)
+
+        try:
+            maybe_update_spec_complement(spec)
+        except Exception as e:
+            _note(f"[yellow]⚠[/yellow] Complement update failed (non-fatal): {type(e).__name__}: {e}", json_only=json_only)
+
+        _note("[green]✓[/green] Predicate analysis complete", json_only=json_only)
+        return
+
+    if isinstance(change, PredicateRemove):
+        _hdr("Predicate removed", f"[bold]{change.pred_name}[/bold]", json_only=json_only)
+        check_scenarios(spec, predicates=[change.pred_name], json_only=json_only)
+        check_traces(spec, art_cont=art_cont, art_map=art_map, traces=[], json_only=json_only)
+
+        try:
+            maybe_update_spec_complement(spec)
+        except Exception as e:
+            _note(f"[yellow]⚠[/yellow] Complement update failed (non-fatal): {type(e).__name__}: {e}", json_only=json_only)
+
+        _note("[green]✓[/green] Scenario refresh complete", json_only=json_only)
+        return
+
+    # ----------------------------
+    # Transitions changed
+    # ----------------------------
+    if isinstance(change, (TransitionAdd, TransitionEdit)):
+        _hdr("Transition change", f"Transition: [bold]{change.trans_name}[/bold]", json_only=json_only)
+        check_transitions(spec, names=[change.trans_name], json_only=json_only)
+        check_scenarios(spec, transitions=[change.trans_name], json_only=json_only)
+        check_traces(spec, art_cont=art_cont, art_map=art_map, traces=[], json_only=json_only)
+
+        try:
+            maybe_update_spec_complement(spec)
+        except Exception as e:
+            _note(f"[yellow]⚠[/yellow] Complement update failed (non-fatal): {type(e).__name__}: {e}", json_only=json_only)
+
+        _note("[green]✓[/green] Transition analysis complete", json_only=json_only)
+        return
+
+    if isinstance(change, TransitionRemove):
+        _hdr("Transition removed", f"[bold]{change.trans_name}[/bold]", json_only=json_only)
+        check_scenarios(spec, transitions=[change.trans_name], json_only=json_only)
+        check_traces(spec, art_cont=art_cont, art_map=art_map, traces=[], json_only=json_only)
+
+        try:
+            maybe_update_spec_complement(spec)
+        except Exception as e:
+            _note(f"[yellow]⚠[/yellow] Complement update failed (non-fatal): {type(e).__name__}: {e}", json_only=json_only)
+
+        _note("[green]✓[/green] Scenario refresh complete", json_only=json_only)
+        return
+
+    # ----------------------------
+    # Scenarios changed
+    # ----------------------------
+    if isinstance(change, (ScenarioAdd, ScenarioEdit)):
+        _hdr("Scenario change", f"Scenario: [bold]{change.scenario_name}[/bold]", json_only=json_only)
+        check_scenarios(spec, names=[change.scenario_name], json_only=json_only)
+        check_traces(spec, art_cont=art_cont, art_map=art_map, traces=[], json_only=json_only)
+
+        try:
+            maybe_update_spec_complement(spec)
+        except Exception as e:
+            _note(f"[yellow]⚠[/yellow] Complement update failed (non-fatal): {type(e).__name__}: {e}", json_only=json_only)
+
+        _note("[green]✓[/green] Scenario analysis complete", json_only=json_only)
+        return
+
+    if isinstance(change, ScenarioRemove):
+        _hdr("Scenario removed", "Refreshing scenarios, predicates, and traces", json_only=json_only)
+        check_scenarios(spec, json_only=json_only)
+        check_predicates(spec, json_only=json_only)
+        check_traces(spec=spec, art_cont=art_cont, art_map=art_map, traces=[], json_only=json_only)
+
+        try:
+            maybe_update_spec_complement(spec)
+        except Exception as e:
+            _note(f"[yellow]⚠[/yellow] Complement update failed (non-fatal): {type(e).__name__}: {e}", json_only=json_only)
+
+        _note("[green]✓[/green] Full refresh complete", json_only=json_only)
+        return
+
+    # ----------------------------
+    # Trace artifacts changed
+    # ----------------------------
+    if isinstance(change, AddTestTrace):
+        if not art_cont.test_traces:
+            return
+
+        tt = art_cont.test_traces[-1]
+        # best-effort sanity check; no-op if mismatch
+        if change.art_id is not None and tt.art_id != change.art_id:
+            pass
+
+        assert tt.art_id is not None
+
+        check_traces(
+            spec=spec,
+            art_cont=art_cont,
+            art_map=art_map,
+            traces=[tt.art_id],
+            json_only=json_only,
+        )
+
+        _note("[green]✓[/green] Trace analysis complete", json_only=json_only)
+        return
+
+    if isinstance(change, AddLogTrace):
+        if not art_cont.log_traces:
+            return
+
+        lt = art_cont.log_traces[-1]
+        if change.art_id is not None and lt.art_id != change.art_id:
+            pass
+
+        assert lt.art_id is not None
+
+        check_traces(
+            spec=spec,
+            art_cont=art_cont,
+            art_map=art_map,
+            traces=[lt.art_id],
+            json_only=json_only,
+        )
+
+        _note("[green]✓[/green] Trace analysis complete", json_only=json_only)
+        return
+
+    if isinstance(change, (EditTestTrace, EditLogTrace)):
+        check_traces(
+            spec=spec,
+            art_cont=art_cont,
+            art_map=art_map,
+            traces=[change.art_id],
+            json_only=json_only,
+        )
+
+        _note("[green]✓[/green] Trace analysis complete", json_only=json_only)
+        return
+
+    # ----------------------------
+    # Explicit no-op branch
+    # ----------------------------
+    # All remaining change types (data artifacts, mapping edits, etc.)
+    # are intentionally ignored here and handled elsewhere.
+    return

speclogician/logic/strings.py

@@ -0,0 +1,194 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/logic/strings.py
+#
+
+
+from __future__ import annotations
+
+import re
+from typing import Sequence
+
+from ..modeling.scenario import Scenario
+
+def parens(x: str) -> str:
+    x = x.strip()
+    return x if (x.startswith("(") and x.endswith(")")) else f"({x})"
+
+
+def and_all(conjuncts: Sequence[str]) -> str:
+    if not conjuncts:
+        return "true"
+    return " && ".join(parens(c) for c in conjuncts)
+
+
+def mk_predicates_only_instance_src(
+    name: str,
+    *,
+    given: Sequence[str],     # state predicate names: p : state -> bool
+    when: Sequence[str],      # action predicate names: q : state -> action -> bool (state first!)
+    state_type: str = "state",
+    action_type: str = "action",
+    state_var: str = "s",
+    action_var: str = "a",
+) -> str:
+    """
+    Consistency query: only predicates (given/when), no transitions.
+
+    Produces:
+          (p1 s) && (q1 s a) && ...
+    """
+    lines : list[str] = ["fun (s : state) (a : action) -> "]
+
+    exprs: list[str] = []
+    exprs += [f"{p} {state_var}" for p in given]
+    exprs += [f"{q} {state_var} {action_var}" for q in when]
+
+    lines.append(f"    {and_all(exprs)}")
+    result =  "\n".join(lines)
+
+    return result
+
+
+def mk_same_action_trace_instance_src(
+    name: str,
+    *,
+    given: Sequence[str],        # state predicate names
+    when: Sequence[str],         # action predicate names
+    transitions: Sequence[str],  # transition fn names: t : state -> action -> state
+    state_type: str = "state",
+    action_type: str = "action",
+    state0_var: str = "s0",
+    action_var: str = "a",
+    when_each_step: bool = True,  # apply action predicates at each pre-state
+) -> str:
+    """
+    Trace query: transitions applied sequentially using the SAME action `a`.
+
+    Produces:
+
+      instance <name> :
+        let s0 : state = s0 in
+        let a  : action = a  in
+        let s1 = t0 s0 a in
+        let s2 = t1 s1 a in
+          (given(s0)) && (when(s0,a)) && (when(s1,a)) ...
+
+    Note: for N transitions, `when` is applied to s0..s{N-1} if when_each_step=True.
+    """
+    lines: list[str] = [f"instance {name} :"]
+
+    # typed existentials
+    lines.append(f"  let {state0_var} : {state_type} = {state0_var} in")
+    lines.append(f"  let {action_var} : {action_type} = {action_var} in")
+
+    # let-chain states
+    # s0 already exists; create s1..sN
+    for i, tname in enumerate(transitions):
+        si = state0_var if i == 0 else f"s{i}"
+        si1 = f"s{i+1}"
+        lines.append(f"  let {si1} = {tname} {si} {action_var} in")
+
+    exprs: list[str] = []
+    exprs += [f"{p} {state0_var}" for p in given]
+
+    if when_each_step:
+        for i in range(len(transitions)):
+            si = state0_var if i == 0 else f"s{i}"
+            exprs += [f"{q} {si} {action_var}" for q in when]
+    else:
+        exprs += [f"{q} {state0_var} {action_var}" for q in when]
+
+    lines.append(f"    {and_all(exprs)}")
+    return "\n".join(lines)
+
+
+def mk_scenario_expr(sc: Scenario, *, s_var: str = "s", a_var: str = "a") -> str:
+    parts: list[str] = []
+    parts += [f"({p} {s_var})" for p in sc.given]
+    parts += [f"({q} {s_var} {a_var})" for q in sc.when]
+    return "true" if not parts else " && ".join(parts)
+
+def mk_spec_disjunction_expr(scenarios: Sequence[Scenario]) -> str:
+    disj = " || ".join(f"({mk_scenario_expr(sc)})" for sc in scenarios)
+    return "false" if not disj else disj
+
+def mk_goal_def(goal_name: str, goal_expr: str, *, needs_action: bool) -> str:
+    if needs_action:
+        return (
+            f"let {goal_name} (s : state) (a : action) : bool =\n"
+            f"  {goal_expr}\n"
+        )
+    else:
+        return (
+            f"let {goal_name} (s : state) : bool =\n"
+            f"  {goal_expr}\n"
+        )
+
+def collect_pred_names(scenarios: Sequence[Scenario]) -> tuple[list[str], list[str]]:
+    state_names: list[str] = []
+    action_names: list[str] = []
+    for sc in scenarios:
+        state_names += list(sc.given)
+        action_names += list(sc.when)
+    return state_names, action_names
+
+LET_RE = re.compile(r"^\s*let\s+([a-zA-Z_][a-zA-Z0-9_']*)\s*(?::\s*[^=]+)?=\s*(.+)$", re.DOTALL)
+
+def normalize_optional(s: str | None) -> str | None:
+    if s is None:
+        return None
+    s2 = s.strip()
+    return s2 if s2 else None
+
+def mk_typed_let(binding_src: str, *, expected_type: str, default_name: str) -> tuple[str, str]:
+    """
+    Returns: (let_src, bound_name)
+    Accepts either:
+      - `let x = ...` (or `let x : t = ...`)  -> keeps x
+      - `<expr>`                              -> wraps as `let <default_name> : expected_type = (<expr>)`
+    """
+    m = LET_RE.match(binding_src.strip())
+    if m:
+        name = m.group(1)
+        # Keep user's let as-is; we just trust their annotation (or lack of).
+        # (Type errors will be caught by eval_model.)
+        return binding_src.strip(), name
+
+    name = default_name
+    let_src = f"let {name} : {expected_type} = (\n{binding_src.strip()}\n)"
+    return let_src, name
+
+def mk_instance_src_for_expr(*, name: str, expr: str, needs_action: bool) -> str:
+    # Assumes `state` and (optionally) `action` exist in the model context.
+    # `expr` must be boolean and can mention `s` and optionally `a`.
+    if needs_action:
+        return f"""
+instance {name} =
+  {{ s : state; a : action }}
+  where {expr}
+"""
+    return f"""
+instance {name} =
+  {{ s : state }}
+  where {expr}
+"""
+
+def errs_to_string(eval_res: object) -> str | None:
+    """
+    Your eval_model result looks like it may have .has_errors and .errors.
+    Convert to a multi-line string.
+    """
+    if not bool(getattr(eval_res, "has_errors", False)):
+        return None
+
+    errs = getattr(eval_res, "errors", None)
+    if not errs:
+        return "Domain/trace model has errors"
+
+    # errs items could be strings or structured; stringify safely
+    lines: list[str] = []
+    for e in errs:
+        lines.append(str(e))
+    return "\n".join(lines)

speclogician/logic/utils.py

@@ -0,0 +1,135 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/logic/utils.py
+#
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+InstanceStatus = Literal["sat", "unsat", "unknown", "err"]
+
+_ONEOF_CANDIDATES = ("result", "res", "outcome", "status", "response")
+
+def instance_status(res: Any) -> InstanceStatus:
+
+    # 1) Prefer oneof introspection if available
+    for oneof_name in _ONEOF_CANDIDATES:
+        try:
+            which = res.WhichOneof(oneof_name)
+        except Exception:
+            continue
+        if which in ("sat", "unsat", "unknown", "err"):
+            return which  # type: ignore[return-value]
+
+    # 2) Fallback to HasField checks
+    for k in ("sat", "unsat", "unknown", "err"):
+        try:
+            if res.HasField(k):
+                return k  # type: ignore[return-value]
+        except Exception:
+            pass
+
+    # 3) Conservative fallback
+    return "unknown"
+
+
+def instance_is_sat(res: Any) -> bool:
+    return res.sat is not None
+
+def instance_model(res: Any) -> Any | None:
+    """
+    Returns Model if SAT, else None.
+    """
+    return res.sat.model.src if res.sat is not None and res.sat.model is not None else None 
+
+def instance_model_src(res: Any) -> str | None:
+    """
+    Returns Model.src if SAT, else None.
+    """
+    m = instance_model(res)
+    if m is None:
+        return None
+    return getattr(m, "src", None)
+
+
+def instance_model_artifact(res: Any) -> Any | None:
+    """
+    Returns Model.artifact if SAT, else None.
+    """
+    m = instance_model(res)
+    if m is None:
+        return None
+    return getattr(m, "artifact", None)
+
+
+def instance_unsat_proof(res: Any) -> str | None:
+    """
+    Returns Unsat.proof_pp if UNSAT, else None.
+    """
+    if instance_status(res) != "unsat":
+        return None
+    try:
+        return res.unsat.proof_pp
+    except Exception:
+        return None
+
+
+def instance_unknown_reason(res: Any) -> str | None:
+    """
+    Returns unknown StringMsg content if available.
+    `_utils_pb2.StringMsg` typically stores a `msg` or `value` field; handle both.
+    """
+    if instance_status(res) != "unknown":
+        return None
+    u = getattr(res, "unknown", None)
+    if u is None:
+        return None
+    return getattr(u, "msg", None) or getattr(u, "value", None) or str(u)
+
+
+def instance_has_errors(res: Any) -> bool:
+    try:
+        return len(res.errors) > 0
+    except Exception:
+        return False
+
+
+def instance_to_jsonable(res: Any) -> dict[str, Any]:
+    """
+    Minimal, stable JSONable view for SpecLogician logs/CLI:
+      - status
+      - model.src (if sat)
+      - unsat.proof_pp (if unsat)
+      - unknown reason (if unknown)
+      - errors count (+ optionally stringified errors)
+      - task (stringified)
+    """
+    st = instance_status(res)
+    out: dict[str, Any] = {
+        "status": st,
+        "has_errors": instance_has_errors(res),
+        "errors_count": len(res.errors) if hasattr(res, "errors") else 0,
+    }
+
+    if st == "sat":
+        m = res.sat.model
+        out["model"] = {
+            "m_type": str(getattr(m, "m_type", "")),
+            "src": getattr(m, "src", ""),
+            # artifact can be huge; include a string repr unless you want deeper extraction
+            "artifact": str(getattr(m, "artifact", "")),
+        }
+    elif st == "unsat":
+        out["proof_pp"] = getattr(res.unsat, "proof_pp", "")
+    elif st == "unknown":
+        out["reason"] = instance_unknown_reason(res)
+    elif st == "err":
+        out["reason"] = "err"
+
+    # Task is protobuf; stringify safely
+    if hasattr(res, "task"):
+        out["task"] = str(res.task)
+
+    return out