7 Process Mining

9.0

7 Process Mining🔗ℹ

package: spindle

The process mining module discovers defeasible rules from event logs, enabling automated rule extraction from observed behavior.

7.1 Overview🔗ℹ

Process mining in Spindle:

Reads event logs (traces of activities)
Discovers process structure using the Alpha algorithm
Converts to defeasible rules with support/confidence
Identifies conflicts and choice points

7.2 Event Logs🔗ℹ

procedure
(event? v) → boolean?
v : any/c

Returns #t if v is an event.

procedure
(make-event timestamp
activity
[ #:actor actor
#:bindings bindings]) → event?
  timestamp : any/c
  activity : string?
  actor : (or/c string? #f) = #f
  bindings : hash? = (hash)

Create an event with timestamp, activity name, and optional metadata.

procedure
(case? v) → boolean?
v : any/c

Returns #t if v is a case (trace).

procedure
(make-case id events) → case?
id : string?
events : (listof event?)

Create a case from a list of events.

procedure
(event-log? v) → boolean?
v : any/c

Returns #t if v is an event log.

procedure
(make-event-log cases) → event-log?
cases : (listof case?)

Create an event log from cases.

7.2.1 Loading Event Logs🔗ℹ

procedure
(json->event-log input) → event-log?
input : input-port?

Parse a JSON event log.

Expected format:

{
  "cases": [
    {
      "id": "case-1",
      "events": [
        {"timestamp": "2024-01-01T10:00:00Z", "activity": "start"},
        {"timestamp": "2024-01-01T10:05:00Z", "activity": "process"}
      ]
    }
  ]
}

procedure
(xes->event-log input) → event-log?
input : input-port?

Parse an XES (IEEE standard) event log.

7.3 Rule Discovery🔗ℹ

procedure
(mine-rules log
[ #:min-support min-support
#:min-confidence min-confidence
#:generalize generalize]) → mining-result?
  log : event-log?
  min-support : exact-positive-integer? = 1
  min-confidence : (real-in 0 1) = 0.0
  generalize : boolean? = #f

Discover defeasible rules from an event log.

Options:

min-support — Minimum number of occurrences
min-confidence — Minimum confidence threshold
generalize — Generalize with variables

(define result (mine-rules my-log #:min-confidence 0.8))
(for ([rule (mining-result-rules result)])
(displayln (learned-rule-rule rule)))

7.4 Mining Results🔗ℹ

procedure
(mining-result? v) → boolean?
v : any/c

Returns #t if v is a mining result.

procedure
(mining-result-rules r) → (listof learned-rule?)
r : mining-result?

Get discovered rules.

procedure
(mining-result-conflicts r) → (listof conflict?)
r : mining-result?

Get detected conflicts.

procedure
(mining-result-choice-points r) → (listof choice-point?)
r : mining-result?

Get discovered choice points.

7.4.1 Learned Rules🔗ℹ

procedure
(learned-rule? v) → boolean?
v : any/c

Returns #t if v is a learned rule.

procedure
(learned-rule-rule lr) → rule?
lr : learned-rule?

Get the actual rule.

procedure
(learned-rule-support lr) → exact-positive-integer?
lr : learned-rule?

Get the support count (number of traces supporting this rule).

procedure
(learned-rule-confidence lr) → (real-in 0 1)
lr : learned-rule?

Get the confidence (support / total applicable cases).

7.5 Petri Net Discovery🔗ℹ

The Alpha algorithm first discovers a Petri net:

procedure
(petri-net? v) → boolean?
v : any/c

Returns #t if v is a Petri net.

procedure
(petri-net->dfl net log) → (listof learned-rule?)
net : petri-net?
log : event-log?

Convert a Petri net to defeasible rules.

7.6 Conflict Detection🔗ℹ

procedure
(conflict? v) → boolean?
v : any/c

Returns #t if v is a conflict.

Conflict types:

choice — XOR split from structure (exclusive paths)
mutex — Mutual exclusion from traces (never co-occur)

1	Overview
2	Getting Started
3	Core API Reference
4	DFL Syntax Reference
5	SPL Syntax Reference
6	Query Operations
7	Process Mining
8	Explanation System
9	Examples
10	Advanced Topics
	Index

7.1	Overview
7.2	Event Logs
7.3	Rule Discovery
7.4	Mining Results
7.5	Petri Net Discovery
7.6	Conflict Detection