pub fn new(manager: &LDDManagerRef, lps: L) -> Result<Self, MercError> {

        let lps = Rc::new(lps);

        let initial_values = lps.initial_state();

        let num_positions = initial_values.len();

        let mut columns: Vec<IndexedSet<L::Value>> = (0..num_positions).map(|_| IndexedSet::new()).collect();

        let mut initial_vector: Vec<Value> = Vec::with_capacity(num_positions);

        for (position, value) in initial_values.iter().enumerate() {

            let (index, _) = columns[position].insert(*value);

            initial_vector.push(*index as Value);

        }

        let initial_state = manager.with_manager_shared(|m| LDDFunction::singleton(m, &initial_vector))?;

        let mut groups = Vec::with_capacity(lps.summands().len());

        for (index, summand) in lps.summands().iter().enumerate() {

            let mut read_indices: Vec<Value> = summand.read_positions().iter().map(|&p| p as Value).collect();

            let mut write_indices: Vec<Value> = summand.write_positions().iter().map(|&p| p as Value).collect();

            read_indices.sort_unstable();

            write_indices.sort_unstable();

            let (project_ldd, meta, read_positions, write_positions, relation) =

                manager.with_manager_shared(|m| -> Result<_, MercError> {

                    let project_ldd = LDDFunction::projection_meta(m, &read_indices)?;

                        meta,

                        read_positions,

                        write_positions,

                    } = LDDFunction::relation_product_meta(m, &read_indices, &write_indices)?;

                    let relation = LDDFunction::empty_set(m)?;

                    Ok((project_ldd, meta, read_positions, write_positions, relation))

                })?;

            groups.push(SymbolicLpsGroup {

                lps: Rc::clone(&lps),

                index,

                read_indices,

                write_indices,

                read_positions,

                write_positions,

                project_ldd,

                meta,

                relation,

            });

        Ok(SymbolicLps {

            lps,

            groups,

            initial_state,

        })

    }

    fn initial_columns(&self) -> Vec<IndexedSet<L::Value>> {

        let initial_values = self.lps.initial_state();

        let mut columns: Vec<IndexedSet<L::Value>> = (0..initial_values.len()).map(|_| IndexedSet::new()).collect();

        for (position, value) in initial_values.iter().enumerate() {

            columns[position].insert(*value);

        }

        columns

    }

    fn initial_state(&self) -> &LDDFunction {

        &self.initial_state

    }

    fn transition_groups(&self) -> &[Self::Group] {

        &self.groups

    }

    fn transition_groups_mut(&mut self) -> &mut [Self::Group] {

        &mut self.groups

    }

    fn create_context(&self) -> SymbolicContext<L> {

        SymbolicContext {

            enumerate: self.lps.create_context(),

            columns: self.initial_columns(),

        }

    }

    fn relation(&self) -> &LDDFunction {

        &self.relation

    }

    fn read_indices(&self) -> &[u32] {

        &self.read_indices

    }

    fn write_indices(&self) -> &[u32] {

        &self.write_indices

    }

    fn action_label_index(&self) -> Option<usize> {

        None

    }

    fn meta(&self) -> &LDDFunction {

        &self.meta

    }

    fn learn_successors(

        &mut self,

        context: &mut SymbolicContext<L>,

        storage: &LDDManagerRef,

        todo: &LDDFunction,

    ) -> Result<(), MercError> {

        let proj = todo.project(&self.project_ldd)?;

        let SymbolicContext { enumerate, columns } = context;

        let mut full_state = self.lps.initial_state();

        let mut interleaved: Vec<Value> = vec![0; self.read_indices.len() + self.write_indices.len()];

        let mut relation = self.relation.clone();

        let summand = &self.lps.summands()[self.index];

        let mut states = iter(&proj);

        while let Some(short_state) = states.next() {

            debug_assert_eq!(

                short_state.len(),

                self.read_indices.len(),

            for (k, &value) in short_state.iter().enumerate() {

                let full_pos = self.read_indices[k] as usize;

                full_state[full_pos] = *columns[full_pos]

                    .get_by_index(value as usize)

                    .expect("read value must already be interned");

                interleaved[self.read_positions[k]] = value;

            }

            let applicable = self.lps.prepare(enumerate, &full_state).any(|i| i == self.index);

            if !applicable {

                continue;

            }

            let write_indices = &self.write_indices;

            let write_positions = &self.write_positions;

            let interleaved = &mut interleaved;

            let relation = &mut relation;

            summand.enumerate(enumerate, &full_state, |_label, next_state| {

                for (m, &full_pos) in write_indices.iter().enumerate() {

                    let (index, _) = columns[full_pos as usize].insert(next_state[full_pos as usize]);

                    interleaved[write_positions[m]] = *index as Value;

                }

                let cube = storage.with_manager_shared(|m| LDDFunction::singleton(m, interleaved.as_slice()))?;

                *relation = relation.union(&cube)?;

                Ok(())

            })?;

        self.relation = relation;

        Ok(())

    }

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        writeln!(f, "SymbolicLps:")?;

        for (i, group) in self.groups.iter().enumerate() {

            writeln!(f, "  {i}: {group:?}")?;

        Ok(())

    }

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        write!(

            f,

    }