Diff Coverage

            GroundDomain::MSet(mset_attr, inner_domain) => {
                let inner_len = inner_domain.length()?;
                let (min_sz, max_sz) = match mset_attr.size {
                    Range::Unbounded => (0, inner_len),
                    Range::Single(n) => (n, n),
                    Range::UnboundedR(n) => (n, inner_len),
                    Range::UnboundedL(n) => (0, n),
                    Range::Bounded(min, max) => (min, max),
                };
                let mut ans = 0i32;
                for sz in min_sz..=max_sz {
                    // need  "multichoose", ((n  k)) == (n+k-1  k)
                    // Where n=inner_len and k=sz
                    let c = count_combinations(inner_len + sz - 1, sz)?;

            let dom = inner.domain_of().and_then(|dom| dom.resolve())?;
            let GroundDomain::Matrix(_, index_domains) = dom.as_ref() else {
                return None;
            };
            let flat_index = flat_index_to_full_index(index_domains, index - 1);
            let flat_index: Vec<Expr> = flat_index.into_iter().map(Into::into).collect();

            Some(Expr::SafeIndex(Metadata::new(), inner, flat_index))
        }

/// P(n, r) = n! / (n-r)!
///
/// Not defined for r > n.
#[allow(dead_code)]
pub fn count_permutations(n_total: i32, n_choose: i32) -> Result<i32, CombinatoricsError> {
    if n_choose > n_total {
        return Err(CombinatoricsError::not_defined(
            "n_choose must be <= n_total",
        ));

    let start = n_total
        .checked_sub(n_choose)
        .ok_or(CombinatoricsError::Overflow)?
        .checked_add(1i32)
        .ok_or(CombinatoricsError::Overflow)?;
    (start..=n_total).try_fold(1i32, |acc, val| {
        acc.checked_mul(val).ok_or(CombinatoricsError::Overflow)
    })
}