openprocess 0.7.0__py3-none-any.whl

openprocess/mining/dfg.py

@@ -0,0 +1,187 @@
+"""Directly-follows graphs (DFGs) -- the "process map" of tools like Disco.
+
+Definition
+----------
+Activity ``b`` *directly follows* ``a`` in a log, written ``a >_L b``, iff
+some trace contains ``a`` immediately followed by ``b``.  The DFG has one
+node per activity and an edge ``a -> b`` weighted by *how often* that
+happened, plus two artificial nodes ▶ (start) and ■ (end) with edges to the
+first and from the last activity of every trace.
+
+A DFG is not a Petri net: it has no concurrency, and every path through it is
+allowed, so it usually *overgeneralises* (reading: Leemans, Poppe & Wynn,
+"Directly-follows-based process mining").  It is nonetheless the most useful
+first look at a log, and the Inductive Miner family works directly on it.
+
+Performance
+-----------
+When events carry timestamps, each edge also records the time elapsed between
+``a`` and the ``b`` that directly followed it.  Mean and median are shown in
+performance mode.
+
+Simplification
+--------------
+Real logs produce "spaghetti".  :meth:`DFG.simplified` keeps a fraction of
+the activities (most frequent first) and a fraction of the edges, while
+guaranteeing that every kept activity stays connected: each keeps its most
+frequent incoming and outgoing edge.  This is the same idea as Disco's two
+sliders.
+"""
+
+from __future__ import annotations
+
+import statistics
+from collections import Counter, defaultdict
+from dataclasses import dataclass, field
+
+from .log import Classifier, EventLog, SimpleLog
+
+START = "▶"
+END = "■"
+
+
+@dataclass
+class DFG:
+    activities: Counter = field(default_factory=Counter)       # activity -> events
+    edges: Counter = field(default_factory=Counter)            # (a, b) -> count
+    start: Counter = field(default_factory=Counter)            # activity -> traces
+    end: Counter = field(default_factory=Counter)
+    durations: dict[tuple[str, str], list[float]] = field(default_factory=dict)
+    trace_count: int = 0
+    empty_traces: int = 0
+
+    # -- queries --------------------------------------------------------
+    def successors(self, activity: str) -> set[str]:
+        return {b for (a, b) in self.edges if a == activity}
+
+    def predecessors(self, activity: str) -> set[str]:
+        return {a for (a, b) in self.edges if b == activity}
+
+    def mean_duration(self, edge: tuple[str, str]) -> float | None:
+        values = self.durations.get(edge)
+        return statistics.fmean(values) if values else None
+
+    def median_duration(self, edge: tuple[str, str]) -> float | None:
+        values = self.durations.get(edge)
+        return statistics.median(values) if values else None
+
+    def all_edges(self) -> list[tuple[str, str, int]]:
+        """Edges including the artificial start/end ones, as (a, b, count)."""
+        edges = [(START, a, n) for a, n in self.start.items()]
+        edges += [(a, b, n) for (a, b), n in self.edges.items()]
+        edges += [(a, END, n) for a, n in self.end.items()]
+        return edges
+
+    # -- simplification ------------------------------------------------
+    def simplified(self, activity_fraction: float = 1.0, edge_fraction: float = 1.0) -> "DFG":
+        """Keep the top ``activity_fraction`` of activities and ``edge_fraction`` of edges.
+
+        Fractions are in [0, 1].  At least one activity is always kept.
+        Removing activities *projects* them out: we do not reconnect their
+        neighbours, because that would invent directly-follows pairs that
+        never occurred.  Edges touching removed activities disappear.
+        """
+        ranked = [a for a, _ in sorted(self.activities.items(), key=lambda x: (-x[1], x[0]))]
+        keep_count = max(1, round(len(ranked) * activity_fraction))
+        kept = set(ranked[:keep_count])
+
+        candidates = [(a, b, n) for (a, b, n) in self.all_edges()
+                      if (a in kept or a == START) and (b in kept or b == END)]
+        candidates.sort(key=lambda edge: (-edge[2], edge[0], edge[1]))
+        keep_edges = set((a, b) for a, b, _ in candidates[:round(len(candidates) * edge_fraction)])
+
+        # Connectivity guarantee: best incoming and best outgoing per activity.
+        for activity in kept:
+            incoming = [e for e in candidates if e[1] == activity]
+            outgoing = [e for e in candidates if e[0] == activity]
+            if incoming:
+                keep_edges.add(incoming[0][:2])
+            if outgoing:
+                keep_edges.add(outgoing[0][:2])
+
+        result = DFG(trace_count=self.trace_count, empty_traces=self.empty_traces)
+        result.activities = Counter({a: self.activities[a] for a in kept})
+        for a, b, n in candidates:
+            if (a, b) not in keep_edges:
+                continue
+            if a == START:
+                result.start[b] = n
+            elif b == END:
+                result.end[a] = n
+            else:
+                result.edges[(a, b)] = n
+                if (a, b) in self.durations:
+                    result.durations[(a, b)] = self.durations[(a, b)]
+        return result
+
+
+def dfg_from_simple_log(log: SimpleLog) -> DFG:
+    """DFG of a multiset of sequences (no performance information)."""
+    dfg = DFG()
+    for sequence, count in log.items():
+        dfg.trace_count += count
+        if not sequence:
+            dfg.empty_traces += count
+            continue
+        for activity in sequence:
+            dfg.activities[activity] += count
+        dfg.start[sequence[0]] += count
+        dfg.end[sequence[-1]] += count
+        for a, b in zip(sequence, sequence[1:]):
+            dfg.edges[(a, b)] += count
+    return dfg
+
+
+def discover_dfg(log: EventLog | SimpleLog, classifier: Classifier | None = None) -> DFG:
+    """DFG of a log; with an :class:`EventLog`, edge durations are recorded too."""
+    if not isinstance(log, EventLog):
+        return dfg_from_simple_log(log)
+
+    classifier = classifier or log.default_classifier()
+    if log.columnar:
+        return _dfg_from_columns(log, classifier)
+    dfg = DFG()
+    durations: dict[tuple[str, str], list[float]] = defaultdict(list)
+    for trace in log.traces:
+        dfg.trace_count += 1
+        events = [e for e in trace.events if classifier.accepts(e)]
+        if not events:
+            dfg.empty_traces += 1
+            continue
+        labels = [classifier.label(e) for e in events]
+        dfg.activities.update(labels)
+        dfg.start[labels[0]] += 1
+        dfg.end[labels[-1]] += 1
+        for (first, second), (a, b) in zip(zip(events, events[1:]), zip(labels, labels[1:])):
+            dfg.edges[(a, b)] += 1
+            if first.timestamp is not None and second.timestamp is not None:
+                durations[(a, b)].append((second.timestamp - first.timestamp).total_seconds())
+    dfg.durations = dict(durations)
+    return dfg
+
+
+def _dfg_from_columns(log: EventLog, classifier: Classifier) -> DFG:
+    """The same counts and durations, from a columnar log's arrays."""
+    from .columns import NO_TIME
+    store = log.traces.store
+    dfg = DFG()
+    durations: dict[tuple[str, str], list[float]] = defaultdict(list)
+    sequences = store.sequences(classifier.keys, classifier.lifecycles)
+    wanted = None if classifier.lifecycles is None else {v.lower() for v in classifier.lifecycles}
+    lifecycle, micros, offsets = store.lifecycle, store.micros, store.offsets
+    for case, labels in enumerate(sequences):
+        dfg.trace_count += 1
+        if not labels:
+            dfg.empty_traces += 1
+            continue
+        dfg.activities.update(labels)
+        dfg.start[labels[0]] += 1
+        dfg.end[labels[-1]] += 1
+        kept = [i for i in range(offsets[case], offsets[case + 1])
+                if wanted is None or lifecycle.codes[i] < 0 or lifecycle.values[lifecycle.codes[i]].lower() in wanted]
+        for (a, b), (i, j) in zip(zip(labels, labels[1:]), zip(kept, kept[1:])):
+            dfg.edges[(a, b)] += 1
+            if micros[i] != NO_TIME and micros[j] != NO_TIME:
+                durations[(a, b)].append((micros[j] - micros[i]) / 1_000_000)
+    dfg.durations = dict(durations)
+    return dfg

openprocess/mining/discovery/alpha.py

@@ -0,0 +1,168 @@
+"""The α-algorithm (van der Aalst, Weijters & Maruster, 2004).
+
+The eight steps (book, Definition 6.4), for a log L over activities T:
+
+1. ``T_L = { t | t occurs in some trace }``                  -- the transitions
+2. ``T_I = { t | t is the first activity of some trace }``   -- start activities
+3. ``T_O = { t | t is the last activity of some trace }``    -- end activities
+4. ``X_L = { (A, B) | A ⊆ T_L, A ≠ ∅, B ⊆ T_L, B ≠ ∅,
+   ∀a∈A ∀b∈B: a →_L b,  ∀a1,a2∈A: a1 #_L a2,  ∀b1,b2∈B: b1 #_L b2 }``
+5. ``Y_L = { (A, B) ∈ X_L | no (A', B') ∈ X_L with A ⊆ A', B ⊆ B', (A,B) ≠ (A',B') }``
+   -- keep only the *maximal* pairs
+6. ``P_L = { p_(A,B) | (A,B) ∈ Y_L } ∪ { i_L, o_L }``
+7. ``F_L`` connects every ``a ∈ A`` to ``p_(A,B)``, ``p_(A,B)`` to every ``b ∈ B``,
+   ``i_L`` to every start activity and every end activity to ``o_L``
+8. ``α(L) = (P_L, T_L, F_L)``
+
+Intuition for step 4: a place between A and B must be *fed* by the
+activities in A and *consumed* by those in B.  Every a must cause every b
+(``→``), and no two members of A (or of B) may ever be seen together in
+either order (``#``) -- if they were, they would be concurrent, and a single
+place would wrongly force a choice between them.  ``a1 # a2`` with
+``a1 = a2`` forces ``a # a``, which is why an activity in a length-one loop
+(``a > a``) can never be in any pair.
+
+Known limitations, reported by :func:`alpha_miner` as warnings:
+
+* **length-one loops** (``a > a``) -- the activity ends up disconnected;
+* **length-two loops** (``a b a``) -- ``a > b`` and ``b > a`` make them look
+  parallel, so the loop is lost;
+* non-free-choice constructs and duplicate or silent activities cannot be
+  represented at all.
+
+The result object keeps every intermediate set so the app can show the
+derivation step by step -- exactly how exam questions ask for it.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from ..footprint import Footprint, footprint_of_log
+from ..log import SimpleLog
+from ..petrinet import Marking, PetriNet
+
+Pair = tuple[frozenset[str], frozenset[str]]
+
+
+@dataclass
+class AlphaResult:
+    footprint: Footprint
+    T_L: list[str]
+    T_I: list[str]
+    T_O: list[str]
+    X_L: list[Pair]
+    Y_L: list[Pair]
+    net: PetriNet
+    warnings: list[str] = field(default_factory=list)
+
+    def steps(self) -> list[tuple[str, str]]:
+        """The derivation as (step, content) rows, in textbook notation."""
+        def s(items) -> str:
+            return "{" + ", ".join(sorted(items)) + "}"
+
+        def pairs(collection: list[Pair]) -> str:
+            if not collection:
+                return "∅"
+            return "{ " + ", ".join(f"({s(a)}, {s(b)})" for a, b in collection) + " }"
+
+        places = ["i_L"] + [f"p({s(a)},{s(b)})" for a, b in self.Y_L] + ["o_L"]
+        return [
+            ("1. T_L — all activities", s(self.T_L)),
+            ("2. T_I — start activities", s(self.T_I)),
+            ("3. T_O — end activities", s(self.T_O)),
+            ("4. X_L — candidate (A, B) pairs", pairs(self.X_L)),
+            ("5. Y_L — maximal pairs", pairs(self.Y_L)),
+            ("6. P_L — places", "{" + ", ".join(places) + "}"),
+            ("7. F_L — arcs", f"{len(self.net.arcs)} arcs"),
+            ("8. α(L) = (P_L, T_L, F_L)", self.net.summary()),
+        ]
+
+
+def _pair_key(pair: Pair) -> tuple:
+    return (len(pair[0]) + len(pair[1]), sorted(pair[0]), sorted(pair[1]))
+
+
+def alpha_miner(log: SimpleLog, name: str = "α(L)") -> AlphaResult:
+    """Run the α-algorithm on a multiset of activity sequences."""
+    fp = footprint_of_log(log)
+    T_L = fp.activities
+    T_I = sorted({trace[0] for trace in log if trace})
+    T_O = sorted({trace[-1] for trace in log if trace})
+
+    def independent(group: frozenset[str]) -> bool:
+        """All members pairwise # -- including each with itself."""
+        return all(fp.choice(x, y) for x in group for y in group)
+
+    def causal(a_set: frozenset[str], b_set: frozenset[str]) -> bool:
+        return all(fp.causal(a, b) for a in a_set for b in b_set)
+
+    # Step 4.  Grow pairs from the singleton pairs ({a},{b}) with a → b.
+    # Any (A, B) in X_L can be reached this way by adding one element at a
+    # time, because every sub-pair of a valid pair is itself valid.  The
+    # search is exponential in the worst case, but course-sized logs have at
+    # most a few dozen activities, so this is instantaneous in practice.
+    seeds = {(frozenset({a}), frozenset({b}))
+             for a in T_L for b in T_L
+             if fp.causal(a, b) and fp.choice(a, a) and fp.choice(b, b)}
+    X_L: set[Pair] = set(seeds)
+    frontier = list(seeds)
+    while frontier:
+        next_frontier = []
+        for a_set, b_set in frontier:
+            for extra in T_L:
+                if extra not in a_set:
+                    grown_a = a_set | {extra}
+                    candidate = (grown_a, b_set)
+                    if candidate not in X_L and independent(grown_a) and causal(grown_a, b_set):
+                        X_L.add(candidate)
+                        next_frontier.append(candidate)
+                if extra not in b_set:
+                    grown_b = b_set | {extra}
+                    candidate = (a_set, grown_b)
+                    if candidate not in X_L and independent(grown_b) and causal(a_set, grown_b):
+                        X_L.add(candidate)
+                        next_frontier.append(candidate)
+        frontier = next_frontier
+
+    # Step 5.  Keep only the maximal pairs.
+    Y_L = [pair for pair in X_L
+           if not any(pair != other and pair[0] <= other[0] and pair[1] <= other[1]
+                      for other in X_L)]
+
+    X_sorted = sorted(X_L, key=_pair_key)
+    Y_sorted = sorted(Y_L, key=_pair_key)
+
+    # Steps 6-8.  Build the net.
+    net = PetriNet(name)
+    transitions = {a: net.add_transition(a, id=f"t_{a}") for a in T_L}
+    source = net.add_place("i_L", id="i_L")
+    sink = net.add_place("o_L", id="o_L")
+    for number, (a_set, b_set) in enumerate(Y_sorted, 1):
+        label = "p({" + ",".join(sorted(a_set)) + "},{" + ",".join(sorted(b_set)) + "})"
+        place = net.add_place(label, id=f"p{number}")
+        for a in a_set:
+            net.add_arc(transitions[a], place)
+        for b in b_set:
+            net.add_arc(place, transitions[b])
+    for a in T_I:
+        net.add_arc(source, transitions[a])
+    for a in T_O:
+        net.add_arc(transitions[a], sink)
+    net.initial_marking = Marking({source.id: 1})
+    net.final_marking = Marking({sink.id: 1})
+    net.info["algorithm"] = "α-algorithm"
+
+    warnings = []
+    loops1 = [a for a in T_L if (a, a) in fp.directly_follows]
+    if loops1:
+        warnings.append("Length-one loops detected (" + ", ".join(loops1) + "). The "
+                        "α-algorithm cannot discover these; the activities end up "
+                        "without input/output places.")
+    loops2 = sorted({tuple(sorted((trace[i], trace[i + 1])))
+                     for trace in log for i in range(len(trace) - 2)
+                     if trace[i] == trace[i + 2] and trace[i] != trace[i + 1]})
+    if loops2:
+        warnings.append("Length-two loops detected (" + ", ".join(f"{a}–{b}" for a, b in loops2)
+                        + "). The α-algorithm treats these pairs as parallel.")
+    return AlphaResult(fp, T_L, T_I, T_O, X_sorted, Y_sorted, net, warnings)

openprocess/mining/discovery/heuristics.py

@@ -0,0 +1,332 @@
+"""Heuristics Miner: frequency-aware dependency graphs (Weijters & van der Aalst).
+
+Where the α-algorithm asks the yes/no question "does a ever directly precede
+b?", the Heuristics Miner asks *how strongly* the log supports ``a`` causing
+``b``, using counts ``|a >_L b|`` (how often b directly follows a):
+
+Dependency measure, for ``a ≠ b``::
+
+             |a > b| − |b > a|
+    a ⇒ b = ───────────────────        value in (−1, 1)
+             |a > b| + |b > a| + 1
+
+It is close to 1 when b follows a often and a almost never follows b, close
+to 0 when both orders are equally common (concurrency, or noise), negative
+when the dependency is the other way round.  The ``+ 1`` damps small counts:
+one occurrence gives only 0.5, a hundred give 0.99.
+
+Length-one loop (``a`` directly followed by itself)::
+
+    a ⇒ a = |a > a| / (|a > a| + 1)
+
+Length-two loop (``a b a`` patterns, counted as ``|a >> b|``)::
+
+    a ⇒2 b = (|a >> b| + |b >> a|) / (|a >> b| + |b >> a| + 1)
+
+An edge ``a → b`` is kept when ``a ⇒ b`` reaches the *dependency threshold*
+and ``|a > b|`` reaches the *positive observations* threshold.  With
+*all tasks connected* on (the default), every activity additionally keeps its
+single best incoming and outgoing edge, so no activity is left floating.
+
+The output of :func:`heuristics_miner` is a *dependency graph*: which
+activity causes which, without saying whether a fork is a choice (XOR) or
+runs in parallel (AND).
+
+From dependency graph to Petri net (:func:`heuristics_net`)
+-----------------------------------------------------------
+The split/join semantics come from the log, as a **causal net** (C-net,
+van der Aalst, *Process Mining*, 2016, Section 7.3).  Every activity gets a
+set of *input bindings* and *output bindings*: which of its predecessors it
+waited for, and which of its successors it enabled.  Replaying each trace
+on the dependency graph gives them:
+
+* the output binding of ``a`` at position ``i`` is every successor ``b`` of
+  ``a`` that occurs after ``i`` with no other ``a`` in between (its first
+  such occurrence);
+* the input binding of ``b`` at position ``j`` is every predecessor ``a``
+  of ``b`` that occurs before ``j`` with no other ``b`` in between.
+
+These two rules match up exactly: ``b`` is in ``a``'s output binding iff
+``a`` is in the input binding of that occurrence of ``b``.  A virtual start
+activity precedes the first event of every trace and a virtual end activity
+follows the last one.  So after ``a`` in ``[⟨a,b,c,d⟩³, ⟨a,c,b,d⟩², ⟨a,e,d⟩]``,
+``{b, c}`` (5 times) and ``{e}`` (once) are the output bindings: b and c
+run in parallel, as an alternative to e.
+
+The C-net becomes a Petri net in the standard way: a place for every arc
+``(a, b)`` of the dependency graph, a transition per activity, and where an
+activity has several bindings on a side, a silent transition per binding
+that takes (or fills) exactly the places of that binding.  Silent steps that
+make no difference to the behaviour are then removed.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass, field
+
+from ..dfg import DFG, dfg_from_simple_log
+from ..log import SimpleLog
+
+
+@dataclass
+class DependencyGraph:
+    activities: Counter
+    #: (a, b) -> (dependency value, |a > b|) for every kept edge
+    edges: dict[tuple[str, str], tuple[float, int]] = field(default_factory=dict)
+    start: Counter = field(default_factory=Counter)
+    end: Counter = field(default_factory=Counter)
+    #: dependency value of every ordered pair that directly follows at least once
+    all_dependencies: dict[tuple[str, str], float] = field(default_factory=dict)
+
+
+def dependency(dfg: DFG, a: str, b: str) -> float:
+    ab, ba = dfg.edges.get((a, b), 0), dfg.edges.get((b, a), 0)
+    if a == b:
+        return ab / (ab + 1)
+    return (ab - ba) / (ab + ba + 1)
+
+
+def heuristics_miner(log: SimpleLog, dependency_threshold: float = 0.5,
+                     min_observations: int = 1, loop_two_threshold: float = 0.5,
+                     all_tasks_connected: bool = True) -> DependencyGraph:
+    dfg = dfg_from_simple_log(log)
+
+    # |a >> b|: occurrences of the pattern a b a.
+    two_loops: Counter = Counter()
+    for trace, n in log.items():
+        for i in range(len(trace) - 2):
+            if trace[i] == trace[i + 2] and trace[i] != trace[i + 1]:
+                two_loops[(trace[i], trace[i + 1])] += n
+
+    graph = DependencyGraph(Counter(dfg.activities), start=Counter(dfg.start),
+                            end=Counter(dfg.end))
+    for (a, b), count in dfg.edges.items():
+        value = dependency(dfg, a, b)
+        graph.all_dependencies[(a, b)] = value
+        if value >= dependency_threshold and count >= min_observations:
+            graph.edges[(a, b)] = (value, count)
+
+    # Length-two loops: a b a with both a⇒a and b⇒b weak (otherwise they are
+    # already length-one loops) keeps both directions a→b and b→a.
+    for (a, b), count in two_loops.items():
+        mutual = count + two_loops.get((b, a), 0)
+        value = mutual / (mutual + 1)
+        if value >= loop_two_threshold:
+            for x, y in ((a, b), (b, a)):
+                if (x, y) in dfg.edges:
+                    graph.edges[(x, y)] = (value, dfg.edges[(x, y)])
+
+    if all_tasks_connected:
+        for activity in dfg.activities:
+            outgoing = [(dependency(dfg, activity, b), b) for (x, b) in dfg.edges
+                        if x == activity and b != activity]
+            incoming = [(dependency(dfg, a, activity), a) for (a, y) in dfg.edges
+                        if y == activity and a != activity]
+            if outgoing and activity not in dfg.end:
+                value, best = max(outgoing)
+                graph.edges.setdefault((activity, best), (value, dfg.edges[(activity, best)]))
+            if incoming and activity not in dfg.start:
+                value, best = max(incoming)
+                graph.edges.setdefault((best, activity), (value, dfg.edges[(best, activity)]))
+    return graph
+
+
+# ---------------------------------------------------------------------------
+# Causal nets and their Petri nets
+# ---------------------------------------------------------------------------
+#: The virtual activities before the first and after the last event.
+START, END = "▶ start", "■ end"
+
+
+@dataclass
+class CausalNet:
+    """A dependency graph with, for every activity, its observed input and
+    output bindings (frozensets of activities) and how often each occurred."""
+
+    graph: DependencyGraph
+    inputs: dict[str, Counter] = field(default_factory=dict)
+    outputs: dict[str, Counter] = field(default_factory=dict)
+
+
+@dataclass
+class HeuristicsResult:
+    """What the Heuristics Miner found: the graph, the C-net, the Petri net."""
+
+    net: "PetriNet"
+    causal: CausalNet
+    dependency_threshold: float
+
+    @property
+    def graph(self) -> DependencyGraph:
+        return self.causal.graph
+
+
+def causal_net(log: SimpleLog, graph: DependencyGraph) -> CausalNet:
+    """Learn the input and output bindings by replaying ``log`` on ``graph``."""
+    successors: dict[str, set[str]] = {}
+    predecessors: dict[str, set[str]] = {}
+    for a, b in graph.edges:
+        successors.setdefault(a, set()).add(b)
+        predecessors.setdefault(b, set()).add(a)
+    net = CausalNet(graph)
+
+    def record(side: dict[str, Counter], activity: str, binding: set[str], n: int) -> None:
+        if binding:
+            side.setdefault(activity, Counter())[frozenset(binding)] += n
+
+    for trace, n in log.items():
+        if not trace:
+            record(net.outputs, START, {END}, n)
+            record(net.inputs, END, {START}, n)
+            continue
+        record(net.outputs, START, {trace[0]}, n)
+        record(net.inputs, END, {trace[-1]}, n)
+        for i, a in enumerate(trace):
+            outputs = {END} if i == len(trace) - 1 else set()
+            for b in successors.get(a, ()):
+                if b == a:                                # a self-loop: only a a
+                    if i + 1 < len(trace) and trace[i + 1] == a:
+                        outputs.add(a)
+                    continue
+                for later in trace[i + 1:]:
+                    if later == a:
+                        break
+                    if later == b:
+                        outputs.add(b)
+                        break
+            record(net.outputs, a, outputs, n)
+            inputs = {START} if i == 0 else set()
+            for c in predecessors.get(a, ()):
+                if c == a:
+                    if i > 0 and trace[i - 1] == a:
+                        inputs.add(a)
+                    continue
+                for earlier in reversed(trace[:i]):
+                    if earlier == a:
+                        break
+                    if earlier == c:
+                        inputs.add(c)
+                        break
+            record(net.inputs, a, inputs, n)
+    return net
+
+
+def causal_net_to_petri_net(causal: CausalNet, name: str = "Heuristics net") -> "PetriNet":
+    """The Petri net of a C-net: arc places, activity transitions, and a
+    silent transition per binding where an activity has more than one."""
+    from ..petrinet import Marking, PetriNet
+    net = PetriNet(name)
+    activities = set(causal.inputs) | set(causal.outputs)
+    places: dict[tuple[str, str], str] = {}
+
+    def arc_place(a: str, b: str) -> str:
+        if (a, b) not in places:
+            places[(a, b)] = net.add_place(f"({a},{b})").id
+        return places[(a, b)]
+
+    transitions: dict[str, str] = {}
+    for activity in sorted(activities, key=lambda x: (x != START, x == END, x)):
+        silent = activity in (START, END)
+        transitions[activity] = net.add_transition(None if silent else activity,
+                                                   name=activity).id
+    source, sink = net.add_place("start"), net.add_place("end")
+    net.add_arc(source.id, transitions[START])
+    net.add_arc(transitions[END], sink.id)
+
+    for activity, bindings in sorted(causal.inputs.items()):
+        target = transitions[activity]
+        if len(bindings) == 1:
+            for before in next(iter(bindings)):
+                net.add_arc(arc_place(before, activity), target)
+            continue
+        joined = net.add_place(f"in({activity})").id
+        net.add_arc(joined, target)
+        for binding in sorted(bindings, key=sorted):
+            join = net.add_transition(
+                None, name=f"τ {{{', '.join(sorted(binding))}}} → {activity}").id
+            for before in sorted(binding):
+                net.add_arc(arc_place(before, activity), join)
+            net.add_arc(join, joined)
+    for activity, bindings in sorted(causal.outputs.items()):
+        origin = transitions[activity]
+        if len(bindings) == 1:
+            for after in next(iter(bindings)):
+                net.add_arc(origin, arc_place(activity, after))
+            continue
+        split = net.add_place(f"out({activity})").id
+        net.add_arc(origin, split)
+        for binding in sorted(bindings, key=sorted):
+            fork = net.add_transition(
+                None, name=f"τ {activity} → {{{', '.join(sorted(binding))}}}").id
+            net.add_arc(split, fork)
+            for after in sorted(binding):
+                net.add_arc(fork, arc_place(activity, after))
+    net.initial_marking = Marking({source.id: 1})
+    net.final_marking = Marking({sink.id: 1})
+    _remove_redundant_silent_steps(net)
+    return net
+
+
+def _remove_redundant_silent_steps(net) -> None:
+    """Remove τ transitions that only pass one token from one place to the next.
+
+    Two classic reductions, both keeping the visible behaviour:
+
+    * τ is the only consumer of its input place p: drop τ and p, and let
+      whatever filled p fill τ's output place instead;
+    * τ is the only producer of its output place q: drop τ and q, and let
+      whatever took from q take from τ's input place instead.
+
+    A τ with one input and one output place is applied only when the arcs
+    have weight 1 and the places are different.
+    """
+    from ..petrinet import Marking
+    changed = True
+    while changed:
+        changed = False
+        for transition_id, transition in list(net.transitions.items()):
+            if not transition.silent:
+                continue
+            ins = [a for a in net.arcs if a.target == transition_id]
+            outs = [a for a in net.arcs if a.source == transition_id]
+            if len(ins) != 1 or len(outs) != 1 or ins[0].weight != 1 or outs[0].weight != 1:
+                continue
+            p, q = ins[0].source, outs[0].target
+            if p == q:
+                continue
+            consumers_of_p = [a for a in net.arcs if a.source == p]
+            producers_of_q = [a for a in net.arcs if a.target == q]
+            if len(consumers_of_p) == 1:
+                # p only feeds τ: whatever filled p fills q.
+                for arc in [a for a in net.arcs if a.target == p]:
+                    net.add_arc(arc.source, q, arc.weight)
+                if net.initial_marking[p]:
+                    net.initial_marking = Marking({**dict(net.initial_marking.items()),
+                                                   q: net.initial_marking[p], p: 0})
+                if net.final_marking[p]:
+                    continue
+                net.remove_transition(transition_id)
+                net.remove_place(p)
+                changed = True
+                break
+            if len(producers_of_q) == 1 and not net.final_marking[q] \
+                    and not net.initial_marking[q]:
+                # q is only filled by τ: whatever took from q takes from p.
+                for arc in [a for a in net.arcs if a.source == q]:
+                    net.add_arc(p, arc.target, arc.weight)
+                net.remove_transition(transition_id)
+                net.remove_place(q)
+                changed = True
+                break
+
+
+def heuristics_net(log: SimpleLog, dependency_threshold: float = 0.5,
+                   **options) -> HeuristicsResult:
+    """Heuristics Miner all the way to a Petri net (dependency graph, C-net,
+    Petri net), without PM4Py.  ``options`` go to :func:`heuristics_miner`."""
+    graph = heuristics_miner(log, dependency_threshold=dependency_threshold, **options)
+    causal = causal_net(log, graph)
+    net = causal_net_to_petri_net(causal)
+    net.info["algorithm"] = f"Heuristics Miner (dependency ≥ {dependency_threshold:g})"
+    return HeuristicsResult(net, causal, dependency_threshold)