class_docstr: Rules 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
docstr: Generate an instance from the plain python representation 
docstr_tok: ["Generate","an","instance","from","the","plain","python","representation"]
code: def _from_python(cls, data: dict):
      """Generate an instance from the plain python representation"""
      self = cls("")
      for key in ["full_implications", "beta_triggers", "prereq"]:
          d = defaultdict(set)
          d.update(data[key])
          setattr(self, key, d)
      self.beta_rules = data["beta_rules"]
      self.defined_facts = set(data["defined_facts"])
  
      return self
  
imports: from collections import defaultdict
  from typing import Iterator
  from .logic import Logic, And, Or, Not
label_desc: Use image node_id 3 for calling the FactRules obj's underlying member method code with example usage: obj._from_python(cls, data) and returns: self