+ jZLRt^RIHt^RIHt^RIHtHtHtH t Rt Rt Rt Rt RtR t!R R ]4t!R R 4t!RR4t!RR]4t!RR]4tR#)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)LogicAndOrNotcJ\V\4'd VP#V#)z\Return the literal fact of an atom. Effectively, this merely strips the Not around a fact.  isinstancerargatoms&Q/home/luca/screen-checking/.venv/lib/python3.14/site-packages/sympy/core/facts.py _base_factr7s $xx cR\V\4'dVPR3#VR3#)FTr r s&r_as_pairrBs($%  d|rc\V4p\4P!\\V4!pVF;pVF2pWC3V9gK VFpW53V9gK VPWE34K! K4 K= V#)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_closurerKssL)u{{C%678H Av**!Av!22)--qf5" rc YUUu.uFwr\V4\V43NK upp,p\\4p\V4pVF$wrVWV8XdK W5,P V4K& VP 4F>wrWVP V4\V4pW9gK)\RV: RV: RV: 24h V#uuppi)zdeduce 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 ->  )rrrrritemsdiscard ValueError) rrrresrabimplnas & rdeduce_alpha_implicationsr)_s( ,"O,CFCF#3,"OOL c C*<8! 6   1 "99; Q V :@A2tLN N  J##Ps!C ca a /pVP4Fp\W,4.3W#&K VF/wpo VPFpWR9dK \4.3W%&K K1 RpV'dRpVFwpo \V\4'g \ R4h\VP4o VP 4FjwpwrxWs0,p S V 9gKS PV 4'gK3VPS 4VPS 4p V eWz^,,pRpKl K K\V4Fwp wpo \VP4o VP 4FwpwrxWs0,p S V 9dK\;QJd V V 3RlV 4F 'gK RM RM!V V 3RlV 44'dK^S V ,'gKoVPV 4K K V#)a~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] TFzCond is not Andc3l<"TF)p\V4S9;'g\V4S8HxK+ R#5iN)r).0xibargsbimpls& r ,apply_beta_to_alpha_route..s.H%B3r7e#77s2w%'77%s44) keysrargsr r TypeErrorr!issubsetrget enumerateanyappend)alpha_implications beta_rulesx_implxbcondbkseen_static_extensionximplsbbx_all bimpl_implbidxr/r0s&& @@rapply_beta_to_alpha_routerGs8F  $ $ &+./4 '" u**B|%FJ#!  %&LE5eS)) 122 OE#)<<> 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=? )rrr!r rr4r)rulesprereqr%_r'rs& r rules_2prereqrLsy. F  a  q AFQ!S!!FF1I IMM! & Mrc]tRt^tRtRtR#)TautologyDetectedz:(internal) Prover uses it for reporting detected tautologyN)__name__ __module__ __qualname____firstlineno____doc____static_attributes__rOrrrNrNsDrrNc\a]tRtRtoRtRtRt]R4t]R4t Rt Rt R t Vt R #) Proveriaai - 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. c2.Vn\4VnR#r,) proved_rulesr _rules_seenselfs&r__init__Prover.__init__s5rc .p.pVPFAwr4\V\4'dVPW434K/VPW434KC W3#)z-split proved rules into alpha and beta chains)rYr rr:)r\ rules_alpha rules_betar%r&s& rsplit_alpha_betaProver.split_alpha_beta"sV  %%DA!S!!!!1&)""A6* & &&rc0VP4^,#)rbr[s&rr`Prover.rules_alpha-$$&q))rc0VP4^,#)rfr[s&rraProver.rules_beta1rhrc V'd\V\4'dR#\V\4'dR#W3VP9dR#VPPW34VP W4R# \ dR#i;i)zprocess a -> b ruleN)r boolrZr _process_rulerN)r\r%r&s&&&r process_ruleProver.process_rule5srjD))  a    6T%% %     ! (    q $    s*A== B  B c \V\4'd8\VP\R7pVFpVP W4K R#\V\ 4'd\VP\R7p\V\4'gW9d \WR4hTP \VPUu.uFp\V4NK up!\V44\\V44FLpW5,pVRVW5^,R,pVP \V\V44\ V!4KN R#\V\4'dL\VP\R7pW'9d \WR4hVPPW34R#\V\ 4'dJ\VP\R7pW'9d \WR4hVFpVP W4K R#VPPW34VPP\V4\V434R#uupi))keyz a -> a|c|...Nz a & b -> az a | b -> a)r rsortedr4strrorrrNrrangelenrYr:) r\r%r& sorted_bargsbargrFbrest sorted_aargsaargs &&& rrnProver._process_ruleFs a  !!&&c2L$!!!*% 2  !!&&c2La''$+A.AA   c!&&#A&$CI&#ABCF Kc,/0#)$Ud+l!89.EE!!#aT"3RZ@13  !!&&c2L 'l;;    $ $aV ,2  !!&&c2L 'l;;$!!$*%    $ $aV ,    $ $c!fc!f%5 69$BsI )rZrYN)rPrQrRrSrTr]rbpropertyr`rarornrU__classdictcell__ __classdict__s@rrWrWsK8! '****"1717rrWca]tRtRtoRtRtV3RlRlt]V3RlRl4tRt R t R t R t V3R lR lt RtVtR#) FactRulesi|aRules 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  \V\4'dVP4p\4pVFpVP R^4wrEp\ P !V4p\ P !V4pVR8XdVPWF4K^VR8Xd%VPWF4VPWd4K\RV,4h .Vn VPFNwrxVPPVPUu0uFp\V4kK up\V434KP \VP4p \!WP4p V P#4U u0uFp \%V 4kK up Vn\)\*4p \)\*4p V P-4F<wp wrVUu0uFp\V4kK upV \V 4&W\V 4&K> WnWn\)\*4p\3V 4pVP-4Fwp pVV ;;,V,uu&K VVnR#uupiuup iuupi)z)Compile rules into internal lookup tablesNz->z==z unknown op %r)r rt splitlinesrWsplitr fromstringror#r<rar:r4rr)r`rGr3r defined_factsrrr!r beta_triggersrLrJ)r\rIPruler%opr&r?r0impl_aimpl_abrrrr'betaidxsrrJ rel_prereqpitemss&& rr]FactRules.__init__s eS ! !$$&E HDzz$*HA1  #A  #ATzq$tq$q$ 2!566 LLLE OO " "',zz2z!(1+z2HUOD F) +1==9 ,FLLA6=\\^D^jm^D(,#C( #*==? ACG-H4ahqk4-H hqk *)1(1+ &$3"3*S!"#45 #))+IAv 1I I, ;3E .Is I 1II#c <V^8dQhRS[/#return)rt)formatrs"r __annotate__FactRules.__annotate__s--C-rc @RPVP44#)zCGenerate a string with plain python representation of the instance  )join print_rulesr[s&r _to_pythonFactRules._to_pythonsyy))+,,rc <V^8dQhRS[/#)rdata)dict)rrs"rrrs   rc V!R4pRF5p\\4pVPW,4\W#V4K7 VR,Vn\VR,4VnV#)z:Generate an instance from the plain python representation r<r)rrrJ)rrupdatesetattrr<r)clsrr\rrds&& r _from_pythonFactRules._from_pythons_2wCC#A HHTY  Dq !D|, o!67 rc#h"Rx\VP4F pRV: R2xK RxR#5i)zdefined_facts = [ ,z] # defined_factsN)rsr)r\facts& r_defined_facts_linesFactRules._defined_facts_liness5!!4--.D" "/!!s02c#"Rx\VP4F[pR FRpRV RV R2xRV: RV: R2xVPW3,p\V4F pRV: R2xK R xR xKT K] R xR #5i)zfull_implications = dict( [z # Implications of  = :z ((, z ), set( ( rz ) ),z ),z ] ) # full_implicationsN)TF)rsrr)r\rvaluerimplieds& r_full_implications_lines"FactRules._full_implications_liness++4--.D&.tfCwa@@thb ;;#55tmD %l3G$WKq11 4##'/)(sA?Bc#"RxRx\VP4FGpRV 2xRV: R2x\VPV,4F pRV: R2xK RxRxKI RxR #5i) z prereq = {rz. # facts that could determine the value of rz: {rrz },z } # prereqN)rsrJ)r\rpfacts& r _prereq_linesFactRules._prereq_linessx4;;'DB4&I I% % D 12  ++3NH (sA/A1c #"\\4p\VP4F wpwr4W,P W234K" RxRxRx^p/p\ V4FlpVwrxRV RV 2xW,FKwr2WVV&V^, pRP \\\ V444p RV R2xRV: R 2xKM RxKn R xR x\ VP4F<p V wrxVPV ,Uu.uF q&V,NK p pR V : R V : R2xK> RxR#uupi5i)z@# Note: the order of the beta rules is used in the beta_triggerszbeta_rules = [rz # Rules implying rrz ({z},rz),z] # beta_ruleszbeta_triggers = {rz: rz} # beta_triggersN) rlistr8r<r:rsrrrtr) r\reverse_implicationsnprermindicesrrsetstrquerytriggerss & r_beta_rules_linesFactRules._beta_rules_linessW*40!*4??!; A~ ) 0 0# :"<QP 23G!KD)$s5': :.77 Q3sF3K#89xs++  2.. 8 H4!!D../EKD,0,>,>u,EF,Eq ,EHF HD9 D>c0<V^8dQhRS[S[,/#r)rrt)rrs"rrr#skkXc]krc# ."VP4RjxL RxRxVP4RjxL RxRxVP4RjxL RxRxVP4RjxL RxRxRxRxR#LvLXL:L5i)z@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&rrFactRules.print_rules#s,,...00222%%'''))+++ppjj / 3 ( ,sCBB BBBBB6B7BBBB)r<rrrrJN)rPrQrRrSrTr]r classmethodrrrrrrrUr~rs@rrr|sN<9v--  " ) ":kkrrc&a]tRtRtoRtRtVtR#)InconsistentAssumptionsi5c:VPwrpV: RV: RV: 2#)r=)r4)r\kbrrs& r__str__InconsistentAssumptions.__str__6s))% $..rrON)rPrQrRrSrrUr~rs@rrr5s//rrc<a]tRtRtoRtRtRtRtRtRt Vt R#) FactKBi;zL A simple propositional knowledge base relying on compiled inference rules. cRRP\VP44Uu.uF pRV,NK up4,#uupi)z{ %s}z, z %s: %s)rrsr!)r\rs& rrFactKB.__str__?sB%**%+DJJL%9 :%9Z!^^%9 :<< < :sA cWnR#r,rI)r\rIs&&rr]FactKB.__init__Cs rc dW9d&W,eW,V8XdR#\WV4hW V&R#)zhAdd fact k=v to the knowledge base. Returns True if the KB has actually been updated, False otherwise. FT)r)r\rvs&&&r_tell FactKB._tellFs3 9,w!|-dq99Grc aSPPpSPPpSPPp\ V\ 4'dVP 4pV'd\4pVF_wrgSPWg4'dVfK"W&V3,FwrSPW4K VPW6V3,4Ka .pVF`p WJ,wr\;QJdV3RlV 4F 'dK RM RM!V3RlV 44'gKOVPV 4Kb KR#)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. Nc3N<"TFwrSPV4VJxK R#5ir,)r7)r-rrr\s& rr1*FactKB.deduce_all_facts..ys :EDAtxx{a'Es"%FT) rIrrr<r rr!rrrallr:) r\factsrrr<beta_maytriggerrrrrrrFr?r0s f& rdeduce_all_factsFactKB.deduce_all_factsWs!JJ88 00 ZZ** eT " "KKME!eOzz!''19#4qD"9"9JCJJs*#: &&}T':;E')/ 3:E:333:E:::LL'(!rrN) rPrQrRrSrTrr]rrrUr~rs@rrr;s#< "#(#(rrN)rT collectionsrtypingrlogicrrrrrrrr)rGrL ExceptionrNrWrr#rrrrOrrrs{.`$&&(%PL^L  v7v7vvkvkr/j/ ?(T?(r