o gZL@sdZddlmZddlmZddlmZmZmZm Z ddZ dd Z d d Z d d Z ddZddZGdddeZGdddZGdddZGdddeZGdddeZdS)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)LogicAndOrNotcCst|tr|jS|S)zdReturn the literal fact of an atom. Effectively, this merely strips the Not around a fact.  isinstancerargatomrG/var/www/visachat/venv/lib/python3.10/site-packages/sympy/core/facts.py _base_fact7s rcCst|tr |jdfS|dfS)NFTr r rrr_as_pairBs  rcCsbt|}tjtt|}|D]}|D]}||f|vr-|D]}||f|vr,|||fqqq|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_implicationsliteralskijrrrtransitive_closureKs  rcCs|dd|D}tt}t|}|D]\}}||krq|||q|D]\}}||t|}||vrBtd|||fq(|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, ...]) cSs g|] \}}t|t|fqSrr).0rrrrr ss z-deduce_alpha_implications..z*implications are inconsistent: %s -> %s %s)rrrritemsdiscardr ValueError)rresrabimplnarrrdeduce_alpha_implications_s    r(c sji}|D] }t||gf||<q|D]\}|jD]}||vr#qtgf||<qqd}|rxd}|D]A\}t|tsAtdt|j|D]*\}\}}||hB} | vrt| rt|| } | durr|| dO}d}qJq4|s0t |D]6\} \}t|j|D]&\}\}}||hB} | vrqt fdd| Drq| @r| | qq||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 AndNrc3s(|]}t|vpt|kVqdSNr)rxibargsbimplrr s&z,apply_beta_to_alpha_route..) keysrargsr r TypeErrorr issubsetrget enumerateanyappend) alpha_implications beta_rulesx_implxbcondbkseen_static_extensionximplsbbx_all bimpl_implbidxrr+rapply_beta_to_alpha_routesP              rCcCsftt}|D](\\}}}t|tr|jd}|D]\}}t|tr(|jd}|||qq|S)aMbuild 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 rr0r)rulesprereqr$_r&rrrr rules_2prereqs     rGc@seZdZdZdS)TautologyDetectedz:(internal) Prover uses it for reporting detected tautologyN)__name__ __module__ __qualname____doc__rrrrrHsrHc@sHeZdZdZddZddZeddZedd Zd d Z d d Z 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. cCsg|_t|_dSr)) proved_rulesr _rules_seenselfrrr__init__s zProver.__init__cCsHg}g}|jD]\}}t|tr|||fq|||fq||fS)z-split proved rules into alpha and beta chains)rNr rr6)rQ rules_alpha rules_betar$r%rrrsplit_alpha_beta"s zProver.split_alpha_betacC |dS)NrrUrPrrrrS- zProver.rules_alphacCrV)NrrWrPrrrrT1rXzProver.rules_betacCsj|rt|tr dSt|trdS||f|jvrdS|j||fz |||WdSty4YdSw)zprocess a -> b ruleN)r boolrOr _process_rulerH)rQr$r%rrr process_rule5s  zProver.process_rulec Cst|trt|jtd}|D]}|||qdSt|trnt|jtd}t|ts4||vr4t||d|tdd|jDt |t t |D]!}||}|d|||dd}|t|t |t|qJdSt|trt|jtd}||vrt||d|j ||fdSt|trt|jtd}||vrt||d|D]}|||qdS|j ||f|j t |t |fdS)N)keyz a -> a|c|...cSsg|]}t|qSrr)rbargrrrr[z(Prover._process_rule..rz a & b -> az a | b -> a)r rsortedr0strr[rrrHrrangelenrNr6) rQr$r% sorted_bargsr]rBbrest sorted_aargsaargrrrrZFs<         zProver._process_ruleN) rIrJrKrLrRrUpropertyrSrTr[rZrrrrrMs   rMc@sjeZdZdZddZdefddZedefdd Z d d Z d d Z ddZ ddZ deefddZdS) 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 cCszt|tr |}t}|D]6}|dd\}}}t|}t|}|dkr.|||q|dkr?||||||qtd|g|_ |j D]\}}|j dd|j Dt |fqKt|j} t| |j } dd| D|_tt} tt} | D]\} \}}d d|D| t | <|| t | <q| |_| |_tt}t| }|D] \} }|| |O<q||_dS) z)Compile rules into internal lookup tablesNz->z==z unknown op %rcSh|]}t|qSrr)rr$rrr r^z%FactRules.__init__..cSrjr)r)rrrrrrlr^cSrjrrkrrrrrrlr^)r r` splitlinesrMsplitr fromstringr[r"r8rTr6r0rr(rSrCr/ defined_factsrrr r beta_triggersrGrE)rQrDPruler$opr%r;r-impl_aimpl_abrrrrr&betaidxsrE rel_prereqpitemsrrrrRsB        zFactRules.__init__returncCsd|S)zD Generate a string with plain python representation of the instance  )join print_rulesrPrrr _to_pythonszFactRules._to_pythondatacCsP|d}dD]}tt}|||t|||q|d|_t|d|_|S)z; Generate an instance from the plain python representation )rrrrEr8rq)rrupdatesetattrr8rq)clsrrQr\drrr _from_pythons zFactRules._from_pythonccs0dVt|jD] }d|dVq dVdS)Nzdefined_facts = [ ,z] # defined_facts)r_rq)rQfactrrr_defined_facts_liness  zFactRules._defined_facts_linesccsdVt|jD]6}dD]1}d|d|dVd|d|dV|j||f}t|D] }d |d Vq.d Vd Vq q d VdS)Nzfull_implications = dict( [)TFz # Implications of  = :z ((, z ), set( ( rz ) ),z ),z ] ) # full_implications)r_rqr)rQrvaluerimpliedrrr_full_implications_liness  z"FactRules._full_implications_linesccspdVdVt|jD]&}d|Vd|dVt|j|D] }d|dVq"dVdVq d VdS) Nz prereq = {rz. # facts that could determine the value of rz: {rrz },z } # prereq)r_rE)rQrpfactrrr _prereq_liness  zFactRules._prereq_linesc #s(tt}t|jD]\}\}}||||fq dVdVdVd}it|D];}|\}}d|d|V||D]$\}}||<|d7}dttt|}d |d Vd |d Vq>dVq+d VdVt|j D]} | \}}fdd|j | D} d| d| dVqrdVdS)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 = {csg|]}|qSrr)rnindicesrrrr^z/FactRules._beta_rules_lines..rz: rz} # beta_triggers) rlistr4r8r6r_r}rr`rr) rQreverse_implicationsrprermrrsetstrquerytriggersrrr_beta_rules_liness4  zFactRules._beta_rules_linesccsz|EdHdVdV|EdHdVdV|EdHdVdV|EdHdVdVdVdVdS)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})rrrrrPrrrr~#s zFactRules.print_rulesN)rIrJrKrLrRr`r classmethoddictrrrrrrr~rrrrrh|s;   rhc@seZdZddZdS)InconsistentAssumptionscCs|j\}}}d|||fS)Nz %s, %s=%s)r0)rQkbrrrrr__str__6s zInconsistentAssumptions.__str__N)rIrJrKrrrrrr5s rc@s0eZdZdZddZddZddZdd Zd S) FactKBzT A simple propositional knowledge base relying on compiled inference rules. cCs ddddt|DS)Nz{ %s}z, cSsg|]}d|qS)z %s: %srrmrrrrAr^z"FactKB.__str__..)r}r_r rPrrrr?szFactKB.__str__cCs ||_dSr))rD)rQrDrrrrRCs zFactKB.__init__cCs<||vr||dur|||krdSt||||||<dS)zxAdd fact k=v to the knowledge base. Returns True if the KB has actually been updated, False otherwise. NFT)r)rQrvrrr_tellFs   z FactKB._tellc sjj}jj}jj}t|tr|}|rgt}|D])\}}||r*|dur+q|||fD] \}} || q1| |||fqg}|D]} || \} } t fdd| Drb| | qJ|sdSdS)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. Nc3s"|] \}}||uVqdSr))r3)rrrrPrrr.ys z*FactKB.deduce_all_facts..) rDrrrr8r rr rrrallr6) rQfactsrrrr8beta_maytriggerrrr\rrBr;r-rrPrdeduce_all_factsWs(      zFactKB.deduce_all_factsN)rIrJrKrLrrRrrrrrrr;s  rN)rL collectionsrtypingrlogicrrrrrrrr(rCrG ExceptionrHrMrhr"rrrrrrrs  0   (O&{: