o FZhZL@sdZddlmZddlmZddlmZmZmZm Z ddZ dd Z d d Z d d Z ddZddZGdddeZGdddZGdddZGdddeZGdddeZdS)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)Iterator)LogicAndOrNotcCst|tr|jS|S)zdReturn the literal fact of an atom. Effectively, this merely strips the Not around a fact.  isinstancerargZatomr ?/var/www/auris/lib/python3.10/site-packages/sympy/core/facts.py _base_fact7s rcCst|tr |jdfS|dfS)NFTr r r r r_as_pairBs  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_closureKs  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 ss 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)rxiZbargsbimplr r s&z,apply_beta_to_alpha_route..) keysrargsr r TypeErrorrissubsetrget enumerateanyappend) Zalpha_implications beta_rulesZx_implxbcondZbkZseen_static_extensionZximplsZbbZx_allZ bimpl_implbidxr r*rapply_beta_to_alpha_routesP              r9cCsftt}|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     r=c@seZdZdZdS)TautologyDetectedz:(internal) Prover uses it for reporting detected tautologyN)__name__ __module__ __qualname____doc__r r r rr>sr>c@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)rDr rr4)rG rules_alpha rules_betar#r$r r rsplit_alpha_beta"s zProver.split_alpha_betacC |dS)NrrKrFr r rrI- zProver.rules_alphacCrL)NrrMrFr r rrJ1rNzProver.rules_betacCsj|rt|tr dSt|trdS||f|jvrdS|j||fz |||WdSty4YdSw)zprocess a -> b ruleN)r boolrEr _process_ruler>)rGr#r$r r r process_rule5s  zProver.process_rulec Cst|trt|jtd}|D]}|||qdSt|trnt|jtd}t|ts4||vr4t||d|tdd|jDt |t t |D]!}||}|d|||dd}|t|t |t|qJdSt|trt|jtd}||vrt||d|j ||fdSt|trt|jtd}||vrt||d|D]}|||qdS|j ||f|j t |t |fdS)N)keyz a -> a|c|...cSsg|]}t|qSr r)rbargr r rr[z(Prover._process_rule..rz a & b -> az a | b -> a)r rsortedr.strrQrrr>rrangelenrDr4) rGr#r$Z sorted_bargsrSr8ZbrestZ sorted_aargsZaargr r rrPFs<         zProver._process_ruleN) r?r@rArBrHrKpropertyrIrJrQrPr r r rrCs   rCc@sjeZdZdZddZdefddZedefdd Z d d Z d d Z ddZ ddZ deefddZdS) 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 rTz%FactRules.__init__..cSr\r )r)rrr r rr^rTcSr\r r]rrr r rr^rT)r rV splitlinesrCsplitrZ fromstringrQr!r5rJr4r.rr'rIr9r- defined_factsrrrr beta_triggersr=r;)rGr:Pruler#opr$r7r+Zimpl_aZimpl_abrrcrr%Zbetaidxsr;Z rel_prereqZpitemsr r rrHsB        zFactRules.__init__returncCsd|S)zD Generate a string with plain python representation of the instance  )join print_rulesrFr r r _to_pythonszFactRules._to_pythondatacCsP|d}dD]}tt}|||t|||q|d|_t|d|_|S)z; Generate an instance from the plain python representation )rrcr;r5rb)rrupdatesetattrr5rb)clsrlrGrRdr r r _from_pythons zFactRules._from_pythonccs0dVt|jD] }d|dVq dVdS)Nzdefined_facts = [ ,z] # defined_facts)rUrb)rGfactr r r_defined_facts_liness  zFactRules._defined_facts_linesccsdVt|jD]6}dD]1}d|d|dVd|d|dV|j||f}t|D] }d |d Vq.d Vd Vq q d VdS)Nzfull_implications = dict( [)TFz # Implications of  = :z ((, z ), set( ( rtz ) ),z ),z ] ) # full_implications)rUrbr)rGruvaluerimpliedr r r_full_implications_liness  z"FactRules._full_implications_linesccspdVdVt|jD]&}d|Vd|dVt|j|D] }d|dVq"dVdVq d VdS) Nz prereq = {rmz. # facts that could determine the value of rsz: {rzrtz },z } # prereq)rUr;)rGruZpfactr r r _prereq_liness  zFactRules._prereq_linesc #s(tt}t|jD]\}\}}||||fq dVdVdVd}it|D];}|\}}d|d|V||D]$\}}||<|d7}dttt|}d |d Vd |d Vq>dVq+d VdVt|j D]} | \}}fdd|j | D} d| d| dVqrdVdS)Nz@# Note: the order of the beta rules is used in the beta_triggerszbeta_rules = [rmrz # Rules implying rwrryz ({z},rzz),z] # beta_ruleszbeta_triggers = {csg|]}|qSr r )rnindicesr rrrTz/FactRules._beta_rules_lines..rsz: rtz} # beta_triggers) rlistr2r5r4rUrirrVrc) rGZreverse_implicationsrprer|mrur{Zsetstrquerytriggersr rr_beta_rules_liness4  zFactRules._beta_rules_linesccsz|EdHdVdV|EdHdVdV|EdHdVdV|EdHdVdVdVdVdS)zA Returns a generator with lines to represent the facts and rules Nrmz`generated_assumptions = {'defined_facts': defined_facts, 'full_implications': full_implications,zZ 'prereq': prereq, 'beta_rules': beta_rules, 'beta_triggers': beta_triggers})rvr}r~rrFr r rrj#s zFactRules.print_rulesN)r?r@rArBrHrVrk classmethoddictrrrvr}r~rrrjr r r rrZ|s;   rZc@seZdZddZdS)InconsistentAssumptionscCs|j\}}}d|||fS)Nz %s, %s=%s)r.)rGkbrur{r r r__str__6s zInconsistentAssumptions.__str__N)r?r@rArr r r rr5s rc@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 r_r r rrArTz"FactKB.__str__..)rirUrrFr r rr?szFactKB.__str__cCs ||_dSr()r:)rGr:r r rrHCs 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)r)rGrvr r r_tellFs   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()r1)rrrrFr rr,ys z*FactKB.deduce_all_facts..) r:rrcr5r rrrrrnallr4) rGZfactsrrcr5Zbeta_maytriggerrrrRr{r8r7r+r rFrdeduce_all_factsWs(      zFactKB.deduce_all_factsN)r?r@rArBrrHrrr r r rr;s  rN)rB collectionsrtypingrZlogicrrrrrrrr'r9r= Exceptionr>rCrZr!rrrr r r rs  0   (O&{: