hensel_code 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ade0ad51689f11d1f36d2ac3e62c40a6ec61fef5142f11371e5403e195ad70a
-  data.tar.gz: 0f7288540b1000124be29836ef664ea31d2670a9f0390c24b075e90febba6e42
+  metadata.gz: 3141783b56aaeef35545764e8016b975917e6da6a4000c741c8a4974741181a3
+  data.tar.gz: f45277dbbcef5551ca0ee0e756a6494dc26ade17906e5cc9692b197b1a597a57
 SHA512:
-  metadata.gz: 457aef94ccb7bf0d107e54e85731d26c8463d24f6a176f5769f55737adb602af753441e7964ea8c5b1ccd53e16357a54eada4221ba62e14b696204f72f76942c
-  data.tar.gz: 4604cc97de514dbb23cecf574a727e83510947158b6565909c6f556d621fab36b972cd2bbe128b89c693e715fc19d2123dcd44681b1bfe860b016eb93b7091eb
+  metadata.gz: e96d107ee37379ab95ff1daa3cea566dbc0383f2513db5c6054bbf93c8e74c82ce30b994325713085289b39337b8993639322b059bc26ddd180f3b367b510336
+  data.tar.gz: 7dfe989626ceb077f9b9115e94a6f8cf6f8aa4816bc255822edb1aaba81f258b48cd9642c6b3662f4b1ee9cf913b050bd098e92313ebfb738f90f5b0d7298310

data/README.md

@@ -1,9 +1,13 @@
 # HenselCode
 
-![example workflow](https://github.com/davidwilliam/hensel_code/actions/workflows/main.yml/badge.svg) [![codecov](https://codecov.io/gh/davidwilliam/hensel_code/branch/main/graph/badge.svg?token=XJ0C0U7P2M)](https://codecov.io/gh/davidwilliam/hensel_code) [![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop/rubocop) ![GitHub](https://img.shields.io/github/license/davidwilliam/hensel_code)
+![example workflow](https://github.com/davidwilliam/hensel_code/actions/workflows/main.yml/badge.svg) [![codecov](https://codecov.io/gh/davidwilliam/hensel_code/branch/main/graph/badge.svg?token=XJ0C0U7P2M)](https://codecov.io/gh/davidwilliam/hensel_code) [![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop/rubocop) ![GitHub](https://img.shields.io/github/license/davidwilliam/hensel_code) ![Gem](https://img.shields.io/gem/v/hensel_code) ![GitHub release (latest by date)](https://img.shields.io/github/v/release/davidwilliam/hensel_code)
 
 Hensel Code allows you to homomorphically encode rational numbers as integers using the finite-segment p-adic arithmetic, also known as Hensel codes. 
 
+T. M. Rao describes the use of finite-segment p-adic arithmetic as a practical method for performing error-free computation and the term *Hensel code* as the first `r` digits of the infinite p-adic expansion of a rational number `x/y`. The use of Hensel codes allows us to replace the arithmetic opertations on rational numbers by corresponding aritmetic operation over the integers under certain conditions.
+
+Rao also remarks that the theory of Hensel codes, although lifted from the p-adic number theory, can be introduced without the need of a complete undertanding of the theoretical aspects of p-adic numbers if the goal is to work with Hensel codes alone. This is due to the fact that the finite-segment p-adic arithmetic is well-defined, self-contained, and it has immediate pratical applications in a wide range of real-world scenarios.
+
 ## Mathematical Background
 
 In our Wiki, you can find a brief [introduction to the mathematical background on Hensel codes](https://github.com/davidwilliam/hensel_code/wiki/Mathematical-Background). We will continue to update that area as we update the gem.
@@ -28,7 +32,14 @@ Or install it yourself as:
 
     $ gem install hensel_code
 
-## Usage
+# Usage
+
+There are several types of Hensel codes. There are currently two of the available in the gem HenselCode: 
+
+1. Truncated finite-segment p-adic Hensel codes (added in v0.1.0)
+2. Finite-segment p-adic Hensel codes (added in v0.2.0)
+
+## Truncated finite-segment p-adic Hensel codes
 
 Let `p=257` and `r=3`. Given two rational numbers `rat1 = Rational(3,5)` and `rat2 = Rational(4,3)`, we encode `rat1` and `rat2` as follows:
 
@@ -80,8 +91,101 @@ rat1 - rat2
 # => (-11/15)
 rat1 * rat2
 # => (4/5)
+rat1 / rat2
+# => (9/20)
+```
+
+### Which Prime Should I Use?
+
+The choice of the prime you should use for encoding rationals into integers depends on two factors:
+
+1. What rationals you want to encode,
+2. What computations you want to perform over the encoded rationals.
+
+To help you in this decision, given any Hensel code object `h`, you can check `h.n`:
+
+```ruby
+h = HenselCode::TruncatedFinitePadicExpansion.new p, r, Rational(2,3)
+# => [HenselCode: 11316396, prime: 257, exponent: 3, modulus: 16974593]
+h.n
+# => 2913
 ```
 
+In the mathematical background provided on our Wiki, you will see that the fractions associated with any choise of `p` and `r` are bounded by a value of `N`. In the HenselCode gem we refer to `n`, since capital letters are reserved to constants in Ruby. In the above example, we can encode fractions with numerator and denominator bounded in absolute value to `n` and we can perform computations on Hensel codes until a result that encodes a rational number with numerator and denominator bounded in absolute value to `n`. 
+
+### Correctness Depends on the Choices for `p` and `r`
+
+If `p = 7` and `r = 2`, then `n = 4`. If I try to encode a rational number `rat = Rational(11,23)` with my choices of `p` and `r` I will not obtain the intended result:
+
+```ruby
+rat = Rational(11,23)
+h = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat
+# => [HenselCode: 9, prime: 7, exponent: 2, modulus: 49]
+h.to_r
+# => (-4/5)
+```
+
+So, instead of `11/23`, we obtain `-4/5` and this happens because `n = 4` and the rational number `11/23` does not have numerator and denominator bounded in absolute value to `n`. Therefore correctness fails.
+
+The same occurs with computation on Hensel codes. If `rat1 = Rational(2,3)` and `rat2 = Rational(3,4)`, both `rat1` and `rat2` can be correctly encoded and decoded with our choice of `p` and `r` since they both have numerators and denominators bounded in absolute value to `n = 4`. However, computation addition of `rat1` and `rat2` will fail correctness since the result violates the bound imposed by `n`:
+
+```ruby
+h1 = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat1
+# => [HenselCode: 17, prime: 7, exponent: 2, modulus: 49]
+h2 = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat2
+# => [HenselCode: 13, prime: 7, exponent: 2, modulus: 49]
+h1_plus_h2 = h1 + h2
+# => [HenselCode: 30, prime: 7, exponent: 2, modulus: 49]
+h1_plus_h2.to_r
+# => (3/5)
+```
+
+We obtain the incorrect result because `2/3 + 2/4 = 17/12` and this result is not supported by `p = 7` and `r = 2`. 
+
+If instead we define `p = 56807` and `r = 3`, we have:
+
+```ruby
+h1 = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat1
+=> [HenselCode: 122212127593296, prime: 56807, exponent: 3, modulus: 183318191389943]
+h2 = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat2
+=> [HenselCode: 137488643542458, prime: 56807, exponent: 3, modulus: 183318191389943]
+h1_plus_h2 = h1 + h2
+=> [HenselCode: 76382579745811, prime: 56807, exponent: 3, modulus: 183318191389943]
+h1_plus_h2.to_r
+# => (17/12)
+```
+
+This time we obtain the correct result because `h1.n = 9573875`, and therefore correctness is guaranteed to any result associated with a numerator and a denominator bounded in absolute value to `9573875`.
+
+Thefore, the larger `p` and `r` are, the larger the rationals one can correctly encode and decode and the more computations on Hensel codes will be perfomed and correctly decoded.
+
+### It Could Be Any Integer, But...
+
+The p-adic number theory establishes that `p` is a prime number. The fact that a prime number does not share any common divisor (other than `1`) with any other number smaller than itself makes it a very special number.
+
+However, as an example, one could decided that `p = 25` and `r = 3`. Notice that `25` is not prime, yet, will work for some cases:
+
+```ruby
+p = 25
+r = 3
+rat1 = Rational(1,2)
+h1 = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat1
+# => [HenselCode: 7813, prime: 25, exponent: 3, modulus: 15625]
+h1.to_r
+# => (1/2)
+```
+
+However, it will fail in the following case:
+
+```ruby
+rat2 = Rational(2,5)
+h2 = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat2
+# => 5 has no inverse modulo 15625 (ZeroDivisionError)
+```
+
+We can't compute a Hensel code for `2/5` with `p = 25` and `r = 3` because `gcd(5,25) = 5` and therefore there is no modular multiplicative inverse of `5` modulo `25`.
+
+Therefore it is important that `p` is a prime (preferred), or a prime power power (less interesting since we already have `r`), or a prime composite (it can be useful for larger prime factors).
 ### Constraints
 
 In order to operate on two or more Hensel codes, they all must be of the same object type and have the same prime and exponent, otherwise HenselCode will raise an exception. Again, let `rat1 = Rational(3,5)` and `rat2 = Rational(4,3)`, and `p1 = 241`, `p2 = 251`, `r1 = 3`, and `r2 = 4`:
@@ -94,7 +198,7 @@ h2 = HenselCode::TruncatedFinitePadicExpansion.new(p1, r2, rat1)
 h3 = HenselCode::TruncatedFinitePadicExpansion.new(p2, r1, rat1)
 # => [HenselCode: 6325301, prime: 251, exponent: 3, modulus: 15813251]
 h4 = HenselCode::TruncatedFinitePadicExpansion.new(p2, r2, rat1)
-=> [HenselCode: 1587650401, prime: 251, exponent: 4, modulus: 3969126001]
+# => [HenselCode: 1587650401, prime: 251, exponent: 4, modulus: 3969126001]
 ```
 
 The following operations will raise exceptions:
@@ -168,6 +272,110 @@ h.replace_hensel_code(38769823656)
 # => (-685859/94809)
 ```
 
+## Finite-segment p-adic Hensel codes
+
+The truncated finite-segment p-adic Hensel codes can be described as a polynomial truncated to its leading coefficient/monomial in non-standard form (increasing degree order). The finite-segment p-adic Hensel codes are expressed with a polynomial of degree `r-1`.
+
+Let `p = 359`, `r = 3`, and `rat = Rational(2,3)`:
+
+```ruby
+h1 = HenselCode::FinitePadicExpansion.new p, r, rat
+# => [HenselCode: 240 + 119p + 239p^2, prime: 359, exponent: 3, modulus: 359]
+puts h1
+# => 240 + 119p + 239p^2
+```
+
+We say that `h` is a p-adic number with `r` digits. We clearly see the correspondence of p-adic digits if we compute a truncated Hensel code with the same `p` but `r=1`:
+
+```ruby
+h2 = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat
+# => [HenselCode: 240, prime: 359, exponent: 1, modulus: 359]
+```
+
+Notice that the truncated Hensel code `h2` equals the first digit of the finite-segment Hensel code `h1`, which is also the same of computing
+
+```ruby
+HenselCode::FinitePadicExpansion.new p, 1, rat
+# => [HenselCode: 240, prime: 359, exponent: 1, modulus: 359]
+```
+
+The following expressions are equivalent:
+
+```ruby
+r = 3
+h1 = HenselCode::FinitePadicExpansion.new p, r, rat
+# => [HenselCode: 240 + 119p + 239p^2, prime: 359, exponent: 3, modulus: 359]
+h1.to_r
+# => (2/3)
+h2 = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat
+# => [HenselCode: 30845520, prime: 359, exponent: 3, modulus: 46268279]
+h2.to_r
+# => (2/3)
+```
+
+that is, they not only represent the same rational but also `30845520` is just the evaluation of the polynomial `240 + 119p + 239p^2`.
+
+We can obtain just the coefficients of `h1` as follows:
+
+```ruby
+h1.to_a
+# => => [240, 119, 239]
+```
+
+We can obtain the truncated version of `h1` as follows:
+
+```ruby
+h1.to_truncated
+# => [HenselCode: 30845520, prime: 359, exponent: 3, modulus: 46268279]
+h1.to_truncated.class
+# => HenselCode::TruncatedFinitePadicExpansion
+```
+
+#### Arithmetic
+
+Let `p = 409`, `r = 5`, `rat1 = Rational(2,3)` and `rat2 = Rational(11,7)` such that
+
+```ruby
+h1 = HenselCode::FinitePadicExpansion.new p, r, rat1
+# => [HenselCode: 137 + 136p + 136p^2 + 136p^3 + 136p^4, prime: 409, exponent: 5, modulus: 409]
+h2 = HenselCode::FinitePadicExpansion.new p, r, rat2
+# => [HenselCode: 60 + 292p + 233p^2 + 350p^3 + 116p^4, prime: 409, exponent: 5, modulus: 409]
+```
+
+We compute addition, subtraction, multiplication, and division as follows:
+
+```ruby
+h1_plus_h2 =h1 + h2
+# => [HenselCode: 197 + 19p + 370p^2 + 77p^3 + 253p^4, prime: 409, exponent: 5, modulus: 409]
+h1_minus_h2 = h1 - h2
+# => [HenselCode: 77 + 253p + 311p^2 + 194p^3 + 19p^4, prime: 409, exponent: 5, modulus: 409]
+h1_times_h2 = h1 * h2
+# => [HenselCode: 40 + 331p + 155p^2 + 97p^3 + 214p^4, prime: 409, exponent: 5, modulus: 409]
+h1_div_h2 = h1 / h2
+# => [HenselCode: 50 + 161p + 12p^2 + 347p^3 + 309p^4, prime: 409, exponent: 5, modulus: 409]
+```
+
+And we can verify that
+
+```ruby
+h1_plus_h2.to_r
+# => (47/21)
+rat1 + rat2
+# => (47/21)
+rat1 - rat2
+# => (-19/21)
+h1_minus_h2.to_r
+# => (-19/21)
+h1_times_h2.to_r
+# => (22/21)
+rat1 * rat2
+# => (22/21)
+h1_div_h2.to_r
+# => (14/33)
+rat1 / rat2
+# => (14/33)
+```
+
 ### Class Alias
 
 Since `HenselCode::TruncatedFinitePadicExpansion` is a bit long, the alias `HenselCode::TFPE` can be used instead.

data/lib/hensel_code/finite_padic_expansion.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # finite p-adic expansion hensel code class
+  class FinitePadicExpansion < PAdicBase
+    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}, prime: #{prime}, exponent: #{exponent}, modulus: #{modulus}]"
+    end
+
+    private
+
+    def evaluate(operation, other)
+      h_ = to_truncated.send(operation, other.to_truncated).hensel_code
+      new_hensel_code = (0..exponent - 1).map { |i| h_ / (prime**i) % prime }
+      self.class.new prime, exponent, new_hensel_code
+    end
+
+    def polynomial_variable(index)
+      i = index > 1 ? 2 : index
+      ["", "p", "p^#{index}"][i]
+    end
+
+    def polynomial_form
+      to_s
+    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
+      h_ = TruncatedFinitePadicExpansion.new(prime, exponent, rational).hensel_code
+      @hensel_code = (0..exponent - 1).map { |i| h_ / (prime**i) % prime }
+    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
+  end
+end

data/lib/hensel_code/padic_base.rb

@@ -0,0 +1,78 @@
+# 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)
+      @prime = prime
+      @exponent = exponent
+      @n = Integer.sqrt(((prime**exponent) - 1) / 2)
+      valid_number?(number)
+      encode
+    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 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/truncated_finite_padic_expansion.rb

@@ -2,39 +2,11 @@
 
 module HenselCode
   # truncated finite p-adic expansion hensel code class
-  class TruncatedFinitePadicExpansion
-    include Tools
-    include TFPEVerifier
-
-    attr_accessor :prime, :exponent, :rational, :hensel_code, :n
-    private :prime=, :exponent=, :rational=, :hensel_code=
-
-    def initialize(prime, exponent, number)
-      @prime = prime
-      @exponent = exponent
-      @n = Integer.sqrt((modulus - 1) / 2)
-
-      valid_number?(number)
-      encode
-    end
-
+  class TruncatedFinitePadicExpansion < PAdicBase
     def modulus
       prime**exponent
     end
 
-    def numerator
-      rational.numerator
-    end
-
-    def denominator
-      rational.denominator
-    end
-
-    def to_r
-      decode
-      rational
-    end
-
     def to_i
       hensel_code
     end
@@ -43,61 +15,23 @@ module HenselCode
       hensel_code.to_s
     end
 
-    def replace_prime(new_prime)
-      self.prime = new_prime
-      encode
-      decode
-      self
-    end
-
-    def replace_exponent(new_exponent)
-      self.exponent = new_exponent
-      encode
-      decode
-      self
-    end
-
-    def replace_rational(new_rational)
-      self.rational = new_rational
-      encode
-      decode
-      self
-    end
-
-    def replace_hensel_code(new_hensel_code)
-      self.hensel_code = new_hensel_code
-      decode
-      encode
-      self
-    end
-
-    def +(other)
-      valid?(other)
-      self.class.new prime, exponent, (hensel_code + other.hensel_code) % modulus
-    end
-
-    def -(other)
-      valid?(other)
-      self.class.new prime, exponent, (hensel_code - other.hensel_code) % modulus
-    end
-
-    def *(other)
-      valid?(other)
-      self.class.new prime, exponent, (hensel_code * other.hensel_code) % modulus
-    end
-
-    def /(other)
-      valid?(other)
-      h2_hensel_code_inverse = mod_inverse(other.hensel_code, modulus)
-      self.class.new prime, exponent, (hensel_code * h2_hensel_code_inverse) % modulus
-    end
-
     def inspect
       "[HenselCode: #{hensel_code}, prime: #{prime}, exponent: #{exponent}, modulus: #{modulus}]"
     end
 
     private
 
+    def evaluate(operation, other)
+      if operation == "/"
+        other_hensel_code = mod_inverse(other.hensel_code, modulus)
+        op = "*"
+      else
+        other_hensel_code = other.hensel_code
+        op = operation
+      end
+      self.class.new prime, exponent, hensel_code.send(op, other_hensel_code) % modulus
+    end
+
     def valid_number?(number)
       case number
       when Rational
@@ -111,6 +45,11 @@ module HenselCode
       end
     end
 
+    def valid_hensel_code?(new_hensel_code)
+      message = "must be an integer up to #{modulus - 1}"
+      raise WrongHenselCodeInputType, message unless new_hensel_code < modulus
+    end
+
     def encode
       denominator_inverse = mod_inverse(denominator, modulus)
       @hensel_code = (numerator * denominator_inverse) % modulus

data/lib/hensel_code/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HenselCode
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/hensel_code.rb

@@ -14,11 +14,14 @@ module HenselCode
   class HenselCodesWithDifferentExponents < StandardError; end
   class IncompatibleOperandTypes < StandardError; end
 
-  autoload  :Tools,                           "hensel_code/tools"
-  autoload  :TFPEVerifier,                    "hensel_code/tfpe_verifier"
-  autoload  :TruncatedFinitePadicExpansion,   "hensel_code/truncated_finite_padic_expansion"
+  autoload  :Tools, "hensel_code/tools"
+  autoload  :PAdicBase, "hensel_code/padic_base"
+  autoload  :PAdicVerifier, "hensel_code/padic_verifier"
+  autoload  :FinitePadicExpansion, "hensel_code/finite_padic_expansion"
+  autoload  :TruncatedFinitePadicExpansion, "hensel_code/truncated_finite_padic_expansion"
 
   # aliases for classes with long names
   TFPE = TruncatedFinitePadicExpansion
   HCWDPAE = HenselCodesWithDifferentPrimesAndExponents
+  WHIT = WrongHenselCodeInputType
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hensel_code
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - David William Silva
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-03 00:00:00.000000000 Z
+date: 2022-03-05 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby library for homomorphically representing rational numbers as integers.
 email:
@@ -26,7 +26,9 @@ files:
 - Rakefile
 - codecov
 - lib/hensel_code.rb
-- lib/hensel_code/tfpe_verifier.rb
+- lib/hensel_code/finite_padic_expansion.rb
+- lib/hensel_code/padic_base.rb
+- lib/hensel_code/padic_verifier.rb
 - lib/hensel_code/tools.rb
 - lib/hensel_code/truncated_finite_padic_expansion.rb
 - lib/hensel_code/version.rb