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

speclogician/modeling/domain.py

@@ -1,150 +1,61 @@
 #
 #   Imandra Inc.
 #
-#   speclogician/modeling/domain.py
+#   domain.py
 #
 
-from typing import Sequence
-from pydantic import BaseModel, Field
+import re
+from typing import List
+from pydantic import BaseModel
 
-from .predicates import (
-    StatePredicate, ActionPredicate, Transition, PredicateType
-)
-from .__init__ import extract_declared_types
-from enum import StrEnum
-
-class BaseStatus(StrEnum):
-    UNKNOWN = "unknown"
-    INVALID_IML = "invalid_iml"
-    VALID = "valid"
-
-class DomainModel(BaseModel):
-    """ 
-    The domain model (base model with state/action types + other auxillary functions,
-    and predicates/transition functions)
-    """
-
-    base_status : BaseStatus = BaseStatus.UNKNOWN # IML status
-    base_has_state : bool = False # Model contains `state` type definition
-    base_has_action : bool = False # Model contains `action` type definition
-    base : str = "" # Includes type definitions and other 
-
-    transitions : list[Transition] = Field(default_factory=list[Transition]) # 'state * action -> state' tansition functions
-    state_preds : list[StatePredicate] = Field(default_factory=list[StatePredicate]) # 'state -> bool' predicates
-    action_preds : list[ActionPredicate] = Field(default_factory=list[ActionPredicate]) # 'state * action -> bool' predicates
-
-    # transitions
-    num_trans_total : int = 0
-    num_trans_matched : int = 0
-    num_trans_valid_logic : int = 0
-    num_trans_errored : int = 0
-
-    # state-only predicates
-    num_state_preds_total : int = 0
-    num_state_preds_matched : int = 0
-    num_state_preds_valid_logic : int = 0
-    num_state_preds_errored : int = 0
-
-    # state x action predicates
-    num_action_preds_total : int = 0
-    num_action_preds_matched : int = 0
-    num_action_preds_valid_logic : int = 0
-    num_action_preds_errored : int = 0
-
-    # predicate totals
-    num_preds_total : int = 0
-    num_preds_matched : int = 0
-    num_preds_valid_logic : int = 0
-    num_preds_errored : int = 0
-
-    def assert_has_predicates(
-        self,
-        *,
-        given: Sequence[str],
-        when: Sequence[str],
-    ) -> None:
-        """Ensure all predicates referenced by a scenario exist in the domain model.
-
-        - `given` must reference state predicates (state -> bool)
-        - `when` must reference action predicates (state -> action -> bool)
-
-        Raises ValueError with a helpful message if anything is missing or mismatched.
-        """
-        missing_state: list[str] = []
-        missing_action: list[str] = []
-        wrong_kind_given: list[str] = []
-        wrong_kind_when: list[str] = []
-
-        for name in given:
-            p = self.get_pred_by_name(name)
-            if p is None:
-                missing_state.append(name)
-            elif p not in self.state_preds:
-                # Exists, but it's an action predicate (or otherwise not a state pred)
-                wrong_kind_given.append(name)
+from rich.table import Table
+from rich.syntax import Syntax
 
-        for name in when:
-            p = self.get_pred_by_name(name)
-            if p is None:
-                missing_action.append(name)
-            elif p not in self.action_preds:
-                # Exists, but it's a state predicate (or otherwise not an action pred)
-                wrong_kind_when.append(name)
+from .predicates import StatePredicate, ActionPredicate, Transition
+from .report import DomainModelReport
 
-        if missing_state or missing_action or wrong_kind_given or wrong_kind_when:
-            parts: list[str] = []
-            if missing_state:
-                parts.append(f"missing state predicates (given): {missing_state}")
-            if wrong_kind_given:
-                parts.append(f"not state predicates (given): {wrong_kind_given}")
-            if missing_action:
-                parts.append(f"missing action predicates (when): {missing_action}")
-            if wrong_kind_when:
-                parts.append(f"not action predicates (when): {wrong_kind_when}")
+from enum import Enum
 
-            raise ValueError("Scenario references invalid predicates: " + "; ".join(parts))
+from dotenv import load_dotenv
+load_dotenv("../.env")
 
-    def assert_has_transitions(self, *, then: Sequence[str]) -> None:
-        """Ensure all transitions referenced by a scenario exist in the domain model.
-
-        `then` is a list of transition function names.
-
-        Raises ValueError with a helpful message if anything is missing.
-        """
-        missing: list[str] = []
-
-        for name in then:
-            t = self.get_trans_by_name(name)
-            if t is None:
-                missing.append(name)
+IML_TYPE_REGEX = re.compile(
+    r"""
+    ^\s*type\s+                    # 'type' keyword
+    (?P<name>[a-zA-Z_][a-zA-Z0-9_]*)  # type name
+    \s*=                            # '=' sign
+    """,
+    re.MULTILINE | re.VERBOSE,
+)
 
-        if missing:
-            raise ValueError(f"Scenario references unknown transitions (then): {missing}")
+def strip_iml_comments(text: str) -> str:
+    """Remove OCaml-style (* ... *) and // comments."""
+    # Remove block comments
+    text = re.sub(r"\(\*.*?\*\)", "", text, flags=re.DOTALL)
+    # Remove line comments
+    text = re.sub(r"//.*", "", text)
+    return text
 
-    def get_pred_by_name (self, name:str) -> StatePredicate|ActionPredicate|None:
-        """ Return a predicate body for the specified name """
-        s_pred = next((p for p in self.state_preds if p.name == name), None)
+def extract_declared_types(iml_text: str) -> List[str]:
+    """Return all declared type names in an IML file."""
+    clean = strip_iml_comments(iml_text)
+    return [m.group("name") for m in IML_TYPE_REGEX.finditer(clean)]
 
-        if s_pred is None:
-            return next((p for p in self.action_preds if p.name == name), None)
-        else:
-            return s_pred
+class PredicateType(Enum):
+    STATE = 1
+    ACTION = 2
 
-    def get_trans_by_name (self, name:str) -> Transition|None:
-        """ Return transition body for a specified name """
-        return next((p for p in self.transitions if p.name == name), None)
+class DomainModel(BaseModel):
+    """ 
+    The domain model
+    """
 
-    def action_pred_names(self) -> list[str]:
-        """ List of action predicate names """
-        return list(map(lambda x: x.name, self.action_preds))
-    
-    def state_pred_names(self) -> list[str]:
-        """ List of available state predicate names """
-        return list(map(lambda x: x.name, self.state_preds))
+    base_status : str = "UNKOWN" # IML status
+    base : str = "" # Includes type definitions and other things...
 
-    def transition_names(self) -> list[str]:
-        """ List of available transitions """
-        return list(map(lambda x: x.name, self.transitions))
+    transitions : list[Transition] = [] # 'state * action -> state' tansition functions
+    state_preds : list[StatePredicate] = [] # 'state -> bool' predicates
+    action_preds : list[ActionPredicate] = [] # 'state * action -> bool' predicates
 
     def pred_exists(self, name:str) -> bool:
         """
@@ -154,113 +65,11 @@ class DomainModel(BaseModel):
             return True    
         return next ((p for p in self.action_preds if p.name == name), None) is not None
     
-    def add_predicate(self, name: str, ptype: PredicateType, src_code: str) -> None:
-        """Add a new predicate to the domain model."""
-
-        # Enforce global uniqueness across all predicates
-        if any(p.name == name for p in self.state_preds) or \
-        any(p.name == name for p in self.action_preds):
-            raise ValueError(f"Predicate '{name}' already exists in domain model")
-
-        if ptype == PredicateType.STATE:
-            pred = StatePredicate(
-                name=name,
-                src_code=src_code,
-            )
-            self.state_preds.append(pred)
-
-        elif ptype == PredicateType.ACTION:
-            pred = ActionPredicate(
-                name=name,
-                src_code=src_code,
-            )
-            self.action_preds.append(pred)
-
-        else:
-            raise ValueError(f"Attempting to add unknown type of predicate: {ptype}")
-
-    def edit_predicate(self, name: str, src_code: str) -> None:
-        """Edit a predicate by name and update last_updated."""
-
-        matches = [p for p in self.state_preds if p.name == name] + \
-                [p for p in self.action_preds if p.name == name]
-
-        if not matches:
-            raise ValueError(f"Predicate '{name}' not found")
-
-        if len(matches) > 1:
-            raise ValueError(f"Predicate '{name}' is ambiguous (found {len(matches)} matches)")
-
-        pred = matches[0]
-        pred.set_src_code(src_code)
-
-    def rem_predicate(self, name: str) -> None:
-        """Remove a predicate (state or action) by name."""
-
-        removed = False
-
-        # Remove from state predicates
-        for i, p in enumerate(self.state_preds):
-            if p.name == name:
-                del self.state_preds[i]
-                removed = True
-                break
-
-        # Remove from action predicates
-        for i, p in enumerate(self.action_preds):
-            if p.name == name:
-                del self.action_preds[i]
-                removed = True
-                break
-
-        if not removed:
-            raise ValueError(f"Predicate '{name}' not found in domain model")
-        
-    def add_transition(self, name: str, src_code: str) -> None:
-        """Add a new transition function to the domain model."""
-
-        # Ensure uniqueness
-        if any(t.name == name for t in self.transitions):
-            raise ValueError(f"Transition '{name}' already exists in domain model")
-
-        transition = Transition(
-            name=name,
-            src_code=src_code,
-        )
-
-        self.transitions.append(transition)
-
-    def edit_transition(self, name: str, src_code: str) -> None:
-        """Edit a transition function by name and update last_updated."""
-        matches = [t for t in self.transitions if t.name == name]
-
-        if not matches:
-            raise ValueError(f"Transition '{name}' not found in domain model")
-
-        if len(matches) > 1:
-            raise ValueError(
-                f"Transition name '{name}' is ambiguous "
-                f"({len(matches)} transitions found)"
-            )
-
-        transition = matches[0]
-        transition.set_src_code(src_code)
-
-    def rem_transition(self, name: str) -> None:
-        """Remove a transition function by name."""
-
-        for i, t in enumerate(self.transitions):
-            if t.name == name:
-                del self.transitions[i]
-                return
-
-        raise ValueError(f"Transition '{name}' not found in domain model")
-
     def trans_exists(self, name:str) -> bool:
-        """ Return True/False if transitions with specified name exists """
+        """ """
         return next ((t for t in self.transitions if t.name == name), None) is not None
 
-    def state_specified (self) -> bool:
+    def state_specified(self) -> bool:
         """
         Return True if the `state` type is properly specified
         """
@@ -285,65 +94,69 @@ class DomainModel(BaseModel):
     
     def set_base (
             self, 
-            new_base : str) -> None:
+            new_base : str, 
+            do_check : bool = True) -> None | DomainModelReport:
         """
-        Update the base model
         """
         self.base = new_base
 
+        if do_check:
+            return self.report()
         return None
 
-    def make_iml_model (
-        self, 
-        state_pred_names : list[str], 
-        action_pred_names : list[str],
-        transition_names : list[str]
-        ) -> str:
-        """ 
-        Return base model with required predicates/transitions if needed 
+    def report(self) -> DomainModelReport:
+        """
+        Generate a DomainModelReport
         """
 
-        state_preds_str = ""
-        for p in state_pred_names:
-            pred = self.get_pred_by_name(p)
-            if pred is None:
-                continue
-            state_preds_str += f"{pred.to_iml()}"
-        if len(state_preds_str):
-            state_preds_str = f"(* State predicates *)\n{state_preds_str}"
-        
-        action_preds_str = ""
-        for p in action_pred_names:
-            pred = self.get_pred_by_name(p)
-            if pred is None:
-                continue
-            action_preds_str += f"\n{pred.to_iml()}\n"
-        if len(action_preds_str):
-            action_preds_str = f"(* Action predicates *)\n{action_preds_str}"
-
-        trans_str = ""
-        for t in transition_names:
-            trans = self.get_trans_by_name(t)
-            if trans is None:
-                continue
-            trans_str += f"\n{trans.to_iml()}\n"
-        if len(trans_str):
-            trans_str = f"(* Transitions *)\n{trans_str}"
+        return DomainModelReport()
 
+    def to_iml(self):
+        """
+        Create a consolidated IML model
+        """
+        state_predicates    = "\n".join(map(lambda x: x.to_iml(), self.state_preds))
+        action_predicates   = "\n".join(map(lambda x: x.to_iml(), self.action_preds))
+        transitions         = "\n".join(map(lambda x: x.to_iml(), self.transitions))
+     
         return f"""
 (* Domain Model *)
 
 (* Base *)
 {self.base}
-{state_preds_str}
-{action_preds_str}
-{trans_str}
-""".rstrip("\n")
 
-    def to_iml(self):
+(* State predicates *)
+{state_predicates}
+
+(* Action predicates *)
+{action_predicates}
+
+(* Transitions *)
+{transitions}
+"""
+
+    def __rich__ (self):
         """
-        Create a consolidated IML model with all predicates and transitions
+        Return a nice table we can visualize
         """
-        return self.make_iml_model(
-            self.state_pred_names(), self.action_pred_names(), self.transition_names()
-        )
+        t = Table(title="Domain model")
+
+        t.add_column("Attribute", "Value")
+        t.add_row("Base", Syntax(self.base, "OCaml"))
+        t.add_row("State predicates", Syntax("\n".join(map(lambda x: x.to_iml(), self.state_preds)) , "OCaml"))
+        t.add_row("Action predicates", Syntax("\n".join(map(lambda x: x.to_iml(), self.action_preds)), "OCaml"))
+        t.add_row("Transitions", Syntax("\n".join(map(lambda x: x.to_iml(), self.transitions)) , "OCaml"))
+
+        return t
+    
+if __name__ == "__main__":
+
+    # 
+    m = DomainModel(
+        base_status = "UNKNOWN"
+    )
+    m.set_base("type state = int\ntype action = int")
+
+    print (f"State is specified: {m.state_specified()}")
+    print (f"Action is specified: {m.action_specified()}")
+

speclogician/modeling/model.py

@@ -0,0 +1,206 @@
+    #
+#   Imandra Inc.
+#
+#   model.py
+#
+
+from pydantic import BaseModel
+
+from .report import (
+    ModelReport, DomainModelReport, ScenarioReport
+)
+from .domain import DomainModel
+from .scenario import Scenario 
+from ..utils.imx import run_decomp
+
+from imandrax_api_models import DecomposeRes, InstanceRes, VerifyRes
+
+from ..state.change import (
+    ModelChange, 
+    DomainModelBaseEdit, 
+    PredicateAdd, 
+    PredicateEdit,
+    PredicateRemove, 
+    TransitionAdd, 
+    TransitionEdit, 
+    ScenarioAdd,
+    ScenarioEdit,
+    ScenarioRemoved
+)
+
+from ..utils import console
+
+class PredicateDetails(BaseModel):
+    """ 
+    We use this to compute details on how the predicates are used, how to search for it, etc...
+    """
+
+    predicate : str # predicate itself
+    num_given : int # number of times it appears in given
+    num_when : int # number of times it appears in when
+    num_complements : int # number of times the complement appears
+
+    given_scenarios : list[Scenario] # Scenarios where the predicate appears in 'Given' clause
+    where_scenarios : list[Scenario] # Scenarios where the predicate appears in 'Where' clause
+    then_scenarios  : list[Scenario] # Scenarios where the predicate appears in 'Then' clause
+
+class ModelSummaryInfo(BaseModel):
+    """ """
+    domain_iml_status : str
+
+    preds_errored : int
+    preds_total : int
+
+    scenarios_total : int
+    scenarios_errored : int
+    
+class Model(BaseModel):
+    """
+    A model is a combination of Domain Model and list of scenarios
+    """
+
+    domain_model : DomainModel = DomainModel() # Domain model
+    scenarios : list[Scenario] = [] # The list of Scenarios
+
+    def info(self) -> ModelSummaryInfo:
+        """
+
+        """
+        
+        preds_errored = 0
+        scenarios_errored = 0
+        
+        msi = ModelSummaryInfo (
+            domain_iml_status=self.domain_model.base_status,
+
+            preds_total = len(self.domain_model.state_preds) + len(self.domain_model.action_preds),
+            preds_errored = preds_errored,
+
+            scenarios_total = len(self.scenarios),
+            scenarios_errored = scenarios_errored
+        )
+
+        return msi
+
+    def proc_change(self, change : ModelChange):
+        """
+        Process model change
+        """
+        if isinstance(change, DomainModelBaseEdit):
+            self.domain_model.set_base(change.new_base_src)
+        elif isinstance(change, PredicateAdd):
+            pass
+        elif isinstance(change, PredicateEdit):
+            pass
+        elif isinstance(change, PredicateRemove):
+            pass
+        elif isinstance(change, TransitionAdd):
+            pass
+        elif isinstance(change, TransitionEdit):
+            pass
+        elif isinstance(change, ScenarioAdd):
+            pass
+        elif isinstance(change, ScenarioEdit):
+            pass
+        elif isinstance(change, ScenarioRemoved):
+            pass
+        else:
+            pass
+
+    def scenario_model(self):
+        """
+        Synthesize a model from the scenarios
+        """
+
+        scenario_logic = ""
+        for s in self.scenarios:
+            scenario_logic += f"{s.full_model_to_iml()}\n"
+
+        model = f"""
+let scenarios (s : state) (a : action) = 
+{scenario_logic} else
+false
+"""
+        return model
+
+    def scenario_complement(self, json_out:bool = False) -> None|DecomposeRes:
+        """
+        Perform region decomp on the model 
+        """
+
+        pred_str = ""
+
+        for s in self.scenarios:
+            pred_str += f"if (\n{s.pred_calls_to_iml()}\n) then true else\n"
+        
+        decomp_query = f"""
+    
+let complement (s : state) (a : action) = 
+{pred_str}
+false
+
+let not_covered (s : state) (a : action) = 
+    (complement s a) = false
+
+let wrapper (s : state) (a : action) = 
+    complement s a
+[@@decomp top ~assuming:[%id not_covered] ()]
+"""
+        
+        if not json_out:
+            with console.status(":robot: [bold]Computing regions..."):        
+                result = run_decomp(self.domain_model.to_iml(), decomp_query)
+        else:
+            result = run_decomp(self.domain_model.to_iml(), decomp_query)
+
+
+        if not result.regions_str:
+            if not json_out:
+                console.print(":warning: Failed to compute regions...")
+            return None
+
+        if not json_out:
+            console.print(f":robot::rocket: [bold]Computed: {len(result.regions_str)} regions!")        
+            for idx, region_str in enumerate(result.regions_str):
+                console.rule(f"[bold red]Region: {idx+1}")
+                
+                if region_str.constraints_str:
+                    console.print("Constraints:")
+                    for c in region_str.constraints_str:
+                        console.print (f"    - {c}")
+                            
+                if region_str.model_str:
+                    console.print("Sample model input:")
+                    console.print(f"    - {region_str.model_str}")
+            return None        
+        else:
+            return result
+
+    def report(self) -> ModelReport:
+
+        dmodel_report = self.domain_model.report()
+
+        scenario_report = ScenarioReport(
+#            num_scenarios=len(self.)
+            num_scenarios = 0,
+            num_conflicted = 0,
+            num_failed= 0
+        )
+
+        return ModelReport(dmodel_report=dmodel_report, scenario_report=scenario_report)
+
+    def check_logic(self):
+        """
+        Check that the resulting logic is correct
+        """
+        pass
+
+    def rich_scenarios(self):
+        """
+        Return a table of scenarios 
+        """
+        pass
+
+    def __rich__(self):
+        """ """
+        pass