fn flatten_matrix(expr: &Expr, symbols: &SymbolTable) -> ApplicationResult {

    if let Expr::Flatten(_, n, matrix) = expr {

        if n.is_some() {

            return Err(RuleNotApplicable);

        }

        let Expr::Atomic(_, Atom::Reference(decl)) = matrix.as_ref() else {

            return Err(RuleNotApplicable);

        let Name::WithRepresentation(name, reprs) = &decl.name() as &Name else {

            return Err(RuleNotApplicable);

        if reprs.first().is_none_or(|x| x.as_str() != "matrix_to_atom") {

            return Err(RuleNotApplicable);

        }

        let decl = symbols.lookup(name.as_ref()).unwrap();

        let repr = symbols

            .get_representation(name.as_ref(), &["matrix_to_atom"])

            .unwrap()[0]

            .clone();

        let dom = decl.resolved_domain().ok_or(RuleNotApplicable)?;

        let GroundDomain::Matrix(_, index_domains) = dom.as_ref() else {

            return Err(RuleNotApplicable);

        let Ok(matrix_values) = repr.expression_down(symbols) else {

            return Err(RuleNotApplicable);

        let flat_values = matrix::enumerate_indices(index_domains.clone())

            .map(|i| {

                matrix_values[&Name::Represented(Box::new((

                    name.as_ref().clone(),

                    "matrix_to_atom".into(),

                    i.iter().join("_").into(),

                )))]

                    .clone()

            })

            .collect_vec();

        return Ok(Reduction::pure(into_matrix_expr![flat_values]));

    }

    Err(RuleNotApplicable)

}