def count_existential(quantifiers): ''' Returns the number of universally quantified variables ''' quantified_variables = [] for quantifier in quantifiers: Translation.get_existentially_quantified(quantifier, quantified_variables)
def existential_predicate(predicate, quantifiers): if predicate == [] or quantifiers == []: return False existentials = [] for quant in quantifiers: Translation.get_existentially_quantified(quant, existentials) if all([x in existentials for x in predicate[1:]]): return predicate else: return False
def universal_predicate(predicate, quantifiers): if predicate == [] or quantifiers == []: return False universals = [] for quant in quantifiers: Translation.get_universally_quantified(quant, universals) if all([x in universals for x in predicate[1:]]): return predicate else: return False
def generate_all_axiom(sentences): ''' Utility function which accepts a raw set of axioms and returns a set of quantified CNF axioms ''' new_sentences = [] for sentence in sentences: # Skip the import lines if sentence[0] == 'cl-imports': continue cnf = [] print("[+] Sentence:") pprint.pprint(sentence) quantifiers, axiom = Translation.translate_sentence(sentence) axioms = extract_conjuncts(axiom[:]) print("[+] Translated Sentence:") pprint.pprint(axiom) print("------------------") for axiom in axioms: cnf.append(generate_quantifier(axiom, copy.deepcopy(quantifiers))) print("[-] ", cnf[-1]) new_sentences.append((sentence, cnf)) print("") return new_sentences
def extract_conjuncts(sentence): ''' Accepts a conjunction and returns a list of individual conjuncts to be examined later ''' axioms = [] if Translation.is_conjunction(sentence): axioms += Translation.is_conjunction(sentence) elif Translation.is_disjunction(sentence): axioms = [sentence] else: print("We're going down captain!") return axioms
def count_variables(axiom): ''' Returns the number of variables actually used in the clause, as opposed to over the entire conjunction it may be part of. ''' variables = set() for clause in axiom: if Translation.is_negated(clause): clause = Translation.is_negated(clause) if Translation.is_unary(clause): variables.add(clause[1]) elif Translation.is_binary(clause): variables.add(clause[1]) variables.add(clause[2]) return len(variables)
def generate_quantifier(sentence, quantifiers): ''' Take a sentence and set of quantifiers and trim the quantifiers so only variables in the sentence exist in the quantifier. Return the new quantifier and sentence together in a list. return list axiom, [[quantifiers], [sentence]] ''' new_quantifiers = quantifiers[:] predicates = [] Translation.find_binary_predicates(sentence, predicates) Translation.find_unary_predicates(sentence, predicates) predicates = list(set([get_predicate_name(p) for p in predicates])) #print("[+] Found Predicates:", predicates) quantified_variables = [] for quantifier in new_quantifiers: Translation.get_universally_quantified(quantifier, quantified_variables) Translation.get_existentially_quantified(quantifier, quantified_variables) quantified_variables = list(set(quantified_variables)) #print("[+] Found Quantified Variables:", quantified_variables) flattened_axiom = list(set(list(Util.flatten(sentence)))) variables = list(filter(Translation.is_nonlogical, flattened_axiom)) variables = [v for v in variables if v not in predicates] #print("[+] Found Variables:", variables) variables_to_trim = [v for v in quantified_variables if v not in variables] #print("[+] Removing Variables:", variables_to_trim) #print("[+] Starting Quantifier:", new_quantifiers) new_quantifiers = trim_quantifier(new_quantifiers, variables_to_trim) #print("[+] Generated Quantifier:", new_quantifiers) return [copy.deepcopy(new_quantifiers), copy.deepcopy(sentence)]
def same_variables(pred_one, pred_two): ''' Returns true if both predicates are over the same variable ''' if Translation.is_negated(pred_one): pred_one = Translation.negate_negation(pred_one) if Translation.is_negated(pred_two): pred_two = Translation.negate_negation(pred_two) if Translation.is_unary(pred_one) and Translation.is_unary(pred_two): if pred_one[1] == pred_two[1]: return True if Translation.is_binary(pred_one) and Translation.is_binary(pred_two): if pred_one[1] == pred_two[1] and pred_one[2] == pred_two[2]: return True return False
help='Input Clif', required=True) args = parser.parse_args() axioms, extractions = Extractions.get_all_extractions(args.file) unary = set() binary = set() for a in axioms: print(a) unary_predicates = [] binary_predicates = [] Translation.find_unary_predicates(a[0], unary_predicates) Translation.find_binary_predicates(a[0], binary_predicates) print('-----------') #pp.pprint(s) print('') #print(is_all_unary(translated[1])) #pp.pprint(translated) print(unary_predicates) print(binary_predicates) for u in unary_predicates: unary.add(u[0]) for b in binary_predicates:
def negative_predicates(lst): return [Translation.is_negated(i) for i in lst if Translation.is_negated(i)]
def positive_predicates(lst): return [i for i in lst if not Translation.is_negated(i)]