ReForma 0.1.0__tar.gz

reforma-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+include ReForma/bin/ReFormaTool.jar

reforma-0.1.0/PKG-INFO

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: ReForma
+Version: 0.1.0
+Summary: Python bindings for the RePA/ReForma probabilistic automaton tool
+Author-email: Joshua Dourado <joshuadourado@ua.pt>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: networkx
+Requires-Dist: matplotlib
+
+# ReForma — Python bindings for the RePA/ReForma tool
+
+A clean Python library that wraps the `ReFormaTool.jar` CLI via subprocess,
+giving you a Pythonic interface for simulation, training, PDL/PCTL
+verification, and export.
+
+---
+
+## Installation
+
+```bash
+# From the project root (where pyproject.toml lives)
+pip install -e .
+```
+
+Requires **Python 3.10+** and a working `java` on your PATH.
+
+---
+
+## Quick Start
+
+```python
+from ReForma import ReForma
+
+# Point to your compiled JAR
+ReForma = ReForma("path/to/ReFormaTool.jar")
+
+# Load a model
+state = ReForma.load_file("examples/recommender.r")
+
+print(state.current_states)   # ['Home']
+print(state.enabled)          # [Transition('go_work': Home → Office, p=0.500), ...]
+
+# Simulate
+state = ReForma.step("go_work")
+state = ReForma.step("easy_task")
+state = ReForma.undo()            # undo last step
+
+# Reset to initial state
+ReForma.reset()
+```
+
+---
+
+## Simulation
+
+```python
+state = ReForma.load_file("model.r")
+
+# Check what's enabled
+for t in state.enabled:
+    print(f"{t.label}: {t.from_state} → {t.to_state}  (p={t.probability:.3f})")
+
+# Take a step by label
+state = ReForma.step("go_work")
+
+# Undo / reset
+state = ReForma.undo()
+state = ReForma.reset()
+
+# Inspect variables
+print(state.variables)   # {'counter': 0, 'flag': 1}
+
+# History of labels taken
+print(ReForma.history)       # ['go_work']
+```
+
+---
+
+## Training
+
+Train the model on a batch of sessions (lists of event labels):
+
+```python
+ReForma.train([
+    ["go_work", "easy_task", "easy_task", "go_home"],
+    ["battery_low", "go_charge", "finish_charge", "socialize"],
+    ["no_money", "go_work", "go_home"],
+])
+
+# Or train directly from a log file (one session per line, comma-separated)
+ReForma.train_from_file("logs/sessions.txt")
+
+# sessions.txt format:
+#   go_work,easy_task,go_home
+#   battery_low,go_charge,finish_charge
+
+# Save the updated model with new weights
+ReForma.save_source("model_trained.r")
+```
+
+---
+
+## PDL / PCTL Verification
+
+```python
+# Quantitative: probability of eventually reaching Office
+prob = ReForma.check_pdl_value("Home", "{P=?[F Office]}")
+print(f"P(reach Office from Home) = {prob:.4f}")
+
+# Qualitative: is it probable?
+holds = ReForma.check_pdl_value("Home", "{P>=0.4[F Office]}")
+print(f"P>=0.4? {holds}")   # True / False
+
+# PDL: is there a path via go_work to Office?
+holds = ReForma.check_pdl_value("Home", "<go_work>Office")
+print(holds)   # True
+
+# Get the raw string result
+raw = ReForma.check_pdl("Home", "{P=?[F Office]}")
+print(raw)  # "Result: 0.50000"
+```
+
+### Formula syntax reference
+
+| Formula                     | Meaning                                        |
+|-----------------------------|------------------------------------------------|
+| `{P=?[F target]}`           | Probability of eventually reaching `target`    |
+| `{P=?[G safe]}`             | Probability of staying in `safe` forever       |
+| `{P=?[X next]}`             | Probability of reaching `next` in one step     |
+| `{P=?[a U b]}`              | Probability of `a` until `b`                   |
+| `{P>=0.5[F target]}`        | Is probability of reaching target ≥ 0.5?       |
+| `<action>state`             | There exists a path via `action` to `state`    |
+| `[action]state`             | All paths via `action` lead to `state`         |
+
+---
+
+## Export
+
+```python
+# PRISM DTMC
+prism_code = ReForma.export_prism()
+ReForma.save_prism("output/model.pm")
+
+# mCRL2
+mcrl2_code = ReForma.export_mcrl2()
+
+# GLTS (imperative translation)
+glts_code = ReForma.export_glts()
+
+# Mermaid diagram (initial state)
+diagram = ReForma.export_mermaid()
+
+# Mermaid diagram (full LTS — all reachable states)
+full_diagram = ReForma.export_mermaid(full_lts=True)
+```
+
+---
+
+## Loading from a string
+
+```python
+source = """
+name MyModel
+init s0
+s0 ---> s1: a (0.6)
+s0 ---> s2: b (0.4)
+s1 ---> s0: back (1.0)
+"""
+
+state = ReForma.load(source, name="MyModel")
+```
+
+---
+
+## Running the tests
+
+```bash
+pip install pytest
+pytest tests/ -v
+```
+
+---
+
+## Project structure
+
+```
+ReForma/
+├── __init__.py       # Public API exports
+├── client.py         # ReForma — high-level Python API
+├── jar_bridge.py     # JarBridge — low-level subprocess wrapper
+└── model.py          # ReFormaModel, SimulationState, Transition data classes
+tests/
+└── test_ReForma.py       # Full test suite (mocked, no JAR needed)
+pyproject.toml
+README.md
+```
+
+---
+
+## Error handling
+
+```python
+from ReForma.jar_bridge import JarError
+
+try:
+    result = ReForma.check_pdl("Home", "{P=?[F Office]}")
+except JarError as e:
+    print(f"JAR error: {e}")
+except RuntimeError as e:
+    print(f"Usage error: {e}")   # e.g. no model loaded, invalid transition
+```

reforma-0.1.0/README.md

@@ -0,0 +1,202 @@
+# ReForma — Python bindings for the RePA/ReForma tool
+
+A clean Python library that wraps the `ReFormaTool.jar` CLI via subprocess,
+giving you a Pythonic interface for simulation, training, PDL/PCTL
+verification, and export.
+
+---
+
+## Installation
+
+```bash
+# From the project root (where pyproject.toml lives)
+pip install -e .
+```
+
+Requires **Python 3.10+** and a working `java` on your PATH.
+
+---
+
+## Quick Start
+
+```python
+from ReForma import ReForma
+
+# Point to your compiled JAR
+ReForma = ReForma("path/to/ReFormaTool.jar")
+
+# Load a model
+state = ReForma.load_file("examples/recommender.r")
+
+print(state.current_states)   # ['Home']
+print(state.enabled)          # [Transition('go_work': Home → Office, p=0.500), ...]
+
+# Simulate
+state = ReForma.step("go_work")
+state = ReForma.step("easy_task")
+state = ReForma.undo()            # undo last step
+
+# Reset to initial state
+ReForma.reset()
+```
+
+---
+
+## Simulation
+
+```python
+state = ReForma.load_file("model.r")
+
+# Check what's enabled
+for t in state.enabled:
+    print(f"{t.label}: {t.from_state} → {t.to_state}  (p={t.probability:.3f})")
+
+# Take a step by label
+state = ReForma.step("go_work")
+
+# Undo / reset
+state = ReForma.undo()
+state = ReForma.reset()
+
+# Inspect variables
+print(state.variables)   # {'counter': 0, 'flag': 1}
+
+# History of labels taken
+print(ReForma.history)       # ['go_work']
+```
+
+---
+
+## Training
+
+Train the model on a batch of sessions (lists of event labels):
+
+```python
+ReForma.train([
+    ["go_work", "easy_task", "easy_task", "go_home"],
+    ["battery_low", "go_charge", "finish_charge", "socialize"],
+    ["no_money", "go_work", "go_home"],
+])
+
+# Or train directly from a log file (one session per line, comma-separated)
+ReForma.train_from_file("logs/sessions.txt")
+
+# sessions.txt format:
+#   go_work,easy_task,go_home
+#   battery_low,go_charge,finish_charge
+
+# Save the updated model with new weights
+ReForma.save_source("model_trained.r")
+```
+
+---
+
+## PDL / PCTL Verification
+
+```python
+# Quantitative: probability of eventually reaching Office
+prob = ReForma.check_pdl_value("Home", "{P=?[F Office]}")
+print(f"P(reach Office from Home) = {prob:.4f}")
+
+# Qualitative: is it probable?
+holds = ReForma.check_pdl_value("Home", "{P>=0.4[F Office]}")
+print(f"P>=0.4? {holds}")   # True / False
+
+# PDL: is there a path via go_work to Office?
+holds = ReForma.check_pdl_value("Home", "<go_work>Office")
+print(holds)   # True
+
+# Get the raw string result
+raw = ReForma.check_pdl("Home", "{P=?[F Office]}")
+print(raw)  # "Result: 0.50000"
+```
+
+### Formula syntax reference
+
+| Formula                     | Meaning                                        |
+|-----------------------------|------------------------------------------------|
+| `{P=?[F target]}`           | Probability of eventually reaching `target`    |
+| `{P=?[G safe]}`             | Probability of staying in `safe` forever       |
+| `{P=?[X next]}`             | Probability of reaching `next` in one step     |
+| `{P=?[a U b]}`              | Probability of `a` until `b`                   |
+| `{P>=0.5[F target]}`        | Is probability of reaching target ≥ 0.5?       |
+| `<action>state`             | There exists a path via `action` to `state`    |
+| `[action]state`             | All paths via `action` lead to `state`         |
+
+---
+
+## Export
+
+```python
+# PRISM DTMC
+prism_code = ReForma.export_prism()
+ReForma.save_prism("output/model.pm")
+
+# mCRL2
+mcrl2_code = ReForma.export_mcrl2()
+
+# GLTS (imperative translation)
+glts_code = ReForma.export_glts()
+
+# Mermaid diagram (initial state)
+diagram = ReForma.export_mermaid()
+
+# Mermaid diagram (full LTS — all reachable states)
+full_diagram = ReForma.export_mermaid(full_lts=True)
+```
+
+---
+
+## Loading from a string
+
+```python
+source = """
+name MyModel
+init s0
+s0 ---> s1: a (0.6)
+s0 ---> s2: b (0.4)
+s1 ---> s0: back (1.0)
+"""
+
+state = ReForma.load(source, name="MyModel")
+```
+
+---
+
+## Running the tests
+
+```bash
+pip install pytest
+pytest tests/ -v
+```
+
+---
+
+## Project structure
+
+```
+ReForma/
+├── __init__.py       # Public API exports
+├── client.py         # ReForma — high-level Python API
+├── jar_bridge.py     # JarBridge — low-level subprocess wrapper
+└── model.py          # ReFormaModel, SimulationState, Transition data classes
+tests/
+└── test_ReForma.py       # Full test suite (mocked, no JAR needed)
+pyproject.toml
+README.md
+```
+
+---
+
+## Error handling
+
+```python
+from ReForma.jar_bridge import JarError
+
+try:
+    result = ReForma.check_pdl("Home", "{P=?[F Office]}")
+except JarError as e:
+    print(f"JAR error: {e}")
+except RuntimeError as e:
+    print(f"Usage error: {e}")   # e.g. no model loaded, invalid transition
+```

reforma-0.1.0/ReForma.egg-info/PKG-INFO

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: ReForma
+Version: 0.1.0
+Summary: Python bindings for the RePA/ReForma probabilistic automaton tool
+Author-email: Joshua Dourado <joshuadourado@ua.pt>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: networkx
+Requires-Dist: matplotlib
+
+# ReForma — Python bindings for the RePA/ReForma tool
+
+A clean Python library that wraps the `ReFormaTool.jar` CLI via subprocess,
+giving you a Pythonic interface for simulation, training, PDL/PCTL
+verification, and export.
+
+---
+
+## Installation
+
+```bash
+# From the project root (where pyproject.toml lives)
+pip install -e .
+```
+
+Requires **Python 3.10+** and a working `java` on your PATH.
+
+---
+
+## Quick Start
+
+```python
+from ReForma import ReForma
+
+# Point to your compiled JAR
+ReForma = ReForma("path/to/ReFormaTool.jar")
+
+# Load a model
+state = ReForma.load_file("examples/recommender.r")
+
+print(state.current_states)   # ['Home']
+print(state.enabled)          # [Transition('go_work': Home → Office, p=0.500), ...]
+
+# Simulate
+state = ReForma.step("go_work")
+state = ReForma.step("easy_task")
+state = ReForma.undo()            # undo last step
+
+# Reset to initial state
+ReForma.reset()
+```
+
+---
+
+## Simulation
+
+```python
+state = ReForma.load_file("model.r")
+
+# Check what's enabled
+for t in state.enabled:
+    print(f"{t.label}: {t.from_state} → {t.to_state}  (p={t.probability:.3f})")
+
+# Take a step by label
+state = ReForma.step("go_work")
+
+# Undo / reset
+state = ReForma.undo()
+state = ReForma.reset()
+
+# Inspect variables
+print(state.variables)   # {'counter': 0, 'flag': 1}
+
+# History of labels taken
+print(ReForma.history)       # ['go_work']
+```
+
+---
+
+## Training
+
+Train the model on a batch of sessions (lists of event labels):
+
+```python
+ReForma.train([
+    ["go_work", "easy_task", "easy_task", "go_home"],
+    ["battery_low", "go_charge", "finish_charge", "socialize"],
+    ["no_money", "go_work", "go_home"],
+])
+
+# Or train directly from a log file (one session per line, comma-separated)
+ReForma.train_from_file("logs/sessions.txt")
+
+# sessions.txt format:
+#   go_work,easy_task,go_home
+#   battery_low,go_charge,finish_charge
+
+# Save the updated model with new weights
+ReForma.save_source("model_trained.r")
+```
+
+---
+
+## PDL / PCTL Verification
+
+```python
+# Quantitative: probability of eventually reaching Office
+prob = ReForma.check_pdl_value("Home", "{P=?[F Office]}")
+print(f"P(reach Office from Home) = {prob:.4f}")
+
+# Qualitative: is it probable?
+holds = ReForma.check_pdl_value("Home", "{P>=0.4[F Office]}")
+print(f"P>=0.4? {holds}")   # True / False
+
+# PDL: is there a path via go_work to Office?
+holds = ReForma.check_pdl_value("Home", "<go_work>Office")
+print(holds)   # True
+
+# Get the raw string result
+raw = ReForma.check_pdl("Home", "{P=?[F Office]}")
+print(raw)  # "Result: 0.50000"
+```
+
+### Formula syntax reference
+
+| Formula                     | Meaning                                        |
+|-----------------------------|------------------------------------------------|
+| `{P=?[F target]}`           | Probability of eventually reaching `target`    |
+| `{P=?[G safe]}`             | Probability of staying in `safe` forever       |
+| `{P=?[X next]}`             | Probability of reaching `next` in one step     |
+| `{P=?[a U b]}`              | Probability of `a` until `b`                   |
+| `{P>=0.5[F target]}`        | Is probability of reaching target ≥ 0.5?       |
+| `<action>state`             | There exists a path via `action` to `state`    |
+| `[action]state`             | All paths via `action` lead to `state`         |
+
+---
+
+## Export
+
+```python
+# PRISM DTMC
+prism_code = ReForma.export_prism()
+ReForma.save_prism("output/model.pm")
+
+# mCRL2
+mcrl2_code = ReForma.export_mcrl2()
+
+# GLTS (imperative translation)
+glts_code = ReForma.export_glts()
+
+# Mermaid diagram (initial state)
+diagram = ReForma.export_mermaid()
+
+# Mermaid diagram (full LTS — all reachable states)
+full_diagram = ReForma.export_mermaid(full_lts=True)
+```
+
+---
+
+## Loading from a string
+
+```python
+source = """
+name MyModel
+init s0
+s0 ---> s1: a (0.6)
+s0 ---> s2: b (0.4)
+s1 ---> s0: back (1.0)
+"""
+
+state = ReForma.load(source, name="MyModel")
+```
+
+---
+
+## Running the tests
+
+```bash
+pip install pytest
+pytest tests/ -v
+```
+
+---
+
+## Project structure
+
+```
+ReForma/
+├── __init__.py       # Public API exports
+├── client.py         # ReForma — high-level Python API
+├── jar_bridge.py     # JarBridge — low-level subprocess wrapper
+└── model.py          # ReFormaModel, SimulationState, Transition data classes
+tests/
+└── test_ReForma.py       # Full test suite (mocked, no JAR needed)
+pyproject.toml
+README.md
+```
+
+---
+
+## Error handling
+
+```python
+from ReForma.jar_bridge import JarError
+
+try:
+    result = ReForma.check_pdl("Home", "{P=?[F Office]}")
+except JarError as e:
+    print(f"JAR error: {e}")
+except RuntimeError as e:
+    print(f"Usage error: {e}")   # e.g. no model loaded, invalid transition
+```

reforma-0.1.0/ReForma.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+MANIFEST.in
+README.md
+pyproject.toml
+ReForma.egg-info/PKG-INFO
+ReForma.egg-info/SOURCES.txt
+ReForma.egg-info/dependency_links.txt
+ReForma.egg-info/requires.txt
+ReForma.egg-info/top_level.txt
+tests/test_pyRe.py

reforma-0.1.0/ReForma.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

reforma-0.1.0/ReForma.egg-info/requires.txt

@@ -0,0 +1,2 @@
+networkx
+matplotlib

reforma-0.1.0/ReForma.egg-info/top_level.txt

@@ -0,0 +1 @@
+

reforma-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ReForma"
+version = "0.1.0"
+description = "Python bindings for the RePA/ReForma probabilistic automaton tool"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+    { name = "Joshua Dourado", email = "joshuadourado@ua.pt" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering",
+]
+dependencies = [
+    "networkx",
+    "matplotlib"
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["ReForma*"]
+
+[tool.setuptools.package-data]
+ReForma = ["bin/RePATool.jar"]

reforma-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

reforma-0.1.0/tests/test_pyRe.py

@@ -0,0 +1,285 @@
+"""
+tests/test_reforma.py — full test suite (mocked, no real JAR needed).
+"""
+
+import pytest
+from unittest.mock import MagicMock, patch
+
+from reforma import reforma
+
+from reforma.model import reformaModel, Transition, SimulationState
+from reforma.jar_bridge import JarBridge, JarError
+from reforma.client import _parse_pdl_result
+
+# ---------------------------------------------------------------------------
+SIMPLE_SOURCE = """\
+name Simple
+init Home
+Home ---> Office: go_work (0.5)
+Home ---> Station: go_charge (0.5)
+Office ---> Home: go_home (1.0)
+"""
+STEP_OUTPUT = """\
+Estado Atual: Home
+Transicoes Habilitadas:
+  - [go_work] de Home para Office (P=0.500)
+  - [go_charge] de Home para Station (P=0.500)
+"""
+STEP_OUTPUT_OFFICE = """\
+Estado Atual: Office
+Transicoes Habilitadas:
+  - [go_home] de Office para Home (P=1.000)
+"""
+
+
+def make_reforma(step_output: str = STEP_OUTPUT) -> reforma:
+    """reforma with a fully mocked JarBridge — no JAR or Java needed."""
+    with patch("reforma.client.JarBridge") as MockBridge:
+        instance = MockBridge.return_value
+        instance.list_transitions.return_value = step_output
+        reforma = reforma()          # no jar_path — uses bundled (mocked away)
+        reforma._bridge = instance
+        reforma.load(SIMPLE_SOURCE)
+    return reforma
+
+
+# ---------------------------------------------------------------------------
+# reformaModel
+# ---------------------------------------------------------------------------
+class TestreformaModel:
+    def test_from_string(self):
+        m = reformaModel.from_string("init s0\ns0 ---> s1: a", name="test")
+        assert m.name == "test"
+
+    def test_from_file(self, tmp_path):
+        p = tmp_path / "model.r"
+        p.write_text(SIMPLE_SOURCE)
+        m = reformaModel.from_file(str(p))
+        assert m.name == "model"
+        assert "Home" in m.source
+
+
+# ---------------------------------------------------------------------------
+# SimulationState
+# ---------------------------------------------------------------------------
+class TestSimulationState:
+    def test_transition_named_found(self):
+        t = Transition("Home", "Office", "go_work", "go_work", 0.5)
+        s = SimulationState(["Home"], [t], {}, False, None)
+        assert s.transition_named("go_work") is t
+
+    def test_transition_named_not_found(self):
+        s = SimulationState(["Home"], [], {}, False, None)
+        assert s.transition_named("missing") is None
+
+
+# ---------------------------------------------------------------------------
+# JarBridge — bundled JAR discovery
+# ---------------------------------------------------------------------------
+class TestJarBridge:
+    def test_explicit_missing_raises(self):
+        with pytest.raises(FileNotFoundError):
+            JarBridge("/nonexistent/RePATool.jar")
+
+    def test_no_bundled_jar_raises(self):
+        with patch("reforma.jar_bridge._bundled_jar_path", return_value=None):
+            with pytest.raises(FileNotFoundError, match="bundled"):
+                JarBridge()      # no explicit path, no bundled jar
+
+    def test_bundled_jar_used_when_present(self, tmp_path):
+        fake_jar = tmp_path / "RePATool.jar"
+        fake_jar.write_bytes(b"PK")   # minimal fake
+        with patch("reforma.jar_bridge._bundled_jar_path", return_value=fake_jar):
+            bridge = JarBridge()
+        assert bridge.jar_path == str(fake_jar)
+
+    def test_explicit_jar_overrides_bundled(self, tmp_path):
+        custom = tmp_path / "custom.jar"
+        custom.write_bytes(b"PK")
+        bridge = JarBridge(str(custom))
+        assert "custom" in bridge.jar_path
+
+    def test_run_nonzero_raises(self, tmp_path):
+        fake = tmp_path / "f.jar"
+        fake.write_bytes(b"")
+        bridge = JarBridge.__new__(JarBridge)
+        bridge.jar_path = str(fake)
+        bridge.java_bin = "java"
+        import subprocess
+        with patch("reforma.jar_bridge.subprocess.run") as mock_run:
+            mock_run.return_value = MagicMock(returncode=1, stdout="", stderr="err")
+            with pytest.raises(JarError):
+                bridge._run("-step", "x.r")
+
+
+# ---------------------------------------------------------------------------
+# reforma.bundled_jar()
+# ---------------------------------------------------------------------------
+class TestBundledJar:
+    def test_returns_none_when_absent(self):
+        with patch("reforma.jar_bridge._bundled_jar_path", return_value=None):
+            assert reforma.bundled_jar() is None
+
+    def test_returns_path_when_present(self, tmp_path):
+        fake = tmp_path / "RePATool.jar"
+        fake.write_bytes(b"PK")
+        with patch("reforma.jar_bridge._bundled_jar_path", return_value=fake):
+            assert reforma.bundled_jar() == str(fake)
+
+
+# ---------------------------------------------------------------------------
+# reforma high-level
+# ---------------------------------------------------------------------------
+class TestreformaLoad:
+    def test_load_parses_state(self):
+        reforma = make_reforma()
+        assert reforma.state.current_states == ["Home"]
+
+    def test_enabled_transitions(self):
+        reforma = make_reforma()
+        labels = {t.label for t in reforma.state.enabled}
+        assert {"go_work", "go_charge"} == labels
+
+    def test_probabilities(self):
+        reforma = make_reforma()
+        t = reforma.state.transition_named("go_work")
+        assert abs(t.probability - 0.5) < 1e-6
+
+    def test_no_model_raises(self):
+        with patch("reforma.client.JarBridge"):
+            reforma = reforma()
+        with pytest.raises(RuntimeError, match="No model loaded"):
+            reforma.step("x")
+
+
+class TestreformaSimulation:
+    def test_step_moves_state(self):
+        reforma = make_reforma()
+        reforma._bridge.list_transitions.return_value = STEP_OUTPUT_OFFICE
+        state = reforma.step("go_work")
+        assert state.current_states == ["Office"]
+
+    def test_step_invalid_raises(self):
+        reforma = make_reforma()
+        with pytest.raises(RuntimeError, match="not enabled"):
+            reforma.step("fly_to_moon")
+
+    def test_history_tracks_steps(self):
+        reforma = make_reforma()
+        reforma._bridge.list_transitions.return_value = STEP_OUTPUT_OFFICE
+        reforma.step("go_work")
+        assert reforma.history == ["go_work"]
+
+    def test_undo_pops_history(self):
+        reforma = make_reforma()
+        reforma._bridge.list_transitions.return_value = STEP_OUTPUT_OFFICE
+        reforma.step("go_work")
+        reforma._bridge.list_transitions.return_value = STEP_OUTPUT
+        reforma.undo()
+        assert reforma.history == []
+
+    def test_undo_empty_raises(self):
+        reforma = make_reforma()
+        with pytest.raises(RuntimeError, match="Nothing to undo"):
+            reforma.undo()
+
+    def test_reset_clears_history(self):
+        reforma = make_reforma()
+        reforma._bridge.list_transitions.return_value = STEP_OUTPUT_OFFICE
+        reforma.step("go_work")
+        reforma.reset()
+        assert reforma.history == []
+
+
+class TestreformaTraining:
+    def test_train_updates_source(self):
+        reforma = make_reforma()
+        updated = SIMPLE_SOURCE.replace("(0.5)", "(0.7)")
+        reforma._bridge.train.return_value = updated
+        reforma._bridge.list_transitions.return_value = STEP_OUTPUT
+        reforma.train([["go_work", "go_home"]])
+        assert "(0.7)" in reforma.source
+
+    def test_train_resets_history(self):
+        reforma = make_reforma()
+        reforma._bridge.list_transitions.return_value = STEP_OUTPUT_OFFICE
+        reforma.step("go_work")
+        reforma._bridge.train.return_value = SIMPLE_SOURCE
+        reforma._bridge.list_transitions.return_value = STEP_OUTPUT
+        reforma.train([["go_work"]])
+        assert reforma.history == []
+
+    def test_train_from_file(self, tmp_path):
+        log = tmp_path / "log.txt"
+        log.write_text("go_work,go_home\ngo_charge\n")
+        reforma = make_reforma()
+        reforma._bridge.train.return_value = SIMPLE_SOURCE
+        reforma._bridge.list_transitions.return_value = STEP_OUTPUT
+        reforma.train_from_file(str(log))
+        assert reforma._bridge.train.call_args[0][1] == ["go_work,go_home", "go_charge"]
+
+
+class TestreformaVerification:
+    def test_check_pdl_string(self):
+        reforma = make_reforma()
+        reforma._bridge.check_pdl.return_value = "Result: 0.50000"
+        assert "0.50000" in reforma.check_pdl("Home", "{P=?[F Office]}")
+
+    def test_check_pdl_value_float(self):
+        reforma = make_reforma()
+        reforma._bridge.check_pdl.return_value = "Result: 0.75000"
+        assert abs(reforma.check_pdl_value("Home", "{P=?[F Office]}") - 0.75) < 1e-6
+
+    def test_check_pdl_true(self):
+        reforma = make_reforma()
+        reforma._bridge.check_pdl.return_value = "Result: true"
+        assert reforma.check_pdl_value("Home", "<go_work>Office") is True
+
+    def test_check_pdl_false(self):
+        reforma = make_reforma()
+        reforma._bridge.check_pdl.return_value = "Result: false"
+        assert reforma.check_pdl_value("Home", "[]false") is False
+
+
+class TestreformaExport:
+    def test_export_prism(self):
+        reforma = make_reforma()
+        reforma._bridge.get_prism.return_value = "dtmc\n..."
+        assert reforma.export_prism().startswith("dtmc")
+
+    def test_export_mcrl2(self):
+        reforma = make_reforma()
+        reforma._bridge.get_mcrl2.return_value = "act\n..."
+        assert reforma.export_mcrl2().startswith("act")
+
+    def test_export_glts(self):
+        reforma = make_reforma()
+        reforma._bridge.get_glts.return_value = "int go_work_active = 1"
+        assert "go_work_active" in reforma.export_glts()
+
+    def test_save_prism(self, tmp_path):
+        reforma = make_reforma()
+        reforma._bridge.get_prism.return_value = "dtmc\n..."
+        out = tmp_path / "model.pm"
+        reforma.save_prism(str(out))
+        assert out.read_text().startswith("dtmc")
+
+    def test_save_source(self, tmp_path):
+        reforma = make_reforma()
+        out = tmp_path / "out.r"
+        reforma.save_source(str(out))
+        assert "Home" in out.read_text()
+
+
+class TestParsePdlResult:
+    def test_float(self):
+        assert abs(_parse_pdl_result("Result: 0.33333") - 0.33333) < 1e-4
+
+    def test_true(self):
+        assert _parse_pdl_result("Result: true") is True
+
+    def test_false(self):
+        assert _parse_pdl_result("Result: false") is False
+
+    def test_unparseable(self):
+        assert isinstance(_parse_pdl_result("Deadlock found"), str)