void TheoryEngineModelBuilder::processBuildModel(TheoryModel* m, bool fullModel)
{
if (fullModel) {
Trace("model-builder") << "Assigning function values..." << endl;
//construct function values
for( std::map< Node, std::vector< Node > >::iterator it = m->d_uf_terms.begin(); it != m->d_uf_terms.end(); ++it ){
Node n = it->first;
if( m->d_uf_models.find( n )==m->d_uf_models.end() ){
TypeNode type = n.getType();
uf::UfModelTree ufmt( n );
Node default_v, un, simp, v;
for( size_t i=0; i<it->second.size(); i++ ){
un = it->second[i];
vector<TNode> children;
children.push_back(n);
for (size_t j = 0; j < un.getNumChildren(); ++j) {
children.push_back(m->getRepresentative(un[j]));
}
simp = NodeManager::currentNM()->mkNode(un.getKind(), children);
v = m->getRepresentative(un);
Trace("model-builder") << " Setting (" << simp << ") to (" << v << ")" << endl;
ufmt.setValue(m, simp, v);
default_v = v;
}
if( default_v.isNull() ){
//choose default value from model if none exists
TypeEnumerator te(type.getRangeType());
default_v = (*te);
}
ufmt.setDefaultValue( m, default_v );
ufmt.simplify();
Node val = ufmt.getFunctionValue( "_ufmt_" );
Trace("model-builder") << " Assigning (" << n << ") to (" << val << ")" << endl;
m->d_uf_models[n] = val;
//ufmt.debugPrint( std::cout, m );
}
}
}
}
Node TheoryModel::getModelValue(TNode n, bool hasBoundVars) const
{
Assert(n.getKind() != kind::FORALL && n.getKind() != kind::EXISTS);
if(n.getKind() == kind::LAMBDA) {
NodeManager* nm = NodeManager::currentNM();
Node body = getModelValue(n[1], true);
// This is a bit ugly, but cache inside simplifier can change, so can't be const
// The ite simplifier is needed to get rid of artifacts created by Boolean terms
body = const_cast<ITESimplifier*>(&d_iteSimp)->simpITE(body);
body = Rewriter::rewrite(body);
return nm->mkNode(kind::LAMBDA, n[0], body);
}
if(n.isConst() || (hasBoundVars && n.getKind() == kind::BOUND_VARIABLE)) {
return n;
}
TypeNode t = n.getType();
if (t.isFunction() || t.isPredicate()) {
if (d_enableFuncModels) {
std::map< Node, Node >::const_iterator it = d_uf_models.find(n);
if (it != d_uf_models.end()) {
// Existing function
return it->second;
}
// Unknown function symbol: return LAMBDA x. c, where c is the first constant in the enumeration of the range type
vector<TypeNode> argTypes = t.getArgTypes();
vector<Node> args;
NodeManager* nm = NodeManager::currentNM();
for (unsigned i = 0; i < argTypes.size(); ++i) {
args.push_back(nm->mkBoundVar(argTypes[i]));
}
Node boundVarList = nm->mkNode(kind::BOUND_VAR_LIST, args);
TypeEnumerator te(t.getRangeType());
return nm->mkNode(kind::LAMBDA, boundVarList, *te);
}
// TODO: if func models not enabled, throw an error?
Unreachable();
}
if (n.getNumChildren() > 0) {
std::vector<Node> children;
if (n.getKind() == APPLY_UF) {
Node op = getModelValue(n.getOperator(), hasBoundVars);
children.push_back(op);
}
else if (n.getMetaKind() == kind::metakind::PARAMETERIZED) {
children.push_back(n.getOperator());
}
//evaluate the children
for (unsigned i = 0; i < n.getNumChildren(); ++i) {
Node val = getModelValue(n[i], hasBoundVars);
children.push_back(val);
}
Node val = Rewriter::rewrite(NodeManager::currentNM()->mkNode(n.getKind(), children));
Assert(hasBoundVars || val.isConst());
return val;
}
if (!d_equalityEngine.hasTerm(n)) {
// Unknown term - return first enumerated value for this type
TypeEnumerator te(n.getType());
return *te;
}
Node val = d_equalityEngine.getRepresentative(n);
Assert(d_reps.find(val) != d_reps.end());
std::map< Node, Node >::const_iterator it = d_reps.find( val );
if( it!=d_reps.end() ){
return it->second;
}else{
return Node::null();
}
}
