bool KnowledgeBase::IsSatisfiable(const Argument& arg) { // get answer Answer *ans = GetAnswer(arg, VariableMap(), std::set<size_t>()); // return if any valid substitution exists bool res = ans->next(); delete ans; return res; }
bool KnowledgeBase::IsSatisfiable(const std::string& s_arg) { Argument arg(s_arg, symbol_table, true, log); // get answer Answer *ans = GetAnswer(arg, VariableMap(), std::set<size_t>()); // return if any valid substitution exists bool res = ans->next(); delete ans; return res; }
std::list<Argument*> KnowledgeBase::Ask(const Argument& arg, bool checkForDoubles) { std::list<Argument*> out; // get answer Answer *ans = GetAnswer(arg, VariableMap(), std::set<size_t>()); // get all the valid substitution and add them to list if(!checkForDoubles) { while(ans->next()) { Argument* temp = Unify::GetSubstitutedArgument(&arg, ans->GetVariableMap()); out.push_back(temp); } } else { std::set<std::string> str_ans; while(ans->next()) { Argument* temp = Unify::GetSubstitutedArgument(&arg, ans->GetVariableMap()); std::stringstream stream; stream << *temp; //SymbolDecodeStream sds(symbol_table); //sds << *temp << endl; if(str_ans.find(stream.str()) == str_ans.end()) { out.push_back(temp); str_ans.insert(stream.str()); } else delete temp; } } // delete answer delete ans; return out; }
void KIFFlattener::FlattenRelation(const DGraphNode* n, const KnowledgeBase& all_kb, const std::set<size_t>& state_independent, KnowledgeBase& m_kb, std::list<Clause>& f_clauses, std::list<Fact>& f_facts) { //compute signature of relation const size_t& sig = n->id; // get all the facts and clauses associated with this signature const KnowledgeBase::FactList* facts = all_kb.GetFacts(sig); const KnowledgeBase::ClauseList* p_clauses = all_kb.GetClauses(sig); if(p_clauses == NULL) { if(facts != NULL) for(KnowledgeBase::FactList::const_iterator it = facts->begin(); it != facts->end();it++) { f_facts.push_back(*it); m_kb.Tell(*it); } return; } const KnowledgeBase::ClauseList& clauses = *p_clauses; // to store the heads of the flattened clauses // these will be added later to temporary knowledge base list<Argument*> f_heads; // start flattening clauses for(list<Clause>::const_iterator it = clauses.begin();it != clauses.end();it++) { // if the clause is already ground add it directly // add its head to heads list if((*it).IsGround()) { Clause* to_add = new Clause(*it); f_clauses.push_back(*to_add); f_heads.push_back(to_add->head); to_add->head = NULL; delete to_add; continue; } // pre-process the clause // adjust the extra variables which are present in body but not head // adjust 'not' relation appropriately Clause* p_clause = ProcessClause(*it, state_independent); // add the processed clause temporarily to knowledge base size_t c_index = m_kb.Tell(*p_clause); VariableMap h_v_map; Argument* question = SpecialArgCopy2(p_clause->head, h_v_map); // after adding the head of the clause will be the question to ask Answer* ans = m_kb.GetAnswer(*question, VariableMap(), set<size_t>()); while(ans->next()) { VariableMap ans_v_map = ans->GetVariableMap(); for(auto va : h_v_map) ans_v_map.insert(va); // compute the answer with substitution Clause* to_add = Unify::GetSubstitutedClause(&(*it), ans_v_map); // remove all the occurrences of data relations Clause* temp = RemoveDataFromClause(to_add, state_independent); // check whether clause can be converted to fact after data relations removal if(temp == NULL) { Argument* h = to_add->head; to_add->head = NULL; delete to_add; f_facts.push_back(*h); f_facts.back().loc = (*it).loc; f_facts.back().isLocation = (*it).isLocation; f_heads.push_back(h); } else { f_clauses.push_back(*temp); f_clauses.back().loc = (*it).loc; f_clauses.back().isLocation = (*it).isLocation; f_heads.push_back(temp->head); temp->head = NULL; delete temp; } } // delete answer delete ans; // erase the temporary knowledge from knowledge base m_kb.Erase(*p_clause, c_index); // delete the processed clause(without deleting the variables SpecialClauseDelete(p_clause); delete question; } // add all the facts related to this relation to knowledge base if(facts != NULL) for(list<Fact>::const_iterator it = facts->begin();it != facts->end();it++) { f_facts.push_back(*it); m_kb.Tell(*it); } // compute signature and add to appropriate FactVec size_t command = n->id; KnowledgeBase::FactList& fl = m_kb.m_facts[command]; // add heads of all the clauses to knowledge base for(list<Argument*>::iterator it = f_heads.begin();it != f_heads.end();it++) { Fact f; f.arg = *it; fl.push_back(std::move(f)); } }