hensel_code 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50f6a13e6cba426fca07fa46a610b85ef7fae043a4a380481cb20ab6df14de3a
-  data.tar.gz: 89ac88e608472e67fe00238d1e974462747870bf13aa6f85d2391c559656cfcf
+  metadata.gz: 9fe4ccc09920268da571091821a4f4c3d05be182a9c54807099e97710a6c25b3
+  data.tar.gz: de54128ac780eea4fae8f739216b35da2912a42f739f9fd0e66bd09738c9109c
 SHA512:
-  metadata.gz: d67e6bdb32a0a1c70fecc6b00a6d5a3e7b7a6ca426446b02c9b44e3c84f059dccf79e17d6567013ec61f2ddb2641fdc41f34b0887dc36bc287cba89452329398
-  data.tar.gz: 7f4c9d9deb9edb968e99ad1c67e7cb597789169af91c6c83c9c1288990c531d7fcd732065cd71ce4a7f3cb6fd364667d2cd92932a5c20a4b0dad89bdf0b088d7
+  metadata.gz: 8a08b73aeec51d006064ab31ea7324ab3d2cc8f82cecb866b3fe81432eb710045be9b0b77d6da01b624f8a102b2aa06765b8b231dff6e6c01602a10603e40081
+  data.tar.gz: 55380ace482bbbafcca376d87ab48db7061efe2a263195cc4627f078afe307800a2cb12a82e59ba7e41c291ce2c28f55db0232bcd57e3c5884ac8ca848a6e61e

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

@@ -17,6 +17,6 @@ gem "rubocop-rake", "~> 0.6"
 
 gem "minitest-reporters", "~> 1.5"
 
-gem "prime", "~> 0.1.2"
-
 gem "codecov", require: false, group: :test
+
+gem "simplecov-console", "~>0.9", require: false

data/Gemfile.lock

@@ -1,7 +1,9 @@
 PATH
   remote: .
   specs:
-    hensel_code (0.3.0)
+    hensel_code (0.4.1)
+      openssl (~> 3.0.0)
+      prime (~> 0.1.2)
 
 GEM
   remote: https://rubygems.org/
@@ -19,6 +21,7 @@ GEM
       builder
       minitest (>= 5.0)
       ruby-progressbar
+    openssl (3.0.0)
     parallel (1.21.0)
     parser (3.1.1.0)
       ast (~> 2.4.1)
@@ -49,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
@@ -63,11 +72,11 @@ DEPENDENCIES
   hensel_code!
   minitest (~> 5.0)
   minitest-reporters (~> 1.5)
-  prime (~> 0.1.2)
   rake (~> 13.0)
   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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "lib/hensel_code/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "hensel_code"
+  spec.version = HenselCode::VERSION
+  spec.authors = ["David William Silva"]
+  spec.email = ["contact@davidwsilva.com"]
+
+  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."
+  spec.homepage = "https://github.com/davidwilliam/hensel_code"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/davidwilliam/hensel_code"
+  spec.metadata["changelog_uri"] = "https://github.com/davidwilliam/hensel_code/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "openssl", "~> 3.0.0"
+  spec.add_dependency "prime", "~> 0.1.2"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.metadata["rubygems_mfa_required"] = "true"
+end

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/tools.rb

@@ -40,7 +40,7 @@ module HenselCode
       numbers = [send("random_#{type}", bits)]
       while numbers.size < quantity
         number = send("random_#{type}", bits)
-        numbers << number if number != numbers.last
+        numbers << number unless numbers.include?(number)
       end
       numbers
     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.0"
+  VERSION = "0.4.1"
 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,16 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: hensel_code
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - David William Silva
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-13 00:00:00.000000000 Z
-dependencies: []
-description: A Ruby library for homomorphically representing rational numbers as integers.
+date: 2022-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: prime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+description: A Ruby library for error-free computation via homomorphic encoding of
+  rational numbers.
 email:
 - contact@davidwsilva.com
 executables: []
@@ -26,7 +55,9 @@ files:
 - README.md
 - Rakefile
 - 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
@@ -65,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: []