docs: def process_core(self):
          """
              The method deals with a core found previously in
              :func:`get_core`. Clause selectors ``self.core_sels`` and
              sum assumptions involved in the core are treated
              separately of each other. This is handled by calling
              methods :func:`process_sels` and :func:`process_sums`,
              respectively. Whenever necessary, both methods relax the
              core literals, which is followed by creating a new
              totalizer object encoding the sum of the new relaxation
              variables. The totalizer object can be "exhausted"
              depending on the option.
          """
  
          # updating the cost
          self.cost += self.minw
  
          # assumptions to remove
          self.garbage = set()
  
          if len(self.core_sels) != 1 or len(self.core_sums) > 0:
              # process selectors in the core
              self.process_sels()
  
              # process previously introducded sums in the core
              self.process_sums()
  
              if len(self.rels) > 1:
                  # create a new cardunality constraint
                  t = self.create_sum()
  
                  # apply core exhaustion if required
                  b = self.exhaust_core(t) if self.exhaust else 1
  
                  if b:
                      # save the info about this sum and
                      # add its assumption literal
                      self.set_bound(t, b)
                  else:
                      # impossible to satisfy any of these clauses
                      # they must become hard
                      for relv in self.rels:
                          self.oracle.add_clause([relv])
          else:
              # unit cores are treated differently
              # (their negation is added to the hard part)
              self.oracle.add_clause([-self.core_sels[0]])
              self.garbage.add(self.core_sels[0])
  
          # remove unnecessary assumptions
          self.filter_assumps()