gZLdZddlmZddlmZddlmZmZmZm Z dZ dZ dZ d Z d Zd ZGd d eZGddZGddZGddeZGddeZdS)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 L/var/www/html/ai-engine/env/lib/python3.11/site-packages/sympy/core/facts.py _base_factr7s" $x cFt|tr |jdfS|dfS)NFTr rs r_as_pairrBs+$%  d|rct|}tjtt|}|D]/}|D]*}||f|vr"|D]}||f|vr|||f +0|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))suu{C%6778H 66 6 6A1v***!66A1v!222)--q!f555  6 rc r|d|Dz}tt}t|}|D]'\}}||kr |||(|D]E\}}||t |}||vrtd|d|d|F|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, ...]) cPg|]#\}}t|t|f$Sr ).0rrs r z-deduce_alpha_implications..ss-"O"O"OACFFCFF#3"O"O"Orzimplications are inconsistent: z ->  )rrr ritemsdiscardr ValueError)rresrabimplnas rdeduce_alpha_implicationsr0_s( "O"O,"O"O"OOL c  C*<88!1 66  A 1 99;;NN4 Q VV ::*@A222ttLNN N  JrcT i}|D]}t||gf||<|D]'\} |jD]}||vrtgf||<(d}|rd}|D]\} t|tst dt|j |D]`\}\}}||hz} | vrN | r9| | } | || dz}d}a|t|D]{\} \} t|j |D]J\}\}}||hz} | vrt fd| Dr0 | zr| | K||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 AndNrc3`K|](}t|vpt|kV)dSNr$)r%xibargsbimpls r z,apply_beta_to_alpha_route..s>HHB3r77e#7s2ww%'7HHHHHHr) keysrargsr r TypeErrorr(issubsetrget enumerateanyappend)alpha_implications beta_rulesx_implxbcondbkseen_static_extensionximplsbbx_all bimpl_implbidxr5r6s @@rapply_beta_to_alpha_routerLs28F  $ $ & &55+A.//4q "%% u* % %BV||%%F2JJ %! 1 %& 1 1LE5eS)) 3 1222 OOE#)<<>> 1 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 r9r)rulesprereqr,_r.rs r rules_2prereqrQs.  F  A a   q A  FQ!S!! F1I 1IMM!      MrceZdZdZdS)TautologyDetectedz:(internal) Prover uses it for reporting detected tautologyN)__name__ __module__ __qualname____doc__r#rrrSrSsDDDrrScVeZdZdZdZdZedZedZdZ dZ 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. c:g|_t|_dSr3) proved_rulesr _rules_seenselfs r__init__zProver.__init__s55rcg}g}|jD]I\}}t|tr|||f2|||fJ||fS)z-split proved rules into alpha and beta chains)r[r rr?)r^ rules_alpha rules_betar,r-s rsplit_alpha_betazProver.split_alpha_beta"su  % + +DAq!S!! +!!1a&))))""Aq6****J&&rc6|dS)Nrrcr]s rrazProver.rules_alpha-$$&&q))rc6|dS)Nrrer]s rrbzProver.rules_beta1rfrc|rt|trdSt|trdS||f|jvrdS|j||f |||dS#t $rYdSwxYw)zprocess a -> b ruleN)r boolr\r _process_rulerS)r^r,r-s r process_rulezProver.process_rule5s jD))  F a    F q6T% % % F   !Q ( ( (    q! $ $ $ $ $     DD sA33 BBc t|tr8t|jt}|D]}|||dSt|t rt|jt}t|ts||vrt||d|td|jDt|tt|D]Z}||}|d|||dzdz}|t|t|t |[dSt|trNt|jt}||vrt||d|j ||fdSt|t rMt|jt}||vrt||d|D]}|||dS|j ||f|j t|t|fdS)N)keyz a -> a|c|...c,g|]}t|Sr#r$)r%bargs rr&z(Prover._process_rule..[s#A#A#A$CII#A#A#Arrz a & b -> az a | b -> a)r rsortedr9strrkrrrSr rangelenr[r?) r^r,r- sorted_bargsrorKbrest sorted_aargsaargs rrjzProver._process_ruleFs a  + 7!!&c222L$ + +!!!T**** + + 2  # 7!!&c222La'' B $$+Aq.AAA   c#A#A!&#A#A#ABCFF K K Kc,//00 A A#D)$UdU+l4!899.EE!!#aT"3"3RZ@@@@ A A3   7!!&c222LL  '1l;;;   $ $aV , , , , ,2   7!!&c222LL  '1l;;;$ + +!!$**** + +   $ $aV , , ,   $ $c!ffc!ff%5 6 6 6 6 6rN) rTrUrVrWr_rcpropertyrarbrkrjr#rrrYrYs8!!! ' ' '**X***X*"1717171717rrYcpeZdZdZdZdefdZedefdZ dZ dZ d Z d Z deefd Zd S) 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 ct|tr|}t}|D]}|dd\}}}t j|}t j|}|dkr|||a|dkr-||||||td|zg|_ |j D]=\}}|j d|j Dt|f>t|j} t!| |j } d| D|_t't(} t't(} | D]6\} \}}d|D| t| <|| t| <7| |_| |_t't(}t1| }|D]\} }|| xx|zcc<||_dS) z)Compile rules into internal lookup tablesNz->z==z unknown op %rc,h|]}t|Sr#r)r%r,s r z%FactRules.__init__..s222!(1++222rc,h|]}t|Sr#)r)r%rs rrz%FactRules.__init__..sDDDjmmDDDrc,h|]}t|Sr#r~r%rs rrz%FactRules.__init__..s-H-H-Hahqkk-H-H-Hr)r rq splitlinesrYsplitr fromstringrkr*rArbr?r9rr0rarLr8 defined_factsrrr(r beta_triggersrQrO)r^rNPruler,opr-rDr6impl_aimpl_abrrrr.betaidxsrO rel_prereqpitemss rr_zFactRules.__init__sf eS ! ! '$$&&E HH 7 7Dzz$**HAr1 ##A ##ATzzq!$$$$tq!$$$q!$$$$ 2!5666L F FLE5 O " "22uz222HUOOD F F F F+1=99 ,FALAAEDW\\^^DDD(,,#C(( #*==?? 2 2 Ah-H-H4-H-H-H hqkk *)1M(1++ & &!2*S!!"#455 #))++  IAv 1III IIII rreturncPd|S)zD Generate a string with plain python representation of the instance  )join print_rulesr]s r _to_pythonzFactRules._to_pythons yy))++,,,rdatac|d}dD]B}tt}|||t|||C|d|_t|d|_|S)z; Generate an instance from the plain python representation )rrrOrAr)rrupdatesetattrrAr)clsrr^rmds r _from_pythonzFactRules._from_pythons~s2wwC " "C#A HHT#Y    D#q ! ! ! !|, o!677 rc#XKdVt|jD] }d|dV dVdS)Nzdefined_facts = [ ,z] # defined_facts)rpr)r^facts r_defined_facts_lineszFactRules._defined_facts_linessX!!!!4-.. # #D"""" " " " "!!!!!!rc#KdVt|jD]N}dD]I}d|d|dVd|d|dV|j||f}t|D] }d |d V d Vd VJOd VdS)Nzfull_implications = dict( [)TFz # Implications of  = :z ((, z ), set( ( rz ) ),z ),z ] ) # full_implications)rprr)r^rvaluerimplieds r_full_implications_linesz"FactRules._full_implications_liness++++4-..  D&  @t@@@@@@@@;t;;;;;;;;#5tUmD %l3322G1W1111111#### )(((((rc#KdVdVt|jD]>}d|Vd|dVt|j|D] }d|dV dVdV?d VdS) Nz prereq = {rz. # facts that could determine the value of rz: {rrz },z } # prereq)rprO)r^rpfacts r _prereq_lineszFactRules._prereq_liness4;''  DI4II I I I%%%% % % % D 122 , ,++++++++NNNHHHHrc #d Ktt}t|jD]%\}\}}||||f&dVdVdVd}i t |D]r}|\}}d|d|V||D]T\}}| |<|dz }dttt |}d |d Vd |d VUdVsd VdVt |j D]+} | \}} fd|j | D} d| d| dV,dVdS)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 = {c g|] }| Sr#r#)r%nindicess rr&z/FactRules._beta_rules_lines..sFFFq FFFrrz: rz} # beta_triggers) rlistr=rAr?rprrrqr) r^reverse_implicationsrprermrrsetstrquerytriggersrs @r_beta_rules_lineszFactRules._beta_rules_liness*400!*4?!;!; ; ; A~W  ) 0 0#q : : : :PPPP 233  G!KD%:$::5:: : : :.w7 / /Q Q3sF3KK#8#899+++++++........HHHH!!!!D.// 2 2EKD%FFFFD,>u,EFFFH111H111 1 1 1 1!!!!!!rc#*K|Ed{VdVdV|Ed{VdVdV|Ed{VdVdV|Ed{VdVdVdVdVdS)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})rrrrr]s rrzFactRules.print_rules#s,,.........00222222222%%'''''''''))+++++++++ppppjjjjjjrN)rTrUrVrWr_rqr classmethoddictrrrrrrrr#rrrzrz|s<999v-C----    [ """ ) ) )   """:kXc]kkkkkkrrzceZdZdZdS)InconsistentAssumptionsc,|j\}}}|d|d|S)Nr=)r9)r^kbrrs r__str__zInconsistentAssumptions.__str__6s&)D% bb$$$..rN)rTrUrVrr#rrrr5s#/////rrc*eZdZdZdZdZdZdZdS)FactKBzT A simple propositional knowledge base relying on compiled inference rules. cdddt|DzS)Nz{ %s}z, cg|]}d|zS)z %s: %sr#rs rr&z"FactKB.__str__..As : : :Z!^ : : :r)rrpr(r]s rrzFactKB.__str__?s@%** : :VDJJLL%9%9 : : :<<< |dSdS)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. Nc3LK|]\}}||uVdSr3)r<)r%rrr^s rr7z*FactKB.deduce_all_facts..ys6::DAqtxx{{a'::::::r) rNrrrAr rr(rrrallr?) r^factsrrrAbeta_maytriggerrrrmrrKrDr6s ` rdeduce_all_factszFactKB.deduce_all_factsWsU!J8 0 Z* eT " " "KKMME (!eeO < <1zz!Q''19#4AqD"9++JCJJsE****&&}QT':;;;;E' ( ()$/ u::::E:::::(LL'''' ( ( ( ( (rN)rTrUrVrWrr_rrr#rrrr;sZ<<<   "#(#(#(#(#(rrN)rW collectionsrtypingrlogicrrrr rrr r0rLrQ ExceptionrSrYrzr*rrrr#rrrs..`$#####&&&&&&&&&&&&(%%%PLLL^L        v7v7v7v7v7v7v7v7vvkvkvkvkvkvkvkvkr/////j/// ?(?(?(?(?(T?(?(?(?(?(r