pub fn new<I, F>(

        initial_state: StateIndex,

        num_of_states: Option<usize>,

        mut transition_iter: F,

        labels: Vec<Label>,

    ) -> LabelledTransitionSystem<Label>

    where

        F: FnMut() -> I,

        I: Iterator<Item = (StateIndex, LabelIndex, StateIndex)>,

        let mut states = ByteCompressedVec::new();

        if let Some(num_of_states) = num_of_states {

            states.resize_with(num_of_states, Default::default);

        }

        let mut num_of_transitions = 0;

        for (from, _, to) in transition_iter() {

            if states.len() <= *from.max(to) {

                states.resize_with(*from.max(to) + 1, || 0);

            }

            states.update(*from, |start| *start += 1);

            num_of_transitions += 1;

            if let Some(num_of_states) = num_of_states {

                debug_assert!(

                    *from < num_of_states && *to < num_of_states,

            }

        if initial_state.value() >= states.len() {

            // Ensure that the initial state is a valid state (and all states before it exist).

            states.resize_with(initial_state.value() + 1, Default::default);

        }

        states.fold(0, |count, start| {

            let result = count + *start;

            *start = count;

            result

        });

        let mut transition_labels = bytevec![LabelIndex::new(labels.len()); num_of_transitions];

        let mut transition_to = bytevec![StateIndex::new(states.len()); num_of_transitions];

        for (from, label, to) in transition_iter() {

            states.update(*from, |start| {

                transition_labels.set(*start, label);

                transition_to.set(*start, to);

                *start += 1

            });

        states.fold(0, |previous, start| {

            let result = *start;

            *start = previous;

            result

        });

        states.push(transition_labels.len());

        LabelledTransitionSystem::from_raw_parts(initial_state, states, transition_labels, transition_to, labels)

    }

    fn merge_disjoint_impl<L: LTS<Label = Label>>(mut self, other: &L) -> (Self, StateIndex) {

        let mut all_labels = self.labels().to_vec();

        for label in other.labels() {

            if !all_labels.contains(label) {

                all_labels.push(label.clone());

            }

        let label_indices: HashMap<Label, TagIndex<usize, LabelTag>> = HashMap::from_iter(

            all_labels

                .iter()

                .enumerate()

                .map(|(i, label)| (label.clone(), LabelIndex::new(i))),

        let total_number_of_states = self.num_of_states() + other.num_of_states();

        self.states

            .reserve(other.num_of_states(), total_number_of_states.bytes_required());

        self.transition_labels

            .reserve(other.num_of_transitions(), all_labels.len().bytes_required());

        self.transition_to

            .reserve(other.num_of_transitions(), total_number_of_states.bytes_required());

        let offset = self.num_of_states();

        self.states.pop();

        for state_index in other.iter_states() {

            self.states.push(self.num_of_transitions());

            for transition in other.outgoing_transitions(state_index) {

                // Add the transitions of the other LTS, offsetting the state indices

                self.transition_to.push(StateIndex::new(transition.to.value() + offset));

                // Map the label to the new index in all_labels

                let label_name = &other.labels()[transition.label.value()];

                self.transition_labels

                    .push(*label_indices.get(label_name).expect("Label should exist in all_labels"));

            }

        self.states.push(self.num_of_transitions());

        debug_assert_eq!(self.num_of_states(), total_number_of_states);

        (

            Self::from_raw_parts(

                self.initial_state,

                self.states,

                self.transition_labels,

                self.transition_to,

                all_labels,

            ),

            StateIndex::new(offset + other.initial_state_index().value()),

        )

    }

    pub fn new_from_permutation<P>(lts: Self, permutation: P) -> Self

    where

        P: Fn(StateIndex) -> StateIndex + Copy,

        let mut inverse = vec![StateIndex::new(0); lts.num_of_states()];

        for state_index in lts.iter_states() {

            inverse[*permutation(state_index)] = state_index;

        }

        let mut states = ByteCompressedVec::new();

        let mut transition_labels = ByteCompressedVec::new();

        let mut transition_to = ByteCompressedVec::new();

        for old_index in &inverse {

            states.push(transition_labels.len());

            let start = lts.states.index(**old_index);

            let end = lts.states.index(**old_index + 1);

            for i in start..end {

                transition_labels.push(lts.transition_labels.index(i));

                transition_to.push(permutation(lts.transition_to.index(i)));

            }

        states.push(transition_labels.len());

        Self::from_raw_parts(

            permutation(lts.initial_state),

            states,

            transition_labels,

            transition_to,

            lts.labels,

    }

    pub fn relabel_all<L, F>(self, labelling: F) -> Result<LabelledTransitionSystem<L>, MercError>

    where

        F: Fn(Label) -> Result<L, MercError>,

        L: TransitionLabel,

        let new_labels: Vec<L> = self.labels.into_iter().map(labelling).collect::<Result<_, _>>()?;

        Ok(LabelledTransitionSystem::from_raw_parts(

            self.initial_state,

            self.states,

            self.transition_labels,

            self.transition_to,

            new_labels,

        ))

    }

    pub fn from_raw_parts(

        initial_state: StateIndex,

        states: ByteCompressedVec<usize>,

        transition_labels: ByteCompressedVec<LabelIndex>,

        transition_to: ByteCompressedVec<StateIndex>,

        labels: Vec<Label>,

    ) -> Self {

        let lts = LabelledTransitionSystem {

            initial_state,

            states,

            transition_labels,

            transition_to,

            labels,

        };

        lts.assert_valid();

        lts

    }

    pub fn assert_valid(&self) {

        let num_states = self.num_of_states();

        let num_transitions = self.num_of_transitions();

        debug_assert!(

            !self.states.is_empty(),

        debug_assert!(

            self.initial_state.value() < num_states,

        debug_assert_eq!(

            self.states.index(num_states),

        debug_assert_eq!(

            self.transition_labels.len(),

            self.transition_to.len(),

        assert!(

            self.labels

                .first()

                .expect("At least one label (the hidden label) must be provided")

                .is_tau_label(),

        for i in 0..num_states {

            debug_assert!(

                self.states.index(i) <= self.states.index(i + 1),

        for i in 0..num_transitions {

            let label = self.transition_labels.index(i);

            debug_assert!(

                label.value() < self.labels.len(),

            let to = self.transition_to.index(i);

            debug_assert!(

                to.value() < num_states,

    }

    fn initial_state_index(&self) -> StateIndex {

        self.initial_state

    }

    fn outgoing_transitions(&self, state_index: StateIndex) -> impl Iterator<Item = Transition> + '_ {

        let start = self.states.index(*state_index);

        let end = self.states.index(*state_index + 1);

        (start..end).map(move |i| Transition {

            label: self.transition_labels.index(i),

            to: self.transition_to.index(i),

        })

    }

    fn iter_states(&self) -> impl Iterator<Item = StateIndex> + '_ {

        (0..self.num_of_states()).map(StateIndex::new)

    }

    fn num_of_states(&self) -> usize {

        self.states.len() - 1

    }

    fn num_of_labels(&self) -> usize {

        self.labels.len()

    }

    fn num_of_transitions(&self) -> usize {

        self.transition_labels.len()

    }

    fn labels(&self) -> &[Self::Label] {

        &self.labels[0..]

    }

    fn is_hidden_label(&self, label_index: LabelIndex) -> bool {

        label_index.value() == 0

    }

    fn merge_disjoint<T: LTS<Label = Self::Label>>(self, other: &T) -> (Self, StateIndex) {

        self.merge_disjoint_impl(other)

    }

pub fn check_equivalent<L: LTS>(lts: &L, lts_read: &L) {

    println!("LTS labels: {:?}", lts.labels());

    println!("Read LTS labels: {:?}", lts_read.labels());

    let mapping = lts

        .labels()

        .iter()

        .enumerate()

        .map(|(_i, label)| lts_read.labels().iter().position(|l| l == label))

        .collect::<Vec<_>>();

    for (i, m) in mapping.iter().enumerate() {

        println!("Label {} mapped to {:?}", i, m);

    }

    assert_eq!(lts.num_of_transitions(), lts_read.num_of_transitions());

    for state_index in lts.iter_states() {

        let transitions: Vec<_> = lts.outgoing_transitions(state_index).collect();

        let transitions_read: Vec<_> = if state_index.value() < lts_read.num_of_states() {

            lts_read.outgoing_transitions(state_index).collect()

            Vec::new()

        transitions.iter().for_each(|t| {

            let mapped_label = mapping[t.label.value()].expect(&format!("Label {} should be found", t.label));

            assert!(

                transitions_read

                    .iter()

                    .any(|tr| tr.to == t.to && tr.label.value() == mapped_label)

        });

}

    fn test_random_labelled_transition_system_merge_disjoint() {

        random_test(100, |rng| {

            let mut files = DumpFiles::new("test_random_merge_disjoint");

            let left = random_lts::<String, _>(rng, 1000, 20);

            files.dump("left.aut", |w| write_aut(w, &left)).unwrap();

            let right = random_lts::<String, _>(rng, 1000, 20);

            files.dump("right.aut", |w| write_aut(w, &right)).unwrap();

            let (merged, right_initial) = left.clone().merge_disjoint(&right);

            files.dump("merged.aut", |w| write_aut(w, &merged)).unwrap();

            assert_eq!(

                num_reachable_states(&left, left.initial_state_index()),

                num_reachable_states(&merged, merged.initial_state_index()),

            assert_eq!(

                num_reachable_states(&right, right.initial_state_index()),

                num_reachable_states(&merged, right_initial),

        });

    }