Upgrade to foliage 0.2 development version

This commit is contained in:
2020-04-17 00:09:44 +02:00
parent f83695b5dc
commit becd8d4c19
9 changed files with 152 additions and 495 deletions

View File

@@ -1,5 +1,5 @@
pub(crate) fn choose_value_in_primitive(term: Box<foliage::Term>,
variable_declaration: &std::rc::Rc<foliage::VariableDeclaration>)
variable_declaration: std::rc::Rc<foliage::VariableDeclaration>)
-> foliage::Formula
{
let variable = foliage::Term::variable(variable_declaration);
@@ -8,7 +8,7 @@ pub(crate) fn choose_value_in_primitive(term: Box<foliage::Term>,
}
pub(crate) fn choose_value_in_term<C>(term: &clingo::ast::Term,
variable_declaration: &std::rc::Rc<foliage::VariableDeclaration>, context: &C)
variable_declaration: std::rc::Rc<foliage::VariableDeclaration>, context: &C)
-> Result<foliage::Formula, crate::Error>
where
C: crate::traits::GetOrCreateFunctionDeclaration
@@ -42,14 +42,16 @@ where
// At this point, we only have to handle (0-ary) constants
if !arguments.is_empty()
{
return Err(crate::Error::new_logic("unexpected arguments, expected (0-ary) constant symbol"));
return Err(crate::Error::new_logic(
"unexpected arguments, expected (0-ary) constant symbol"));
}
let constant_name = symbol.name()
.map_err(|error| crate::Error::new_logic("clingo error").with(error))?;
let constant_declaration = context.get_or_create_function_declaration(constant_name, 0);
let function = foliage::Term::function(&constant_declaration, vec![]);
let constant_declaration =
context.get_or_create_function_declaration(constant_name, 0);
let function = foliage::Term::function(constant_declaration, vec![]);
Ok(choose_value_in_primitive(Box::new(function), variable_declaration))
}
@@ -60,7 +62,7 @@ where
variable_name);
context.assign_variable_declaration_domain(&other_variable_declaration,
crate::Domain::Program);
let other_variable = foliage::Term::variable(&other_variable_declaration);
let other_variable = foliage::Term::variable(other_variable_declaration);
Ok(choose_value_in_primitive(Box::new(other_variable), variable_declaration))
},
@@ -90,22 +92,21 @@ where
let parameter_2 = &parameters[1];
let translated_binary_operation = foliage::Term::binary_operation(operator,
Box::new(foliage::Term::variable(&parameter_1)),
Box::new(foliage::Term::variable(&parameter_2)));
Box::new(foliage::Term::variable(std::rc::Rc::clone(&parameter_1))),
Box::new(foliage::Term::variable(std::rc::Rc::clone(&parameter_2))));
let equals = foliage::Formula::equal(
Box::new(foliage::Term::variable(variable_declaration)),
Box::new(translated_binary_operation));
let choose_value_from_left_argument = choose_value_in_term(
binary_operation.left(), &parameter_1, context)?;
binary_operation.left(), std::rc::Rc::clone(&parameter_1), context)?;
let choose_value_from_right_argument = choose_value_in_term(
binary_operation.right(), &parameter_2, context)?;
binary_operation.right(), std::rc::Rc::clone(&parameter_2), context)?;
let and = foliage::Formula::And(vec![Box::new(equals),
Box::new(choose_value_from_left_argument),
Box::new(choose_value_from_right_argument)]);
let and = foliage::Formula::And(vec![equals, choose_value_from_left_argument,
choose_value_from_right_argument]);
Ok(foliage::Formula::exists(parameters, Box::new(and)))
},
@@ -130,40 +131,42 @@ where
let parameter_r = &parameters[3];
let j_times_q = foliage::Term::multiply(
Box::new(foliage::Term::variable(parameter_j)),
Box::new(foliage::Term::variable(parameter_q)));
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_j))),
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_q))));
let j_times_q_plus_r = foliage::Term::add(Box::new(j_times_q),
Box::new(foliage::Term::variable(parameter_r)));
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_r))));
let i_equals_j_times_q_plus_r = foliage::Formula::equal(
Box::new(foliage::Term::variable(parameter_j)), Box::new(j_times_q_plus_r));
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_j))),
Box::new(j_times_q_plus_r));
let choose_i_in_t1 = choose_value_in_term(binary_operation.left(), parameter_i,
context)?;
let choose_i_in_t1 = choose_value_in_term(binary_operation.left(),
std::rc::Rc::clone(parameter_i), context)?;
let choose_i_in_t2 = choose_value_in_term(binary_operation.left(), parameter_j,
context)?;
let choose_i_in_t2 = choose_value_in_term(binary_operation.left(),
std::rc::Rc::clone(parameter_j), context)?;
let j_not_equal_to_0 = foliage::Formula::not_equal(
Box::new(foliage::Term::variable(parameter_j)),
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_j))),
Box::new(foliage::Term::integer(0)));
let r_greater_or_equal_to_0 = foliage::Formula::greater_or_equal(
Box::new(foliage::Term::variable(parameter_r)),
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_r))),
Box::new(foliage::Term::integer(0)));
let r_less_than_q = foliage::Formula::less(
Box::new(foliage::Term::variable(parameter_r)),
Box::new(foliage::Term::variable(parameter_q)));
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_r))),
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_q))));
let z_equal_to_q = foliage::Formula::equal(
Box::new(foliage::Term::variable(variable_declaration)),
Box::new(foliage::Term::variable(parameter_q)));
Box::new(
foliage::Term::variable(std::rc::Rc::clone(&variable_declaration))),
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_q))));
let z_equal_to_r = foliage::Formula::equal(
Box::new(foliage::Term::variable(variable_declaration)),
Box::new(foliage::Term::variable(parameter_r)));
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_r))));
let last_argument = match operator
{
@@ -172,10 +175,9 @@ where
_ => return Err(crate::Error::new_logic("unreachable code")),
};
let and = foliage::Formula::and(vec![Box::new(i_equals_j_times_q_plus_r),
Box::new(choose_i_in_t1), Box::new(choose_i_in_t2),
Box::new(j_not_equal_to_0), Box::new(r_greater_or_equal_to_0),
Box::new(r_less_than_q), Box::new(last_argument)]);
let and = foliage::Formula::and(vec![i_equals_j_times_q_plus_r, choose_i_in_t1,
choose_i_in_t2, j_not_equal_to_0, r_greater_or_equal_to_0, r_less_than_q,
last_argument]);
Ok(foliage::Formula::exists(parameters, Box::new(and)))
},
@@ -197,16 +199,15 @@ where
crate::Domain::Integer);
let negative_z_prime = foliage::Term::negative(Box::new(
foliage::Term::variable(&parameter_z_prime)));
foliage::Term::variable(std::rc::Rc::clone(&parameter_z_prime))));
let equals = foliage::Formula::equal(
Box::new(foliage::Term::variable(variable_declaration)),
Box::new(negative_z_prime));
let choose_z_prime_in_t_prime = choose_value_in_term(unary_operation.argument(),
&parameter_z_prime, context)?;
std::rc::Rc::clone(&parameter_z_prime), context)?;
let and = foliage::Formula::and(vec![Box::new(equals),
Box::new(choose_z_prime_in_t_prime)]);
let and = foliage::Formula::and(vec![equals, choose_z_prime_in_t_prime]);
let parameters = std::rc::Rc::new(vec![parameter_z_prime]);
@@ -232,25 +233,26 @@ where
let parameter_j = &parameters[1];
let parameter_k = &parameters[2];
let choose_i_in_t_1 = choose_value_in_term(interval.left(), parameter_i, context)?;
let choose_i_in_t_1 = choose_value_in_term(interval.left(),
std::rc::Rc::clone(parameter_i), context)?;
let choose_j_in_t_2 = choose_value_in_term(interval.right(), parameter_j, context)?;
let choose_j_in_t_2 = choose_value_in_term(interval.right(),
std::rc::Rc::clone(parameter_j), context)?;
let i_less_than_or_equal_to_k = foliage::Formula::less_or_equal(
Box::new(foliage::Term::variable(parameter_i)),
Box::new(foliage::Term::variable(parameter_k)));
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_i))),
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_k))));
let k_less_than_or_equal_to_j = foliage::Formula::less_or_equal(
Box::new(foliage::Term::variable(parameter_k)),
Box::new(foliage::Term::variable(parameter_j)));
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_k))),
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_j))));
let z_equals_k = foliage::Formula::equal(
Box::new(foliage::Term::variable(variable_declaration)),
Box::new(foliage::Term::variable(parameter_k)));
Box::new(foliage::Term::variable(std::rc::Rc::clone(parameter_k))));
let and = foliage::Formula::and(vec![Box::new(choose_i_in_t_1),
Box::new(choose_j_in_t_2), Box::new(i_less_than_or_equal_to_k),
Box::new(k_less_than_or_equal_to_j), Box::new(z_equals_k)]);
let and = foliage::Formula::and(vec![choose_i_in_t_1, choose_j_in_t_2,
i_less_than_or_equal_to_k, k_less_than_or_equal_to_j, z_equals_k]);
Ok(foliage::Formula::exists(parameters, Box::new(and)))
},

View File

@@ -105,7 +105,7 @@ where
for definition in definitions.definitions.iter()
{
log::debug!("definition({}/{}): {}.", predicate_declaration.name, predicate_declaration.arity,
crate::output::human_readable::display_formula(&definition.formula, None, &context));
foliage::format::display_formula(&definition.formula, &context));
}
}
@@ -122,14 +122,14 @@ where
let or = foliage::Formula::or(or_arguments);
let head_arguments = definitions.head_atom_parameters.iter()
.map(|x| Box::new(foliage::Term::variable(x)))
.map(|x| foliage::Term::variable(std::rc::Rc::clone(x)))
.collect::<Vec<_>>();
let head_predicate = foliage::Formula::predicate(&predicate_declaration,
head_arguments);
let head_predicate = foliage::Formula::predicate(
std::rc::Rc::clone(predicate_declaration), head_arguments);
let completed_definition = foliage::Formula::if_and_only_if(
Box::new(head_predicate), Box::new(or));
let completed_definition =
foliage::Formula::if_and_only_if(vec![head_predicate, or]);
let scoped_formula = crate::ScopedFormula
{
@@ -154,11 +154,11 @@ where
.collect::<Vec<_>>());
let head_arguments = head_atom_parameters.iter()
.map(|x| Box::new(foliage::Term::variable(x)))
.map(|x| foliage::Term::variable(std::rc::Rc::clone(x)))
.collect();
let head_predicate = foliage::Formula::predicate(&predicate_declaration,
head_arguments);
let head_predicate = foliage::Formula::predicate(
std::rc::Rc::clone(predicate_declaration), head_arguments);
let not = foliage::Formula::not(Box::new(head_predicate));
@@ -197,7 +197,7 @@ where
match output_format
{
crate::output::Format::HumanReadable => print!("{}",
crate::output::human_readable::display_formula(formula, None, &context)),
foliage::format::display_formula(formula, &context)),
crate::output::Format::TPTP => print!("{}",
crate::output::tptp::display_formula(formula, &context)),
}
@@ -380,13 +380,13 @@ fn read_rule(rule: &clingo::ast::Rule, context: &Context) -> Result<(), crate::E
if let HeadType::ChoiceWithSingleAtom(_) = head_type
{
let head_arguments = definitions.head_atom_parameters.iter()
.map(|x| Box::new(foliage::Term::variable(x)))
.map(|x| foliage::Term::variable(std::rc::Rc::clone(x)))
.collect::<Vec<_>>();
let head_predicate = foliage::Formula::predicate(&head_atom.predicate_declaration,
head_arguments);
let head_predicate = foliage::Formula::predicate(
std::rc::Rc::clone(&head_atom.predicate_declaration), head_arguments);
definition_arguments.push(Box::new(head_predicate));
definition_arguments.push(head_predicate);
}
let mut head_atom_arguments_iterator = head_atom.arguments.iter();
@@ -396,9 +396,9 @@ fn read_rule(rule: &clingo::ast::Rule, context: &Context) -> Result<(), crate::E
let head_atom_argument = head_atom_arguments_iterator.next().unwrap();
let translated_head_term = crate::translate::common::choose_value_in_term(
head_atom_argument, head_atom_parameter, context)?;
head_atom_argument, std::rc::Rc::clone(head_atom_parameter), context)?;
definition_arguments.push(Box::new(translated_head_term));
definition_arguments.push(translated_head_term);
}
context.variable_declaration_stack.borrow_mut().pop()?;
@@ -410,18 +410,18 @@ fn read_rule(rule: &clingo::ast::Rule, context: &Context) -> Result<(), crate::E
let definition = match definition_arguments.len()
{
1 => definition_arguments.pop().unwrap(),
0 => Box::new(foliage::Formula::true_()),
_ => Box::new(foliage::Formula::and(definition_arguments)),
0 => foliage::Formula::true_(),
_ => foliage::Formula::and(definition_arguments),
};
let definition = crate::ScopedFormula
{
free_variable_declarations: std::rc::Rc::new(free_variable_declarations),
formula: definition,
formula: Box::new(definition),
};
log::debug!("translated rule with single atom in head: {}",
crate::output::human_readable::display_formula(&definition.formula, None, context));
foliage::format::display_formula(&definition.formula, context));
definitions.definitions.push(definition);
},
@@ -435,7 +435,7 @@ fn read_rule(rule: &clingo::ast::Rule, context: &Context) -> Result<(), crate::E
let formula = match arguments.len()
{
1 => foliage::Formula::not(arguments.pop().unwrap()),
1 => foliage::Formula::not(Box::new(arguments.pop().unwrap())),
0 => foliage::Formula::false_(),
_ => foliage::Formula::not(Box::new(foliage::Formula::and(arguments))),
};
@@ -449,8 +449,7 @@ fn read_rule(rule: &clingo::ast::Rule, context: &Context) -> Result<(), crate::E
let integrity_constraint = crate::universal_closure(scoped_formula);
log::debug!("translated integrity constraint: {}",
crate::output::human_readable::display_formula(&integrity_constraint, None,
context));
foliage::format::display_formula(&integrity_constraint, context));
context.integrity_constraints.borrow_mut().push(integrity_constraint);
},

View File

@@ -208,3 +208,14 @@ impl crate::traits::VariableDeclarationID for Context
}
}
}
impl foliage::format::Format for Context
{
fn display_variable_declaration(&self, formatter: &mut std::fmt::Formatter,
variable_declaration: &std::rc::Rc<foliage::VariableDeclaration>)
-> std::fmt::Result
{
crate::output::human_readable::display_variable_declaration(self, formatter,
variable_declaration)
}
}

View File

@@ -30,10 +30,10 @@ where
let parameters = std::rc::Rc::new(parameters);
let predicate_arguments = parameters.iter().map(
|parameter| Box::new(foliage::Term::variable(parameter)))
|parameter| foliage::Term::variable(std::rc::Rc::clone(parameter)))
.collect::<Vec<_>>();
let predicate = foliage::Formula::predicate(&predicate_declaration, predicate_arguments);
let predicate = foliage::Formula::predicate(predicate_declaration, predicate_arguments);
let predicate_literal = match sign
{
@@ -53,12 +53,11 @@ where
let mut parameters_iterator = parameters.iter();
let mut arguments = function.arguments().iter().map(
|x| crate::translate::common::choose_value_in_term(x, &parameters_iterator.next().unwrap(),
context)
.map(|x| Box::new(x)))
|x| crate::translate::common::choose_value_in_term(x,
std::rc::Rc::clone(&parameters_iterator.next().unwrap()), context))
.collect::<Result<Vec<_>, _>>()?;
arguments.push(Box::new(predicate_literal));
arguments.push(predicate_literal);
let and = foliage::Formula::and(arguments);
@@ -120,12 +119,12 @@ where
let parameter_z2 = &parameters_iterator.next().unwrap();
let choose_z1_in_t1 = crate::translate::common::choose_value_in_term(comparison.left(),
parameter_z1, context)?;
std::rc::Rc::clone(parameter_z1), context)?;
let choose_z2_in_t2 = crate::translate::common::choose_value_in_term(comparison.right(),
parameter_z2, context)?;
std::rc::Rc::clone(parameter_z2), context)?;
let variable_1 = foliage::Term::variable(parameter_z1);
let variable_2 = foliage::Term::variable(parameter_z2);
let variable_1 = foliage::Term::variable(std::rc::Rc::clone(parameter_z1));
let variable_2 = foliage::Term::variable(std::rc::Rc::clone(parameter_z2));
let operator = crate::translate::common::translate_comparison_operator(
comparison.comparison_type());
@@ -133,8 +132,8 @@ where
let compare_z1_and_z2 = foliage::Formula::compare(operator, Box::new(variable_1),
Box::new(variable_2));
let and = foliage::Formula::and(vec![Box::new(choose_z1_in_t1),
Box::new(choose_z2_in_t2), Box::new(compare_z1_and_z2)]);
let and =
foliage::Formula::and(vec![choose_z1_in_t1, choose_z2_in_t2, compare_z1_and_z2]);
Ok(foliage::Formula::exists(parameters, Box::new(and)))
},
@@ -153,7 +152,6 @@ where
+ crate::traits::AssignVariableDeclarationDomain
{
body_literals.iter()
.map(|body_literal| translate_body_literal(body_literal, context)
.map(|value| Box::new(value)))
.map(|body_literal| translate_body_literal(body_literal, context))
.collect::<Result<foliage::Formulas, crate::Error>>()
}