int main(int argc, char** argv) { // set up vtree and manager SddLiteral var_count = 4; const char* type = "right"; Vtree* vtree = sdd_vtree_new(var_count,type); SddManager* manager = sdd_manager_new(vtree); // construct the term X_1 ^ X_2 ^ X_3 ^ X_4 SddNode* alpha = sdd_manager_literal(1,manager); alpha = sdd_conjoin(alpha,sdd_manager_literal(2,manager),manager); alpha = sdd_conjoin(alpha,sdd_manager_literal(3,manager),manager); alpha = sdd_conjoin(alpha,sdd_manager_literal(4,manager),manager); // construct the term ~X_1 ^ X_2 ^ X_3 ^ X_4 SddNode* beta = sdd_manager_literal(-1,manager); beta = sdd_conjoin(beta,sdd_manager_literal(2,manager),manager); beta = sdd_conjoin(beta,sdd_manager_literal(3,manager),manager); beta = sdd_conjoin(beta,sdd_manager_literal(4,manager),manager); // construct the term ~X_1 ^ ~X_2 ^ X_3 ^ X_4 SddNode* gamma = sdd_manager_literal(-1,manager); gamma = sdd_conjoin(gamma,sdd_manager_literal(-2,manager),manager); gamma = sdd_conjoin(gamma,sdd_manager_literal(3,manager),manager); gamma = sdd_conjoin(gamma,sdd_manager_literal(4,manager),manager); printf("== before referencing:\n"); printf(" live sdd size = %zu\n", sdd_manager_live_size(manager)); printf(" dead sdd size = %zu\n", sdd_manager_dead_size(manager)); // ref SDDs so that they are not garbage collected sdd_ref(alpha,manager); sdd_ref(beta,manager); sdd_ref(gamma,manager); printf("== after referencing:\n"); printf(" live sdd size = %zu\n", sdd_manager_live_size(manager)); printf(" dead sdd size = %zu\n", sdd_manager_dead_size(manager)); // garbage collect sdd_manager_garbage_collect(manager); printf("== after garbage collection:\n"); printf(" live sdd size = %zu\n", sdd_manager_live_size(manager)); printf(" dead sdd size = %zu\n", sdd_manager_dead_size(manager)); sdd_deref(alpha,manager); sdd_deref(beta,manager); sdd_deref(gamma,manager); printf("saving vtree & shared sdd ...\n"); sdd_vtree_save_as_dot("output/shared-vtree.dot",vtree); sdd_shared_save_as_dot("output/shared.dot",manager); sdd_vtree_free(vtree); sdd_manager_free(manager); return 0; }
int main(int argc, char** argv) { //Read input and convert to KFormulas. Options* opts = new Options(argc,argv); KFormula* notPsiNNF; std::string input; getline (std::cin, input); if (opts->verbose) std::cout << "Building Kformulas from input...\n"; if (input.length() == 0) { std::cout << "Empty formula is valid."; return 0; } else if (opts->satisfying) { notPsiNNF = KFormula::toBoxNNF(KFormula::parseKFormula(input.c_str())); } else { notPsiNNF = KFormula::toBoxNNF(new KFormula(KFormula::NOT,KFormula::parseKFormula(input.c_str()),NULL)); } if (opts->verbose) std::cout << " Kformulas built!\n"; //Gather atoms from KFormulas and assign literals. if (opts->verbose) std::cout << "Assigning literals...\n"; std::vector<KFormula*> atoms = KFormula::getAtoms(notPsiNNF); SddLiteral var_count = compiler::setLiterals(atoms, literalsToAtoms, atomsToLiterals); if (opts->verbose) { std::cout << " Literals assigned!\n"; } //Initialise SDD library. Vtree* vtree = sdd_vtree_new(var_count,"balanced"); SddManager* m = sdd_manager_new(vtree); sdd_vtree_free(vtree); sdd_manager_auto_gc_and_minimize_on(m); //sdd_manager_set_minimize_function(sdd_vtree_minimize,m); //Build SDDs if (opts->verbose) std::cout << "Converting Kformulas to SDDs...\n"; std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now(); SddNode* notPsiSdd = compiler::KtoSDD(notPsiNNF,m); sdd_ref(notPsiSdd,m); std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now(); auto SddDuration = std::chrono::duration_cast<std::chrono::microseconds>( t2 - t1 ).count(); int SddCount = sdd_count(notPsiSdd); int SddSize = sdd_size(notPsiSdd); if (opts->reportSize) { std::cout << SddCount << "\n"; return 0; } if (opts->verbose) std::cout << " SDD conversion complete!\n"; //Check satisfiability or validity Prover* prover = proverFactory::getProver(opts->logic,literalsToAtoms, atomsToLiterals); t1 = std::chrono::high_resolution_clock::now(); bool isSat = prover->isSatisfiable(notPsiSdd,m); t2 = std::chrono::high_resolution_clock::now(); auto SolveDuration = std::chrono::duration_cast<std::chrono::microseconds>( t2 - t1 ).count(); //Output results. if (opts->verbose) { std::cout << "Stats:\n"; std::cout << " Initial Lit count = " << var_count << "\n"; std::cout << " Initial SDD size = " << SddSize << "\n"; std::cout << " Initial SDD count = " << SddCount << "\n"; std::cout << " Final manager size = " << sdd_manager_size(m) << "\n"; std::cout << " Time to build = " << SddDuration << "\n"; std::cout << " Time to solve = " << SolveDuration << "\n"; std::cout << " Total time = " << SddDuration + SolveDuration << "\n\n"; } if (opts->satisfying) { if (!isSat) std::cout << "Psi is not satisfiable!\n"; else std::cout << "Psi is satisfiable!\n"; } else { if (!isSat) std::cout << "Psi is valid!\n"; else std::cout << "Psi is not valid!\n"; } //Finish up. sdd_manager_free(m); return 0; }
int main(int argc, char** argv) { // set up vtree and manager SddLiteral var_count = 5; int auto_gc_and_minimize = 0; SddManager* m = sdd_manager_create(var_count,auto_gc_and_minimize); SddLiteral A = 1, B = 2, C = 3, faulty1 = 4, faulty2 = 5; SddNode* delta = sdd_manager_true(m); SddNode* alpha; ////////// CONSTRUCT KNOWLEDGE BASE ////////// // ~faulty1 => ( A <=> ~B ) alpha = sdd_equiv(sdd_manager_literal(A,m),sdd_manager_literal(-B,m),m); alpha = sdd_imply(sdd_manager_literal(-faulty1,m),alpha,m); delta = sdd_conjoin(delta,alpha,m); // faulty1 => ( ( A <=> B ) v ~B ) alpha = sdd_equiv(sdd_manager_literal(A,m),sdd_manager_literal(B,m),m); alpha = sdd_disjoin(alpha,sdd_manager_literal(-B,m),m); alpha = sdd_imply(sdd_manager_literal(faulty1,m),alpha,m); delta = sdd_conjoin(delta,alpha,m); // ~faulty2 => ( B <=> ~C ) alpha = sdd_equiv(sdd_manager_literal(B,m),sdd_manager_literal(-C,m),m); alpha = sdd_imply(sdd_manager_literal(-faulty2,m),alpha,m); delta = sdd_conjoin(delta,alpha,m); // faulty2 => ( ( B <=> C ) v ~C ) alpha = sdd_equiv(sdd_manager_literal(B,m),sdd_manager_literal(C,m),m); alpha = sdd_disjoin(alpha,sdd_manager_literal(-C,m),m); alpha = sdd_imply(sdd_manager_literal(faulty2,m),alpha,m); delta = sdd_conjoin(delta,alpha,m); ////////// PERFORM QUERY ////////// int* variables; SddLiteral health_vars = 2, health_vars_count, missing_health_vars; // make observations delta = sdd_condition(A,delta,m); delta = sdd_condition(-C,delta,m); // check if observations are normal SddNode* gamma; gamma = sdd_condition(-faulty1,delta,m); gamma = sdd_condition(-faulty2,gamma,m); int is_abnormal = gamma == sdd_manager_false(m); // sdd_node_is_false(gamma,m); printf("observations normal? : %s\n", is_abnormal ? "abnormal":"normal"); // project onto faults SddNode* diagnosis = sdd_exists(B,delta,m); // diagnosis no longer depends on variables A,B or C // count the number of diagnoses SddModelCount count = sdd_model_count(diagnosis,m); // adjust for missing faults variables = sdd_variables(diagnosis,m); health_vars_count = variables[faulty1] + variables[faulty2]; missing_health_vars = health_vars - health_vars_count; count <<= missing_health_vars; // multiply by 2^missing_health_vars free(variables); // find minimum cardinality diagnoses SddNode* min_diagnosis = sdd_minimize_cardinality(diagnosis,m); variables = sdd_variables(min_diagnosis,m); // adjust for missing faults if ( variables[faulty1] == 0 ) min_diagnosis = sdd_conjoin(min_diagnosis,sdd_manager_literal(-faulty1,m),m); if ( variables[faulty2] == 0 ) min_diagnosis = sdd_conjoin(min_diagnosis,sdd_manager_literal(-faulty2,m),m) ; free(variables); // count the number of minimum cardinality diagnoses, and minimum cardinality SddModelCount min_count = sdd_model_count(min_diagnosis,m); SddLiteral min_card = sdd_minimum_cardinality(min_diagnosis); printf("sdd model count : %"PRImcS"\n",count); printf("sdd model count (min) : %"PRImcS"\n",min_count); printf("sdd cardinality : %"PRIlitS"\n",min_card); ////////// SAVE SDDS ////////// printf("saving sdd and dot ...\n"); sdd_save("output/circuit-kb.sdd",delta); sdd_save("output/diagnosis.sdd",diagnosis); sdd_save("output/diagnosis-min.sdd",min_diagnosis); sdd_save_as_dot("output/circuit-kb.dot",delta); sdd_save_as_dot("output/diagnosis.dot",diagnosis); sdd_save_as_dot("output/diagnosis-min.dot",min_diagnosis); ////////// CLEAN UP ////////// sdd_manager_free(m); return 0; }
int main(int argc, char** argv) { //{ //* //0:A 1:B 2:S 3:T 4:U 5:X 6:Y int nonTerm = 7; int term = 2; int nonRuleCount = 6; int termRuleCount = 4; int start = 2; int len = 3; int nonRules[nonRuleCount][3]; int termRules[termRuleCount][2]; //S->XT nonRules[0][0] = 2; nonRules[0][1] = 5; nonRules[0][2] = 3; //S->UY nonRules[1][0] = 2; nonRules[1][1] = 4; nonRules[1][2] = 6; //X->AA nonRules[2][0] = 5; nonRules[2][1] = 0; nonRules[2][2] = 0; //Y->BB nonRules[3][0] = 6; nonRules[3][1] = 1; nonRules[3][2] = 1; //T->TB nonRules[4][0] = 3; nonRules[4][1] = 3; nonRules[4][2] = 1; //U->UA nonRules[5][0] = 4; nonRules[5][1] = 4; nonRules[5][2] = 0; //T->b termRules[0][0] = 3; termRules[0][1] = 1; //U->a termRules[1][0] = 4; termRules[1][1] = 0; //A->a termRules[2][0] = 0; termRules[2][1] = 0; //B->b termRules[3][0] = 1; termRules[3][1] = 1; //*/ // //0:A 1:B 2:T 3:S; 0:a 1:b //first example from text /* int nonTerm = 4; int term = 2; int nonRuleCount = 3; int termRuleCount = 2; int start = 3; int len = 4; int nonRules[nonRuleCount][3]; int termRules[termRuleCount][2]; //S->AT nonRules[0][0] = 3; nonRules[0][1] = 0; nonRules[0][2] = 2; //S->AB nonRules[1][0] = 3; nonRules[1][1] = 0; nonRules[1][2] = 1; //T->SB nonRules[2][0] = 2; nonRules[2][1] = 3; nonRules[2][2] = 1; //A->a termRules[0][0] = 0; termRules[0][1] = 0; //B->b termRules[1][0] = 1; termRules[1][1] = 1; */ /* { //* //0:A 1:B 2:S 3:T 4:U 5:X 6:Y int nonTerminal = 7; int terminal = 2; int ruleCount = 10; int start = 2; int len = 4; int rules[ruleCount][3]; int string[len]; string[0] = 0; string[1] = 0; int i; for(i = 2; i < len; i++) string[i] = 1; //S->XT rules[0][0] = 2; rules[0][1] = 5; rules[0][2] = 3; //S->UY rules[1][0] = 2; rules[1][1] = 4; rules[1][2] = 6; //X->AA rules[2][0] = 5; rules[2][1] = 0; rules[2][2] = 0; //Y->BB rules[3][0] = 6; rules[3][1] = 1; rules[3][2] = 1; //T->TB rules[4][0] = 3; rules[4][1] = 3; rules[4][2] = 1; //U->UA rules[5][0] = 4; rules[5][1] = 4; rules[5][2] = 0; //T->b rules[6][0] = -1; rules[6][1] = 3; rules[6][2] = 1; //U->a rules[7][0] = -1; rules[7][1] = 4; rules[7][2] = 0; //A->a rules[8][0] = -1; rules[8][1] = 0; rules[8][2] = 0; //B->b rules[9][0] = -1; rules[9][1] = 1; rules[9][2] = 1; /// //0:A 1:B 2:T 3:S; 0:a 1:b /* //first example from text int nonTerminal = 4; int terminal = 2; int ruleCount = 5; int start = 3; int len = 6; int rules[ruleCount][3]; int string[6] = {0,0,0,1,1,1}; //S->AT rules[0][0] = 3; rules[0][1] = 0; rules[0][2] = 2; //S->AB rules[1][0] = 3; rules[1][1] = 0; rules[1][2] = 1; //T->SB rules[2][0] = 2; rules[2][1] = 3; rules[2][2] = 1; //A->a rules[3][0] = -1; rules[3][1] = 0; rules[3][2] = 0; //B->b rules[4][0] = -1; rules[4][1] = 1; rules[4][2] = 1; /// //} */ // initialize manager SddLiteral var_count = term*len + nonTerm*len*(len+1)/2; // initial number of variables int auto_gc_and_minimize = 0; // disable (0) or enable (1) auto-gc & auto-min SddManager* m = sdd_manager_create(var_count,auto_gc_and_minimize); //Vtree* vtree = sdd_vtree_new(var_count, "right"); //SddManager* m = sdd_manager_new(vtree); //SddNode* returned = cfgStringSdd(m,nonTerminal,terminal,rules,start,ruleCount,string,len); //SddNode* returned = cfgWithRef(m,vtree,nonTerminal,terminal,rules,start,ruleCount,string,len); SddNode* returned = sddParsings(m,nonTerm,term,nonRules,termRules,nonRuleCount,termRuleCount,start,len); returned = sdd_condition(-1,returned,m); int modelCount = sdd_model_count(returned,m); printf("count: %d\n",modelCount); sdd_save_as_dot("cfgSdd.dot",returned); /* int size = sdd_size(returned); printf("size: %d\n",size); if (returned == sdd_manager_false(m)){ printf("not valid\n"); } else printf("valid\n"); if (returned == sdd_manager_true(m)){ printf("true\n"); } else printf("not true\n"); sdd_save_as_dot("cfgSdd.dot",returned); */ // free manager sdd_manager_free(m); // free vtree //sdd_vtree_free(vtree); return 0; }