def test_is_leap_year(): answer = set(run("date_consider_month_2020.lp")) assert ({clingo.parse_term("is_leap_year(2020)")} <= answer) answer = set(run("date_consider_month_2021.lp")) assert (clingo.parse_term("is_leap_year(2021)") not in answer) answer = set(run("date_consider_month_2004.lp")) assert ({clingo.parse_term("is_leap_year(2004)")} <= answer)
def process_evidence(self,raw_evidence): evidSet = raw_evidence.split('.') self.evidence_atom_assignemnt = [] for e in evidSet: e = e.strip('\n') if e == "": continue elif "not" in e: self.evidence_atom_assignemnt.append((clingo.parse_term((e.split("not")[1].strip(" "))), True)) else: self.evidence_atom_assignemnt.append((clingo.parse_term((e.split(":-")[1].strip(" "))), False))
def parseEvidence(self,obs = None): if obs == None: evidSet = self.observation.split('.') else: evidSet = obs.split('.') atomAssignment = [] for e in evidSet: e = e.strip() if e == "": continue elif "not" in e: atomAssignment.append((clingo.parse_term((e.split("not")[1].strip(" "))),1)) else: atomAssignment.append((clingo.parse_term((e.split(":-")[1].strip(" "))),0)) return atomAssignment
def parse_signature(constraint) -> None: """ Extract the signature information of the theory terms of the theory atom Populate the Signature data structure with that information :param constraint: clingo TheoryAtom """ for atom in constraint.elements: # this gives me the "type" of the term | e.g. for +~on(..) it would return +~ term_type: str = atom.terms[0].name if "++" in term_type: sign = 1 elif "--" in term_type: sign = -1 else: raise TypeError(f"Wrong term type {term_type} for a signature") signature: Tuple[str, int] = (atom.terms[0].arguments[0].name, len(atom.terms[0].arguments[0].arguments) + 1) Signatures.sigs.add((sign, signature)) sig_tuple_term = (atom.terms[0].arguments[0].name, tuple(atom.terms[0].arguments[0].arguments)) s_atom = clingo.parse_term(str(atom.terms[0].arguments[0])) sig_tuple = (s_atom.name, tuple(s_atom.arguments)) Signatures.add_fullsig(sig_tuple, sig_tuple_term) yield sign, signature
def _grounder(self, input_list, output_list, predicate): ground_atoms = [] for out in output_list: symbol = clingo.parse_term(predicate + '(' + input_list[0] + "," + out + ')') ground_atoms.append(symbol) return ground_atoms
def d2asp(self, input): self._xml_processor(input) g_lpmln = "" for key, items in self.config_dic.items(): out_dom = "dom_out_" + key in_dom = "input_" + key card_rule = items["cad_min"]+"{" + \ (items["predicate"][0] +'(I_'+ key+ ",D_" +key+ ')') + \ ":"+ (out_dom+'(D_' + key + ')')+\ "}" + items["cad_max"] + \ " :- " + (in_dom+'(I_' + key + ')') + ".\n" out_dom_rules = "" in_dom_rules = in_dom + '(' for out in items["output_list"]: out_dom_rules += str( clingo.parse_term(out_dom + '(' + out + ')')) + ".\n" for input in items["input_list"]: in_dom_rules += input[0] + ";" in_dom_rules = in_dom_rules[:-1] + ').\n' soft_atoms = self._weight_bounder(items) g_lpmln += card_rule + out_dom_rules + in_dom_rules + soft_atoms return g_lpmln
def enumerate_unknown(self): # if no unknowns, or computed all: return if not self.unknown: self.more_models = False return if self.computed_all(): return # if quick: print message and update opt_models if self.options.improve_limit[3]: self.print_unknown_optimal_models(self.unknown, self.mapping) self.opt_models += len(self.unknown) return # if improve_no_check: print message if self.options.improve_limit[4]: self.print_unknown_nonoptimal_models(self.unknown, self.mapping) return # ELSE: print *shown* atoms # create boolean array representing unknown unknowns = [False] * (self.last_model + 1) for i in self.unknown: unknowns[i] = True # create holds dictionary for unknowns holds = {} for i in self.control.symbolic_atoms.by_signature(self.holds_str, 2): try: step = int(i.symbol.arguments[1].number) if unknowns[step]: alist = holds.setdefault(step, []) alist.append(i.symbol.arguments[0]) except: pass # enumerate iterating over holds old = self.same_shown_function self.same_shown_function = self.same_shown_false for step in self.unknown: if self.computed_all(): return # pre self.holds = holds.get(step, []) self.nholds = [ x for x in self.holds_domain if x not in set(self.holds) ] delete_model = clingo.parse_term("{}({})".format( self.delete_str, step)) self.control.assign_external(delete_model, True) if self.options.project: old = self.options.max_models self.options.max_models = self.opt_models + 1 # enumerate self.enumerate(add_one=False) # post if self.options.project: self.options.max_models = old self.control.release_external(delete_model) self.same_shown_function = old self.more_models = False
def _parse_minimize(self, val): var = parse_term(val) if var.type == SymbolType.Number: return False self._minimize = var return True
def __init__(self): if self.underscores is not None: return Helper.underscores = utils.underscores term = "{}({})".format(self.underscore(MODEL), self.underscore(M1)) Helper.m1 = clingo.parse_term(term) term = "{}({})".format(self.underscore(MODEL), self.underscore(M2)) Helper.m2 = clingo.parse_term(term) term = "{}".format(self.underscore(M1)) # for holds Helper.simple_m1 = clingo.parse_term(term) term = "{}".format(self.underscore(M2)) # for holds Helper.simple_m2 = clingo.parse_term(term) Helper.zero = clingo.parse_term("0") Helper.volatile = self.underscore(VOLATILE) Helper.unsat = self.underscore(UNSAT) Helper.show = self.underscore(SHOW) Helper.edge = self.underscore(EDGE)
def getModelFromText(txt): #print txt model = [] answers = txt.lstrip(' ').lstrip('\n').lstrip('\r') atoms = answers.split(' ') for atom in atoms: model.append(clingo.parse_term(atom)) return model
def test_parse(self): ''' Test term parsing. ''' self.assertEqual(str(parse_term("p(3)")), "p(3)") log = [] self.assertRaises(RuntimeError, parse_term, "p(1/0)", lambda code, message: log.append((code, message))) self.assertEqual(len(log), 0)
def _decode_str(x: str, key: str) -> Any: if key == "location": return str_to_location(x) if key == "symbol": return clingo.parse_term(x) assert key in ("name", "id", "code", "elements", "term", "list", "operator_name") return x
def iniWMC(self): wmc = self.formula.wmc(log_mode=True) for key, items in self.nameMappingDic.items(): symbol = clingo.parse_term(key) if (symbol.name == "unsat"): wmc.set_literal_weight(-eval(str(items)), eval(str(symbol.arguments[1]).strip('\"'))) orgWMC = math.exp(wmc.propagate()) return wmc,orgWMC
def adjustSDDWeight(self,wmc,adj): for key, items in self.nameMappingDic.items(): symbol = clingo.parse_term(key) for tuple in adj: if str(symbol) == str(tuple[0]): if tuple[1]: wmc.set_literal_weight(-eval(str(items)), -float("inf")) else: wmc.set_literal_weight(eval(str(items)), -float("inf")) orgWMC = math.exp(wmc.propagate()) return wmc, orgWMC
def do_base(self): options, control = self.__options, self.__control programs = self.__programs # constants constants = options['constants'].items() old = [key for key, value in constants] new = [clingo.parse_term(value) for key, value in constants] # add and ground string = programs[BASE][""].get_string() self.__add_and_ground(BASE, old, string, [(BASE, new)]) string = programs[GENERATE][""].get_string() self.__add_and_ground(GENERATE, [], string, [(GENERATE, [])])
def interpretationInfer(self,interpretation): wmc, orgWNC = self.iniWMC() for atoms in interpretation: for key, items in self.nameMappingDic.items(): symbol = clingo.parse_term(key) if (str(symbol) == str(atoms[0])): if atoms[1]: wmc.set_literal_weight(-eval(str(items)), -float("inf")) else: wmc.set_literal_weight(eval(str(items)), -float("inf")) after =math.exp(wmc.propagate()) return after/orgWNC
def do_spec(self): control, programs = self.__control, self.__programs u, options = self.__underscores, self.__options # specification constants = options['constants'].items() old = [ key for key, value in constants ] new = [ clingo.parse_term(value) for key, value in constants ] string = programs[SPEC][""].get_string() if options['check']: string += CHECK_SPEC.replace("##",u) self.__add_and_ground(SPEC,old,string,[(SPEC,new)]) pr = printer.Printer() errors = False if options['check']: # get specification warnings and errors for atom in control.symbolic_atoms.by_signature(u+WARN_PRED, 1): string = self.__cat(atom.symbol.arguments[0]) + "\n" pr.print_spec_warning(string) for atom in control.symbolic_atoms.by_signature(u+ERROR_PRED, 1): string = self.__cat(atom.symbol.arguments[0]) + "\n" pr.print_spec_error(string) errors = True # get non domain errors for i in [(PREFERENCE,2),(PREFERENCE,5),(OPTIMIZE,1)]: ui0 = u + i[0] for atom in control.symbolic_atoms.by_signature(ui0, i[1]): if not atom.is_fact: pr.print_spec_error(self.__non_domain_message(atom, i)) errors = True # get preference types, and test for corresponding programs out = set() upreference = u + PREFERENCE for atom in control.symbolic_atoms.by_signature(upreference,2): out.add(str(atom.symbol.arguments[1])) if options['check']: ok = self.__program_exists(atom) if not ok: errors = True # observe if self.__observer: self.__observer.add_specification(string, old, new) # if errors if errors: raise Exception("parsing failed") return out
def main(): # preprocessing generator_class = temporal.DLPGenerator if len(sys.argv) >= 2 and sys.argv[1] == "simple": generator_class = temporal.DLPGeneratorSimplifier generator = generator_class( files=["test.lp"], #adds = [("base", [], base)], parts=[("base", [])], #options = ["0"], #compute_cautious = False, #compute_brave = False, ) # start dlp = generator.run() #print(generator) ctl = clingo.Control(["0"]) dlp.start(ctl) #print(dlp) # ground and set externals steps = 3 dlp.ground(steps - 1) dlp.ground(1) for i in range(1, steps): dlp.release_external(i, clingo.parse_term("last")) dlp.assign_external(steps, clingo.parse_term("last"), True) # solve with ctl.solve(assumptions=dlp.get_assumptions(), yield_=True) as handle: answers = 0 for m in handle: answers += 1 print("Answer: {}".format(answers)) answer = dlp.get_answer(m, steps) print(" ".join(["{}:{}".format(x, y) for x, y in answer])) if not answers: print("UNSATISFIABLE")
def hex2clingo(self, term): if isinstance(term, ClingoID): return term.symlit.sym elif isinstance(term, str): if term[0] == '"': ret = clingo.String(term[1:-1]) else: ret = clingo.parse_term(term) elif isinstance(term, int): ret = clingo.Number(term) else: raise Exception("cannot convert external atom term {} to clingo term!".format(repr(term))) return ret
def on_raw_data(self, raw_data): data = raw_data.split('.') for atom in data: if not (len(atom) == 1 and atom[0] == '\n'): if atom[0] == '%' and atom[1] == '$': atom = atom[2 :].lower() self.on_control_symbol(clingo.parse_term(atom)) else: self._data.append(atom) self._raw_data = '' if len(self._data) > 0: self.on_data(self._data) self._data = []
def learn_ini_WMC_with_observation(self, parsed_observation): wmc = self.formula.wmc(log_mode=False) for key, items in self.nameMappingDic.items(): symbol = clingo.parse_term(key) if (symbol.name == "unsat"): wmc.set_literal_weight(-eval(str(items)), math.exp(eval(str(symbol.arguments[1]).strip('\"')))) for tuple in parsed_observation: if str(symbol) == str(tuple[0]): if tuple[1] == 0: wmc.set_literal_weight(eval(str(items)),0) else: wmc.set_literal_weight(-eval(str(items)),0) orgWMC = wmc.propagate() return wmc,orgWMC
def print(self, res: 'Results') -> None: for fact in res.already: print(fact + '.') for act in res.acts: print(act + '!') if res.status: print(res.status + '.') if res.shows: terms = [clingo.parse_term(r) for r in res.shows] terms.sort() that = ' | '.join(res.replace_names(str(t)) for t in terms) if len(that) / len(terms) > 30: that = that.replace(' | ', '\n | ') print(f'that: {that}.') print()
def _assumptionFromModel(self, mdl): # mdl contains the answer set candidate # we here create assumptions for compatible set auxiliaries ret = [] # # for all atoms in Pi that are not replatoms we create an assumption # # symbolic atoms that are not replatoms for iatm, atm in self.po.int2atom.items(): if iatm in self.po.replatoms: continue # TODO cache csAtom <-> iatm csAtom = clingo.parse_term(prefixAtom(str(atm), Aux.CSATOM)) # TODO maybe use is_true here too (iatm) TODO benchmark this ret.append((csAtom, mdl.contains(atm))) # clasp auxiliaries (that are implicitly never replatoms) for iauxatm in self.po.auxatoms: # TODO cache csAtom <-> iauxatm csAtom = clingo.Function( name=prefixAtom(self.po.formatAtom(iauxatm), Aux.CSATOM)) ret.append((csAtom, mdl.is_true(iauxatm))) # # additionally, for choice auxiliaries of chatoms in Pi we create assumptions # these assumptions are the negation of the positive chatom value # # choice auxiliaries of chatoms for ichatom, chauxatom in self.chauxatoms.items(): # TODO cache csAtom <-> iauxatm csAtom = clingo.parse_term(prefixAtom(chauxatom, Aux.CSATOM)) ret.append((csAtom, not mdl.is_true(ichatom))) return ret
def on_raw_data(self, raw_data): #the visualizer seperates every atom and control symbol with the '.' character data = raw_data.split('.') for atom in data: if len(atom) > 0: if not (len(atom) == 1 and atom[0] == '\n'): #the split function returns the string "\n" as last string which should not be processed if atom[0] == '%' and atom[1] == '$': #strings that begin with '%$' are control symbols and are handles by the on_control_symbol function atom = atom[2 :].lower() self.on_control_symbol(clingo.parse_term(atom)) else: self._data.append(atom) self._raw_data = '' if len(self._data) > 0: #processed asp atoms self.on_data(self._data) self._data = []
def inferencePrtQuery(self): self.fillQueryAtoms() for queryAtom in self.queryAtoms: if self.observation == "": wmc,orgWNC = self.iniWMC() else: wmc,orgWNC = self.ini_WMC_with_observation() for key, items in self.nameMappingDic.items(): symbol = clingo.parse_term(key) if (str(symbol) == str(queryAtom[0])): wmc.set_literal_weight(-eval(str(items)), -float("inf")) after = math.exp(wmc.propagate()) queryAtom[1] = after / orgWNC break for atom in self.queryAtoms: print(atom)
def receive(self): if self._s is None or self._parser is None: return -1 data = self._receive_data() if data is None: return if data == '': return for str_atom in data.split('.'): if len(str_atom) != 0 and not (len(str_atom) == 1 and str_atom[0] == '\n'): if str_atom == '%$RESET': self._parser.clear_model() else: self._parser.on_atom(clingo.parse_term(str_atom)) self._parser.done_instance()
def receive(self): if self._s is None or self._parser is None or self._model is None: return -1 data = self._receive_data() if data is None: return if data == '': return for str_atom in data.split('.'): if len(str_atom) != 0 and not (len(str_atom) == 1 and str_atom[0] == '\n'): if str_atom == '%$RESET': self._parser.clear_model_actions(True) else: self._parser.on_atom(clingo.parse_term(str_atom)) self._model.update_windows()
def ini_WMC_with_observation(self): wmc = self.formula.wmc(log_mode=True) for key, items in self.nameMappingDic.items(): symbol = clingo.parse_term(key) if (symbol.name == "unsat"): wmc.set_literal_weight(-eval(str(items)), eval(str(symbol.arguments[1]).strip('\"'))) for tuple in self.evidenceAssignment: if str(symbol) == str(tuple[0]): if tuple[1] == 0: wmc.set_literal_weight(eval(str(items)),-float("inf")) else: wmc.set_literal_weight(-eval(str(items)),-float("inf")) orgWMC = math.exp(wmc.propagate()) return wmc,orgWMC
def hex2clingo(self, term): if isinstance(term, ClingoID): return term.symlit.sym elif isinstance(term, str): if term[0] == '"': ret = clingo.String(term[1:-1]) else: try: ret = clingo.parse_term(term) except: logging.warning( "cannot parse external atom term {} with clingo! (creating a string out of it)" .format(repr(term))) ret = clingo.String(str(term)) elif isinstance(term, int): ret = clingo.Number(term) else: raise Exception( "cannot convert external atom term {} to clingo term!".format( repr(term))) return ret
def receive(self): if self._s is None or self._parser is None: return -1 data = self._receive_data() empty = True reset = False if data is None: return if data == '': return self._waiting = False for str_atom in data.split('.'): if len(str_atom) != 0 and not (len(str_atom) == 1 and str_atom[0] == '\n'): if str_atom == '%$RESET': self._parser.clear_model() reset = True empty = False else: self._parser.on_atom(clingo.parse_term(str_atom)) empty = False if not empty: self._parser.done_instance(reset)