docs: def create(cls, *args, **kwargs):
          """Instantiate while applying automatic simplifications
  
          Instead of directly instantiating `cls`, it is recommended to use
          :meth:`create`, which applies simplifications to the args and keyword
          arguments according to the :attr:`simplifications` class attribute, and
          returns an appropriate object (which may or may not be an instance of
          the original `cls`).
  
          Two simplifications of particular importance are :func:`.match_replace`
          and :func:`.match_replace_binary` which apply rule-based
          simplifications.
  
          The :func:`.temporary_rules` context manager may be used to allow
          temporary modification of the automatic simplifications that
          :meth:`create` uses, in particular the rules for
          :func:`.match_replace` and :func:`.match_replace_binary`. Inside the
          managed context, the :attr:`simplifications` class attribute may be
          modified and rules can be managed with :meth:`add_rule` and
          :meth:`del_rules`.
          """
          global LEVEL
          if LOG:
              logger = logging.getLogger('QNET.create')
              logger.debug(
                  "%s%s.create(*args, **kwargs); args = %s, kwargs = %s",
                  ("  " * LEVEL), cls.__name__, args, kwargs)
              LEVEL += 1
          key = cls._get_instance_key(args, kwargs)
          try:
              if cls.instance_caching:
                  instance = cls._instances[key]
                  if LOG:
                      LEVEL -= 1
                      logger.debug("%s(cached)-> %s", ("  " * LEVEL), instance)
                  return instance
          except KeyError:
              pass
          for i, simplification in enumerate(cls.simplifications):
              if LOG:
                  try:
                      simpl_name = simplification.__name__
                  except AttributeError:
                      simpl_name = "simpl%d" % i
              simplified = simplification(cls, args, kwargs)
              try:
                  args, kwargs = simplified
                  if LOG:
                      logger.debug(
                          "%s(%s)-> args = %s, kwargs = %s", ("  " * LEVEL),
                          simpl_name, args, kwargs)
              except (TypeError, ValueError):
                  # We assume that if the simplification didn't return a tuple,
                  # the result is a fully instantiated object
                  if cls.instance_caching:
                      cls._instances[key] = simplified
                  if cls._create_idempotent and cls.instance_caching:
                      try:
                          key2 = simplified._instance_key
                          if key2 != key:
                              cls._instances[key2] = simplified  # simplified key
                      except AttributeError:
                          #  simplified might e.g. be a scalar and not have
                          #  _instance_key
                          pass
                  if LOG:
                      LEVEL -= 1
                      logger.debug(
                          "%s(%s)-> %s", ("  " * LEVEL), simpl_name, simplified)
                  return simplified
          if len(kwargs) > 0:
              cls._has_kwargs = True
          instance = cls(*args, **kwargs)
          if cls.instance_caching:
              cls._instances[key] = instance
          if cls._create_idempotent and cls.instance_caching:
              key2 = cls._get_instance_key(args, kwargs)
              if key2 != key:
                  cls._instances[key2] = instance  # instantiated key
          if LOG:
              LEVEL -= 1
              logger.debug("%s -> %s", ("  " * LEVEL), instance)
          return instance