o *ήcq=@sdZddlmZddlmZmZmZmZddZddZ d d Z d d Z d dZ ddZ GdddeZGdddZGdddZGdddeZGdddeZdS)a>This is rule-based deduction system for SymPy The whole thing is split into two parts - rules compilation and preparation of tables - runtime inference For rule-based inference engines, the classical work is RETE algorithm [1], [2] Although we are not implementing it in full (or even significantly) it's still worth a read to understand the underlying ideas. In short, every rule in a system of rules is one of two forms: - atom -> ... (alpha rule) - And(atom1, atom2, ...) -> ... (beta rule) The major complexity is in efficient beta-rules processing and usually for an expert system a lot of effort goes into code that operates on beta-rules. Here we take minimalistic approach to get something usable first. - (preparation) of alpha- and beta- networks, everything except - (runtime) FactRules.deduce_all_facts _____________________________________ ( Kirr: I've never thought that doing ) ( logic stuff is that difficult... ) ------------------------------------- o ^__^ o (oo)\_______ (__)\ )\/\ ||----w | || || Some references on the topic ---------------------------- [1] https://en.wikipedia.org/wiki/Rete_algorithm [2] http://reports-archive.adm.cs.cmu.edu/anon/1995/CMU-CS-95-113.pdf https://en.wikipedia.org/wiki/Propositional_formula https://en.wikipedia.org/wiki/Inference_rule https://en.wikipedia.org/wiki/List_of_rules_of_inference ) defaultdict)LogicAndOrNotcCst|tr|jS|S)zdReturn the literal fact of an atom. Effectively, this merely strips the Not around a fact.  isinstancerargatomr 7/tmp/pip-target-vg8gfxp4/lib/python/sympy/core/facts.py _base_fact6s rcCst|tr |jdfS|dfS)NFTrr r r r_as_pairAs  rcCsbt|}tjtt|}|D]}|D]}||f|vr-|D]}||f|vr,|||fqqq|S)z Computes the transitive closure of a list of implications Uses Warshall's algorithm, as described at http://www.cs.hope.edu/~cusack/Notes/Notes/DiscreteMath/Warshall.pdf. )setunionmapadd) implicationsfull_implicationsliteralskijr r rtransitive_closureJs  rcCs|dd|D}tt}t|}|D]\}}||krq|||q|D]\}}||t|}||vrBtd|||fq(|S)a:deduce all implications Description by example ---------------------- given set of logic rules: a -> b b -> c we deduce all possible rules: a -> b, c b -> c implications: [] of (a,b) return: {} of a -> set([b, c, ...]) cSs g|] \}}t|t|fqSr r).0rrr r r rs z-deduce_alpha_implications..z*implications are inconsistent: %s -> %s %s)rrrritemsdiscardr ValueError)rresrabimplnar r rdeduce_alpha_implications^s    r'c sji}|D] }t||gf||<q|D]\}|jD]}||vr#qtgf||<qqd}|rxd}|D]A\}t|tsAtdt|j|D]*\}\}}||hB} | vrt| rt|| } | durr|| dO}d}qJq4|s0t |D]6\} \}t|j|D]&\}\}}||hB} | vrqt fdd| Drq| @r| | qq||S)aapply additional beta-rules (And conditions) to already-built alpha implication tables TODO: write about - static extension of alpha-chains - attaching refs to beta-nodes to alpha chains e.g. alpha_implications: a -> [b, !c, d] b -> [d] ... beta_rules: &(b,d) -> e then we'll extend a's rule to the following a -> [b, !c, d, e] TFzCond is not AndNrc3s(|]}t|vpt|kVqdSNr)rxibargsbimplr r s&z,apply_beta_to_alpha_route..) keysrargsr r TypeErrorrissubsetrget enumerateanyappend) alpha_implications beta_rulesx_implxbcondbkseen_static_extensionximplsbbx_all bimpl_implbidxr r*rapply_beta_to_alpha_routesP              rBcCsftt}|D](\\}}}t|tr|jd}|D]\}}t|tr(|jd}|||qq|S)aMbuild prerequisites table from rules Description by example ---------------------- given set of logic rules: a -> b, c b -> c we build prerequisites (from what points something can be deduced): b <- a c <- a, b rules: {} of a -> [b, c, ...] return: {} of c <- [a, b, ...] Note however, that this prerequisites may be *not* enough to prove a fact. An example is 'a -> b' rule, where prereq(a) is b, and prereq(b) is a. That's because a=T -> b=T, and b=F -> a=F, but a=F -> b=? r)rrrr rr/r)rulesprereqr#_r%rr r r rules_2prereqs     rFc@seZdZdZdS)TautologyDetectedz:(internal) Prover uses it for reporting detected tautologyN)__name__ __module__ __qualname____doc__r r r rrGsrGc@sHeZdZdZddZddZeddZedd Zd d Z d d Z dS)ProveraSai - prover of logic rules given a set of initial rules, Prover tries to prove all possible rules which follow from given premises. As a result proved_rules are always either in one of two forms: alpha or beta: Alpha rules ----------- This are rules of the form:: a -> b & c & d & ... Beta rules ---------- This are rules of the form:: &(a,b,...) -> c & d & ... i.e. beta rules are join conditions that say that something follows when *several* facts are true at the same time. cCsg|_t|_dSr() proved_rulesr _rules_seenselfr r r__init__s zProver.__init__cCsHg}g}|jD]\}}t|tr|||fq|||fq||fS)z-split proved rules into alpha and beta chains)rMr rr5)rP rules_alpha rules_betar#r$r r rsplit_alpha_beta!s zProver.split_alpha_betacC |dS)NrrTrOr r rrR, zProver.rules_alphacCrU)NrrVrOr r rrS0rWzProver.rules_betacCsj|rt|tr dSt|trdS||f|jvrdS|j||fz |||WdSty4YdSw)zprocess a -> b ruleN)r boolrNr _process_rulerG)rPr#r$r r r process_rule4s  zProver.process_rulecCsht|tr|jD]}|||qdSt|trft|ts(||jvr(t||d|tdd|jDt|tt |jD]$}|j|}|jd||j|dd}|t|t|t|q?dSt|tr||jvrvt||d|j ||fdSt|tr||jvrt||d|jD]}|||qdS|j ||f|j t|t|fdS)Nz a -> a|c|...cSsg|]}t|qSr r)rbargr r rrWz(Prover._process_rule..rz a & b -> az a | b -> a) r rr/rZrrrGrrangelenrMr5)rPr#r$r[rAbrestaargr r rrYEs4               zProver._process_ruleN) rHrIrJrKrQrTpropertyrRrSrZrYr r r rrLs   rLc@seZdZdZddZdS) FactRulesaRules that describe how to deduce facts in logic space When defined, these rules allow implications to quickly be determined for a set of facts. For this precomputed deduction tables are used. see `deduce_all_facts` (forward-chaining) Also it is possible to gather prerequisites for a fact, which is tried to be proven. (backward-chaining) Definition Syntax ----------------- a -> b -- a=T -> b=T (and automatically b=F -> a=F) a -> !b -- a=T -> b=F a == b -- a -> b & b -> a a -> b & c -- a=T -> b=T & c=T # TODO b | c Internals --------- .full_implications[k, v]: all the implications of fact k=v .beta_triggers[k, v]: beta rules that might be triggered when k=v .prereq -- {} k <- [] of k's prerequisites .defined_facts -- set of defined fact names cCszt|tr |}t}|D]6}|dd\}}}t|}t|}|dkr.|||q|dkr?||||||qtd|g|_ |j D]\}}|j dd|j Dt |fqKt|j} t| |j } dd| D|_tt} tt} | D]\} \}}d d|D| t | <|| t | <q| |_| |_tt}t| }|D] \} }|| |O<q||_dS) z)Compile rules into internal lookup tablesNz->z==z unknown op %rcSh|]}t|qSr r)rr#r r r r\z%FactRules.__init__..cSrdr )r)rrr r rrfr\cSrdr rerrr r rrfr\)r str splitlinesrLsplitr fromstringrZr!r7rSr5r/rr'rRrBr. defined_factsrrrr beta_triggersrFrD)rPrCPruler#opr$r:r,impl_aimpl_abrrmrr%betaidxsrD rel_prereqpitemsr r rrQsB        zFactRules.__init__N)rHrIrJrKrQr r r rrbvs rbc@seZdZddZdS)InconsistentAssumptionscCs|j\}}}d|||fS)Nz %s, %s=%s)r/)rPkbfactvaluer r r__str__s zInconsistentAssumptions.__str__N)rHrIrJrzr r r rrvs rvc@s0eZdZdZddZddZddZdd Zd S) FactKBzT A simple propositional knowledge base relying on compiled inference rules. cCs ddddt|DS)Nz{ %s}z, cSsg|]}d|qS)z %s: %sr rgr r rrr\z"FactKB.__str__..)joinsortedrrOr r rrzszFactKB.__str__cCs ||_dSr()rC)rPrCr r rrQs zFactKB.__init__cCs<||vr||dur|||krdSt||||||<dS)zxAdd fact k=v to the knowledge base. Returns True if the KB has actually been updated, False otherwise. NFT)rv)rPrvr r r_tells   z FactKB._tellc sjj}jj}jj}t|tr|}|rgt}|D])\}}||r*|dur+q|||fD] \}} || q1| |||fqg}|D]} || \} } t fdd| Drb| | qJ|sdSdS)z Update the KB with all the implications of a list of facts. Facts can be specified as a dictionary or as a list of (key, value) pairs. Nc3s"|] \}}||uVqdSr()r2)rrr~rOr rr-s z*FactKB.deduce_all_facts..) rCrrmr7r dictrrrupdateallr5) rPfactsrrmr7beta_maytriggerrr~keyryrAr:r,r rOrdeduce_all_factss(      zFactKB.deduce_all_factsN)rHrIrJrKrzrQrrr r r rr{s  r{N)rK collectionsrlogicrrrrrrrr'rBrF ExceptionrGrLrbr!rvrr{r r r rs 0  (O&v[