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;
}
