process_mining 0.5.5

Process Mining library for working with (object-centric) event data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use std::collections::HashSet;

use rayon::prelude::*;

use crate::core::event_data::case_centric::utils::activity_projection::ActivityProjectionDFG;

fn no_df_between(df_rel: &HashSet<(usize, usize)>, a: &HashSet<usize>, b: &HashSet<usize>) -> bool {
    for &a1 in a {
        for &b1 in b {
            if df_rel.contains(&(a1, b1)) {
                return false;
            }
        }
    }
    true
}

fn all_dfs_between(
    df_rel: &HashSet<(usize, usize)>,
    a: &HashSet<usize>,
    b: &HashSet<usize>,
) -> bool {
    for &a1 in a {
        for &b1 in b {
            if !df_rel.contains(&(a1, b1)) {
                return false;
            }
        }
    }
    true
}

fn all_dfs_between_vec(df_rel: &HashSet<(usize, usize)>, a: &Vec<usize>, b: &Vec<usize>) -> bool {
    for &a1 in a {
        for &b1 in b {
            if !df_rel.contains(&(a1, b1)) {
                return false;
            }
        }
    }
    true
}
fn not_all_dfs_between(
    df_rel: &HashSet<(usize, usize)>,
    a: &HashSet<usize>,
    b: &HashSet<usize>,
) -> bool {
    for &a1 in a {
        for &b1 in b {
            if !df_rel.contains(&(a1, b1)) {
                return true;
            }
        }
    }
    false
}

/// Checks if a place candidate with input transitions `a` and output transitions `b` satisfies DF-relation criteria
pub fn satisfies_cnd_condition(df_rel: &HashSet<(usize, usize)>, a: &[usize], b: &[usize]) -> bool {
    let a_set: HashSet<usize> = a.iter().copied().collect();
    let b_set: HashSet<usize> = b.iter().copied().collect();
    let a_without_b: HashSet<usize> = a_set.difference(&b_set).copied().collect();
    let b_without_a: HashSet<usize> = b_set.difference(&a_set).copied().collect();

    no_df_between(df_rel, &a_set, &a_without_b)
        && no_df_between(df_rel, &b_without_a, &b_set)
        && all_dfs_between(df_rel, &a_set, &b_set)
        && not_all_dfs_between(df_rel, &b_without_a, &a_without_b)
}

/// Build place candidates (represented as input transitions and output transitions) from a [`ActivityProjectionDFG`]
pub fn build_candidates(dfg: &ActivityProjectionDFG) -> HashSet<(Vec<usize>, Vec<usize>)> {
    let df_relations: HashSet<(usize, usize)> = dfg
        .edges
        .par_iter()
        .filter_map(|((a, b), w)| if w > &0 { Some((*a, *b)) } else { None })
        .collect();
    println!("DF #{:?}", df_relations.len());
    let mut cnds: HashSet<(Vec<usize>, Vec<usize>)> = HashSet::new();
    let mut final_cnds: HashSet<(Vec<usize>, Vec<usize>)> = HashSet::new();
    (0..dfg.nodes.len()).for_each(|a| {
        (0..dfg.nodes.len()).for_each(|b| {
            if df_relations.contains(&(a, b))
                && !df_relations.contains(&(b, a))
                && !df_relations.contains(&(a, a))
                && !df_relations.contains(&(b, b))
            {
                final_cnds.insert((vec![a], vec![b]));
                cnds.insert((vec![a], vec![b]));
            } else {
                cnds.insert((vec![a], vec![b]));
            }
        });
    });

    let mut changed = true;
    let mut new_cnds: HashSet<(Vec<usize>, Vec<usize>)> = cnds.clone();
    while changed {
        changed = false;
        let added_cnds: HashSet<(Vec<usize>, Vec<usize>)> = new_cnds
            .par_iter()
            .flat_map(|(a1, b1)| {
                cnds.par_iter()
                    .filter_map(|(a2, b2)| {
                        if !all_dfs_between_vec(&df_relations, a1, b2)
                            || !all_dfs_between_vec(&df_relations, a2, b1)
                        {
                            return None;
                        }
                        let mut a = [a1.as_slice(), a2.as_slice()].concat();
                        let mut b = [b1.as_slice(), b2.as_slice()].concat();
                        if all_dfs_between_vec(&df_relations, &b, &a) {
                            return None;
                        }
                        a.sort();
                        a.dedup();
                        b.sort();
                        b.dedup();
                        if a != b
                            && !cnds.contains(&(a.clone(), b.clone()))
                            && satisfies_cnd_condition(&df_relations, &a, &b)
                        {
                            return Some((a, b));
                        }
                        None
                    })
                    .collect::<HashSet<(Vec<usize>, Vec<usize>)>>()
            })
            .collect();
        if !added_cnds.is_empty() {
            changed = true;
            for cnd in &added_cnds {
                final_cnds.insert(cnd.clone());
                cnds.insert(cnd.clone());
            }
            new_cnds = added_cnds;
        }
    }
    final_cnds
}