Update automaton's convertion to regex algorithm (#1)

* WIP: Rework convert automaton to regex

* WIP: Remove prints

* WIP: Some good progress

* Update convert to regex algorithm

* Update version

* Fix

Author: alexvbrdn

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "regexsolver"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 authors = ["Alexandre van Beurden"]
 repository = "https://github.com/RegexSolver/regexsolver"
@@ -21,7 +21,6 @@ sha2 = "0.10.8"
 nohash-hasher = "0.2"
 ahash = "0.8.11"
 regex-syntax = "0.8.5"
-petgraph = "0.6.4"
 log = "0.4.21"
 rand = "0.8.5"
 lazy_static = "1.4.0"

src/fast_automaton/convert/mod.rs

@@ -1,4 +1,3 @@
 use super::*;
-use crate::regex::RegularExpression;
 
 mod to_regex;

src/fast_automaton/convert/to_regex/builder/mod.rs

@@ -0,0 +1,170 @@
+use super::*;
+
+mod scc;
+
+impl StateEliminationAutomaton<Range> {
+    pub fn new(automaton: &FastAutomaton) -> Result<Option<Self>, EngineError> {
+        if automaton.is_empty() {
+            return Ok(None);
+        }
+
+        let mut state_elimination_automaton = StateEliminationAutomaton {
+            start_state: 0,  // start_state is not set yet
+            accept_state: 0, // accept_state is not set yet
+            transitions: Vec::with_capacity(automaton.get_number_of_states()),
+            transitions_in: IntMap::with_capacity(automaton.get_number_of_states()),
+            removed_states: IntSet::new(),
+            cyclic: false,
+        };
+
+        let mut states_map = IntMap::with_capacity(automaton.get_number_of_states());
+
+        for from_state in automaton.transitions_iter() {
+            let new_from_state = *states_map
+                .entry(from_state)
+                .or_insert_with(|| state_elimination_automaton.new_state());
+            for (to_state, condition) in
+                automaton.transitions_from_state_enumerate_into_iter(&from_state)
+            {
+                let new_to_state = *states_map
+                    .entry(to_state)
+                    .or_insert_with(|| state_elimination_automaton.new_state());
+
+                state_elimination_automaton.add_transition_to(
+                    new_from_state,
+                    new_to_state,
+                    GraphTransition::Weight(condition.to_range(automaton.get_spanning_set())?),
+                );
+            }
+        }
+
+        state_elimination_automaton.start_state =
+            *states_map.get(&automaton.get_start_state()).unwrap(); // We finally set start_state
+
+        if automaton.get_accept_states().len() == 1 {
+            // If there is only one accept state with just set it
+            state_elimination_automaton.accept_state = *states_map
+                .get(automaton.get_accept_states().iter().next().unwrap())
+                .unwrap();
+        } else {
+            // If not we create a new state that will be the new accept state
+            state_elimination_automaton.accept_state = state_elimination_automaton.new_state();
+            for accept_state in automaton.get_accept_states() {
+                let accept_state = *states_map.get(accept_state).unwrap();
+                // We add an empty string transition to the new accept state
+                state_elimination_automaton.add_transition_to(
+                    accept_state,
+                    state_elimination_automaton.accept_state,
+                    GraphTransition::Epsilon,
+                );
+            }
+        }
+        state_elimination_automaton.identify_and_apply_components()?;
+        //state_elimination_automaton.to_dot();
+        Ok(Some(state_elimination_automaton))
+    }
+
+    pub fn new_state(&mut self) -> usize {
+        if let Some(new_state) = self.removed_states.clone().iter().next() {
+            self.removed_states.remove(new_state);
+            self.transitions_in.insert(*new_state, IntSet::new());
+            *new_state
+        } else {
+            self.transitions.push(IntMap::default());
+            self.transitions_in
+                .insert(self.transitions.len() - 1, IntSet::new());
+            self.transitions.len() - 1
+        }
+    }
+
+    #[inline]
+    pub fn has_state(&self, state: State) -> bool {
+        !(state >= self.transitions.len() || self.removed_states.contains(&state))
+    }
+
+    #[inline]
+    fn assert_state_exists(&self, state: State) {
+        if !self.has_state(state) {
+            panic!("The state {} does not exist", state);
+        }
+    }
+
+    pub fn add_transition_to(
+        &mut self,
+        from_state: State,
+        to_state: State,
+        transition: GraphTransition<Range>,
+    ) {
+        self.assert_state_exists(from_state);
+        if from_state != to_state {
+            self.assert_state_exists(to_state);
+        }
+
+        self.transitions_in
+            .entry(to_state)
+            .or_default()
+            .insert(from_state);
+        match self.transitions[from_state].entry(to_state) {
+            Entry::Occupied(mut o) => {
+                if let (GraphTransition::Weight(current_regex), GraphTransition::Weight(regex)) =
+                    (o.get(), transition)
+                {
+                    o.insert(GraphTransition::Weight(current_regex.union(&regex)));
+                } else {
+                    panic!("Cannot add transition");
+                }
+            }
+            Entry::Vacant(v) => {
+                v.insert(transition);
+            }
+        };
+    }
+
+    pub fn remove_state(&mut self, state: State) {
+        self.assert_state_exists(state);
+        if self.start_state == state || self.accept_state == state {
+            panic!(
+                "Can not remove the state {}, it is still used as start state or accept state.",
+                state
+            );
+        }
+        self.transitions_in.remove(&state);
+        if self.transitions.len() - 1 == state {
+            self.transitions.remove(state);
+
+            let mut s = state;
+            while self.removed_states.contains(&s) {
+                self.transitions.remove(s);
+                self.removed_states.remove(&s);
+                s -= 1;
+            }
+        } else {
+            self.transitions[state].clear();
+            self.removed_states.insert(state);
+        }
+
+        for transitions in self.transitions.iter_mut() {
+            transitions.remove(&state);
+        }
+        for (_, transitions) in self.transitions_in.iter_mut() {
+            transitions.remove(&state);
+        }
+    }
+
+    pub fn remove_transition(&mut self, from_state: State, to_state: State) {
+        self.assert_state_exists(from_state);
+        if from_state != to_state {
+            self.assert_state_exists(to_state);
+        }
+
+        if let Some(from_states) = self.transitions_in.get_mut(&to_state) {
+            from_states.remove(&from_state);
+        }
+
+        self.transitions[from_state].remove(&to_state);
+    }
+
+    pub fn get_transition(&self, from_state: State, to_state: State) -> Option<&GraphTransition<Range>> {
+        self.transitions.get(from_state)?.get(&to_state)
+    }
+}

src/fast_automaton/convert/to_regex/builder/scc.rs

@@ -0,0 +1,207 @@
+use super::*;
+
+impl StateEliminationAutomaton<Range> {
+    pub fn identify_and_apply_components(&mut self) -> Result<(), EngineError> {
+        let mut index = 0;
+        let mut stack = Vec::new();
+        let mut indices = vec![-1; self.transitions.len()];
+        let mut lowlink = vec![-1; self.transitions.len()];
+        let mut on_stack = vec![false; self.transitions.len()];
+        let mut scc = Vec::new();
+
+        for state in self.states_iter() {
+            if self.removed_states.contains(&state) {
+                continue;
+            }
+            if indices[state] == -1 {
+                self.strongconnect(
+                    state,
+                    &mut index,
+                    &mut stack,
+                    &mut indices,
+                    &mut lowlink,
+                    &mut on_stack,
+                    &mut scc,
+                );
+            }
+        }
+
+        let scc = scc
+            .into_iter()
+            .filter(|states| {
+                let first_state = states.iter().next().unwrap();
+                let self_loop = if let Some(transitions_in) = self.transitions_in.get(first_state) {
+                    transitions_in.contains(first_state)
+                } else {
+                    false
+                };
+                states.len() != 1 || self_loop
+            })
+            .collect::<Vec<_>>();
+
+        for component in scc {
+            self.build_component(&component)?;
+        }
+
+        self.cyclic = false;
+
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn strongconnect(
+        &self,
+        v: usize,
+        index: &mut usize,
+        stack: &mut Vec<usize>,
+        indices: &mut Vec<i32>,
+        lowlink: &mut Vec<i32>,
+        on_stack: &mut Vec<bool>,
+        scc: &mut Vec<Vec<usize>>,
+    ) {
+        indices[v] = *index as i32;
+        lowlink[v] = *index as i32;
+        *index += 1;
+        stack.push(v);
+        on_stack[v] = true;
+
+        if let Some(neighbors) = self.transitions.get(v) {
+            for &w in neighbors.keys() {
+                if indices[w] == -1 {
+                    self.strongconnect(w, index, stack, indices, lowlink, on_stack, scc);
+                    lowlink[v] = lowlink[v].min(lowlink[w]);
+                } else if on_stack[w] {
+                    lowlink[v] = lowlink[v].min(indices[w]);
+                }
+            }
+        }
+
+        if lowlink[v] == indices[v] {
+            let mut component = Vec::new();
+            while let Some(w) = stack.pop() {
+                on_stack[w] = false;
+                component.push(w);
+                if w == v {
+                    break;
+                }
+            }
+            scc.push(component);
+        }
+    }
+
+    fn build_component(&mut self, states: &[usize]) -> Result<(), EngineError> {
+        let state_set = states.iter().copied().collect::<IntSet<usize>>();
+        let mut start_states = IntMap::new();
+        let mut accept_states = IntMap::new();
+
+        let mut state_elimination_automaton = StateEliminationAutomaton {
+            start_state: 0,  // start_state is not set yet
+            accept_state: 0, // accept_state is not set yet
+            transitions: Vec::with_capacity(states.len()),
+            transitions_in: IntMap::with_capacity(states.len()),
+            removed_states: IntSet::new(),
+            cyclic: true,
+        };
+
+        let mut states_map = IntMap::with_capacity(states.len());
+        for from_state in states {
+            if *from_state == self.accept_state {
+                self.accept_state = self.new_state();
+                self.add_transition_to(*from_state, self.accept_state, GraphTransition::Epsilon);
+            }
+            if *from_state == self.start_state {
+                self.start_state = self.new_state();
+                self.add_transition_to(self.start_state, *from_state, GraphTransition::Epsilon);
+            }
+            let from_state_new = *states_map
+                .entry(*from_state)
+                .or_insert_with(|| state_elimination_automaton.new_state());
+            for (to_state, transition) in self.transitions_from_state_enumerate_iter(from_state) {
+                if !state_set.contains(to_state) {
+                    accept_states
+                        .entry(*to_state)
+                        .or_insert_with(Vec::new)
+                        .push((from_state_new, transition.clone()));
+                    continue;
+                }
+
+                let to_state_new = *states_map
+                    .entry(*to_state)
+                    .or_insert_with(|| state_elimination_automaton.new_state());
+
+                state_elimination_automaton.add_transition_to(
+                    from_state_new,
+                    to_state_new,
+                    transition.clone(),
+                );
+            }
+
+            for (parent_state, transition) in self.in_transitions_vec(*from_state) {
+                if !state_set.contains(&parent_state) {
+                    start_states
+                        .entry(from_state_new)
+                        .or_insert_with(Vec::new)
+                        .push((parent_state, transition.clone()));
+                }
+            }
+        }
+
+        for state in states {
+            self.remove_state(*state);
+        }
+
+        for (start_state, parent_states) in &start_states {
+            for (parent_state, transition) in parent_states {
+                let new_parent_state = if !transition.is_empty_string() {
+                    let new_parent_state = self.new_state();
+
+                    self.add_transition_to(*parent_state, new_parent_state, transition.clone());
+                    new_parent_state
+                } else {
+                    *parent_state
+                };
+                for (target_state, accept_states_transition) in &accept_states {
+                    let mut new_automaton = state_elimination_automaton.clone();
+
+                    let target_state = if accept_states_transition.len() > 1 {
+                        new_automaton.accept_state = new_automaton.new_state();
+                        for (accept_state, transition) in accept_states_transition {
+                            new_automaton.add_transition_to(
+                                *accept_state,
+                                new_automaton.accept_state,
+                                transition.clone(),
+                            );
+                        }
+                        *target_state
+                    } else {
+                        let (accept_state, transition) =
+                            accept_states_transition.iter().next().unwrap();
+
+                        new_automaton.accept_state = *accept_state;
+                        if !transition.is_empty_string() {
+                            let new_target_state = self.new_state();
+                            self.add_transition_to(
+                                new_target_state,
+                                *target_state,
+                                transition.clone(),
+                            );
+                            new_target_state
+                        } else {
+                            *target_state
+                        }
+                    };
+
+                    new_automaton.start_state = *start_state;
+
+                    self.add_transition_to(
+                        new_parent_state,
+                        target_state,
+                        GraphTransition::Graph(new_automaton),
+                    );
+                }
+            }
+        }
+
+        Ok(())
+    }
+}