hensel_code 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5eaefbf55c5b467595cb52c0034036d2133f802fbd20ca63b17edef4c3ec159a
-  data.tar.gz: c1b9c4e619c032d11d1d68ca2a858b6da7286a67ac40e81c9c19b9f606f1385f
+  metadata.gz: 7109ef429b245037638da445a57e080330889ced172cdbca0402d861618742fe
+  data.tar.gz: f20970c13e3b51a34ebacaf3367072bd62ad45ad4954fa276f5352e65d1b68da
 SHA512:
-  metadata.gz: 3f55c6f2e2ec23a4eac8d098227fc630109c8d3c605b148e281f910111bbe68fbcc79e3437275639c95f808aa63612e97cac44509219431b89bb79e9164321ba
-  data.tar.gz: fd298edc25d8ea23c731727109622895a93804a39b8546598e95e19ec8b9235aba384e90c312f7215e175cb1fb0ff26d9bab8198d69554fe12cfd0e998be1986
+  metadata.gz: d0c8425fd3252229dfa7f837cfacc7a1f0de10afd9e0e5946ee86f7da23fa5ed0c826e2cff02b711834f0d37b8f13ff9c22c7aa71da342efa15e2653789252aa
+  data.tar.gz: e2a24c597c7d3fd415ef3c8ab7fd7eea11ca9ed66fbffff2b8e6055095edc1b29787e3527479a555305918d05f9b58ddea6e0d9ca75a21b8347aa48581bf7062

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.4.0] - 2022-03-29
+- Add the fourth type of supported Hensel code: the finite-segement g-adic Hensel code.
+
+## [0.3.1] - 2022-03-25
+- Fix the method `random_distinct_numbers` in `Tools` which was allowing duplicated random numbers.
+
 ## [0.3.0] - 2022-03-12
 
 - Add the `Polynomial` class for arithmetic with fixed-length polynomials

data/Gemfile

@@ -18,3 +18,5 @@ gem "rubocop-rake", "~> 0.6"
 gem "minitest-reporters", "~> 1.5"
 
 gem "codecov", require: false, group: :test
+
+gem "simplecov-console", "~>0.9", require: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hensel_code (0.3.0)
+    hensel_code (0.3.1)
       openssl (~> 3.0.0)
       prime (~> 0.1.2)
 
@@ -52,9 +52,15 @@ GEM
       docile (~> 1.1)
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
+    simplecov-console (0.9.1)
+      ansi
+      simplecov
+      terminal-table
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
     singleton (0.1.1)
+    terminal-table (3.0.2)
+      unicode-display_width (>= 1.1.1, < 3)
     unicode-display_width (2.1.0)
 
 PLATFORMS
@@ -70,6 +76,7 @@ DEPENDENCIES
   rubocop (~> 1.21)
   rubocop-minitest (~> 0.17.2)
   rubocop-rake (~> 0.6)
+  simplecov-console (~> 0.9)
 
 BUNDLED WITH
    2.3.8

data/README.md

@@ -2,7 +2,7 @@
 
 ![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.
+***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 and as many interesting features as time allows. 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. 
 
 Hensel Code allows you to homomorphically encode rational numbers as integers using the finite-segment p-adic arithmetic, also known as Hensel codes. 
 
@@ -14,6 +14,12 @@ Rao also remarks that the theory of Hensel codes, although lifted from the p-adi
 
 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.
 
+## History
+
+The theory of p-adic numbers was introduced by Kurt Hensel in the early 1900's ([Theorie der algebraischen Zahlen](https://books.google.com/books?hl=en&lr=&id=0w3vAAAAMAAJ&oi=fnd&pg=PR3&dq=Theorie+der+algebraischen+Zahlen&ots=kQfsAd0GYZ&sig=dGsTggln9njYkc2zNYT5hkk2lXU#v=onepage&q=Theorie%20der%20algebraischen%20Zahlen&f=false)). Introductions to p-adic numbers are provided by George Bachman (Introduction to p-Adic Numbers and Valuation Theory), Neal Koblitz ([P-Adic Numbers, P-Adic Analysis, and Zeta Functions](https://books.google.com/books?hl=en&lr=&id=8sTgBwAAQBAJ&oi=fnd&pg=PA1&dq=P-Adic+Numbers,+P-Adic+Analysis,+and+Zeta+Functions&ots=fWIImSqW7-&sig=29LdWtpjSkmQ2kWvVFDmmG5SsOo#v=onepage&q=P-Adic%20Numbers%2C%20P-Adic%20Analysis%2C%20and%20Zeta%20Functions&f=false)), Kurt Mahler ([Introduction to p-adic numbers and their functions](https://books.google.com/books?hl=en&lr=&id=kbc8AAAAIAAJ&oi=fnd&pg=PA1&dq=Introduction+to+P-Adic+Numbers+and+Their+Functions&ots=GFpDeD8vMG&sig=TNSPVG0YA676rlflM9CfogQP7t8)), and Fernando Gouveia ([p-adic Number](https://books.google.com/books?hl=en&lr=&id=VWjsDwAAQBAJ&oi=fnd&pg=PR5&ots=MdgpeNTWLX&sig=9LzgTUkSzN76E1EOD7wna0c8S0I#v=onepage&q&f=false)).
+
+The foundation of the particular application of finite-segement p-adic arithemetic (also known as Hensel codes) for error-free computation can be found in the works of Alparslan, Krishnamurthy, Rao, and Subramanian (Finite p-adic number systems with possible applications, [Finite segmentp-adic number systems with applications to exact computation](https://link.springer.com/article/10.1007/BF03051174), [p-Adic arithmetic procedures for exact matrix computations](https://link.springer.com/article/10.1007/BF03046725), [Error-Free Polynomial Matrix Computations](https://link.springer.com/book/10.1007/978-1-4612-5118-7)), Gregory ([Methods and Applications of Error-Free Computation](https://link.springer.com/book/10.1007/978-1-4612-5242-9), [Error-free computation with rational numbers](https://link.springer.com/article/10.1007/BF01933164), [Error-free computation with finite number systems](https://dl.acm.org/doi/abs/10.1145/1057502.1057503?casa_token=LTLotJJYEPAAAAAA:PQwNY8-RcpuSQyfCkEMv1xIpd10RlR-y7JeTWkCkYNQ3c1IroGEGzk4TVH_5JJ954sJsvcHRlTldtQ), [The use of finite-segmentp-adic arithmetic for exact computation](https://link.springer.com/article/10.1007/BF01930898)), Miola ([Algebraic approach to p-adic conversion of rational numbers](https://www.sciencedirect.com/science/article/abs/pii/002001908490022X)), Morrison ([Parallel p-adic computation](https://www.sciencedirect.com/science/article/abs/pii/0020019088901597)). Many algorithms, ideas, and concepts in Hensel codes are greatly benefitted by the remarkable series The Art of Computer Programming by Donald Knuth. 
+
 ## 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.
@@ -45,6 +51,7 @@ There are several types of Hensel codes in the finite-segment p-adic number theo
 1. Truncated finite-segment p-adic Hensel codes
 2. Finite-segment p-adic Hensel codes 
 3. Truncated finite-segment g-adic Hensel codes
+4. Finite-segmenet g-adic Hensel codes
 
 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.
 
@@ -620,7 +627,75 @@ h4.to_r
 # => (84245698732457344123/198437243845987593234524)
 ```
 
-### Class Aliases
+## Finite-segment g-adic Hensel codes
+
+### Description
+The finite-segment g-adic Hensel codes are analogous to the relationship between truncated finite p-adic expansions and finite p-adic expansions. With the finite-segement g-adic Hensel codes, we have a collection of fixed-degree univariate polynomials for each one of `k` distinct primes used to compute a g-adic Hensel code. 
+
+### Unique Benefits
+
+Finite-segement g-adic Hensel codes combine the best of two worlds: multiple independent Hensel codes which can be computed in parallel / in a distributed manner and computations using fixed-degree polynomials where for each `b`-bit prime `p_i`, the maximum expansion of all computations will take at most `1 + 2b` bits. Combining parallel/distributed computation with minimal computation expansion can be beneficial for a number of applications including massive parallel computations and egde computing. 
+
+### Usage
+```ruby
+primes = [241, 251, 257]
+r = 3
+rat1 = Rational(2,3)
+rat2 = Rational(5,9)
+h1 = HenselCode::FiniteGadicExpansion.new primes, r, rat1
+# => <HenselCode: ["81 + 80p + 80p^2", "168 + 83p + 167p^2", "172 + 85p + 171p^2"]>
+h2 = HenselCode::FiniteGadicExpansion.new primes, r, rat2
+# => <HenselCode: ["188 + 26p + 107p^2", "140 + 111p + 139p^2", "229 + 199p + 142p^2"]>
+h1.to_r
+# => (2/3)
+h2.to_r
+# => (5/9)
+h1.to_a
+# => [[81, 80, 80], [168, 83, 167], [172, 85, 171]]
+h2.to_a
+# => [[188, 26, 107], [140, 111, 139], [229, 199, 142]]
+```
+
+### Arithmetic
+```ruby
+h1_plus_h2 = h1 + h2
+# => <HenselCode: ["28 + 107p + 187p^2", "57 + 195p + 55p^2", "144 + 28p + 57p^2"]>
+h1_minus_h2 = h1 - h2
+# => <HenselCode: ["134 + 53p + 214p^2", "28 + 223p + 27p^2", "200 + 142p + 28p^2"]>
+h1_times_h2 = h1 * h2
+# => <HenselCode: ["45 + 98p + 71p^2", "177 + 241p + 92p^2", "67 + 133p + 9p^2"]>
+h1_div_h2 = h1 / h2
+# => <HenselCode: ["194 + 192p + 192p^2", "202 + 200p + 200p^2", "104 + 51p + 154p^2"]>
+h2.inverse
+# => <HenselCode: ["50 + 48p + 48p^2", "52 + 50p + 50p^2", "156 + 205p + 102p^2"]>
+h1 * h2.inverse
+# => <HenselCode: ["194 + 192p + 192p^2", "202 + 200p + 200p^2", "104 + 51p + 154p^2"]>
+h2 * h2.inverse
+# => <HenselCode: ["1 + 0p + 0p^2", "1 + 0p + 0p^2", "1 + 0p + 0p^2"]>
+```
+
+and we can check that
+
+```ruby
+h1_plus_h2.to_r
+# => (11/9)
+rat1 + rat2
+# => (11/9)
+h1_minus_h2.to_r
+# => (1/9)
+rat1 - rat2
+# => (1/9)
+h1_times_h2.to_r
+# => (10/27)
+rat1 * rat2
+# => (10/27)
+h1_div_h2.to_r
+# => (6/5)
+rat1 / rat2
+# => (6/5)
+```
+
+## Class Aliases
 
 Since some classes can have long names, here are some aliases that can be used for keeping the lines of code shorter:
 

data/hensel_code.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors = ["David William Silva"]
   spec.email = ["contact@davidwsilva.com"]
 
-  spec.summary = "Homomorphic encoding of rational numbers."
-  spec.description = "A Ruby library for homomorphically representing rational numbers as integers."
+  spec.summary = "Error-free computation with homomorphic encoding of rational numbers."
+  spec.description = "A Ruby library for error-free computation via homomorphic encoding of rational numbers as integers."
   spec.homepage = "https://github.com/davidwilliam/hensel_code"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 2.6.0"

data/lib/hensel_code/finite_gadic_expansion.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # truncated finite g-adic expansion hensel code class
+  class FiniteGadicExpansion < GAdicBase
+    def modululi
+      primes.map { |prime| prime**exponent }
+    end
+
+    def to_a
+      hensel_code.map(&:to_a)
+    end
+
+    def to_s
+      hensel_code.map(&:to_s).to_s
+    end
+
+    def inspect
+      "<HenselCode: #{self}>"
+    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::FinitePadicExpansion]
+        @hensel_code = number
+        decode
+      else
+        message = "number must be a Rational or an\
+        Array of finite p-adic Hensel codes and it was a #{number.class}"
+        raise WrongHenselCodeInputType, message
+      end
+    end
+
+    def valid_hensel_code?(new_hensel_code)
+      condition = new_hensel_code.is_a?(Array) && new_hensel_code.map(&:class).uniq == [HenselCode::FPE]
+      message = "must be an array of finite p-adic Hensel codes"
+      raise WrongHenselCodeInputType, message unless condition
+    end
+
+    def encode
+      @g = primes.inject(:*)
+      @hensel_code = primes.map do |prime|
+        FinitePadicExpansion.new prime, exponent, rational
+      end
+    end
+
+    def decode
+      hs = hensel_code.map { |h| h.to_truncated.hensel_code }
+      h = TruncatedFinitePadicExpansion.new g, exponent, crt(modululi, hs)
+      @rational = h.to_r
+    end
+  end
+end

data/lib/hensel_code/truncated_finite_gadic_expansion.rb

@@ -38,8 +38,9 @@ module HenselCode
         @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}"
+        message = "number must be a Rational or an\
+        Array of truncated p-adic Hensel codes and it was a #{number.class}"
+        raise WrongHenselCodeInputType, message
       end
     end
 

data/lib/hensel_code/version.rb

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

data/lib/hensel_code.rb

@@ -23,11 +23,13 @@ module HenselCode
   autoload  :GAdicVerifier, "hensel_code/gadic_verifier"
   autoload  :ModularArithmetic, "hensel_code/modular_arithmetic"
   autoload  :FinitePadicExpansion, "hensel_code/finite_padic_expansion"
+  autoload  :FiniteGadicExpansion, "hensel_code/finite_gadic_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
+  FPE = 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.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - David William Silva
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-25 00:00:00.000000000 Z
+date: 2022-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: openssl
@@ -38,7 +38,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.2
-description: A Ruby library for homomorphically representing rational numbers as integers.
+description: A Ruby library for error-free computation via homomorphic encoding of
+  rational numbers as integers.
 email:
 - contact@davidwsilva.com
 executables: []
@@ -56,6 +57,7 @@ files:
 - codecov
 - hensel_code.gemspec
 - lib/hensel_code.rb
+- lib/hensel_code/finite_gadic_expansion.rb
 - lib/hensel_code/finite_padic_expansion.rb
 - lib/hensel_code/gadic_base.rb
 - lib/hensel_code/gadic_verifier.rb
@@ -94,5 +96,5 @@ requirements: []
 rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
-summary: Homomorphic encoding of rational numbers.
+summary: Error-free computation with homomorphic encoding of rational numbers.
 test_files: []