U ZʹjZL@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|SdS)zdReturn the literal fact of an atom. Effectively, this merely strips the Not around a fact. N isinstancerargZatomr O/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sympy/core/facts.py _base_fact7s rcCs t|tr|jdfS|dfSdS)NFTr r r r r_as_pairBs  rcCsbt|}tjtt|}|D]>}|D]4}||f|kr&|D]}||f|kr:|||fq:q&q|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_implicationsliteralskijr r rtransitive_closureKs  rcCs|dd|D}tt}t|}|D] \}}||kr8q&|||q&|D]4\}}||t|}||krPtd|||fqP|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|fqSr r).0rrr r r ssz-deduce_alpha_implications..z*implications are inconsistent: %s -> %s %s)rrrritemsdiscardr ValueError)rresrabimplnar r rdeduce_alpha_implications_s   r'c sti}|D]}t||gf||<q |D],\}|jD]}||krFq8tgf||<q8q*d}|rd}|D]\}t|tstdt|j|D]T\}\}}||hB} | kr| r|| } | dk r|| dO}d}qqhq\t |D]x\} \}t|j|D]X\}\}}||hB} | kr8qt fdd| DrVq| @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|kpt|kVqdSNr)rxiZbargsbimplr r sz,apply_beta_to_alpha_route..) keysrargsr r TypeErrorrissubsetrget enumerateanyappend) Zalpha_implications beta_rulesZx_implxbcondZbkZseen_static_extensionZximplsZbbZx_allZ bimpl_implbidxr r*rapply_beta_to_alpha_routesD               r9cCsftt}|D]P\\}}}t|tr0|jd}|D]*\}}t|trP|jd}|||q4q|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)rrrr rr.r)rulesprereqr#_r%rr r r rules_2prereqs     r=c@seZdZdZdS)TautologyDetectedz:(internal) Prover uses it for reporting detected tautologyN)__name__ __module__ __qualname____doc__r r r rr>sr>c@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_seenselfr r r__init__szProver.__init__cCsHg}g}|jD]0\}}t|tr0|||fq|||fq||fS)z-split proved rules into alpha and beta chains)rDr rr4)rG rules_alpha rules_betar#r$r r rsplit_alpha_beta"s zProver.split_alpha_betacCs |dS)NrrKrFr r rrI-szProver.rules_alphacCs |dS)NrrLrFr r rrJ1szProver.rules_betacCsl|rt|trdSt|tr dS||f|jkr2dS|j||fz|||Wntk rfYnXdS)zprocess a -> b ruleN)r boolrEr _process_ruler>)rGr#r$r r r process_rule5s zProver.process_rulec Cst|tr2t|jtd}|D]}|||qn\t|trt|jtd}t|tsh||krht||d|tdd|jDt |t t |D]B}||}|d|||dd}|t|t |t|qnt|trt|jtd}||kr t||d|j ||fnrt|trft|jtd}||krLt||d|D]}|||qPn(|j ||f|j t |t |fdS)N)keyz a -> a|c|...cSsg|] }t|qSr r)rbargr r rr[sz(Prover._process_rule..rz a & b -> az a | b -> a)r rsortedr.strrOrrr>rrangelenrDr4) rGr#r$Z sorted_bargsrQr8ZbrestZ sorted_aargsZaargr r rrNFs6           zProver._process_ruleN) r?r@rArBrHrKpropertyrIrJrOrNr r r rrCs   rCc@sjeZdZdZddZedddZeeddd Z d d Z d d Z ddZ ddZ eedddZdS) 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 cCst|tr|}t}|D]n}|dd\}}}t|}t|}|dkr\|||q|dkr~||||||qtd|qg|_ |j D](\}}|j dd|j Dt |fqt|j} t| |j } dd| D|_tt} tt} | D]0\} \}}d d|D| t | <|| t | <q| |_| |_tt}t| }|D]\} }|| |O<qZ||_dS) z)Compile rules into internal lookup tablesNz->z==z unknown op %rcSsh|] }t|qSr r)rr#r r r sz%FactRules.__init__..cSsh|] }t|qSr )r)rrr r rrZscSsh|] }t|qSr rYrrr r rrZs)r rS splitlinesrCsplitr fromstringrOr!r5rJr4r.rr'rIr9r- defined_factsrrrr beta_triggersr=r;)rGr:Pruler#opr$r7r+Zimpl_aZimpl_abrr`rr%Zbetaidxsr;Z rel_prereqZpitemsr r rrHsB      zFactRules.__init__)returncCsd|S)zD Generate a string with plain python representation of the instance  )join print_rulesrFr r r _to_pythonszFactRules._to_python)datacCsP|d}dD]&}tt}|||t|||q |d|_t|d|_|S)z; Generate an instance from the plain python representation )rr`r;r5r_)rrupdatesetattrr5r_)clsrirGrPdr r r _from_pythons zFactRules._from_pythonccs.dVt|jD]}d|dVqdVdS)Nzdefined_facts = [ ,z] # defined_facts)rRr_)rGfactr r r_defined_facts_linesszFactRules._defined_facts_linesccsdVt|jD]l}dD]b}d|d|dVd|d|dV|j||f}t|D]}d |d VqZd Vd Vqqd VdS)Nzfull_implications = dict( [)TFz # Implications of  = :z ((, z ), set( ( rqz ) ),z ),z ] ) # full_implications)rRr_r)rGrrvaluerimpliedr r r_full_implications_liness  z"FactRules._full_implications_linesccsndVdVt|jD]L}d|Vd|dVt|j|D]}d|dVqBdVdVqd VdS) Nz prereq = {rjz. # facts that could determine the value of rpz: {rwrqz },z } # prereq)rRr;)rGrrZpfactr r r _prereq_liness zFactRules._prereq_linesc #s&tt}t|jD]\}\}}||||fqdVdVdVd}it|D]v}|\}}d|d|V||D]H\}}||<|d7}dttt|}d |d Vd |d VqzdVqTd VdVt|j D]8} | \}}fdd|j | D} d| d| dVqdVdS)Nz@# Note: the order of the beta rules is used in the beta_triggerszbeta_rules = [rjrz # Rules implying rtrrvz ({z},rwz),z] # beta_ruleszbeta_triggers = {csg|] }|qSr r )rnindicesr rrsz/FactRules._beta_rules_lines..rpz: rqz} # beta_triggers) rlistr2r5r4rRrfrrSr`) rGZreverse_implicationsr|prerymrrrxZsetstrquerytriggersr r}r_beta_rules_liness2 zFactRules._beta_rules_linesccsx|EdHdVdV|EdHdVdV|EdHdVdV|EdHdVdVdVdVdS)zA Returns a generator with lines to represent the facts and rules Nrjz`generated_assumptions = {'defined_facts': defined_facts, 'full_implications': full_implications,zZ 'prereq': prereq, 'beta_rules': beta_rules, 'beta_triggers': beta_triggers})rsrzr{rrFr r rrg#szFactRules.print_rulesN)r?r@rArBrHrSrh classmethoddictrorsrzr{rrrgr r r rrW|s;   rWc@seZdZddZdS)InconsistentAssumptionscCs|j\}}}d|||fS)Nz %s, %s=%s)r.)rGkbrrrxr r r__str__6s zInconsistentAssumptions.__str__N)r?r@rArr r r rr5src@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: %sr r[r r rrAsz"FactKB.__str__..)rfrRrrFr r rr?szFactKB.__str__cCs ||_dSr()r:)rGr:r r rrHCszFactKB.__init__cCsB||kr2||dk r2|||kr$dSt|||n |||<dSdS)zxAdd fact k=v to the knowledge base. Returns True if the KB has actually been updated, False otherwise. NFT)r)rGrvr r r_tellFs  z FactKB._tellc sjj}jj}jj}t|tr*|}|rt}|D]R\}}||r8|dkrVq8|||fD]\}} || qb| |||fq8g}|D]0} || \} } t fdd| Dr| | qq*dS)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 |]\}}||kVqdSr()r1)rrrrFr rr,ysz*FactKB.deduce_all_facts..) r:rr`r5r rrrrrkallr4) rGZfactsrr`r5Zbeta_maytriggerrrrPrxr8r7r+r rFrdeduce_all_factsWs$    zFactKB.deduce_all_factsN)r?r@rArBrrHrrr r r rr;s rN)rB collectionsrtypingrZlogicrrrrrrrr'r9r= Exceptionr>rCrWr!rrrr r r rs0    (O&{: