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
code: def _full_implications_lines(self):
      yield "full_implications = dict( ["
      for fact in sorted(self.defined_facts):
          for value in (True, False):
              yield f"    # Implications of {fact} = {value}:"
              yield f"    (({fact!r}, {value!r}), set( ("
              implications = self.full_implications[(fact, value)]
              for implied in sorted(implications):
                  yield f"        {implied!r},"
              yield "       ) ),"
              yield "     ),"
      yield " ] ) # full_implications"
  
imports: from collections import defaultdict
  from typing import Iterator
  from .logic import Logic, And, Or, Not
label_desc: Use image node_id 5 for calling the FactRules obj's underlying member method code with example usage: obj._full_implications_lines() without return types