hensel_code 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66cd2018d5526bcb03b76f7b36b52dc19247a819d06080e9c4eb9cdda5dfc6f0
-  data.tar.gz: 720e06f45e699a6178dc5817387b5bfedb115d9951ab767460f03519628c6aef
+  metadata.gz: 50f6a13e6cba426fca07fa46a610b85ef7fae043a4a380481cb20ab6df14de3a
+  data.tar.gz: 89ac88e608472e67fe00238d1e974462747870bf13aa6f85d2391c559656cfcf
 SHA512:
-  metadata.gz: de11ee14079125c6220e5181626f0df52574c123d8e1d43a7991d6c3c5788b9cc52ce74d050c02a0baa29367dc474b939680bbcc6a8bb374388cf8c0e51114af
-  data.tar.gz: 4cbddd470e6c5197b5c27efeed44a5e89bdce6549fa7c1dc6c79035e312e4462d9d03cf732ecfdb555e13484db83300d948d14d7de1a6f31608cfbe00dce0674
+  metadata.gz: d67e6bdb32a0a1c70fecc6b00a6d5a3e7b7a6ca426446b02c9b44e3c84f059dccf79e17d6567013ec61f2ddb2641fdc41f34b0887dc36bc287cba89452329398
+  data.tar.gz: 7f4c9d9deb9edb968e99ad1c67e7cb597789169af91c6c83c9c1288990c531d7fcd732065cd71ce4a7f3cb6fd364667d2cd92932a5c20a4b0dad89bdf0b088d7

data/.codecov.yml

@@ -0,0 +1,6 @@
+coverage:
+  status:
+    project:
+      default:
+        target: 99%    # the required coverage value
+        threshold: 1%  # the leniency in hitting the target

data/CHANGELOG.md

@@ -1,5 +1,29 @@
-## [Unreleased]
+## [0.3.0] - 2022-03-12
 
-## [0.1.0] - 2022-03-01
+- Add the `Polynomial` class for arithmetic with fixed-length polynomials
+- Change the class `TruncatedFinitePadicExpansion` for carrying all computaitons over fixed-length polynomials reduced modulo `p`
+- Add the third type of supported Hensel code: the truncated finite-segment g-adic Hensel code.
+- Add `GAdicBase` as the parent class of `TruncatedFiniteGadicExpansion`.
+- Allow converting a finite-segment p-adic Hensel code into a truncated p-adic Hensel code.
+- Add the Chinese Remainder Theorem algorithm (CRT) to the module `Tools`
+- Improve helpers for generating distinct random numbers (integers, primes, and rationals)
+- Add the inverse function for all three currently supported types of Hensel codes
+- Overall improvements in the code
+
+## [0.2.1] - 2022-03-05
+- Fix version build
+
+## [0.2.0] - 2022-03-05
+
+- Add the second type of supported Hensel code: the finite-segment p-adic Hensel code.
+- Allow converting a finite-segment p-adic Hensel code into a truncated p-adic Hensel code.
+- Support all four arithemtic operations.
+- Add `PAdicBase` as the parent class of `FinitePadicExpansion` and `TruncatedFinitePadicExpansion`.
+
+
+## [0.1.0] - 2022-03-03
 
 - Initial release
+- Contain general tools for integer manipulation such us random number generation, random integer generation, extended gcd, and modular multiplicative inverse.
+- Add the first type of supported Hensel code: the truncated finite-segment p-adic expansion Hensel code or simply truncated p-adic Hensel code.
+- Allow encoding rational numbers with the classs `TruncatedFinitePadicExpansion` and perform all four basic arithmetic operations on truncated p-adic Hensel codes: addition, subtraction, multiplication, and division.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hensel_code (0.2.1)
+    hensel_code (0.3.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -2,12 +2,18 @@
 
 ![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)
 
+***NOTICE:*** this README is beign constantly updated. I am currently focused on coding since I want to release as many different types of Hensel codes as possible. At the same time, I want this README to be as informative as possible even for those completely unfamiliar with p-adic numbers and Hensel codes. Therefore, even not in the pace I would want, I will continue to add information to the README to facilitate the use of the gem and to give some practical ideas of the computational possibilities enabled by it.
+
 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.
 
+Ç. K. Koç remarks that the p-adic arithmetic allows error-free representation of fractions and error-ree arithmetic using fractions where infinite-precision p-adic arithemtic is more suitable for software implementation and finite-precision p-adic arithmetic is more suitable for hardware implementations.
+
+A p-adic number can be uniquely written as a inifite p-adic expansion, for `p` prime, where the associated coefficients are integers between `0` and `p - 1`. When this p-adic expansion is finite in length, then we have a finite-segment p-adic expansion. When we only consider the constant term of a p-adic expansion, then we have a truncated finite-segment p-adic expansion. There many types of representations of rationals lifted from the p-adic number theory, and therefore many types of Hensel codes.
+
 ## 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.
@@ -32,22 +38,43 @@ Or install it yourself as:
 
     $ gem install hensel_code
 
-# Usage
+# HenselCode
+
+There are several types of Hensel codes in the finite-segment p-adic number theory. There are currently three of them available in the gem HenselCode: 
 
-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
+2. Finite-segment p-adic Hensel codes 
+3. Truncated finite-segment g-adic Hensel codes
 
-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)
+For each type of supported Hensel code I will briefly discuss their properties and capabilities as well as unique features that make each type of Hensel code distinct from each other.
 
 ## Truncated finite-segment p-adic Hensel codes
 
+### Description
+
+The truncated finite-segment p-adic Hensel codes are integer representations of rationals with respect to a prime `p` and a positive exponent `r`. This integer representation of any given rational is equivalent to a constant term of the finite-segment p-adic expansion that represents that rational.
+
+### Unique Benefits
+
+The truncated finite-segment p-adic Hensel codes are the simplest type of Hensel codes and the easiest ones to perform computations on it. Given a prime `p` and an exponent `r`, Hensel codes are integers between `0` and `p^r - 1`. In Ruby, as in many other modern scripting languages, integers can be arbitarily large, and therefore `p` can be as large as computationally affordable. Addition, subtraction, multiplication, and division on Hensel codes are simply these operations modulo `p^r`. Encoding and decoding are also straightforward. Its use is ideal for applications with very large numbers and/or many consecutive homomorphic computations on Hensel codes, which can be achieved with the efficincy of computations over the integers.
+
+### Usage
+
 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:
 
 ```ruby
 h1 = HenselCode::TruncatedFinitePadicExpansion.new(p, r, rat1)
-# => [HenselCode: 13579675, prime: 257, exponent: 3, modulus: 16974593]
+# => <HenselCode: 13579675>
 h2 = HenselCode::TruncatedFinitePadicExpansion.new(p, r, rat1)
-# => [HenselCode: 5658199, prime: 257, exponent: 3, modulus: 16974593]
+# => <HenselCode: 5658199>
+h1.n
+# => 2913
+h1.prime
+# => 257
+h1.exponent
+# => 3
+h1.modulus
+# => 16974593
 h1.class
 # => HenselCode::TruncatedFinitePadicExpansion
 h2.class
@@ -62,9 +89,19 @@ Now we can carry arithmetic computations on the `h1` and `h2` objects as if we w
 
 ```ruby
 h1_plus_h2 = h1 + h2
+# => <HenselCode: 2263281>
 h1_minus_h2 = h1 - h2
+# => <HenselCode: 7921476>
 h1_times_h2 = h1 * h2
+# => <HenselCode: 6789838>
 h1_div_h2 = h1 / h2
+# => <HenselCode: 5941108>
+h2.inverse
+# => <HenselCode: 4243649>
+h1 * h2.inverse
+# => <HenselCode: 5941108>
+h2 * h2.inverse
+# => <HenselCode: 1>
 ```
 
 All the computations are reduced modulo `p^r`.
@@ -106,7 +143,7 @@ To help you in this decision, given any Hensel code object `h`, you can check `h
 
 ```ruby
 h = HenselCode::TruncatedFinitePadicExpansion.new p, r, Rational(2,3)
-# => [HenselCode: 11316396, prime: 257, exponent: 3, modulus: 16974593]
+# => <HenselCode: 11316396>
 h.n
 # => 2913
 ```
@@ -120,7 +157,7 @@ If `p = 7` and `r = 2`, then `n = 4`. If I try to encode a rational number `rat
 ```ruby
 rat = Rational(11,23)
 h = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat
-# => [HenselCode: 9, prime: 7, exponent: 2, modulus: 49]
+# => <HenselCode: 9>
 h.to_r
 # => (-4/5)
 ```
@@ -131,11 +168,11 @@ The same occurs with computation on Hensel codes. If `rat1 = Rational(2,3)` and
 
 ```ruby
 h1 = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat1
-# => [HenselCode: 17, prime: 7, exponent: 2, modulus: 49]
+# => <HenselCode: 17>
 h2 = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat2
-# => [HenselCode: 13, prime: 7, exponent: 2, modulus: 49]
+# => <HenselCode: 13>
 h1_plus_h2 = h1 + h2
-# => [HenselCode: 30, prime: 7, exponent: 2, modulus: 49]
+# => <HenselCode: 30>
 h1_plus_h2.to_r
 # => (3/5)
 ```
@@ -146,11 +183,11 @@ 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]
+# => <HenselCode: 122212127593296>
 h2 = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat2
-=> [HenselCode: 137488643542458, prime: 56807, exponent: 3, modulus: 183318191389943]
+# => <HenselCode: 137488643542458>
 h1_plus_h2 = h1 + h2
-=> [HenselCode: 76382579745811, prime: 56807, exponent: 3, modulus: 183318191389943]
+# => <HenselCode: 76382579745811>
 h1_plus_h2.to_r
 # => (17/12)
 ```
@@ -170,7 +207,7 @@ p = 25
 r = 3
 rat1 = Rational(1,2)
 h1 = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat1
-# => [HenselCode: 7813, prime: 25, exponent: 3, modulus: 15625]
+# => <HenselCode: 7813>
 h1.to_r
 # => (1/2)
 ```
@@ -192,13 +229,13 @@ In order to operate on two or more Hensel codes, they all must be of the same ob
 
 ```ruby
 h1 = HenselCode::TruncatedFinitePadicExpansion.new(p1, r1, rat1)
-# => [HenselCode: 5599009, prime: 241, exponent: 3, modulus: 13997521]
+# => <HenselCode: 5599009>
 h2 = HenselCode::TruncatedFinitePadicExpansion.new(p1, r2, rat1)
-# => [HenselCode: 1349361025, prime: 241, exponent: 4, modulus: 3373402561]
+# => <HenselCode: 1349361025>
 h3 = HenselCode::TruncatedFinitePadicExpansion.new(p2, r1, rat1)
-# => [HenselCode: 6325301, prime: 251, exponent: 3, modulus: 15813251]
+# => <HenselCode: 6325301>
 h4 = HenselCode::TruncatedFinitePadicExpansion.new(p2, r2, rat1)
-# => [HenselCode: 1587650401, prime: 251, exponent: 4, modulus: 3969126001]
+# => <HenselCode: 1587650401>
 ```
 
 The following operations will raise exceptions:
@@ -221,7 +258,7 @@ Let `p = 541`, `r = 3`, `rat = Rational(11,5)`. We create a Hensel code as befor
 
 ```ruby
 h = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat
-# => [HenselCode: 126672339, prime: 541, exponent: 3, modulus: 158340421]
+# => <HenselCode: 126672339>
 ```
 
 We can change the prime and the exponent:
@@ -230,9 +267,9 @@ We can change the prime and the exponent:
 p = 1223
 r = 4
 h.replace_prime(p)
-# => [HenselCode: 731710629, prime: 1223, exponent: 3, modulus: 1829276567]
+# => <HenselCode: 731710629>
 h.replace_exponent(r)
-# => [HenselCode: 1789764193155, prime: 1223, exponent: 4, modulus: 2237205241441]
+# => <HenselCode: 1789764193155>
 ```
 
 Any change in the prime and/or the exponent of a Hensel code object will change the Hensel code value and the modulus as well, however, the Hensel code object continues to refer to represent the same rational number:
@@ -247,7 +284,7 @@ We can also change the rational number:
 ```ruby
 rat = Rational(13,7)
 h.replace_rational(rat)
-# => [HenselCode: 1278402995111, prime: 1223, exponent: 4, modulus: 2237205241441]
+# => <HenselCode: 1278402995111>
 h.to_r
 # => (13/7)
 ```
@@ -256,6 +293,7 @@ We can initiate a Hensel code object with its Hensel code value, instead of a ra
 
 ```ruby
 h = HenselCode::TruncatedFinitePadicExpansion.new p, r, 53673296543
+# => <HenselCode: 53673296543>
 ```
 
 and then we can check what is the rational number represented by the resulting object:
@@ -269,18 +307,100 @@ We can update the Hensel code value of an existing Hensel code object:
 
 ```ruby
 h.replace_hensel_code(38769823656)
-# => (-685859/94809)
+# => <HenselCode: 38769823656>
+```
+
+## Polynomials
+
+In order to support finite-segment p-adic Hensel codes, the HenselCode gem offers an engine for computing fixed-length polynomials where all the computations ared reduced modulo `p`.
+
+Let `p = 257`. We intantiate polynomials as follows:
+
+```ruby
+f = HenselCode::Polynomial.new p, [29, 102, 232]
+# => <Polynomial: 29 + 102p + 232p^2>
+g = HenselCode::Polynomial.new p, [195, 83, 244]
+# => <Polynomial: 195 + 83p + 244p^2>
+f.prime
+# => 257
+f.coefficients
+# => [29, 102, 232]
+f.degree
+# => 2
+puts f
+# => 29 + 102p + 232p^2
+```
+
+### Arithmetic
+
+All the mathematical oeprations objects of the `Polynomial` are over fixed-length single-variable polynomails in non-standard form (the terms are in ascending order with respect to their degrees). All the computation on the polynomial coefficients are reduced modulo `p` in every single step of unitary calculations, that is, no indivudal step of computation exceeds an addition followed by a binary multiplication in which the operands are bounded by `p` (a carry + a product of two integers). Therefore, if `p` has bit length `b`, the maximum space required for expanding the result of each step of computation is `1 + 2b` bits.
+
+```ruby
+f + g
+# => <Polynomial: 224 + 185p + 219p^2>
+f - g
+# => <Polynomial: 91 + 18p + 245p^2>
+f * g
+# => <Polynomial: 1 + 217p + 216p^2>
+f / g
+# => <Polynomial: 70 + 238p + 233p^2>
+g.inverse
+# => <Polynomial: 29 + 234p + 219p^2
+f * g.inverse
+# => <Polynomial: 70 + 238p + 233p^2>
+g * g.inverse
+# => <Polynomial: 1 + 0p + 0p^2>
+```
+
+### Constraints
+
+Operations with fixed-length polynomials require operands with the same degree:
+
+```ruby
+f = HenselCode::Polynomial.new p, [29, 102, 232]
+# => <Polynomial: 29 + 102p + 232p^2>
+g = HenselCode::Polynomial.new p, [195, 83, 244, 99]
+# => <Polynomial: 195 + 83p + 244p^2 + 99p^3>
+f.degree
+# => 2
+g.degree
+# => 3
+f + g
+# => polynomials must have same degree (HenselCode::WrongHenselCodeInputType)
+```
+
+Operations with fixed-length polynomials also require operands with the same prime:
+
+```ruby
+f = HenselCode::Polynomial.new 251, [133, 206, 58]
+# => <Polynomial: 133 + 206p + 58p^2>
+g = HenselCode::Polynomial.new 257, [105, 129, 238]
+# => <Polynomial: 105 + 129p + 238p^2>
+f + g
+# => polynomials must have same prime (HenselCode::WrongHenselCodeInputType)
+g.prime = 251
+# => 251
+f + g
+# => <Polynomial: 238 + 84p + 46p^2>
 ```
 
 ## 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`.
+### Description
+The finite-segment p-adic Hensel code is a p-adic integer that can be seen as a polynomial of degree `r - 1` in non-standard form (increasing degree order). Each coefficient of such polynomials are called *p-adic digits* ranging from `0` to `p - 1`. Computations on p-adic digits reduced modulo `p` must take the *carry* into consideration so we can guarantee that the results of addition, subtraction, multiplication, and division also range from `0` to `p - 1`.
+
+### Unique Benefits
+The finite-segment p-adic Hensel code takes advantage of the finite-segmenet p-adic number system in which we can compute all four basic arithemtic operations (and consequently, any function) without requiring a substantial expansion in space for each individual computation. In fact, as mentioned in the section on Polynomials, given a prime `p` of bit length `b`, all unitary computations will take at most `1 + 2b` bits.
+
+In Ruby, as is several other scripting languages, we can work with arbitrarily large integers and therefore the truncated p-adic Hensel code can be a good choice for representing large rational numbers. However, Ruby can run in a variety of systems, some of which will have limited resources, such as many instances in the IoT world. Additionally, a Ruby application can be one amongts many other components that together compose a larger application. Some of these other components might run in systems with integers limited to small bit lengths, say, 16. This is where finite-segment p-adic Hensel codes can be intrumental by allowing arbitrarily large p-adic expansions with coefficients bounded to a small prime. 
+
+### Usage
 
 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]
+# => <HenselCode: 240 + 119p + 239p^2>
 puts h1
 # => 240 + 119p + 239p^2
 ```
@@ -289,26 +409,26 @@ We say that `h` is a p-adic number with `r` digits. We clearly see the correspon
 
 ```ruby
 h2 = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat
-# => [HenselCode: 240, prime: 359, exponent: 1, modulus: 359]
+# => <HenselCode: 240>
 ```
 
 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]
+# => <HenselCode: 240>
 ```
 
-The following expressions are equivalent:
+The following expressions are equivalent (they represent the same quantity):
 
 ```ruby
 r = 3
 h1 = HenselCode::FinitePadicExpansion.new p, r, rat
-# => [HenselCode: 240 + 119p + 239p^2, prime: 359, exponent: 3, modulus: 359]
+# => <HenselCode: 240 + 119p + 239p^2>
 h1.to_r
 # => (2/3)
 h2 = HenselCode::TruncatedFinitePadicExpansion.new p, r, rat
-# => [HenselCode: 30845520, prime: 359, exponent: 3, modulus: 46268279]
+# => <HenselCode: 30845520>
 h2.to_r
 # => (2/3)
 ```
@@ -326,7 +446,7 @@ We can obtain the truncated version of `h1` as follows:
 
 ```ruby
 h1.to_truncated
-# => [HenselCode: 30845520, prime: 359, exponent: 3, modulus: 46268279]
+# => <HenselCode: 30845520>
 h1.to_truncated.class
 # => HenselCode::TruncatedFinitePadicExpansion
 ```
@@ -337,22 +457,28 @@ Let `p = 409`, `r = 5`, `rat1 = Rational(2,3)` and `rat2 = Rational(11,7)` such
 
 ```ruby
 h1 = HenselCode::FinitePadicExpansion.new p, r, rat1
-# => [HenselCode: 137 + 136p + 136p^2 + 136p^3 + 136p^4, prime: 409, exponent: 5, modulus: 409]
+# => <HenselCode: 137 + 136p + 136p^2 + 136p^3 + 136p^4>
 h2 = HenselCode::FinitePadicExpansion.new p, r, rat2
-# => [HenselCode: 60 + 292p + 233p^2 + 350p^3 + 116p^4, prime: 409, exponent: 5, modulus: 409]
+# => <HenselCode: 60 + 292p + 233p^2 + 350p^3 + 116p^4>
 ```
 
 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_plus_h2 = h1 + h2
+# => <HenselCode: 197 + 19p + 370p^2 + 77p^3 + 253p^4>
 h1_minus_h2 = h1 - h2
-# => [HenselCode: 77 + 253p + 311p^2 + 194p^3 + 19p^4, prime: 409, exponent: 5, modulus: 409]
+# => <HenselCode: 77 + 253p + 311p^2 + 194p^3 + 19p^4>
 h1_times_h2 = h1 * h2
-# => [HenselCode: 40 + 331p + 155p^2 + 97p^3 + 214p^4, prime: 409, exponent: 5, modulus: 409]
+# => <HenselCode: 40 + 331p + 155p^2 + 97p^3 + 214p^4>
 h1_div_h2 = h1 / h2
-# => [HenselCode: 50 + 161p + 12p^2 + 347p^3 + 309p^4, prime: 409, exponent: 5, modulus: 409]
+# => <HenselCode: 50 + 161p + 12p^2 + 347p^3 + 309p^4>
+h2.inverse
+# => <HenselCode: 75 + 37p + 223p^2 + 111p^3 + 260p^4>
+h1 * h2.inverse
+# => <HenselCode: 50 + 161p + 12p^2 + 347p^3 + 309p^4>
+h2 * h2.inverse
+# => <HenselCode: 1 + 0p + 0p^2 + 0p^3 + 0p^4>
 ```
 
 And we can verify that
@@ -376,9 +502,131 @@ rat1 / rat2
 # => (14/33)
 ```
 
-### Class Alias
+## Truncated finite-segment g-adic Hensel codes
+### Description
+Kurt Mahler refers to p-adic numbers based on multiple distinct primes as `g-adic numbers` (Lectures on Diophantine Approximations, 1961 and Introduction to p-adic Numbers and Their Functions, 1973). John F. Morrison, 1988, remarks that `g` is the product of `k` distinct primes, which are used to generate a g-adic number with a unique g-adic representation. 
+
+### Unique Benefits
+
+Since each digit of a truncated finite-segment g-adic Expansion (or simply truncated g-adic Hensel codes) is independently computed with respect to their corresponding prime, we can carry computations on each digit also independetly. This makes the truncated g-adic Hensel codes ideal for parallel/distributed processing, that is, given a rational number, several g-adic digits of that rational are independently computed and computations can be carried on those digits, also indpendently. 
+
+### Usage
+
+Let `primes = [241, 251, 257]`, `r = 3`, `rat1 = Rational(2,3)`, and `rat2 = Rational(5,4)`:
+
+```ruby
+h1 = HenselCode::TruncatedFiniteGadicExpansion.new primes, r, rat1
+# => <HenselCode: [4665841, 10542168, 11316396]>
+h2 = HenselCode::TruncatedFiniteGadicExpansion.new primes, r, rat2
+# => <HenselCode: [10498142, 3953314, 12730946]>
+h1.primes
+# => [241, 251, 257]
+h1.exponent
+# => 3
+h1.g
+# => 15546187
+h1.n
+# => 43343186168
+h1.hensel_code
+# => [<HenselCode: 4665841>, <HenselCode: 10542168>, <HenselCode: 11316396>]
+h1.to_r
+# => (2/3)
+h2.to_r
+# => (5/4)
+```
+
+### Arithmetic
+
+We compute addition, subtraction, multiplication, and division as follows:
+
+```ruby
+h1_plus_h2 = h1 + h2
+# => <HenselCode: [1166462, 14495482, 7072749]>
+h1_minus_h2 = h1 - h2
+# => <HenselCode: [8165220, 6588854, 15560043]>
+h1_times_h2 = h1 * h2
+# => <HenselCode: [2332921, 13177710, 14145495]>
+h1_div_h2 = h1 / h2
+# => <HenselCode: [6532177, 2108434, 15842954]>
+h2.inverse
+# => <HenselCode: [2799505, 3162651, 6789838]>
+h1 * h2.inverse
+# => <HenselCode: [6532177, 2108434, 15842954]>
+h2 * h2.inverse
+# => <HenselCode: [1, 1, 1]>
+```
+
+And we can verify that
+
+```ruby
+h1_plus_h2.to_r
+# => (23/12)
+rat1 + rat2
+# => (23/12)
+rat1 - rat2
+# => (-7/12)
+h1_minus_h2.to_r
+# => (-7/12)
+h1_times_h2.to_r
+# => (5/6)
+rat1 * rat2
+# => (5/6)
+h1_div_h2.to_r
+# => (8/15)
+rat1 / rat2
+# => (8/15)
+```
+
+### Relatable, and yet, Unique
+
+When we execute the following:
+
+```ruby
+h1.hensel_code
+# => [<HenselCode: 4665841>, <HenselCode: 10542168>, <HenselCode: 11316396>]
+```
+
+it is clear that the truncated g-adic Hensel code is a collection of individual Hensel codes, each one computed for the same rational but with distinct primes. One can be tempted to think that these multiple independent Hensel codes are "extra" material, not really needed for representing the given rational. This is far from the truth. Besides enabling parallel/distributed computaitons over Hensel codes (which is already a great benefit to have), to illustrate another aspect of working with truncated g-adic Hensel codes, consider the rational `rat3 = Rational(37897,52234)`:
+
+```ruby
+h3 = HenselCode::TruncatedFiniteGadicExpansion.new primes, r, rat3
+# => <HenselCode: [3698890, 5577355, 7406440]>
+h3.hensel_code
+# => [<HenselCode: 3698890>, <HenselCode: 5577355>, <HenselCode: 7406440>]
+```
+
+We can clearly see that each Hensel code in the truncated g-adic Hensel code is only a partial representation of `rat3` when we decode each individual Hensel code to see which rational they are representing:
+
+```ruby
+h3.hensel_code.map(&:to_r)
+# => [(1471/4613), (409/981), (-207/3298)]
+```
+
+None of the above rationals equals `rat3`. The reason is that each individual prime in `primes` are insufficient for representing `rat3` and therefore they can only, individually, partially represent `rat3`. However, when considered as part of the same g-adic number system, they can jointly represent much larger rationals, yet independently:
+
+```ruby
+h3.to_r
+ => (37897/52234)
+```
+
+Therefore, even without increasing the size of each individual prime, we can homomorphically represent very large rationals by considering more primes in the g-adic system:
+
+```ruby
+rat4 = Rational(84245698732457344123,198437243845987593234524
+primes = [349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409]
+h4 = HenselCode::TruncatedFiniteGadicExpansion.new primes, r, rat4
+# => HenselCode: [16442637, 10524943, 2432723, 10742241, 37389750, 10164016, 7690494, 32341841, 26459590, 50463786, 28362831]>
+h4.to_r
+# => (84245698732457344123/198437243845987593234524)
+```
+
+### Class Aliases
+
+Since some classes can have long names, here are some aliases that can be used for keeping the lines of code shorter:
 
-Since `HenselCode::TruncatedFinitePadicExpansion` is a bit long, the alias `HenselCode::TFPE` can be used instead.
+- `HenselCode::TruncatedFinitePadicExpansion` => `HenselCode::TFPE`
+- `HenselCode::HenselCodesWithDifferentPrimesAndExponents` => `HenselCode::HCWDPAE`
+- `HenselCode::WrongHenselCodeInputType` => `HenselCode::WHIT`
 
 ## Coming Soon
 
@@ -396,4 +644,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/davidw
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/hensel_code/finite_padic_expansion.rb

@@ -3,6 +3,8 @@
 module HenselCode
   # finite p-adic expansion hensel code class
   class FinitePadicExpansion < PAdicBase
+    attr_accessor :polynomial
+
     def modulus
       prime
     end
@@ -22,26 +24,25 @@ module HenselCode
     end
 
     def inspect
-      "[HenselCode: #{polynomial_form}, prime: #{prime}, exponent: #{exponent}, modulus: #{modulus}]"
+      "<HenselCode: #{polynomial_form}>"
     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 }
+    def inverse
+      new_hensel_code = polynomial.inverse.coefficients
       self.class.new prime, exponent, new_hensel_code
     end
 
-    def polynomial_variable(index)
-      i = index > 1 ? 2 : index
-      ["", "p", "p^#{index}"][i]
-    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
@@ -66,8 +67,8 @@ module HenselCode
     end
 
     def encode
-      h_ = TruncatedFinitePadicExpansion.new(prime, exponent, rational).hensel_code
-      @hensel_code = (0..exponent - 1).map { |i| h_ / (prime**i) % prime }
+      @hensel_code = rational_to_padic_digits
+      @polynomial = Polynomial.new prime, hensel_code
     end
 
     def decode
@@ -75,5 +76,31 @@ module HenselCode
       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

@@ -10,11 +10,13 @@ module HenselCode
     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
@@ -69,6 +71,11 @@ module HenselCode
 
     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]

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

data/lib/hensel_code/truncated_finite_padic_expansion.rb

@@ -16,7 +16,12 @@ module HenselCode
     end
 
     def inspect
-      "[HenselCode: #{hensel_code}, prime: #{prime}, exponent: #{exponent}, modulus: #{modulus}]"
+      "<HenselCode: #{hensel_code}>"
+    end
+
+    def inverse
+      new_hensel_code = mod_inverse(hensel_code, modulus)
+      self.class.new prime, exponent, new_hensel_code
     end
 
     private

data/lib/hensel_code/version.rb

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

data/lib/hensel_code.rb

@@ -13,12 +13,18 @@ module HenselCode
   class HenselCodesWithDifferentPrimesAndExponents < StandardError; end
   class HenselCodesWithDifferentExponents < StandardError; end
   class IncompatibleOperandTypes < StandardError; end
+  class NonInitializableClass < StandardError; end
 
   autoload  :Tools, "hensel_code/tools"
   autoload  :PAdicBase, "hensel_code/padic_base"
+  autoload  :GAdicBase, "hensel_code/gadic_base"
+  autoload  :Polynomial, "hensel_code/polynomial"
   autoload  :PAdicVerifier, "hensel_code/padic_verifier"
+  autoload  :GAdicVerifier, "hensel_code/gadic_verifier"
+  autoload  :ModularArithmetic, "hensel_code/modular_arithmetic"
   autoload  :FinitePadicExpansion, "hensel_code/finite_padic_expansion"
   autoload  :TruncatedFinitePadicExpansion, "hensel_code/truncated_finite_padic_expansion"
+  autoload  :TruncatedFiniteGadicExpansion, "hensel_code/truncated_finite_gadic_expansion"
 
   # aliases for classes with long names
   TFPE = TruncatedFinitePadicExpansion

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hensel_code
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - David William Silva
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-05 00:00:00.000000000 Z
+date: 2022-03-13 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby library for homomorphically representing rational numbers as integers.
 email:
@@ -17,6 +17,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codecov.yml"
 - ".rubocop.yml"
 - CHANGELOG.md
 - Gemfile
@@ -27,9 +28,14 @@ files:
 - codecov
 - lib/hensel_code.rb
 - lib/hensel_code/finite_padic_expansion.rb
+- lib/hensel_code/gadic_base.rb
+- lib/hensel_code/gadic_verifier.rb
+- lib/hensel_code/modular_arithmetic.rb
 - lib/hensel_code/padic_base.rb
 - lib/hensel_code/padic_verifier.rb
+- lib/hensel_code/polynomial.rb
 - lib/hensel_code/tools.rb
+- lib/hensel_code/truncated_finite_gadic_expansion.rb
 - lib/hensel_code/truncated_finite_padic_expansion.rb
 - lib/hensel_code/version.rb
 - sig/hensel_code.rbs