ó ~9­\c@ s dZddlmZmZddlmZddlmZmZm Z m Z ddl m Z m Z d„Zd„Zd „Zd „Zd „Zd „Zd efd„ƒYZdefd„ƒYZdefd„ƒYZdefd„ƒYZdefd„ƒYZdS(sDThis 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 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 iÿÿÿÿ(tprint_functiontdivision(t defaultdicti(tLogictAndtOrtNot(t string_typestrangecC st|tƒr|jS|SdS(sdReturn the literal fact of an atom. Effectively, this merely strips the Not around a fact. N(t isinstanceRtarg(tatom((s/lib/python2.7/site-packages/sympy/core/facts.pyt _base_fact:scC s*t|tƒr|jtfS|tfSdS(N(R RR tFalsetTrue(R ((s/lib/python2.7/site-packages/sympy/core/facts.pyt_as_pairEs cC s›t|ƒ}tƒjtt|ƒŒ}xm|D]e}x\|D]T}||f|kr;x9|D].}||f|krZ|j||fƒqZqZWq;q;Wq.W|S(s½ 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. (tsettuniontmaptadd(t implicationstfull_implicationstliteralstktitj((s/lib/python2.7/site-packages/sympy/core/facts.pyttransitive_closureNs    %c C sé|g|D]$\}}t|ƒt|ƒf^q }ttƒ}t|ƒ}x7|D]/\}}||krrqTn||j|ƒqTWx[|jƒD]M\}}|j|ƒt|ƒ}||kr”td|||fƒ‚q”q”W|S(s: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, ...]) s*implications are inconsistent: %s -> %s %s(RRRRRtitemstdiscardt ValueError( RRRtresRtatbtimpltna((s/lib/python2.7/site-packages/sympy/core/facts.pytdeduce_alpha_implicationsbs5      c  s(i}x.|jƒD] }t||ƒgf||Wt}xá|rpt}xÎ|D]Æ\}‰t|tƒsÍtdƒ‚nt|jƒ‰xŠ|jƒD]|\}\}}||hB} ˆ| kréˆj | ƒré|j ˆƒ|j ˆƒ} | dk r\|| dO}nt}qéqéWq£WqWx°t |ƒD]¢\} \}‰t|jƒ‰x~|jƒD]p\}\}}||hB} ˆ| krÝq¬nt‡‡fd†| Dƒƒrq¬nˆ| @r¬|j| ƒq¬q¬Wq~W|S(s¶apply 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] sCond is not Andic3 s3|])}t|ƒˆkp*t|ƒˆkVqdS(N(R(t.0txi(tbargstbimpl(s/lib/python2.7/site-packages/sympy/core/facts.pys ÐsN(tkeysRtargsRR R Rt TypeErrorRtissubsetRtgettNonet enumeratetanytappend( talpha_implicationst beta_rulestx_impltxtbcondtbktseen_static_extensiontximplstbbtx_allt bimpl_impltbidx((R&R's/lib/python2.7/site-packages/sympy/core/facts.pytapply_beta_to_alpha_routeŠsD        cC s™ttƒ}x†|jƒD]x\\}}}t|tƒrJ|jd}nxD|D]<\}}t|tƒr||jd}n||j|ƒqQWqW|S(sMbuild 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=? i(RRRR RR)R(trulestprereqRt_R!R((s/lib/python2.7/site-packages/sympy/core/facts.pyt rules_2prereqÙs tTautologyDetectedcB seZdZRS(s:(internal) Prover uses it for reporting detected tautology(t__name__t __module__t__doc__(((s/lib/python2.7/site-packages/sympy/core/facts.pyRBÿstProvercB sPeZdZd„Zd„Zed„ƒZed„ƒZd„Zd„Z RS(sSai - 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. cC sg|_tƒ|_dS(N(t proved_rulesRt _rules_seen(tself((s/lib/python2.7/site-packages/sympy/core/facts.pyt__init__!s cC shg}g}xO|jD]D\}}t|tƒrG|j||fƒq|j||fƒqW||fS(s-split proved rules into alpha and beta chains(RGR RR0(RIt rules_alphat rules_betaRR ((s/lib/python2.7/site-packages/sympy/core/facts.pytsplit_alpha_beta%scC s|jƒdS(Ni(RM(RI((s/lib/python2.7/site-packages/sympy/core/facts.pyRK0scC s|jƒdS(Ni(RM(RI((s/lib/python2.7/site-packages/sympy/core/facts.pyRL4scC sˆ| st|tƒrdSt|tƒr-dS||f|jkrFdS|jj||fƒy|j||ƒWntk rƒnXdS(sprocess a -> b ruleN(R tboolRHRt _process_ruleRB(RIRR ((s/lib/python2.7/site-packages/sympy/core/facts.pyt process_rule8s cC st|tƒr6xð|jD]}|j||ƒqWnÌt|tƒr$t|tƒs{||jkr{t||dƒ‚q{n|jtg|jD]}t|ƒ^qŽŒt|ƒƒxLtt |jƒƒD]T}|j|}|j| |j|d}|jt|t|ƒƒt|ŒƒqÉWnÞt|tƒrp||jkrWt||dƒ‚n|j j ||fƒn’t|tƒrÊ||jkr£t||dƒ‚nx\|jD]}|j||ƒq­Wn8|j j ||fƒ|j j t|ƒt|ƒfƒdS(Ns a -> a|c|...is a & b -> as a | b -> a( R RR)RPRRRBRRtlenRGR0(RIRR tbargR<tbresttaarg((s/lib/python2.7/site-packages/sympy/core/facts.pyROIs.8 ,( RCRDRERJRMtpropertyRKRLRPRO(((s/lib/python2.7/site-packages/sympy/core/facts.pyRFs   t FactRulescB seZdZd„ZRS(s•Rules 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 cC s0t|tƒr|jƒ}ntƒ}x¥|D]}|jddƒ\}}}tj|ƒ}tj|ƒ}|dkrŒ|j||ƒq.|dkr»|j||ƒ|j||ƒq.t d|ƒ‚q.Wg|_ xF|j D];\}}|j j t d„|jDƒƒt|ƒfƒqâWt|jƒ} t| |j ƒ} t d„| jƒDƒƒ|_tt ƒ} tt ƒ} xP| jƒD]B\} \}}t d„|Dƒƒ| t| ƒ<|| t| ƒs==s unknown op %rcs s|]}t|ƒVqdS(N(R(R$R((s/lib/python2.7/site-packages/sympy/core/facts.pys µscs s|]}t|ƒVqdS(N(R (R$R((s/lib/python2.7/site-packages/sympy/core/facts.pys Áscs s|]}t|ƒVqdS(N(R(R$R((s/lib/python2.7/site-packages/sympy/core/facts.pys ÇsN(R Rt splitlinesRFtsplitR-Rt fromstringRPRR2RLR0RR)RR#RKR=R(t defined_factsRRRt beta_triggersRAR?(RIR>tPtruleRtopR R5R'timpl_atimpl_abRR[RR!tbetaidxsR?t rel_prereqtpitems((s/lib/python2.7/site-packages/sympy/core/facts.pyRJ™s@      *       (RCRDRERJ(((s/lib/python2.7/site-packages/sympy/core/facts.pyRVzstInconsistentAssumptionscB seZd„ZRS(cC s#|j\}}}d|||fS(Ns %s, %s=%s(R)(RItkbtfacttvalue((s/lib/python2.7/site-packages/sympy/core/facts.pyt__str__Ös(RCRDRh(((s/lib/python2.7/site-packages/sympy/core/facts.pyRdÕstFactKBcB s2eZdZd„Zd„Zd„Zd„ZRS(sT A simple propositional knowledge base relying on compiled inference rules. cC s4ddjgt|jƒƒD]}d|^qƒS(Ns{ %s}s, s %s: %s(tjointsortedR(RIR((s/lib/python2.7/site-packages/sympy/core/facts.pyRhßs cC s ||_dS(N(R>(RIR>((s/lib/python2.7/site-packages/sympy/core/facts.pyRJãscC sW||krE||dk rE|||kr0tSt|||ƒ‚n|||sN( R>RR[R2R tdictRRRmR-tupdatetallR0( RItfactsRR[R2tbeta_maytriggerRRltkeyRgR<R5R'((RIs/lib/python2.7/site-packages/sympy/core/facts.pytdeduce_all_facts÷s$      (RCRDRERhRJRmRt(((s/lib/python2.7/site-packages/sympy/core/facts.pyRiÛs    N(REt __future__RRt collectionsRtlogicRRRRtsympy.core.compatibilityRRR RRR#R=RAt ExceptionRBtobjectRFRVRRdRnRi(((s/lib/python2.7/site-packages/sympy/core/facts.pyt1s"  ( O &v[