pub fn symbolize_and_assert(&self, constraint: &il::Expression) -> Result<bool> {
        let expression = self.symbolize_expression(constraint)?;

        if expression.all_constants() {
            Ok(eval(&expression)?.is_one())
        } else if self.merged_constraints.is_empty() {
            let mut constraints = self.path_constraints();
            constraints.push(expression);

            Ok(solve(&constraints, &il::expr_scalar("asisjelisf", 1))?.is_some())
        }
        // If we have merged constraints, we need to assert that at least one
        // set of merged constraints is true
        else {
            let path_constraints = self
                .path_constraints()
                .into_iter()
                .fold(il::expr_const(1, 1), |sum, constraint| {
                    il::Expression::and(sum, constraint).unwrap()
                });
            let merged_constraints =
                self.merged_constraints()
                    .into_iter()
                    .fold(path_constraints, |ite, constraints| {
                        let constraints = constraints
                            .into_iter()
                            .fold(il::expr_const(1, 1), |sum, constraint| {
                                il::Expression::and(sum, constraint).unwrap()
                            });
                        il::Expression::ite(constraints, il::expr_const(1, 1), ite).unwrap()
                    });

            let merged_constraints = il::Expression::and(expression, merged_constraints)?;

            Ok(solve(&[merged_constraints], &il::expr_scalar("lsdkfjsoeifjs", 1))?.is_some())
        }
    }
/// Symbolize the given expression, replacing all scalars with the symbolic
/// values held in this state, and evaluate whether the given constraint is
/// true/satisfiable
Symbolize the given expression, replacing all scalars with the symbolic
values held in this state, and evaluate whether the given constraint is
true/satisfiable
Symbolize the given expression replacing all scalars with the symbolic values held in this state and evaluate whether the given constraint is true / satisfiable
pub fn symbolize_and_assert(&self, constraint: &il::Expression) -> Result<bool> {
        let expression = self.symbolize_expression(constraint)?;
        if expression.all_constants() {
            Ok(eval(&expression)?.is_one())
        } else if self.merged_constraints.is_empty() {
            let mut constraints = self.path_constraints();
            constraints.push(expression);
            Ok(solve(&constraints, &il::expr_scalar("asisjelisf", 1))?.is_some())
        }
        // If we have merged constraints, we need to assert that at least one
        // set of merged constraints is true
        else {
            let path_constraints = self
                .path_constraints()
                .into_iter()
                .fold(il::expr_const(1, 1), |sum, constraint| {
                    il::Expression::and(sum, constraint).unwrap()
                });
            let merged_constraints =
                self.merged_constraints()
                    .into_iter()
                    .fold(path_constraints, |ite, constraints| {
                        let constraints = constraints
                            .into_iter()
                            .fold(il::expr_const(1, 1), |sum, constraint| {
                                il::Expression::and(sum, constraint).unwrap()
                            });
                        il::Expression::ite(constraints, il::expr_const(1, 1), ite).unwrap()
                    });
            let merged_constraints = il::Expression::and(expression, merged_constraints)?;
            Ok(solve(&[merged_constraints], &il::expr_scalar("lsdkfjsoeifjs", 1))?.is_some())
        }
    }
pub fn symbolize_and_assert ( & self , constraint : & il :: Expression ) -> Result < bool > { let expression = self . symbolize_expression ( constraint ) ? ; if expression . all_constants ( ) { Ok ( eval ( & expression ) ? . is_one ( ) ) } else if self . merged_constraints . is_empty ( ) { let mut constraints = self . path_constraints ( ) ; constraints . push ( expression ) ; Ok ( solve ( & constraints , & il :: expr_scalar ( " " , 1 ) ) ? . is_some ( ) ) } // If we have merged constraints, we need to assert that at least one // set of merged constraints is true else { let path_constraints = self . path_constraints ( ) . into_iter ( ) . fold ( il :: expr_const ( 1 , 1 ) , | sum , constraint | { il :: Expression :: and ( sum , constraint ) . unwrap ( ) } ) ; let merged_constraints = self . merged_constraints ( ) . into_iter ( ) . fold ( path_constraints , | ite , constraints | { let constraints = constraints . into_iter ( ) . fold ( il :: expr_const ( 1 , 1 ) , | sum , constraint | { il :: Expression :: and ( sum , constraint ) . unwrap ( ) } ) ; il :: Expression :: ite ( constraints , il :: expr_const ( 1 , 1 ) , ite ) . unwrap ( ) } ) ; let merged_constraints = il :: Expression :: and ( expression , merged_constraints ) ? ; Ok ( solve ( & [ merged_constraints ] , & il :: expr_scalar ( " " , 1 ) ) ? . is_some ( ) ) } }
Symbolize the given expression, replacing all scalars with the symbolic
values held in this state, and evaluate whether the given constraint is
true/satisfiable
Symbolize the given expression replacing all scalars with the symbolic values held in this state and evaluate whether the given constraint is true / satisfiable
&self
constraint
&il::Expression