code: def decrease_exponent_to(self, new_exp):
          
          if new_exp > self.exponent:
              raise ValueError('New exponent %i should be more negative than'
                               'old exponent %i' % (new_exp, self.exponent))
          factor = pow(self.BASE, self.exponent - new_exp)
          new_enc = self.encoding * factor % self.public_key.n
          return self.__class__(self.public_key, new_enc, new_exp)
docs: Return an `EncodedNumber` with same value but lower exponent.
  
          If we multiply the encoded value by :attr:`BASE` and decrement
          :attr:`exponent`, then the decoded value does not change. Thus
          we can almost arbitrarily ratchet down the exponent of an
          :class:`EncodedNumber` - we only run into trouble when the encoded
          integer overflows. There may not be a warning if this happens.
  
          This is necessary when adding :class:`EncodedNumber` instances,
          and can also be useful to hide information about the precision
          of numbers - e.g. a protocol can fix the exponent of all
          transmitted :class:`EncodedNumber` to some lower bound(s).
  
          Args:
            new_exp (int): the desired exponent.
  
          Returns:
            EncodedNumber: Instance with the same value and desired
              exponent.
  
          Raises:
            ValueError: You tried to increase the exponent, which can't be
              done without decryption.