docs: def undivision(
         cls,
         integer_part,
         non_repeating_part,
         repeating_part,
         base
      ):
          """
          Find divisor and dividend that yield component parts.
  
          :param integer_part: the integer part
          :type integer_part: list of int
          :param non_repeating_part: the non_repeating_part
          :type non_repeating_part: list of int
          :param repeating_part: the repeating part
          :type repeating_part: list of int
          :param int base: the base
  
          :returns: divisor and dividend in lowest terms
          :rtype: tuple of list of int * list of int
  
          Complexity: O(len(non_repeating_part + repeating_part + integer_part))
          """
          if base < 2:
              raise BasesValueError(base, "base", "must be at least 2")
  
          if any(x < 0 or x >= base for x in integer_part):
              raise BasesValueError(
                 integer_part,
                 "integer_part",
                 "for all elements, e, 0 <= e < base required"
              )
  
          if any(x < 0 or x >= base for x in non_repeating_part):
              raise BasesValueError(
                 non_repeating_part,
                 "non_repeating_part",
                 "for all elements, e, 0 <= e < base required"
              )
  
          if any(x < 0 or x >= base for x in repeating_part):
              raise BasesValueError(
                 repeating_part,
                 "repeating_part",
                 "for all elements, e, 0 <= e < base required"
              )
  
          shift_length = len(repeating_part)
          frac_length = len(non_repeating_part)
  
          top = fractions.Fraction(
             Nats.convert_to_int(
                integer_part + non_repeating_part + repeating_part,
                base
             ),
             base ** frac_length
          )
  
          if shift_length == 0:
              return (
                 Nats.convert_from_int(top.denominator, base),
                 Nats.convert_from_int(top.numerator, base)
              )
  
          bottom = fractions.Fraction(
             Nats.convert_to_int(integer_part + non_repeating_part, base),
             base ** frac_length
          )
          result = (top - bottom) / ((base ** shift_length) - 1)
          return (
             Nats.convert_from_int(result.denominator, base),
             Nats.convert_from_int(result.numerator, base)
          )