code: def _propagate_incompatibility(
          self, incompatibility
      ):  # type: (Incompatibility) -> Union[str, _conflict, None]
          
          # The first entry in incompatibility.terms that's not yet satisfied by
          # _solution, if one exists. If we find more than one, _solution is
          # inconclusive for incompatibility and we can't deduce anything.
          unsatisfied = None
  
          for term in incompatibility.terms:
              relation = self._solution.relation(term)
  
              if relation == SetRelation.DISJOINT:
                  # If term is already contradicted by _solution, then
                  # incompatibility is contradicted as well and there's nothing new we
                  # can deduce from it.
                  return
              elif relation == SetRelation.OVERLAPPING:
                  # If more than one term is inconclusive, we can't deduce anything about
                  # incompatibility.
                  if unsatisfied is not None:
                      return
  
                  # If exactly one term in incompatibility is inconclusive, then it's
                  # almost satisfied and [term] is the unsatisfied term. We can add the
                  # inverse of the term to _solution.
                  unsatisfied = term
  
          # If *all* terms in incompatibility are satisfied by _solution, then
          # incompatibility is satisfied and we have a conflict.
          if unsatisfied is None:
              return _conflict
  
          self._log(
              "derived: {}{}".format(
                  "not " if unsatisfied.is_positive() else "", unsatisfied.dependency
              )
          )
  
          self._solution.derive(
              unsatisfied.dependency, not unsatisfied.is_positive(), incompatibility
          )
  
          return unsatisfied.dependency.name
docs: If incompatibility is almost satisfied by _solution, adds the
          negation of the unsatisfied term to _solution.
  
          If incompatibility is satisfied by _solution, returns _conflict. If
          incompatibility is almost satisfied by _solution, returns the
          unsatisfied term's package name.
  
          Otherwise, returns None.