openprocess 0.16.0__tar.gz → 0.16.2__tar.gz

{openprocess-0.16.0/openprocess.egg-info → openprocess-0.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openprocess
-Version: 0.16.0
+Version: 0.16.2
 Summary: Process mining, Petri nets and workflows in one open app: every algorithm visible, every result reproducible, every step teachable
 Author: Sam Struthers
 License: MIT
@@ -742,6 +742,9 @@ course).
 
 ## For developers
 
+Want to report a wrong result, add an algorithm or fix something? See
+[**CONTRIBUTING.md**](CONTRIBUTING.md).
+
 ```bash
 pytest -q                 # the whole suite, including GUI tests that run offscreen
 openprocess --help              # command line: check, simulate, state space, mining
@@ -1089,7 +1092,10 @@ Plainly stated:
    each use its own copy of the page. Subpages used once, at any depth,
    simulate.
 2. **No CPN monitors or simulation reports**, and **no fairness
-   properties** in the state space report (it says so).
+   properties** in the state space report (it says so). **Transition
+   priorities and code segments are kept but not run**: a model that uses
+   them simulates differently from CPN Tools, and the Problems tab and the
+   state space report list where.
 3. **CPN ML is a large subset, not all of Standard ML**: no `exception`
    declarations or `handle`, no `datatype` or `structure` declarations, and
    characters are one-letter strings. See

{openprocess-0.16.0 → openprocess-0.16.2}/README.md

@@ -700,6 +700,9 @@ course).
 
 ## For developers
 
+Want to report a wrong result, add an algorithm or fix something? See
+[**CONTRIBUTING.md**](CONTRIBUTING.md).
+
 ```bash
 pytest -q                 # the whole suite, including GUI tests that run offscreen
 openprocess --help              # command line: check, simulate, state space, mining
@@ -1047,7 +1050,10 @@ Plainly stated:
    each use its own copy of the page. Subpages used once, at any depth,
    simulate.
 2. **No CPN monitors or simulation reports**, and **no fairness
-   properties** in the state space report (it says so).
+   properties** in the state space report (it says so). **Transition
+   priorities and code segments are kept but not run**: a model that uses
+   them simulates differently from CPN Tools, and the Problems tab and the
+   state space report list where.
 3. **CPN ML is a large subset, not all of Standard ML**: no `exception`
    declarations or `handle`, no `datatype` or `structure` declarations, and
    characters are one-letter strings. See

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/__init__.py

@@ -48,7 +48,7 @@ from .sim.simulator import Simulator
 #: The one place the version number is written (pyproject.toml, the update
 #: check and packaging/build.py read it from here).  A release is tagged
 #: "v" + this, e.g. v0.2.0.
-__version__ = "0.16.0"
+__version__ = "0.16.2"
 
 __all__ = [
     "Arc", "BindingElement", "CPNet", "Marking", "Multiset", "Page", "Place",

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/analysis/state_space.py

@@ -451,6 +451,13 @@ class StateSpace:
         if self.partial:
             add("  WARNING: the properties below describe only the explored")
             add("           fragment and are not proofs about the whole model.")
+        ignored = getattr(self.net, "warnings", [])
+        if ignored:
+            add(f"  WARNING: {len(ignored)} transition priorities or code segments are not")
+            add("           implemented and were not used: this state space can differ")
+            add("           from the one CPN Tools computes.")
+            for issue in ignored[:max_listed]:
+                add(f"             {issue.element_name or issue.element_id} ({issue.field_name})")
         add("")
 
         add("Boundedness Properties")

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/flow/boxes/check.py

@@ -48,6 +48,12 @@ def check_fit(model: PetriNet, log: EventLog,
     scores = Scores(model.name, {"fitness": fitness, "precision": precision(model, simple),
                                  "generalisation": generalisation(replay), "simplicity": simplicity(model)})
     scores.note = f"Checked against all {replay.trace_count} cases of {log.name} ({method.lower()})."
+    if replay.unknown_events:
+        missing = ", ".join(f"{a} ({n:,})" for a, n in replay.unknown_totals().most_common(5))
+        text = (f"{replay.unknown_events:,} events are of activities the model does not have: {missing}"
+                f"{', …' if len(replay.unknown_totals()) > 5 else ''}.")
+        flow.note(text + " In token replay each counts one missing and one remaining token.")
+        scores.note += " " + text
     if method == "Alignments" and alignments.incomplete:
         cases = sum(a.count for a in alignments.incomplete)
         scores.note += (f" No optimal alignment was found for {len(alignments.incomplete)} variants "

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/flow/derivation.py

@@ -94,7 +94,8 @@ def value_markdown(value: Any, limit: int = 50) -> str:
                 + _md_table(["Variant", "Cases", "p", "c", "m", "r"], rows))
     if isinstance(value, AlignmentResult):
         rows = [[f"⟨{', '.join(a.trace)}⟩", a.count, a.cost, f"{a.fitness:.3f}"] for a in value.alignments[:limit]]
-        return (f"Fitness {value.average_fitness:.4f}; {value.fitting_traces:,} of {value.trace_count:,} cases "
+        return (f"Fitness {'' if value.exact else 'at least '}{value.average_fitness:.4f}; "
+                f"{value.fitting_traces:,} of {value.trace_count:,} cases "
                 f"align without a deviation\n\n" + _md_table(["Variant", "Cases", "Cost", "Fitness"], rows))
     if isinstance(value, OCEL):
         return value.summary()

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/flow/figures.py

@@ -49,7 +49,7 @@ def tile_parts(value) -> tuple[str, str] | None:
     if isinstance(value, ReplayResult):
         return f"{value.fitness:.2f} fitness", f"{value.fitting_traces:,} of {value.trace_count:,} cases fit"
     if isinstance(value, AlignmentResult):
-        return (f"{value.average_fitness:.2f} fitness",
+        return (f"{'' if value.exact else '≥ '}{value.average_fitness:.2f} fitness",
                 f"{value.fitting_traces:,} of {value.trace_count:,} cases align")
     if isinstance(value, Text):
         first = str(value).strip().splitlines()[0] if str(value).strip() else ""

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/gui/flow/report.py

@@ -293,8 +293,14 @@ class Section(QFrame):
         if result is not None and result.status == DONE:
             parts = key_figure(result.value)
             if parts is not None:
-                tile = StatTile("Key figure", *parts)
-                tile.setMaximumWidth(320)
+                figure, line = parts
+                if len(line) > 72:
+                    line = line[:71].rstrip() + "…"
+                tile = StatTile("Key figure", figure, line)
+                # One line each, the tile as wide as they need: a wrapped line in a
+                # tile of fixed height was drawn over the figure above it.
+                tile.value.setWordWrap(False)
+                tile.sub.setWordWrap(False)
                 self.body_layout.addWidget(tile, 0, Qt.AlignLeft)
         self.body_widget = page.result_view(node, result)
         self.body_layout.addWidget(self.body_widget)

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/gui/flow/viewers.py

@@ -362,6 +362,10 @@ def result_widget(value, page=None, node=None) -> QWidget:
         add(label(f"Fitness {value.fitness:.4f}: p = {value.produced}, c = {value.consumed}, "
                   f"m = {value.missing}, r = {value.remaining}; {value.fitting_traces} of "
                   f"{value.trace_count} cases fit.", "muted", wrap=True))
+        if value.unknown_events:
+            add(label(f"{value.unknown_events:,} events are of activities the model does not have ("
+                      + ", ".join(f"{a}: {n:,}" for a, n in value.unknown_totals().most_common(8))
+                      + "). Each counts one missing and one remaining token.", "muted", wrap=True))
     elif isinstance(value, AlignmentResult):
         from ..studio.alignment_view import AlignmentList, legend_items, projection
         from ..studio.widgets import Legend, LegendSwatch

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/gui/learn/answer_boxes.py

@@ -42,9 +42,13 @@ CAPTIONS = {
 }
 
 #: Status of a task -> (chip text, status colour key).
+#: The answer was shown before it was given: right now, but it does not count.
+SHOWN = "shown"
+
 STATUS = {
     CORRECT: ("Correct", "good"), PARTIAL: ("Almost", "warning"),
     INCORRECT: ("Not yet", "critical"), "done": ("Done", "good"),
+    SHOWN: ("Answer shown", "muted"),
 }
 
 
@@ -771,6 +775,9 @@ class TaskCard(QFrame):
         self.status: str | None = None
         #: The share of the block's points the last check gave (for partial answers).
         self.share: float = 0.0
+        #: *Show answer* was pressed before the answer was right: a right answer
+        #: after that is the shown one typed in, so it is not marked Correct.
+        self.revealed: bool = False
         #: In an exam there is no hint, no answer, and Check only says if it is right.
         self.exam = exam
         layout = QVBoxLayout(self)
@@ -838,7 +845,7 @@ class TaskCard(QFrame):
     # -- feedback ------------------------------------------------------------------------
     def _edited(self) -> None:
         # Feedback is about the answer as it was: it goes when you change it.
-        if self.status in (CORRECT, PARTIAL, INCORRECT) or not self.feedback.isHidden():
+        if self.status in (CORRECT, PARTIAL, INCORRECT, SHOWN) or not self.feedback.isHidden():
             self.set_status(None)
             self.feedback.setHidden(True)
             self._clear_detail()
@@ -876,8 +883,12 @@ class TaskCard(QFrame):
         status = result.status
         self.share = float(getattr(result, "share", 0.0) or 0.0)
         icon = {CORRECT: "✓", PARTIAL: "◐", INCORRECT: "✕"}.get(status, "")
-        self.feedback.setText(f"<b>{icon}</b>&nbsp; {escape(result.message)}" if icon
-                              else escape(result.message))
+        message = escape(result.message)
+        if self.revealed and status in (CORRECT, PARTIAL):
+            # Still told whether it is right, but it earns nothing and is not "done".
+            status, self.share = SHOWN, 0.0
+            message += " <i>The answer was shown first, so this does not count.</i>"
+        self.feedback.setText(f"<b>{icon}</b>&nbsp; {message}" if icon else message)
         self.feedback.setProperty("state", STATUS.get(status, ("", ""))[1])
         self._repolish(self.feedback)
         self.feedback.setHidden(False)
@@ -912,8 +923,17 @@ class TaskCard(QFrame):
         self.solution_label.body.set_markdown(text)
         self.solution_label.setHidden(False)
         self.answer_button.setHidden(True)
-        if self.task.type == "open" and self.status != "done":
-            self.assess_row.setHidden(False)
+        if self.task.type == "open":
+            if self.status != "done":
+                self.assess_row.setHidden(False)
+        elif self.status not in (CORRECT, "done") and not self.revealed:
+            # An answer that was already right stays right; anything else was not
+            # answered before the answer was seen.  (An open answer is judged by
+            # yourself against the model answer, so showing it is the point.)
+            self.revealed = True
+            if self.status == PARTIAL:
+                self.set_status(None)
+            self.changed.emit(self.task)
 
     def assess(self, had_it: bool) -> None:
         self.assess_row.setHidden(True)

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/gui/learn/mode.py

@@ -59,7 +59,7 @@ from ...learn.checks import check as check_answer
 from ...learn.checks import expected, footprint_of, model_answer_text
 from ...learn.exam import ExamState, marks_csv
 from ...learn.pack import Exercise, Pack, load_pack
-from .answer_boxes import TaskCard, debounce, make_editor
+from .answer_boxes import SHOWN, TaskCard, debounce, make_editor
 from .concealment import Concealment
 from ..studio.markdown_view import MarkdownLabel
 from ..studio.widgets import SegmentedControl, button, hbox, label, scroll
@@ -802,7 +802,7 @@ class ExerciseView(QWidget):
             self._workflow_timer = debounce(self, WORKFLOW_SAVE_DELAY, self._save_workflow)
         self._workflow_timer.start()
         card = self.cards.get(task.id)
-        if card is not None and card.status in (CORRECT, PARTIAL, INCORRECT):
+        if card is not None and card.status in (CORRECT, PARTIAL, INCORRECT, SHOWN):
             card.editor.changed.emit()             # the old verdict no longer applies
 
     def _workflow_saved(self, task) -> None:
@@ -839,7 +839,7 @@ class ExerciseView(QWidget):
             self._net_timers[task.id] = timer
         timer.start()
         card = self.cards.get(task.id)
-        if card is not None and card.status in (CORRECT, PARTIAL, INCORRECT):
+        if card is not None and card.status in (CORRECT, PARTIAL, INCORRECT, SHOWN):
             card.editor.changed.emit()             # the old verdict no longer applies
 
     def _save_net(self, page, target: Path) -> None:
@@ -1004,6 +1004,7 @@ class ExerciseView(QWidget):
         saved = self.progress.get(card.task.id, {})
         if card.task.type not in ("net", "workflow") and "answer" in saved:
             card.editor.set_value(saved["answer"])
+        card.revealed = bool(saved.get("shown"))
         status = saved.get("status")
         if status:
             card.set_status(status)
@@ -1018,6 +1019,10 @@ class ExerciseView(QWidget):
             entry["status"] = card.status
         else:
             entry.pop("status", None)
+        if card.revealed:
+            entry["shown"] = True
+        else:
+            entry.pop("shown", None)
         if card.status == PARTIAL and card.share:
             entry["share"] = round(card.share, 4)
         else:

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/gui/studio/app.py

@@ -4261,6 +4261,16 @@ class StudioWindow(QMainWindow):
             self.statusBar().showMessage(message, 8000)
 
         try:
+            if isinstance(document, WorkflowDocument):
+                # Changed by Claude (through the MCP server) or another copy of the
+                # app: the boxes, versions and record are all read again.
+                from ...flow.record import load_all
+                document.workflow, document.record, document.versions = load_all(path, self.library())
+                document.dirty = False
+                self._remember_identity(document)
+                self._replace_page(document)
+                self.statusBar().showMessage(message, 8000)
+                return
             if isinstance(document, TransitionSystemDocument):
                 content = self._read_text_file(path)
                 document.ts = content.ts

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/gui/studio/cpn_page.py

@@ -823,7 +823,11 @@ class CpnPage(QWidget):
     def _update_sim_status(self) -> None:
         if not self.simulating:
             problems = len(self.net.errors)
-            self.sim_status.setText("✓ compiles" if not problems else
+            ignored = len(self.net.warnings)
+            self.sim_status.setText((f"⚠ compiles, but {ignored} priorit"
+                                     f"{'y or code segment is' if ignored == 1 else 'ies or code segments are'}"
+                                     " not used — see the Problems tab" if ignored else "✓ compiles")
+                                    if not problems else
                                     f"⚠ {problems} problem{'s' * (problems != 1)} — see "
                                     "the Problems tab")
             return
@@ -909,18 +913,19 @@ class CpnPage(QWidget):
 
     def _fill_problems(self) -> None:
         errors = list(self.net.errors)
-        count = len(errors)
+        warnings = list(self.net.warnings)
+        count = len(errors) + len(warnings)
         self.inspector_tabs.buttons[2].setText(f"Problems ({count})" if count else "Problems")
         card = self.problems_card
         card.clear()
         if not errors:
             card.add(Verdict("Model compiles", "good", "Every declaration and inscription "
                              "parsed. The model is ready to simulate."))
-            return
-        for issue in errors[:200]:
+        for issue in (errors + warnings)[:200]:
             row = QWidget()
             title = f"{issue.element_name or 'Declarations'} — {issue.field_name}"
-            layout = hbox(Verdict(title, "critical", issue.message), spacing=6)
+            layout = hbox(Verdict(title, "critical" if issue in errors else "warning",
+                                  issue.message), spacing=6)
             if issue.element_id:
                 layout.addWidget(button("Show", lambda _=False, i=issue.element_id:
                                         self.reveal_element(i), kind="ghost"), 0, Qt.AlignTop)

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/gui/studio/dotted_chart.py

@@ -73,6 +73,7 @@ SHAPES = ["circle", "square", "triangle", "diamond", "cross", "star"]
 #: log stays a picture of milliseconds, not seconds.  Shapes, rings and the
 #: lines between a case's events come back as soon as a zoom shows fewer.
 BATCH_FROM = 40_000
+STACK_ALPHA = 0.72        # opacity of a dot; a stack of dots shows darker
 #: Above this many events the dots are worked out on a worker thread.
 BACKGROUND_FROM = 200_000
 #: When drawing the picture took longer than this, a pan or zoom first shows
@@ -381,6 +382,15 @@ class DottedChart(QWidget):
             painter.end()
         return pixmap
 
+    def dot_radius(self, rect: QRectF) -> float:
+        """The radius a dot is drawn with: the size the rows allow (4 px
+        when they are tall, down to 1.6 px when a row is a hairline), scaled
+        by the Dot size setting (4 is 1×), so the slider always does
+        something and a dense chart stays readable."""
+        row_h = rect.height() / max(self.vy1 - self.vy0, 1e-9)
+        fitting = max(1.6, min(4.0, row_h * 0.45))
+        return max(1.0, fitting * self.data.settings.dot_size / 4.0)
+
     def _visible(self, candidates: np.ndarray) -> np.ndarray:
         """The dots of ``candidates`` (dots in the x window) that are in the
         row window and whose colour the legend shows."""
@@ -402,12 +412,7 @@ class DottedChart(QWidget):
         rect = self.plot_rect()
         self._paint_axes(painter, rect, t, s.grid_lines)
 
-        row_h = rect.height() / max(self.vy1 - self.vy0, 1e-9)
-        # The dot size the rows allow (4 px when they are tall, down to 1.6 px
-        # when a row is a hairline), scaled by the Dot size setting (4 is 1×):
-        # the slider always does something, and a dense chart stays readable.
-        fitting = max(1.6, min(4.0, row_h * 0.45))
-        radius = max(1.0, fitting * s.dot_size / 4.0)
+        radius = self.dot_radius(rect)
         # A ring in the surface colour sets a dot apart from its neighbours;
         # drawn on every dot it erases overlapping ones into slivers, so it is
         # kept for the selected case alone, which sits on top.
@@ -423,6 +428,13 @@ class DottedChart(QWidget):
             self._paint_dense(painter, rect, colours, faded, radius, visible)
             on_top = visible[d.case[visible] == selected] if selected >= 0 else []
         else:
+            if selected < 0:
+                # Dots a little translucent, so a stack of events drawn on
+                # the same spot shows darker than a single one.  The dense
+                # picture sets each pixel once, so it stays opaque; the
+                # selected case is opaque to stand out.
+                for colour in colours:
+                    colour.setAlphaF(STACK_ALPHA)
             if s.connect:
                 self._paint_connections(painter, rect, visible, t)
             # Unselected first, the selected case last so it sits on top.
@@ -634,6 +646,16 @@ class DottedChart(QWidget):
         nearest = int(distance.argmin())
         return int(near[nearest]) if distance[nearest] <= tolerance else None
 
+    def stacked_with(self, i: int) -> np.ndarray:
+        """The shown dots drawn over dot ``i``: those on its row whose centre
+        is within a dot's width of it on screen, ``i`` itself first."""
+        d = self.data
+        rect = self.plot_rect()
+        reach = 2 * self.dot_radius(rect) / rect.width() * (self.vx1 - self.vx0)
+        near = d.between(d.xs[i] - reach, d.xs[i] + reach)
+        near = near[(d.rows[near] == d.rows[i]) & d.shown(self.hidden_colours)[d.colour[near]]]
+        return np.concatenate(([i], near[near != i]))
+
     def describe_dot(self, i: int) -> str:
         d = self.data
         event = d.event(i)
@@ -646,6 +668,19 @@ class DottedChart(QWidget):
             if key not in ("concept:name", "time:timestamp"):
                 text = str(value)
                 lines.append(f"{key}: {text[:60] + '…' if len(text) > 60 else text}")
+        stack = self.stacked_with(i)
+        if len(stack) > 1:
+            # A pile of dots looks like one: say how many, and over what span.
+            cases = len(set(d.case[stack].tolist()))
+            text = f"<i>{len(stack) - 1} more event{'s' if len(stack) > 2 else ''} under this dot"
+            if cases > 1:
+                text += f" ({cases} cases)"
+            stamps = [d.event(int(j)).timestamp for j in stack]
+            if all(stamps):
+                first, last = min(stamps), max(stamps)
+                if last > first:
+                    text += f", spanning {format_duration((last - first).total_seconds())}"
+            lines.append(text + ". Drag to zoom in.</i>")
         return "<br>".join(lines)
 
     # -- interaction ------------------------------------------------------------------

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/gui/studio/instances.py

@@ -237,6 +237,8 @@ def properties(props: PropertyReport, key: str) -> list[str]:
             m = marking(net, graph.states[state])
             return [f"{m0} {firing(net, graph.path_to(state))} {m}",
                     f"\\forall t \\in T \\colon t \\text{{ is not enabled in }} {m}"]
+        if props.deadlock_free is None:
+            return ["\\text{not decided: the state space is unbounded or too large}"]
         return [f"\\forall M \\in {reach} \\; \\exists t \\in T \\colon t "
                 "\\text{ enabled in } M"]
     if key == "dead_transition":

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/gui/studio/model_page.py

@@ -627,7 +627,9 @@ class ModelPage(ConcealsResults, QWidget):
                                f"log-level {alignments.log_fitness:.3f}")
             tiles["tbr"].set(f"{replay.fitness:.3f}",
                              f"m {replay.missing:,} · r {replay.remaining:,} · "
-                             f"c {replay.consumed:,} · p {replay.produced:,}")
+                             f"c {replay.consumed:,} · p {replay.produced:,}"
+                             + (f" · {replay.unknown_events:,} events not in the model"
+                                if replay.unknown_events else ""))
             tiles["precision"].set(f"{prec:.3f}", "escaping edges (ETC)")
             tiles["generalisation"].set(f"{gen:.3f}", "token-based")
             tiles["simplicity"].set(f"{simp:.3f}", "arc degree")

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/mcp/api.py

@@ -1020,6 +1020,7 @@ def cpn_info(path: str) -> dict:
     compile problems."""
     net = _cpn(path)
     return {"name": net.name, "problems": [str(e) for e in net.errors],
+            "not_implemented": [str(w) for w in net.warnings],
             "pages": [{"name": p.name, "places": len(p.places), "transitions": len(p.transitions),
                        "arcs": len(p.arcs)} for p in net.pages],
             "colour_sets": {n: type(c).__name__ for n, c in sorted(net.declarations.colour_sets.items())},
@@ -1041,6 +1042,7 @@ def cpn_simulate(path: str, steps: int = 50, seed: int = 0) -> dict:
     return {"steps": taken, "asked": steps, "clock": simulator.clock, "dead": taken < steps,
             "log": [record.describe(net) for record in simulator.log][-200:],
             "final_marking": simulator.marking.describe(net),
+            "not_implemented": [str(w) for w in net.warnings],
             "cite": citations("openprocess.sim"),
             "reproduce": f"openprocess simulate {_q(path)} --steps {steps} --seed {seed}"}
 

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/mining/analysis.py

@@ -338,8 +338,18 @@ class PropertyReport:
         return self.bounded and self.bound <= 1
 
     @property
-    def deadlock_free(self) -> bool:
-        return not self.dead_markings
+    def deadlock_free(self) -> bool | None:
+        """False with a dead marking in hand (in a coverability graph too: a
+        dead node stands for reachable markings in which nothing is enabled).
+        None when no dead marking was found but the search cannot prove there
+        is none: a coverability graph's ω enables what a finite marking may
+        not, so it can hide a deadlock, and a truncated graph has unexplored
+        markings."""
+        if self.dead_markings:
+            return False
+        if self.graph.has_omega or self.graph.truncated:
+            return None
+        return True
 
     @property
     def terminating(self) -> bool | None:
@@ -375,8 +385,12 @@ class PropertyReport:
                      else "some run can go on forever"
                      + (" (the net is unbounded)" if self.graph.has_omega
                         else ": the reachability graph has a cycle")))
-        rows.append(("Deadlock-free", self.deadlock_free,
-                     "every reachable marking enables something" if self.deadlock_free
+        deadlock_free = self.deadlock_free
+        rows.append(("Deadlock-free", deadlock_free,
+                     "every reachable marking enables something" if deadlock_free
+                     else ("not decided: the net is unbounded, and the coverability graph can "
+                           "hide a deadlock" if self.graph.has_omega
+                           else "not decided (truncated state space)") if deadlock_free is None
                      else f"{len(self.dead_markings)} dead marking(s), e.g. "
                      + self.graph.states[self.dead_markings[0]].describe(net)
                      + " via " + self.graph.describe_path(self.dead_markings[0])))
@@ -672,7 +686,7 @@ class ShortCircuitReport:
         return self.properties.safe
 
     @property
-    def deadlock_free(self) -> bool:
+    def deadlock_free(self) -> bool | None:
         return self.properties.deadlock_free
 
     @property

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/mining/conformance/alignments.py

@@ -119,6 +119,15 @@ class AlignmentResult:
     empty_trace_cost: int = 0
     #: What the reader should know: searches that were cut short, and why.
     notes: list[str] = field(default_factory=list)
+    #: False when the search for the model's shortest run gave up: the
+    #: empty-trace cost is then unknown (counted as 0), which makes every
+    #: fitness a lower bound.  (Named as a working value so that a result's
+    #: fingerprint is what it was; ``notes`` says so when it is False.)
+    _empty_trace_complete: bool = True
+
+    @property
+    def empty_trace_complete(self) -> bool:
+        return self._empty_trace_complete
 
     @property
     def trace_count(self) -> int:
@@ -129,16 +138,25 @@ class AlignmentResult:
         """The variants whose optimal alignment was not found (state limit)."""
         return [a for a in self.alignments if not a.complete]
 
+    @property
+    def exact(self) -> bool:
+        """Was an optimal alignment found for every variant and for the empty
+        trace?  If not, the fitness values are lower bounds, not the fitness."""
+        return self.empty_trace_complete and not self.incomplete
+
     @property
     def average_fitness(self) -> float:
-        """Mean of the per-trace fitness values (weighted by frequency)."""
+        """Mean of the per-trace fitness values (weighted by frequency).  A
+        variant whose search gave up counts as 0: a lower bound (see :attr:`exact`)."""
         total = self.trace_count
         return sum(a.fitness * a.count for a in self.alignments) / total if total else 1.0
 
     @property
     def log_fitness(self) -> float:
-        """1 − total cost / total worst-case cost."""
-        cost = sum(a.cost * a.count for a in self.alignments)
+        """1 − total cost / total worst-case cost.  A variant whose search gave
+        up counts its worst case, as it counts 0 in :attr:`average_fitness`."""
+        cost = sum((a.cost if a.complete else len(a.trace) + self.empty_trace_cost) * a.count
+                   for a in self.alignments)
         worst = sum((len(a.trace) + self.empty_trace_cost) * a.count for a in self.alignments)
         return 1 - cost / worst if worst else 1.0
 
@@ -307,7 +325,7 @@ def align_log(net: PetriNet, log: SimpleLog, max_states: int = MAX_STATES,
     from .. import parallel
     compiled = _CompiledNet(net)
     empty = align_trace(net, (), 1, max_states, compiled)
-    result = AlignmentResult(net, empty_trace_cost=empty.cost)
+    result = AlignmentResult(net, empty_trace_cost=empty.cost, _empty_trace_complete=empty.complete)
     variants = sorted(log.items(), key=lambda item: (-item[1], item[0]))
     count = parallel.workers() if workers is None else workers
     if parallel.worth_it(variants, count, "align"):
@@ -318,7 +336,9 @@ def align_log(net: PetriNet, log: SimpleLog, max_states: int = MAX_STATES,
         alignment = searched[number - 1] if searched is not None else align_trace(net, trace, count, max_states,
                                                                                    compiled)
         worst = len(trace) + empty.cost
-        alignment.fitness = 1 - alignment.cost / worst if worst else 1.0
+        # max: with the empty-trace cost unknown (counted as 0) the worst case is
+        # too small, and the value must stay a lower bound of the fitness.
+        alignment.fitness = max(0.0, 1 - alignment.cost / worst) if worst else 1.0
         if not alignment.complete:
             alignment.fitness = 0.0
         result.alignments.append(alignment)
@@ -340,7 +360,9 @@ def align_log(net: PetriNet, log: SimpleLog, max_states: int = MAX_STATES,
             f"variants ({cases:,} cases): the search stopped at {max_states:,} states. Their "
             f"cost is unknown and their fitness is counted as 0."
             if result.incomplete else
-            f"The search for the model's shortest run stopped at {max_states:,} states.")
+            f"The search for the model's shortest run stopped at {max_states:,} states, so the "
+            f"worst-case cost every fitness is measured against is too small: each fitness "
+            f"is a lower bound.")
         reason = _unbounded_reason(net)
         if reason:
             result.notes.append(reason)

{openprocess-0.16.0 → openprocess-0.16.2}/openprocess/mining/conformance/token_replay.py

@@ -34,6 +34,19 @@ through silent moves, then the one missing the fewest tokens.  These are
 heuristics -- token replay is fast but not always optimal, which is why
 alignments exist (see :mod:`alignments`).
 
+Activities the model does not have
+----------------------------------
+The book replays logs whose activities all occur in the model.  A real log
+often has more.  Skipping such an event would count it as if it fitted (a
+trace of nothing but unknown activities would score 1), so it is counted as
+what it is, something the log did that the model cannot do: the event is
+replayed as a transition of its own with one input and one output place that
+nothing else touches.  Its input token is missing and its output token
+remains, so each such event adds 1 to each of p, c, m and r.  This is
+OpenProcess's convention, not a published one; ``unknown_events`` on the
+result says how many events it applied to, and the tokens are counted under
+the activity (they belong to no place of the model).
+
 Diagnostics
 -----------
 Per place we keep the total missing and remaining tokens, and per transition
@@ -59,7 +72,9 @@ class TraceReplay:
     consumed: int
     missing: int
     remaining: int
-    #: activities that do not occur in the model at all
+    #: the activity of every event the model has no transition for, in trace
+    #: order; each counts one missing and one remaining token (see the module's
+    #: "Activities the model does not have")
     unknown_activities: list[str] = field(default_factory=list)
     #: indices of events whose transition was not enabled
     problem_events: list[int] = field(default_factory=list)
@@ -120,6 +135,19 @@ class ReplayResult:
     def trace_count(self) -> int:
         return sum(t.count for t in self.traces)
 
+    @property
+    def unknown_events(self) -> int:
+        """Events whose activity the model does not have, frequency-weighted."""
+        return sum(len(t.unknown_activities) * t.count for t in self.traces)
+
+    def unknown_totals(self) -> Counter:
+        """Those events per activity, frequency-weighted."""
+        totals: Counter = Counter()
+        for t in self.traces:
+            for activity in t.unknown_activities:
+                totals[activity] += t.count
+        return totals
+
     def place_totals(self) -> tuple[Counter, Counter]:
         """(missing, remaining) per place, frequency-weighted."""
         missing, remaining = Counter(), Counter()
@@ -368,11 +396,17 @@ def replay_trace(net: PetriNet, trace: tuple[str, ...], count: int = 1,
         result.fired[transition] += 1
         return current - pre + post
 
+    unknown_remaining = 0
     for index, activity in enumerate(trace):
         candidates = by_label.get(activity)
         if not candidates:
+            # No transition for it: one token missing to do it, one left behind.
             result.unknown_activities.append(activity)
             result.problem_events.append(index)
+            result.produced += 1
+            result.consumed += 1
+            result.missing += 1
+            unknown_remaining += 1
             continue
         chosen: str | None = next((t for t in candidates if net.is_enabled(marking, t)), None)
         if chosen is None:
@@ -408,7 +442,7 @@ def replay_trace(net: PetriNet, trace: tuple[str, ...], count: int = 1,
         marking = marking + short
     result.consumed += final.total
     leftover = marking - final
-    result.remaining = leftover.total
+    result.remaining = leftover.total + unknown_remaining
     result.remaining_by_place.update(dict(leftover.items()))
     return result