def test_flat():
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_CNF.nnf")
assert circuits.LanguageProperties.flat in NNF.language_properties
CNF = circuit_io.parse_CNF_DIMACS("../nnf_examples/test_CNF.cnf")
assert circuits.LanguageProperties.flat in CNF.language_properties
DNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_DNF.nnf")
assert circuits.LanguageProperties.flat in DNF.language_properties
def convert_nnf_to_sdDNNF(circuit):
# if the circuit is eps-inverted, convert to nnf
circuit = convert_to_nnf(circuit)
# convert nnf to cnf
circuit = convert_to_cnf(circuit)
circuit = simplify_cnf(circuit)
# record the file
circuit_io.write_CNF_DIMACS(circuit, "../nnf_examples/tmp_nnf_2.cnf")
subprocess.call(
'../code/compiled_binaries/dsharp -disableAllLits -smoothNNF -Fnnf ../nnf_examples/nnf_conv_sddnnf.nnf ../nnf_examples/tmp_nnf_2.cnf',
shell=True)
return circuit_io.parse_NNF_DIMACS("../nnf_examples/nnf_conv_sddnnf.nnf")
def test_one_leaf():
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_NNF_one_leaf.nnf")
assert circuits.Languages.NNF in NNF.languages
assert circuits.Languages.DNNF in NNF.languages
assert circuits.Languages.dNNF in NNF.languages
assert circuits.Languages.sNNF in NNF.languages
assert circuits.Languages.fNNF in NNF.languages
assert circuits.Languages.dDNNF in NNF.languages
assert circuits.Languages.sdDNNF in NNF.languages
assert circuits.Languages.BDD in NNF.languages
assert circuits.Languages.FBDD in NNF.languages
assert circuits.Languages.OBDD in NNF.languages
assert circuits.Languages.OBDD_LT in NNF.languages
assert circuits.Languages.DNF in NNF.languages
assert circuits.Languages.CNF in NNF.languages
assert circuits.Languages.MODS in NNF.languages
assert circuits.Languages.ODNF in NNF.languages
def convert_nnf_to_dDNNF(circuit):
# if the circuit is eps-inverted, convert to nnf
circuit = convert_to_nnf(circuit)
# convert nnf to cnf
circuit = convert_to_cnf(circuit)
circuit = simplify_cnf(circuit)
# record the file
circuit_io.write_CNF_DIMACS(circuit, "../nnf_examples/tmp_nnf_2.cnf")
# convert to dDNNF
subprocess.call(
'../code/compiled_binaries/dsharp -disableAllLits -Fnnf ../nnf_examples/nnf_conv_ddnnf.nnf ../nnf_examples/tmp_nnf_2.cnf',
shell=True)
tmp_circuit = circuit_io.parse_NNF_DIMACS(
"../nnf_examples/nnf_conv_ddnnf.nnf")
# if tmp_circuit == None:
# if DEBUG:
# print ("dsharp resulted in an empty or non DAG representation")
# subprocess.call('../code/compiled_binaries/d4 ../nnf_examples/tmp_nnf_2.cnf -out="../nnf_examples/nnf_conv_ddnnf.nnf"', shell=True)
# tmp_circuit = circuit_io.parse_NNF_DIMACS("../nnf_examples/nnf_conv_ddnnf.nnf")
# assert tmp_circuit != None, "Yikes... Neither dsharp nor d4 working"
return tmp_circuit
def main():
parser = argparse.ArgumentParser(description='Which domain.')
parser.add_argument("-d", "--domain", default="chopsticks", required=False, help="Which domain?")
args = vars(parser.parse_args())
languages_to_convert_to = [(circuits.Languages.CNF, True),
(circuits.Languages.dDNNF, True),
(circuits.Languages.DNF, True),
circuits.Languages.dDNNF,
#circuits.Languages.sdDNNF,
circuits.Languages.CNF,
circuits.Languages.DNF,
circuits.Languages.OBDD,
# circuits.Languages.MODS,
circuits.Languages.ODNF]
languages_to_convert_to_subset = [(circuits.Languages.CNF, True),
circuits.Languages.dDNNF,
circuits.Languages.DNF,
circuits.Languages.ODNF]
if args['domain'] == "chopsticks":
directory = "../domains/chopsticks_examples/"
# generate_study(directory, "good_agent", languages_to_convert_to, "1", args["domain"], True)
generate_study(directory, "good_agent", languages_to_convert_to, "1", args["domain"], False)
# generate_study(directory, "bad_agent", languages_to_convert_to_subset, "1", "chopsticks", False)
elif args['domain'] == "highway":
directory = "../domains/highway_examples/"
generate_study(directory, "good_agent", languages_to_convert_to, "1", args["domain"], True)
generate_study(directory, "good_agent", languages_to_convert_to, "1", args["domain"], False)
elif args['domain'] == 'emergency':
directory = "../domains/emergency_triage_examples/"
generate_study(directory, "good_agent", languages_to_convert_to, "1", args["domain"], True)
generate_study(directory, "good_agent", languages_to_convert_to, "1", args["domain"], False)
generate_study(directory, "bad_agent", languages_to_convert_to_subset, "1", "emergency", True)
elif args['domain'] == "all":
directory = "../domains/chopsticks_examples/"
study_id = random.getrandbits(32)
generate_study(directory, "good_agent", languages_to_convert_to, str(study_id), "chopsticks", True)
generate_study(directory, "good_agent", languages_to_convert_to, str(study_id), "chopsticks", False)
generate_study(directory, "bad_agent", languages_to_convert_to_subset, str(study_id), "chopsticks", True)
directory = "../domains/highway_examples/"
generate_study(directory, "good_agent", languages_to_convert_to, str(study_id), "highway", True)
generate_study(directory, "good_agent", languages_to_convert_to, str(study_id), "highway", False)
generate_study(directory, "bad_agent", languages_to_convert_to_subset, str(study_id), "highway", True)
directory = "../domains/emergency_triage_examples/"
generate_study(directory, "good_agent", languages_to_convert_to, str(study_id), "emergency", True)
generate_study(directory, "good_agent", languages_to_convert_to, str(study_id), "emergency", False)
generate_study(directory, "bad_agent", languages_to_convert_to_subset, str(study_id), "emergency", True)
elif args['domain'] == "test":
state = [0, 1, 1, 14, 1.7, 39]
predicate_values = evaluate_predicates(state, "../domains/emergency_triage_examples/good_agent/", "emergency")
print (predicate_values)
actions = possible_actions(predicate_values, "../domains/emergency_triage_examples/good_agent/questions-formatted.txt")
print (actions)
action = random_action(actions, False)
print(action)
circuit = circuit_io.parse_NNF_DIMACS("../domains/emergency_triage_examples/good_agent/immediate.nnf")
circuit.graph.graph_logic_formula()
circuit_a = formula_conversions.convert_to_given_language(circuit, circuits.Languages.CNF, False)
circuit_a.graph.graph_logic_formula()
circuit = formula_conversions.convert_to_given_language(circuit, circuits.Languages.CNF, True)
circuit.graph.graph_logic_formula()
print (circuit.graph.collapse_graph_to_formula(circuit.graph.find_dag_root()))
print (circuit.graph.collapse_graph_to_formula(circuit.graph.find_dag_root(), True))
elif args['domain'] == "test2":
state = [0,1,1,17,2.1,68]
generate_image_emergency(state)
def generate_study(directory, agent, languages, study_id, domain, truth_assignment):
"""
Create a user study. Write a CSV file.
For each language in each domain, generate a random state and select an action
with the desired truth assignment.
Parameters:
-----------
directory : string
Where to save the study
agent : string
Should the agent be good or bad?
languages : list
A list of all languages to convert to
study_id : string
An identifier for this study
domain : string
"all", "emergency", "chopsticks", or "highway"
truth_assignment : bool
Whether the agent should take the action or not
Returns
-------
None
Writes to .csv file
"""
directory = directory + agent + "/"
file_exists = os.path.isfile('../' + study_id + '_evaluate_logic_interpretability.csv')
with open('../' + study_id + '_evaluate_logic_interpretability.csv', mode='a') as csv_file:
fieldnames = ['qid',
'domain',
'agent',
'state',
'image_loc',
'target_language',
'eps-inv',
'action',
'action_truth_value',
'explanation',
'explanation_html',
'languages_satisfied',
'epsilon_flips',
'num_predicates',
'circuit_size',]
writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
if not file_exists:
writer.writeheader()
for language in languages:
invert = False
if isinstance(language, tuple):
invert = language[1]
language = language[0]
action = None
while (action == None):
state = random_state_generator(domain)
predicate_values = evaluate_predicates(state, directory, domain)
actions = possible_actions(predicate_values, directory + "questions-formatted.txt")
action = random_action(actions, truth_assignment)
languages_satisfied = []
epsilon_flips = 0
statement_size = 0
# generate explanation(s) for true action
circuit = circuit_io.parse_NNF_DIMACS(directory + str(action) + ".nnf")
circuit = formula_conversions.convert_to_given_language(circuit, language, invert)
num_predicates = circuit.graph.get_variables(circuit.graph.find_dag_root())
logic_formulas = action_natural_language_map[str(action)] + " when " + circuit.graph.collapse_graph_to_formula(circuit.graph.find_dag_root(), True).replace(" ", " ").replace(" ", " ").replace("( ", "(").replace(" )", ")")
logic_formulas_html = action_natural_language_map[str(action)] + " when " + circuit.graph.collapse_graph_to_bullet_list().replace(" ", " ").replace(" ", " ").replace("( ", "(").replace(" )", ")")
languages_satisfied.append( (action, circuit.languages) )
epsilon_flips = len( [node for node in circuit.graph.nodes() if circuit.graph.nodes[node]['value'] in ['nand','nor'] ] )
statement_size = circuit.num_nodes
# true_circuit.graph.graph_logic_formula()
# false_circuit.graph.graph_logic_formula()
if domain == "chopsticks":
image_location = generate_image_chopsticks(state)
elif domain == "highway":
image_location = generate_image_highway(state)
elif domain == "emergency":
image_location = generate_image_emergency(state)
natural_flatsentence = return_to_natural_language(logic_formulas,
directory + "predicates.txt")
natural_htmlsentence = return_to_natural_language(logic_formulas_html,
directory + "predicates.txt")
writer.writerow({'qid': str(domain) + "_" + str(agent) + "_" + str(language) + "_" + str(invert) + "_truth" + str(truth_assignment),
'domain': str(domain),
'agent': str(agent),
'state': str(state),
'image_loc': str(image_location),
'target_language': str(language),
'eps-inv' : str(invert),
'action': str(action),
'action_truth_value': str(truth_assignment),
'explanation': str(natural_flatsentence),
'explanation_html': str(natural_htmlsentence),
'languages_satisfied': str(languages_satisfied),
'epsilon_flips': str(epsilon_flips),
'num_predicates': str(len(num_predicates)),
'circuit_size': str(statement_size)
})
def test_tseitin():
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_CNF.nnf")
cnf = formula_conversions.tseitin(NNF)
assert circuits.Languages.CNF in cnf.languages
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_dDNNF.nnf")
cnf = formula_conversions.tseitin(NNF)
assert circuits.Languages.CNF in cnf.languages
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_DNF.nnf")
cnf = formula_conversions.tseitin(NNF)
assert circuits.Languages.CNF in cnf.languages
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_dNNF.nnf")
cnf = formula_conversions.tseitin(NNF)
assert circuits.Languages.CNF in cnf.languages
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_FBDD.nnf")
cnf = formula_conversions.tseitin(NNF)
assert circuits.Languages.CNF in cnf.languages
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_MODS.nnf")
cnf = formula_conversions.tseitin(NNF)
assert circuits.Languages.CNF in cnf.languages
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_NNF_one_leaf.nnf")
cnf = formula_conversions.tseitin(NNF)
assert circuits.Languages.CNF in cnf.languages
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_OBDD.nnf")
cnf = formula_conversions.tseitin(NNF)
assert circuits.Languages.CNF in cnf.languages
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_OBDD_LT.nnf")
cnf = formula_conversions.tseitin(NNF)
assert circuits.Languages.CNF in cnf.languages
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_sdDNNF.nnf")
cnf = formula_conversions.tseitin(NNF)
assert circuits.Languages.CNF in cnf.languages
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_sNNF.nnf")
cnf = formula_conversions.tseitin(NNF)
assert circuits.Languages.CNF in cnf.languages
def test_ordered_less_than():
BDD = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_OBDD_LT.nnf")
assert circuits.LanguageProperties.ordered_lt in BDD.language_properties
def test_decisive():
BDD = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_FBDD.nnf")
assert circuits.LanguageProperties.decisive in BDD.language_properties
def test_smooth():
sNNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_sNNF.nnf")
assert circuits.LanguageProperties.smooth in sNNF.language_properties
def test_deterministic():
dNNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_dNNF.nnf")
assert circuits.LanguageProperties.deterministic in dNNF.language_properties
def test_decomposable():
dDNNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_dDNNF.nnf")
assert circuits.LanguageProperties.decomposable in dDNNF.language_properties
def test_simple_conjunction():
DNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_DNF.nnf")
assert circuits.LanguageProperties.simple_conjunction in DNF.language_properties
def test_simple_disjunction():
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_CNF.nnf")
assert circuits.LanguageProperties.simple_disjunction in NNF.language_properties
CNF = circuit_io.parse_CNF_DIMACS("../nnf_examples/test_CNF.cnf")
assert circuits.LanguageProperties.simple_disjunction in CNF.language_properties
def test_ODNF():
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_ODNF.nnf")
assert circuits.Languages.ODNF in NNF.languages
def test_non_tseitin_cnf():
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_CNF.nnf")
cnf = formula_conversions.convert_to_cnf(NNF)
assert circuits.Languages.CNF in cnf.languages
assert NNF.graph.collapse_to_truth_table(
) == cnf.graph.collapse_to_truth_table()
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_dDNNF.nnf")
cnf = formula_conversions.convert_to_cnf(NNF)
assert circuits.Languages.CNF in cnf.languages
assert NNF.graph.collapse_to_truth_table(
) == cnf.graph.collapse_to_truth_table()
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_DNF.nnf")
cnf = formula_conversions.convert_to_cnf(NNF)
assert circuits.Languages.CNF in cnf.languages
assert NNF.graph.collapse_to_truth_table(
) == cnf.graph.collapse_to_truth_table()
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_dNNF.nnf")
cnf = formula_conversions.convert_to_cnf(NNF)
assert circuits.Languages.CNF in cnf.languages
assert NNF.graph.collapse_to_truth_table(
) == cnf.graph.collapse_to_truth_table()
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_FBDD.nnf")
cnf = formula_conversions.convert_to_cnf(NNF)
assert circuits.Languages.CNF in cnf.languages
assert NNF.graph.collapse_to_truth_table(
) == cnf.graph.collapse_to_truth_table()
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_MODS.nnf")
cnf = formula_conversions.convert_to_cnf(NNF)
assert circuits.Languages.CNF in cnf.languages
assert NNF.graph.collapse_to_truth_table(
) == cnf.graph.collapse_to_truth_table()
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_NNF_one_leaf.nnf")
cnf = formula_conversions.convert_to_cnf(NNF)
assert circuits.Languages.CNF in cnf.languages
assert NNF.graph.collapse_to_truth_table(
) == cnf.graph.collapse_to_truth_table()
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_OBDD.nnf")
cnf = formula_conversions.convert_to_cnf(NNF)
assert circuits.Languages.CNF in cnf.languages
assert NNF.graph.collapse_to_truth_table(
) == cnf.graph.collapse_to_truth_table()
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_OBDD_LT.nnf")
cnf = formula_conversions.convert_to_cnf(NNF)
assert circuits.Languages.CNF in cnf.languages
assert NNF.graph.collapse_to_truth_table(
) == cnf.graph.collapse_to_truth_table()
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_sdDNNF.nnf")
cnf = formula_conversions.convert_to_cnf(NNF)
assert circuits.Languages.CNF in cnf.languages
assert NNF.graph.collapse_to_truth_table(
) == cnf.graph.collapse_to_truth_table()
NNF = circuit_io.parse_NNF_DIMACS("../nnf_examples/test_sNNF.nnf")
cnf = formula_conversions.convert_to_cnf(NNF)
assert circuits.Languages.CNF in cnf.languages
assert NNF.graph.collapse_to_truth_table(
) == cnf.graph.collapse_to_truth_table()
