pub fn longest_tau_path<L: LTS>(lts: &L) -> Vec<StateIndex> {

    let mut length = vec![0usize; lts.num_of_states()];

    let mut next = vec![None; lts.num_of_states()];

        let mut changed = false;

        for state in lts.iter_states() {

            for transition in lts

                .outgoing_transitions(state)

                .filter(|transition| lts.is_hidden_label(transition.label))

                let new_length = length[transition.to] + 1;

                if new_length > length[state] {

                    length[state] = new_length;

                    next[state] = Some(transition.to);

                    changed = true;

                }

        if !changed {

            break;

        }

    let (max_state, &max_length) = length

        .iter()

        .enumerate()

        .max_by_key(|(_, len)| **len)

        .unwrap_or((0, &0));

    let mut path = Vec::with_capacity(max_length + 1);

    let mut current = StateIndex::new(max_state);

    path.push(current);

    while let Some(next_state) = next[current] {

        path.push(next_state);

        current = next_state;

    }

    path

}