*hZLSrSSKJr SSKJr SSKJrJrJrJ r Sr Sr Sr S r S rS r"S S \5r"SS5r"SS5r"SS\5r"SS\5rg)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)LogicAndOrNotcH[U[5(a UR$U$)z\Return the literal fact of an atom. Effectively, this merely strips the Not around a fact.  isinstancer argatoms M/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sympy/core/facts.py _base_factr7s $xx cP[U[5(aURS4$US4$)NFTr rs r_as_pairrBs($%  d|rc[U5n[5R"[[U56nUH9nUH0nXC4U;dM UHnX54U;dM URXE45 M M2 M; U$)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 KssL)u{{C%678H Av**!Av!22)--qf5" rc XVVs/sHup[U5[U54PM snn-n[[5n[U5nUHupVXV:XaM X5R U5 M! UR 5H=upWUR U5 [U5nX;dM([SU<SU<SU<35e U$s snnf)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 ->  )r rrr ritemsdiscard ValueError) rrrresrabimplnas rdeduce_alpha_implicationsr+_s( ,"O,CFCF#3,"OOL c C*<8! 6   1 "99; Q V :@A2tLN N  J##Ps"Ccn^ ^ 0nUR5Hn[X5/4X#'M UH.unm URHnXR;aM [5/4X%'M M0 SnU(aSnUHunm [U[5(d [ S5e[UR5m UR 5H[unupxXs1-n T U ;dMT RU 5(dM-URT 5 URT 5n U bXzS-nSnM] M U(aM[U5Hun unm [UR5m UR 5HOunupxXs1-n T U ;aM[U U 4SjU 55(aM2T U -(dM>URU 5 MQ M U$)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 Andrc3j># UH(n[U5T;=(d [U5T:Hv M* g7fN)r ).0xibargsbimpls r ,apply_beta_to_alpha_route..s+H%B3r7e#7s2w%'77%s03) keysrargsr r TypeErrorr#issubsetrget enumerateanyappend)alpha_implications beta_rulesx_implxbcondbkseen_static_extensionximplsbbx_all bimpl_implbidxr1r2s @@rapply_beta_to_alpha_routerIs8F  $ $ &+./4 '" u**B|%FJ#!  %&LE5eS)) 122 OE#)<<> Mp U$)abuild 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)rrr#r r r6r)rulesprereqr'_r)rs r rules_2prereqrNsy. F  a  q AFQ!S!!FF1I IMM! & Mrc\rSrSrSrSrg)TautologyDetectedz:(internal) Prover uses it for reporting detected tautologyN)__name__ __module__ __qualname____firstlineno____doc____static_attributes__rRrrrPrPsDrrPcP\rSrSrSrSrSr\S5r\S5r Sr Sr S r g ) 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. c0/Ul[5Ulgr.) proved_rulesr _rules_seenselfs r__init__Prover.__init__s5rc/n/nURH@up4[U[5(aURX445 M.URX445 MB X4$)z-split proved rules into alpha and beta chains)r\r rr<)r_ rules_alpha rules_betar'r(s rsplit_alpha_betaProver.split_alpha_beta"sV  %%DA!S!!!!1&)""A6* & &&rc(UR5S$)Nrrer^s rrcProver.rules_alpha-$$&q))rc(UR5S$)Nrrhr^s rrdProver.rules_beta1rjrc U(a[U[5(ag[U[5(agX4UR;agURRX45 UR X5 g![ a gf=f)zprocess a -> b ruleN)r boolr]r _process_rulerP)r_r'r(s r process_ruleProver.process_rule5srjD))  a    6T%% %     ! (    q $    s#A55 BBc |[U[5(a3[UR[S9nUHnUR X5 M g[U[ 5(a[UR[S9n[U[5(dX;a [XS5eUR [URVs/sHn[U5PM sn6[U55 [[U55H?nX5nUSUX5S-S-nUR [U[U55[ U65 MA g[U[5(aF[UR[S9nX';a [XS5eURRX45 g[U[ 5(aD[UR[S9nX';a [XS5eUHnUR X5 M gURRX45 URR[U5[U545 gs snf)N)keyz a -> a|c|...rz a & b -> az a | b -> a)r rsortedr6strrprrrPr rangelenr\r<) r_r'r( sorted_bargsbargrHbrest sorted_aargsaargs rroProver._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$Bs:H9 )r]r\N) rSrTrUrVrWr`repropertyrcrdrprorXrRrrrZrZsC8! '****"17rrZcp\rSrSrSrSrS\4Sjr\S\ 4Sj5r Sr S r S r S rS\\4S jrS rg) 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 [U[5(aUR5n[5nUHnUR SS5upEn[ R "U5n[ R "U5nUS:XaURXF5 M]US:Xa$URXF5 URXd5 M[SU-5e /Ul URHOupxURRURVs1sHn[U5iM sn[U545 MQ [UR5n [!XR5n U R#5V s1sHn [%U 5iM sn Ul[)[*5n [)[*5n U R-5H=un upUVs1sHn[U5iM snU [U 5'X[U 5'M? XlXl[)[*5n[3U 5nUR-5Hun nUU ==U-ss'M UUlgs snfs sn fs snf)z)Compile rules into internal lookup tablesNz->z==z unknown op %r)r ru splitlinesrZsplitr fromstringrpr%r>rdr<r6rr+rcrIr5r defined_factsrrr#r beta_triggersrNrL)r_rKPruler'opr(rAr2impl_aimpl_abrrrr)betaidxsrrL 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 .IsI +IIreturnc@SRUR55$)zCGenerate a string with plain python representation of the instance  )join print_rulesr^s r _to_pythonFactRules._to_pythonsyy))+,,rdatacU"S5nSH1n[[5nURX5 [X#U5 M3 USUl[US5UlU$)z:Generate an instance from the plain python representation )rrrLr>r)rrupdatesetattrr>r)clsrr_rsds r _from_pythonFactRules._from_pythons_2wCC#A HHTY  Dq !D|, o!67 rc#f# Sv [UR5H nSU<S3v M Sv g7f)Nzdefined_facts = [ ,z] # defined_facts)rtr)r_facts r_defined_facts_linesFactRules._defined_facts_liness5!!4--.D" "/!!s/1c## Sv [UR5HWnSHNnSUSUS3v SU<SU<S3v URX4n[U5H nS U<S 3v M S v S v MP MY S v g7f)Nzfull_implications = dict( [)TFz # Implications of  = :z ((, z ), set( ( rz ) ),z ),z ] ) # full_implications)rtrr)r_rvaluerimplieds r_full_implications_lines"FactRules._full_implications_liness++4--.D&.tfCwa@@thb ;;#55tmD %l3G$WKq11 4##'/)(sA:A<c## Sv Sv [UR5HCnSU3v SU<S3v [URU5H nSU<S3v M Sv Sv ME S v g7f) Nz prereq = {rz. # facts that could determine the value of rz: {rrz },z } # prereq)rtrL)r_rpfacts r _prereq_linesFactRules._prereq_linessx4;;'DB4&I I% % D 12  ++3NH (sA*A,c #X# [[5n[UR5Hunup4XR X245 M Sv Sv Sv Sn0n[ U5HdnUupxSUSU3v XHGup2XVU'US- nSR [[[ U555n S U S 3v S U<S 3v MI Sv Mf S v Sv [ UR5H5n U upxURU Vs/sHo&UPM n nSU <SU <S3v M7 Sv gs snf7f)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) rlistr:r>r<rtrrrur) r_reverse_implicationsnprermindicesrrsetstrquerytriggerss r_beta_rules_linesFactRules._beta_rules_linessR*40!*4??!; A~ ) 0 0# :"<QP 23G!KD)$s5': :.7 Q3sF3K#89xs++  2.. 8 H4!!D../EKD,0,>,>u,EF,Eq ,EHF HrrrrLN)rSrTrUrVrWr`rur classmethoddictrrrrrrrrXrRrrrr|sZ<9v-C-   " ) ":kXc]krrc\rSrSrSrSrg)InconsistentAssumptionsi5c:URupnU<SU<SU<3$)Nr=)r6)r_kbrrs r__str__InconsistentAssumptions.__str__6s))% $..rrRN)rSrTrUrVrrXrRrrrr5s/rrc0\rSrSrSrSrSrSrSrSr g) FactKBi;zL A simple propositional knowledge base relying on compiled inference rules. cSSR[UR55Vs/sHnSU-PM sn5-$s snf)Nz{ %s}z, z %s: %s)rrtr#)r_rs rrFactKB.__str__?s@%**%+DJJL%9 :%9Z!^%9 :<< < :sA cXlgr.rK)r_rKs rr`FactKB.__init__Cs rcJX;aXbXU:Xag[XU5eX U'g)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<^TRRnTRRnTRRn[ U[ 5(aUR 5nU(a[5nUHUupgTRXg5(aUcM X&U4HupTRX5 M URX6U45 MW /nUH6n XJup[U4SjU 55(dM%URU 5 M8 U(aMgg)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># UHupTRU5ULv M g7fr.)r9)r/rrr_s rr3*FactKB.deduce_all_facts..ys :EDAtxx{a'Es"%) rKrrr>r rr#rrrallr<) r_factsrrr>beta_maytriggerrrrsrrHrAr2s ` rdeduce_all_factsFactKB.deduce_all_factsWs!JJ88 00 ZZ** eT " "KKME!eOzz!''19#4qD"9JCJJs*#: &&}T':;E')/ :E:::LL'(!errN) rSrTrUrVrWrr`rrrXrRrrrr;s< "#(rrN)rW collectionsrtypingrlogicrrrr rrr r+rIrN ExceptionrPrZrr%rrrrRrrrs{.`$&&(%PL^L  v7v7vvkvkr/j/ ?(T?(r