7^(hZLdZddlmZddlmZddlmZmZmZm Z dZ dZ dZ d Z d Zd ZGd d eZGddZGddZGddeZGddeZy)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)LogicAndOrNotc>t|tr |jS|S)zdReturn the literal fact of an atom. Effectively, this merely strips the Not around a fact.  isinstancer argatoms N/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/sympy/core/facts.py _base_factr7s $xx cFt|tr|jdfS|dfS)NFTr rs r_as_pairrBs%$%  d|rct|}tjtt|}|D]1}|D]*}||f|vs |D]}||f|vs |j||f,3|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_implicationsliteralskijs rtransitive_closurer KsL)su{{C%678H 6 6A1v**!6A1v!22)--q!f56 66 rc ~||Dcgc]\}}t|t|fc}}z}tt}t|}|D]\}}||k(r ||j |!|j D]9\}}|j |t|}||vs'td|d|d||Scc}}w)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, ...]) zimplications are inconsistent: z ->  )r rrr ritemsdiscard ValueError) rrrresrabimplnas rdeduce_alpha_implicationsr+_s( ,"OACFCF#3"OOL c C*<8!1 6  A 1 99;N4 Q V :@A2tLN N N J##Ps B9c  i}|jD]}t||gf||<|D]*\} |jD]}||vrtgf||<,d}|rd}|D]\} t|ts t dt|j |j D]S\}\}}||hz} | vs j| s&|j |j } | || dz}d}U|rt|D]p\} \} t|j |j D]@\}\}}||hz} | vrt fd| Dr* | zs0|j| Br|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 Andrc3XK|]!}t|vxst|k(#ywN)r ).0xibargsbimpls r z,apply_beta_to_alpha_route..s+HB3r7e#7s2w%'77Hs'*) keysrargsr r TypeErrorr#issubsetrget enumerateanyappend)alpha_implications beta_rulesx_implxbcondbkseen_static_extensionximplsbbx_all bimpl_implbidxr1r2s @@rapply_beta_to_alpha_routerHs8F  $ $ &5+A./4q 5"% u** %BV|%F2J %%!  %& 1LE5eS) 122 OE#)<<> 1 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)rrr#r r r5r)rulesprereqr'_r)rs r rules_2prereqrMs. F  A a q A FQ!S!FF1I 1IMM!   MrceZdZdZy)TautologyDetectedz:(internal) Prover uses it for reporting detected tautologyN)__name__ __module__ __qualname____doc__rrrOrOsDrrOcHeZdZdZdZdZedZedZdZ dZ y) 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. c0g|_t|_yr.) proved_rulesr _rules_seenselfs r__init__zProver.__init__s5rcg}g}|jD]<\}}t|tr|j||f*|j||f>||fS)z-split proved rules into alpha and beta chains)rXr rr;)r[ rules_alpha rules_betar'r(s rsplit_alpha_betazProver.split_alpha_beta"s`  %% +DAq!S!!!1a&)""Aq6*  + J&&rc(|jdS)Nrr`rZs rr^zProver.rules_alpha-$$&q))rc(|jdS)NrrbrZs rr_zProver.rules_beta1rcrc|rt|tryt|try||f|jvry|jj||f |j ||y#t $rYywxYw)zprocess a -> b ruleN)r boolrYr _process_rulerO)r[r'r(s r process_rulezProver.process_rule5srjD)  a   q6T%% %     !Q (    q! $    sA'' A32A3c \t|tr5t|jt}|D]}|j ||yt|t rt|jt}t|ts||vr t||d|j t|jDcgc] }t|c}t|tt|D]@}||}|d|||dzdz}|j t|t|t |Byt|trJt|jt}||vr t||d|jj||fyt|t rFt|jt}||vr t||d|D]}|j ||y|jj||f|jjt|t|fycc}w)N)keyz a -> a|c|...rz a & b -> az a | b -> a)r rsortedr5strrhrrrOr rangelenrXr;) r[r'r( sorted_bargsbargrGbrest sorted_aargsaargs rrgzProver._process_ruleFs a !!&&c2L$ +!!!T* + 2 !!&&c2La' $+Aq.AA   c!&&#A$CI#ABCF Kc,/0 A#D)$Ud+l4!89.EE!!#aT"3RZ@ A3 !!&&c2LL '1l;;    $ $aV ,2 !!&&c2LL '1l;;$ +!!$* +    $ $aV ,    $ $c!fc!f%5 69$Bs0H) N) rPrQrRrSr\r`propertyr^r_rhrgrTrrrVrVsC8! '****"17rrVcbeZdZdZdZdefdZedefdZ dZ dZ d Z d Z deefd Zy ) 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 c t|tr|j}t}|D]}|j dd\}}}t j |}t j |}|dk(r|j||[|dk(r%|j|||j||td|zg|_ |jD]L\}}|jj|jDchc] }t|c}t|fNt|j} t!| |j} | j#D chc] } t%| c} |_t)t*} t)t*} | j-D];\} \}}|Dchc] }t|c}| t| <|| t| <=| |_| |_t)t*}t3| }|j-D]\} }|| xx|zcc<||_ycc}wcc} wcc}w)z)Compile rules into internal lookup tablesNz->z==z unknown op %r)r rl splitlinesrVsplitr fromstringrhr%r=r_r;r5rr+r^rHr4r defined_factsrrr#r beta_triggersrMrK)r[rJPruler'opr(r@r2impl_aimpl_abrrr}r)betaidxsrrK rel_prereqpitemss rr\zFactRules.__init__s eS !$$&E H 7Dzz$*HAr1  #A  #ATzq!$tq!$q!$ 2!566 7 LL FLE5 OO " "',zz2!(1+2HUOD F F +1==9 ,FALLA6=\\^DjmD(,#C( #*==? 2 AhCG-Hahqk-H hqk *)1M(1+ & 2"3*S!"#45 #))+ IAv 1I I  ;3E .Is=H; I5Ireturnc@dj|jS)zD Generate a string with plain python representation of the instance  )join print_rulesrZs r _to_pythonzFactRules._to_pythonsyy))+,,rdatac|d}dD]2}tt}|j||t|||4|d|_t|d|_|S)z; Generate an instance from the plain python representation )rr}rKr=r|)rrupdatesetattrr=r|)clsrr[rjds r _from_pythonzFactRules._from_pythonsg2wC "C#A HHT#Y  D#q ! "|, o!67 rc#`Kdt|jD] }d|d dyw)Nzdefined_facts = [ ,z] # defined_facts)rkr|)r[facts r_defined_facts_lineszFactRules._defined_facts_liness;!!4--. #D" " #!!s,.c#Kdt|jD]P}dD]I}d|d|dd|d|d|j||f}t|D] }d |d  d d KRd yw)Nzfull_implications = dict( [)TFz # Implications of  = :z ((, z ), set( ( rz ) ),z ),z ] ) # full_implications)rkr|r)r[rvaluerimplieds r_full_implications_linesz"FactRules._full_implications_liness++4--. D& .tfCwa@@thb ;;#55tUmD %l32G$WKq112##  )(sA2A4c#Kddt|jD]>}d|d|dt|j|D] }d|d dd@d yw) Nz prereq = {rz. # facts that could determine the value of rz: {rrz },z } # prereq)rkrK)r[rpfacts r _prereq_lineszFactRules._prereq_liness4;;' DB4&I I% % D 12 ,  ++ ,NH  sA$A&c #NKtt}t|jD]\}\}}||j ||f dddd}i}t |D]d}|\}}d|d|||D]G\}}|||<|dz }dj ttt |} d | d d |d Idfd dt |jD]1} | \}}|j| Dcgc]}|| } }d| d| d3dycc}ww)Nz@# Note: the order of the beta rules is used in the beta_triggerszbeta_rules = [rrz # Rules implying rrrz ({z},rz),z] # beta_ruleszbeta_triggers = {rz: rz} # beta_triggers) rlistr9r=r;rkrrrlr}) r[reverse_implicationsnprermindicesrrsetstrquerytriggerss r_beta_rules_lineszFactRules._beta_rules_linessv*40!*4??!; ; A~W  ) 0 0#q : ;QP 23 G!KD%)$s5': :.w7 /Q Q3sF3K#89xs++  2..  / H !!D../ 2EKD%,0,>,>u,EFq FHF HD% D  D%c#,K|jEd{dd|jEd{dd|jEd{dd|jEd{ddddy7u7W797w)zA Returns a generator with lines to represent the facts and rules Nrz`generated_assumptions = {'defined_facts': defined_facts, 'full_implications': full_implications,zZ 'prereq': prereq, 'beta_rules': beta_rules, 'beta_triggers': beta_triggers})rrrrrZs rrzFactRules.print_rules#s,,...00222%%'''))+++ppjj / 3 ( ,sCBB BBBBB6B7BBBBN)rPrQrRrSr\rlr classmethoddictrrrrrrrrTrrrvrv|sZ<9v-C-   " ) ":kXc]krrvceZdZdZy)InconsistentAssumptionsc6|j\}}}|d|d|S)Nr=)r5)r[kbrrs r__str__zInconsistentAssumptions.__str__6s))D% $..rN)rPrQrRrrTrrrr5s/rrc(eZdZdZdZdZdZdZy)FactKBzT A simple propositional knowledge base relying on compiled inference rules. cddjt|jDcgc]}d|z c}zScc}w)Nz{ %s}z, z %s: %s)rrkr#)r[rs rrzFactKB.__str__?s:%**%+DJJL%9 :Z!^ :<< < :s = c||_yr.)rJ)r[rJs rr\zFactKB.__init__Cs  rcL||vr|||||k(ryt||||||<y)zxAdd fact k=v to the knowledge base. Returns True if the KB has actually been updated, False otherwise. FT)r)r[rvs r_tellz FactKB._tellFs= 9a,Aw!|-dAq99DGrcjj}jj}jj}t |t r|j }|rt}|D]Q\}}j||r||||fD]\}} j|| |j|||fSg}|D]0} || \} } tfd| Ds |j| 2|ryy)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. Nc3JK|]\}}j||uywr.)r8)r/rrr[s rr3z*FactKB.deduce_all_facts..ys":DAqtxx{a':s #) rJrr}r=r rr#rrrallr;) r[factsrr}r=beta_maytriggerrrrjrrGr@r2s ` rdeduce_all_factszFactKB.deduce_all_factsWs!JJ88 00 ZZ** eT "KKME!eO <1zz!Q'19#4AqD"9+JCJJsE*+ &&}QT':; <E' ()$/ u:E::LL' (!rN)rPrQrRrSrr\rrrTrrrr;s< "#(rrN)rS collectionsrtypingrlogicrrrr rrr r+rHrM ExceptionrOrVrvr%rrrrTrrrs{.`$&&(%PL^L  v7v7vvkvkr/j/ ?(T?(r