hensel_code 0.1.0 → 0.3.0

data/lib/hensel_code/finite_padic_expansion.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # finite p-adic expansion hensel code class
+  class FinitePadicExpansion < PAdicBase
+    attr_accessor :polynomial
+
+    def modulus
+      prime
+    end
+
+    def to_a
+      hensel_code
+    end
+
+    def to_truncated
+      TruncatedFinitePadicExpansion.new(prime, exponent, rational)
+    end
+
+    def to_s
+      hensel_code.map.with_index do |h, i|
+        "#{h}#{polynomial_variable(i)}"
+      end.join(" + ")
+    end
+
+    def inspect
+      "<HenselCode: #{polynomial_form}>"
+    end
+
+    def inverse
+      new_hensel_code = polynomial.inverse.coefficients
+      self.class.new prime, exponent, new_hensel_code
+    end
+
+    private
+
+    def polynomial_form
+      to_s
+    end
+
+    def evaluate(operation, other)
+      new_hensel_code = polynomial.send(operation, other.polynomial).coefficients
+      self.class.new prime, exponent, new_hensel_code
+    end
+
+    def valid_number?(number)
+      if number.is_a?(Rational)
+        @rational = number
+      elsif number.is_a?(Array) && number.map(&:class).uniq == [Integer] && number.size == exponent
+        @hensel_code = number
+        decode
+      else
+        message = "number must be a Rational or an\
+        Array of integers of size #{exponent}"
+        raise WrongHenselCodeInputType, message
+      end
+    end
+
+    def valid_hensel_code?(new_hensel_code)
+      conditions = [
+        new_hensel_code.is_a?(Array),
+        new_hensel_code.map(&:class).uniq == [Integer],
+        new_hensel_code.size == exponent
+      ]
+      message = "must be an array of integers of size #{exponent}"
+      raise WrongHenselCodeInputType, message unless conditions.uniq == [true]
+    end
+
+    def encode
+      @hensel_code = rational_to_padic_digits
+      @polynomial = Polynomial.new prime, hensel_code
+    end
+
+    def decode
+      number = 0
+      hensel_code.each_with_index { |d, i| number += d * (prime**i) }
+      @rational = TruncatedFinitePadicExpansion.new(prime, exponent, number).to_r
+    end
+
+    def rational_to_padic_digits
+      digits = [rational_to_integer(rational)]
+      alpha = rational - digits.last
+      (exponent - 1).times do
+        alpha = reduce_rational_in_terms_of_prime(alpha)
+        digits << rational_to_integer(alpha)
+        alpha -= digits.last
+      end
+      digits
+    end
+
+    def reduce_rational_in_terms_of_prime(alpha)
+      divisor_numerator = alpha.numerator.gcd(prime)
+      divisor_denominator = alpha.denominator.gcd(prime)
+      if divisor_numerator != 1
+        alpha /= divisor_numerator
+      elsif divisor_denominator != 1
+        alpha *= divisor_denominator
+      end
+      alpha
+    end
+
+    def rational_to_integer(rat)
+      (rat.numerator * mod_inverse(rat.denominator, prime)) % prime
+    end
+  end
+end

data/lib/hensel_code/gadic_base.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # base hensel code class
+  class GAdicBase
+    include Tools
+    include GAdicVerifier
+
+    attr_accessor :primes, :exponent, :rational, :hensel_code, :g, :n
+    private :primes=, :exponent=, :rational=, :hensel_code=
+
+    def initialize(primes, exponent, number)
+      can_initilize?
+      @primes = primes
+      @exponent = exponent
+      @g = primes.inject(:*)
+      @n = Integer.sqrt(((g**exponent) - 1) / 2)
+      valid_number?(number)
+      encode
+      decode
+    end
+
+    def numerator
+      rational.numerator
+    end
+
+    def denominator
+      rational.denominator
+    end
+
+    def to_r
+      decode
+      rational
+    end
+
+    def +(other)
+      valid?(other)
+      evaluate("+", other)
+    end
+
+    def -(other)
+      valid?(other)
+      evaluate("-", other)
+    end
+
+    def *(other)
+      valid?(other)
+      evaluate("*", other)
+    end
+
+    def /(other)
+      valid?(other)
+      evaluate("/", other)
+    end
+
+    def replace_primes(new_primes)
+      replace_attribute("primes=", new_primes, 0)
+    end
+
+    def replace_exponent(new_exponent)
+      replace_attribute("exponent=", new_exponent, 0)
+    end
+
+    def replace_rational(new_rational)
+      replace_attribute("rational=", new_rational, 0)
+    end
+
+    def replace_hensel_code(new_hensel_code)
+      valid_hensel_code?(new_hensel_code)
+      replace_attribute("hensel_code=", new_hensel_code, 1)
+    end
+
+    private
+
+    def can_initilize?
+      message = "#{self.class} can only be inherited."
+      raise NonInitializableClass, message if instance_of?(HenselCode::GAdicBase)
+    end
+
+    def replace_attribute(attribute, new_value, order)
+      send(attribute, new_value)
+      order.zero? ? [encode, decode] : [decode, encode]
+      self
+    end
+  end
+end

data/lib/hensel_code/gadic_verifier.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # verifications pre-evaluation of hensel codes
+  module GAdicVerifier
+    def valid?(other)
+      incompatible_operand_type?(other)
+      different_primes_and_same_exponent?(other)
+      different_primes_and_different_exponent?(other)
+      same_primes_and_different_exponent?(other)
+    end
+
+    def incompatible_operand_type?(other)
+      message = "#{self} is a #{self.class} while #{other} is a #{other.class}"
+      raise IncompatibleOperandTypes, message unless instance_of?(other.class)
+    end
+
+    def different_primes_and_same_exponent?(other)
+      message = "#{self} has primes #{primes} while #{other} has prime #{other.primes}"
+      raise HenselCodesWithDifferentPrimes, message if primes != other.primes && exponent == other.exponent
+    end
+
+    def different_primes_and_different_exponent?(other)
+      message = <<~MSG
+        "#{self} has prime #{primes} and exponent #{exponent}
+        while #{other} has prime #{other.primes} and exponent #{other.exponent}
+      MSG
+      raise HenselCodesWithDifferentPrimesAndExponents, message if primes != other.primes && exponent != other.exponent
+    end
+
+    def same_primes_and_different_exponent?(other)
+      message = "#{self} has exponent #{exponent} while #{other} has exponent #{other.exponent}"
+      raise HenselCodesWithDifferentExponents, message if primes == other.primes && exponent != other.exponent
+    end
+  end
+end

data/lib/hensel_code/modular_arithmetic.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # modular arithmetic class
+  module ModularArithmetic
+    def cauchy_product(prime, coefficients1, coefficients2)
+      product = []
+      carry = 0
+      (0..coefficients1.size - 1).each do |i|
+        sum = 0
+        (0..i).each { |j| sum += (coefficients1[j] * coefficients2[i - j]) }
+        product << ((carry + sum) % prime)
+        carry = (carry + sum) / prime
+      end
+      product
+    end
+
+    def multiplication(prime, coefficients1, coefficients2)
+      partial_multiplications = []
+      coefficients2.each_with_index do |c1, i|
+        rows = multiplication_inner_loop(prime, coefficients1, coefficients2, c1, i)
+        partial_multiplications << rows
+        rows.append(*([0] * i))
+      end
+      sum_of_partial_multiplications(partial_multiplications)
+    end
+
+    private
+
+    def multiplication_inner_loop(prime, coefficients1, coefficients2, c1_, index)
+      rows = []
+      carry = 0
+      coefficients1.each_with_index do |c2, j|
+        rows << ((carry + (c1_ * c2)) % prime)
+        carry = (carry + (c1_ * c2)) / prime
+        (rows << carry).reverse!.insert(0, *([0] * (j - index))) if j == coefficients2.size - 1
+      end
+      rows
+    end
+
+    def sum_of_partial_multiplications(partial_multiplications)
+      carry = 0
+      sum = []
+      partial_multiplications.map(&:reverse).transpose.map do |x|
+        sum << ((carry + x.reduce(:+)) % prime)
+        carry = (carry + x.reduce(:+)) / prime
+      end
+      sum
+    end
+
+    def addition(prime, coefficients1, coefficients2)
+      carry = 0
+      result_coefficients = []
+      coefficients1.zip(coefficients2).each do |x|
+        result_coefficients << ((carry + x.reduce(:+)) % prime)
+        carry = (carry + x.reduce(:+)) / prime
+      end
+      result_coefficients
+    end
+
+    def subtraction(prime,  coefficients1, coefficients2)
+      addition(prime, coefficients1, negation(prime, coefficients2))
+    end
+
+    def negation(prime, coefficients)
+      leading_zeros = coefficients.take_while(&:zero?)
+      coefficients_without_leading_zeros = coefficients.drop_while(&:zero?)
+      new_coefficients = [(prime - coefficients_without_leading_zeros[0]) % prime]
+      new_coefficients += coefficients[leading_zeros.size + 1..].map do |c|
+        ((prime - 1) - c) % prime
+      end
+      leading_zeros + new_coefficients
+    end
+  end
+end

data/lib/hensel_code/padic_base.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # base hensel code class
+  class PAdicBase
+    include Tools
+    include PAdicVerifier
+
+    attr_accessor :prime, :exponent, :rational, :hensel_code, :n
+    private :prime=, :exponent=, :rational=, :hensel_code=
+
+    def initialize(prime, exponent, number)
+      can_initilize?
+      @prime = prime
+      @exponent = exponent
+      @n = Integer.sqrt(((prime**exponent) - 1) / 2)
+      valid_number?(number)
+      encode
+      decode
+    end
+
+    def numerator
+      rational.numerator
+    end
+
+    def denominator
+      rational.denominator
+    end
+
+    def to_r
+      decode
+      rational
+    end
+
+    def +(other)
+      valid?(other)
+      evaluate("+", other)
+    end
+
+    def -(other)
+      valid?(other)
+      evaluate("-", other)
+    end
+
+    def *(other)
+      valid?(other)
+      evaluate("*", other)
+    end
+
+    def /(other)
+      valid?(other)
+      evaluate("/", other)
+    end
+
+    def replace_prime(new_prime)
+      replace_attribute("prime=", new_prime, 0)
+    end
+
+    def replace_exponent(new_exponent)
+      replace_attribute("exponent=", new_exponent, 0)
+    end
+
+    def replace_rational(new_rational)
+      replace_attribute("rational=", new_rational, 0)
+    end
+
+    def replace_hensel_code(new_hensel_code)
+      valid_hensel_code?(new_hensel_code)
+      replace_attribute("hensel_code=", new_hensel_code, 1)
+    end
+
+    private
+
+    def can_initilize?
+      message = "#{self.class} can only be inherited."
+      raise NonInitializableClass, message if instance_of?(HenselCode::PAdicBase)
+    end
+
+    def replace_attribute(attribute, new_value, order)
+      send(attribute, new_value)
+      order.zero? ? [encode, decode] : [decode, encode]
+      self
+    end
+  end
+end

data/lib/hensel_code/{tfpe_verifier.rb → padic_verifier.rb}

@@ -2,7 +2,7 @@
 
 module HenselCode
   # verifications pre-evaluation of hensel codes
-  module TFPEVerifier
+  module PAdicVerifier
     def valid?(other)
       incompatible_operand_type?(other)
       different_prime_and_same_exponent?(other)

data/lib/hensel_code/polynomial.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # polynomial class
+  class Polynomial
+    include HenselCode::Tools
+    include HenselCode::ModularArithmetic
+
+    attr_accessor :prime, :coefficients, :fixed_length
+
+    def initialize(prime, coefficients, fixed_length: true)
+      @prime = prime
+      @coefficients = coefficients
+      @fixed_length = fixed_length
+      valid_prime?
+      valid_coefficients?
+    end
+
+    def +(other)
+      valid_operands?(other)
+      new_coefficients = addition(prime, coefficients, other.coefficients)
+      self.class.new prime, new_coefficients
+    end
+
+    def -(other)
+      valid_operands?(other)
+      new_coefficients = subtraction(prime, coefficients, other.coefficients)
+      self.class.new prime, new_coefficients
+    end
+
+    def *(other)
+      valid_operands?(other)
+      new_coefficients = multiplication(prime, coefficients, other.coefficients)
+      self.class.new prime, new_coefficients[0..coefficients.size - 1]
+    end
+
+    def /(other)
+      valid_operands?(other)
+      new_coefficients = (self * other.inverse).coefficients
+      self.class.new prime, new_coefficients[0..coefficients.size - 1]
+    end
+
+    def inverse
+      x = generate_padic_x
+      two = generate_padic_constant_integer(2)
+      x = (two * x) - (self * x * x) while (x * self).coefficients != [1] + Array.new(coefficients.size - 1, 0)
+      x
+    end
+
+    def to_s
+      coefficients.map.with_index do |c, i|
+        "#{c}#{polynomial_variable(i)}"
+      end.join(" + ")
+    end
+
+    def inspect
+      "<Polynomial: #{polynomial_form}>"
+    end
+
+    def degree
+      coefficients.size - 1
+    end
+
+    private
+
+    def valid_prime?
+      raise ArgumentError, "prime can't be nil" if @prime.nil?
+      raise ArgumentError, "prime must be an integer" unless @prime.is_a?(Integer)
+    end
+
+    def valid_coefficients?
+      coefficients_condition = @coefficients.is_a?(Array) && @coefficients.map(&:class).uniq == [Integer]
+      raise ArgumentError, "coefficients can't be nil" if @coefficients.nil?
+      raise ArgumentError, "coefficients must be an array" unless @coefficients.is_a?(Array)
+      raise ArgumentError, "coefficients must be an array" unless coefficients_condition
+    end
+
+    def valid_operands?(other)
+      s1 = coefficients.size
+      s2 = other.coefficients.size
+      raise WrongHenselCodeInputType, "polynomials must have same degree" if s1 != s2
+      raise WrongHenselCodeInputType, "polynomials must have same prime" if prime != other.prime
+    end
+
+    def generate_padic_x
+      x_coefficients = [mod_inverse(coefficients[0], prime)] + Array.new(coefficients.size - 1) { rand(0..prime - 1) }
+      self.class.new prime, x_coefficients
+    end
+
+    def generate_padic_constant_integer(number)
+      self.class.new prime, [number] + Array.new(coefficients.size - 1, 0)
+    end
+
+    def mul(other)
+      new_coefficients = multiplication(prime, coefficients, other.coefficients)
+      self.class.new prime, new_coefficients
+    end
+
+    def polynomial_form
+      to_s
+    end
+  end
+end

data/lib/hensel_code/tools.rb

@@ -36,13 +36,13 @@ module HenselCode
       end
     end
 
-    def random_distinct_primes(quantity, bits)
-      primes = [random_prime(bits)]
-      while primes.size < quantity
-        prime = random_prime(bits)
-        primes << prime if prime != primes.last
+    def random_distinct_numbers(type, quantity, bits)
+      numbers = [send("random_#{type}", bits)]
+      while numbers.size < quantity
+        number = send("random_#{type}", bits)
+        numbers << number if number != numbers.last
       end
-      primes
+      numbers
     end
 
     def eea_core(num1, num2, bound = 0)
@@ -77,5 +77,23 @@ module HenselCode
 
       y % mod
     end
+
+    def crt(moduli, remainders)
+      g = moduli.inject(:*)
+      result = 0
+      moduli.zip(remainders) do |modulus, remainder|
+        g_prime = g / modulus
+        g_prime_inverse = mod_inverse(g_prime, modulus)
+        result += ((g_prime * g_prime_inverse * remainder))
+      end
+      result % g
+    end
+
+    private
+
+    def polynomial_variable(index)
+      i = index > 1 ? 2 : index
+      ["", "p", "p^#{index}"][i]
+    end
   end
 end

data/lib/hensel_code/truncated_finite_gadic_expansion.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # truncated finite g-adic expansion hensel code class
+  class TruncatedFiniteGadicExpansion < GAdicBase
+    def modululi
+      primes.map { |prime| prime**exponent }
+    end
+
+    def to_a
+      hensel_code.map(&:to_i)
+    end
+
+    def to_s
+      hensel_code.map(&:to_i).to_s
+    end
+
+    def inspect
+      "<HenselCode: #{to_a}>"
+    end
+
+    def inverse
+      new_hensel_code = hensel_code.map(&:inverse)
+      self.class.new primes, exponent, new_hensel_code
+    end
+
+    private
+
+    def evaluate(operation, other)
+      new_hensel_code = hensel_code.zip(other.hensel_code).map { |pair| pair[0].send(operation, pair[1]) }
+      self.class.new primes, exponent, new_hensel_code
+    end
+
+    def valid_number?(number)
+      if number.is_a?(Rational)
+        @rational = number
+      elsif number.is_a?(Array) && number.map(&:class).uniq == [HenselCode::TruncatedFinitePadicExpansion]
+        @hensel_code = number
+        decode
+      else
+        raise WrongHenselCodeInputType, "number must be a Rational or an\
+                                        Array of truncated p-adic Hensel codes and it was a #{number.class}"
+      end
+    end
+
+    def valid_hensel_code?(new_hensel_code)
+      condition = new_hensel_code.is_a?(Array) && new_hensel_code.map(&:class).uniq == [HenselCode::TFPE]
+      message = "must be an array of truncated p-adic Hensel codes"
+      raise WrongHenselCodeInputType, message unless condition
+    end
+
+    def encode
+      @g = primes.inject(:*)
+      @hensel_code = primes.map do |prime|
+        TruncatedFinitePadicExpansion.new prime, exponent, rational
+      end
+    end
+
+    def decode
+      h = TruncatedFinitePadicExpansion.new g, exponent, crt(modululi, hensel_code.map(&:to_i))
+      @rational = h.to_r
+    end
+  end
+end