rh_math 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 860730b2a69b5d2063e5d069f4aca61fac3bdf9599691ef3c3ae02bb93f3b724
+  data.tar.gz: 043745b23d8c68e8edb4dfe21e4d20a19039775ca8fc02b64b438751afc24bbe
+SHA512:
+  metadata.gz: bf61ee583de0bbe1ab09fed6094d25837718cdc8a6a82d7d737e9e34d69858c2b058619b7c01a597e7cd6b7b3670ca7bb7be6c6c5e740e50c7342d27306642d9
+  data.tar.gz: 5f276317ecffecb86f0b6c565c137b2447567e87327957faa26135c439fb1a286e209bf6a119362c91a090368eb6bde8e86a8180adf87467421620bce0243040

data/CITATION.cff

@@ -0,0 +1,12 @@
+cff-version: 1.2.0
+title: rh_math
+message: "If you use this software, please cite it as below."
+type: software
+authors:
+  - family-names: Bass
+    given-names: Tim
+    email: tim@unix.com
+repository-code: "https://github.com/unixneo/rh_math"
+license: MIT
+version: 0.1.0
+date-released: 2026-04-09

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,255 @@
+# rh_math
+
+## Status and Scope
+
+This is a research-oriented, partial implementation focused on bounded evaluation of selected analytic number theory results (for example, Schoenfeld 1976 bounds and real `zeta(s)` for `s > 1`).
+
+It is **not** a general-purpose number theory library.
+
+The implementation is intentionally limited, explicit, and designed to support reproducible evaluation of LLM-generated code against peer-reviewed mathematical results.
+
+`rh_math` is a pure-Ruby research gem for the `rh_llm_benchmark` project.
+
+It provides small, explicit numeric parsing and comparison utilities, plus early arithmetic/bound routines used by executable pointwise benchmark checks.
+
+## Purpose
+
+- keep computation/comparison logic outside Rails orchestration and persistence
+- provide a testable pure-Ruby layer for benchmark evaluation logic
+- support incremental, auditable growth of RH-related routines
+
+## Current Scope
+
+Implemented today:
+
+- `RhMath::NumericParser` for conservative decimal/scientific parsing to `BigDecimal`
+- `RhMath::Comparators::ExactText`
+- `RhMath::Comparators::AbsoluteTolerance`
+- arithmetic helpers:
+  - `RhMath::PrimeSupport.primes_up_to`
+  - `RhMath::ArithmeticFunctions.prime_pi`
+  - `RhMath::ArithmeticFunctions.theta`
+  - `RhMath::ArithmeticFunctions.psi`
+- Schoenfeld 1976 RHS bound helpers:
+  - `RhMath::Bounds::Schoenfeld1976.psi_rh_upper_bound`
+  - `RhMath::Bounds::Schoenfeld1976.theta_rh_upper_bound`
+  - `RhMath::Bounds::Schoenfeld1976.pi_li_rh_upper_bound`
+- pointwise evaluators:
+  - `RhMath::Evaluators::SchoenfeldPointwise.evaluate_psi_bound`
+  - `RhMath::Evaluators::SchoenfeldPointwise.evaluate_theta_bound`
+  - `RhMath::Evaluators::SchoenfeldPointwise.evaluate_pi_li_bound`
+  - validated across representative moderate-x ranges used by the harness seed corpus
+- special function:
+  - `RhMath::SpecialFunctions.li(x)`
+- bounded zeta routines:
+  - `RhMath::Zeta.zeta_real(s, terms: N)` for real `s > 1` via truncated Dirichlet series
+  - `RhMath::Zeta.zeta_real_with_error(s, terms: N)` returning value plus a rigorous truncation tail bound
+
+## Intended Use
+
+- evaluation of LLM-generated code against known mathematical bounds
+- reproducible research workflows
+- small-scale numeric validation of analytic results
+
+Not intended for:
+
+- production numerical computing
+- high-precision analytic number theory
+- large-scale prime computations
+
+## Current Non-Goals
+
+- proving or disproving RH
+- full zeta-function evaluation (complex inputs, analytic continuation, or critical-strip work)
+- zero-finding
+- symbolic theorem parsing
+- complex arithmetic support
+- production-grade high-precision analytic number theory engine
+
+## Local Development Setup
+
+From the gem repo:
+
+```bash
+cd ../rh_math
+ruby -v
+```
+
+Run tests file-by-file:
+
+```bash
+for f in test/*_test.rb; do ruby -Ilib:test "$f" || exit 1; done
+```
+
+## Reproducibility
+
+This gem is consumed by `rh_llm_benchmark` via local path dependency:
+
+```ruby
+gem "rh_math", path: "../rh_math"
+```
+
+Key commands:
+
+- gem tests: `for f in test/*_test.rb; do ruby -Ilib:test "$f" || exit 1; done`
+- zeta reporting via Rails harness: `bin/rails "demo:report_zeta_real"`
+
+## Rails Integration (Local Path)
+
+`rh_llm_benchmark` consumes this gem by local path in its `Gemfile`:
+
+```ruby
+gem "rh_math", path: "../rh_math"
+```
+
+After gem changes, run in Rails repo:
+
+```bash
+cd ../rh_llm_benchmark
+bundle install
+bin/rails runner "puts RhMath::VERSION"
+```
+
+## Public Modules and Classes
+
+- `RhMath::NumericParser`
+- `RhMath::Comparators::ExactText`
+- `RhMath::Comparators::AbsoluteTolerance`
+- `RhMath::PrimeSupport`
+- `RhMath::ArithmeticFunctions`
+- `RhMath::SpecialFunctions`
+- `RhMath::Zeta`
+- `RhMath::Bounds::Schoenfeld1976`
+- `RhMath::Evaluators::SchoenfeldPointwise`
+- `RhMath::ComparisonResult` (struct)
+- `RhMath::PointwiseResult` (struct)
+
+## Usage Examples
+
+### Numeric parsing
+
+```ruby
+require "rh_math"
+
+value = RhMath::NumericParser.parse_decimal("1.25e-3")
+# => #<BigDecimal:...,'0.125E-2',...>
+
+RhMath::NumericParser.parse_decimal("not-a-number")
+# => nil
+```
+
+### Exact text comparison
+
+```ruby
+require "rh_math"
+
+result = RhMath::Comparators::ExactText.compare(
+  reference_text: "  alpha ",
+  observed_text: "alpha"
+)
+
+result.verdict
+# => "pass"
+result.difference_text
+# => "exact match"
+```
+
+### Absolute tolerance comparison
+
+```ruby
+require "rh_math"
+
+result = RhMath::Comparators::AbsoluteTolerance.compare(
+  reference_text: "10.0",
+  observed_text: "10.12",
+  tolerance_text: "0.2"
+)
+
+result.verdict
+# => "pass"
+result.difference_text
+# => "0.12"
+```
+
+### Arithmetic functions (`prime_pi`, `theta`, `psi`)
+
+```ruby
+require "rh_math"
+
+RhMath::ArithmeticFunctions.prime_pi(10)
+# => 4
+
+RhMath::ArithmeticFunctions.theta(10)
+# => sum(log p) for p <= 10
+
+RhMath::ArithmeticFunctions.psi(10)
+# => sum(log p) over prime powers p^k <= 10
+```
+
+### `li(x)` usage
+
+```ruby
+require "rh_math"
+
+RhMath::SpecialFunctions.li(3000)
+# => Float approximation of offset logarithmic integral li(3000)
+```
+
+### `zeta_real(s, terms:)` usage (real s > 1)
+
+```ruby
+require "rh_math"
+
+approx = RhMath::Zeta.zeta_real(2.0, terms: 10_000)
+# => ~1.644834 (approaches pi^2 / 6 as terms increase)
+```
+
+### `zeta_real_with_error(s, terms:)` usage (rigorous truncation bound)
+
+```ruby
+require "rh_math"
+
+bounded = RhMath::Zeta.zeta_real_with_error(2.0, terms: 10_000)
+# => {
+#      value: 1.644834...,         # partial sum
+#      error_bound: 0.000099995...,# rigorous upper bound on tail truncation error
+#      lower_bound: value,
+#      upper_bound: value + error_bound
+#    }
+```
+
+### Schoenfeld pointwise evaluators
+
+```ruby
+require "rh_math"
+
+psi_eval = RhMath::Evaluators::SchoenfeldPointwise.evaluate_psi_bound(1000)
+psi_eval.verdict
+# => "pass" (expected for seeded benchmark path)
+
+theta_eval = RhMath::Evaluators::SchoenfeldPointwise.evaluate_theta_bound(1000)
+pi_li_eval = RhMath::Evaluators::SchoenfeldPointwise.evaluate_pi_li_bound(5000)
+
+pi_li_eval.theorem_key
+# => "schoenfeld_1976_corollary_1_eq_6_18"
+
+# Typical seeded ranges in rh_llm_benchmark:
+# psi: 100, 1000, 5000
+# theta: 700, 1000, 5000
+# pi-li: 3000, 5000, 10000, 20000
+```
+
+## Limitations and Caveats
+
+- This is research software under active development.
+- Mathematical coverage is partial and intentionally narrow.
+- `zeta_real(s, terms:)` and `zeta_real_with_error(s, terms:)` are real-domain only (`s > 1`).
+- No analytic continuation is implemented.
+- No complex arithmetic is implemented.
+- `li(x)` is a moderate-`x`, Float-based numerical routine.
+- `zeta_real_with_error(s, terms:)` provides a rigorous truncation-tail bound `N^(1-s)/(s-1)` for the partial sum; it does **not** bound floating-point roundoff error.
+- Arithmetic routines are straightforward and not optimized for large-scale computation.
+
+## Research Status Note
+
+This gem currently supports benchmark architecture validation and early executable pointwise checks. It does not yet implement full RH computation workflows.

data/lib/rh_math/arithmetic_functions.rb

@@ -0,0 +1,29 @@
+module RhMath
+  module ArithmeticFunctions
+    def self.prime_pi(n)
+      PrimeSupport.primes_up_to(n).length
+    end
+
+    def self.theta(n)
+      PrimeSupport.primes_up_to(n).sum { |p| Math.log(p) }
+    end
+
+    # Chebyshev psi: sum(log p) for each prime power p^k <= n.
+    def self.psi(n)
+      limit = Integer(n)
+      return 0.0 if limit < 2
+
+      PrimeSupport.primes_up_to(limit).sum do |prime|
+        value = prime
+        term_sum = 0.0
+
+        while value <= limit
+          term_sum += Math.log(prime)
+          value *= prime
+        end
+
+        term_sum
+      end
+    end
+  end
+end

data/lib/rh_math/bounds/schoenfeld1976.rb

@@ -0,0 +1,35 @@
+module RhMath
+  module Bounds
+    module Schoenfeld1976
+      COEFFICIENT = 1.0 / (8.0 * Math::PI)
+
+      def self.psi_rh_upper_bound(x)
+        squared_log_bound(x)
+      end
+
+      def self.theta_rh_upper_bound(x)
+        squared_log_bound(x)
+      end
+
+      # Schoenfeld 1976 Corollary 1, eq. (6.18) RHS term.
+      def self.pi_li_rh_upper_bound(x)
+        value = positive_float(x)
+        COEFFICIENT * Math.sqrt(value) * Math.log(value)
+      end
+
+      def self.squared_log_bound(x)
+        value = positive_float(x)
+        COEFFICIENT * Math.sqrt(value) * (Math.log(value)**2)
+      end
+      private_class_method :squared_log_bound
+
+      def self.positive_float(x)
+        value = Float(x)
+        raise ArgumentError, "x must be positive" unless value.positive?
+
+        value
+      end
+      private_class_method :positive_float
+    end
+  end
+end

data/lib/rh_math/comparators/absolute_tolerance.rb

@@ -0,0 +1,38 @@
+module RhMath
+  module Comparators
+    class AbsoluteTolerance
+      COMPARISON_METHOD = "absolute_tolerance_numeric".freeze
+
+      def self.compare(reference_text:, observed_text:, tolerance_text:)
+        reference_value = NumericParser.parse_decimal(reference_text)
+        observed_value = NumericParser.parse_decimal(observed_text)
+        tolerance_value = NumericParser.parse_decimal(tolerance_text)
+
+        if reference_value.nil? || observed_value.nil? || tolerance_value.nil? || tolerance_value.negative?
+          return ComparisonResult.new(
+            verdict: "error",
+            comparison_method: COMPARISON_METHOD,
+            reference_value_used_text: reference_text,
+            observed_value_text: observed_text,
+            tolerance_used_text: tolerance_text,
+            difference_text: nil,
+            notes: "Invalid numeric input for expected, observed, or tolerance text."
+          )
+        end
+
+        difference = (observed_value - reference_value).abs
+        verdict = difference <= tolerance_value ? "pass" : "fail"
+
+        ComparisonResult.new(
+          verdict: verdict,
+          comparison_method: COMPARISON_METHOD,
+          reference_value_used_text: reference_text,
+          observed_value_text: observed_text,
+          tolerance_used_text: tolerance_text,
+          difference_text: difference.to_s("F"),
+          notes: "Absolute tolerance numeric comparison using BigDecimal."
+        )
+      end
+    end
+  end
+end

data/lib/rh_math/comparators/exact_text.rb

@@ -0,0 +1,23 @@
+module RhMath
+  module Comparators
+    class ExactText
+      COMPARISON_METHOD = "demo_exact_text_match".freeze
+
+      def self.compare(reference_text:, observed_text:)
+        reference = reference_text.to_s.strip
+        observed = observed_text.to_s.strip
+        matches = reference == observed
+
+        ComparisonResult.new(
+          verdict: matches ? "pass" : "fail",
+          comparison_method: COMPARISON_METHOD,
+          reference_value_used_text: reference_text,
+          observed_value_text: observed_text,
+          tolerance_used_text: nil,
+          difference_text: matches ? "exact match" : "text differs",
+          notes: "Exact text comparator (trimmed string equality)."
+        )
+      end
+    end
+  end
+end

data/lib/rh_math/comparison_result.rb

@@ -0,0 +1,12 @@
+module RhMath
+  ComparisonResult = Struct.new(
+    :verdict,
+    :comparison_method,
+    :reference_value_used_text,
+    :observed_value_text,
+    :tolerance_used_text,
+    :difference_text,
+    :notes,
+    keyword_init: true
+  )
+end

data/lib/rh_math/evaluators/schoenfeld_pointwise.rb

@@ -0,0 +1,54 @@
+module RhMath
+  module Evaluators
+    module SchoenfeldPointwise
+      PSI_THEOREM_KEY = "schoenfeld_1976_theorem_10_eq_6_2".freeze
+      THETA_THEOREM_KEY = "schoenfeld_1976_theorem_10_eq_6_3".freeze
+      PI_LI_THEOREM_KEY = "schoenfeld_1976_corollary_1_eq_6_18".freeze
+
+      def self.evaluate_psi_bound(x)
+        integer_x = Integer(x)
+        lhs = (ArithmeticFunctions.psi(integer_x) - integer_x).abs
+        rhs = Bounds::Schoenfeld1976.psi_rh_upper_bound(integer_x)
+
+        PointwiseResult.new(
+          theorem_key: PSI_THEOREM_KEY,
+          x_value: integer_x,
+          lhs_value: lhs,
+          rhs_value: rhs,
+          verdict: lhs <= rhs ? "pass" : "fail",
+          notes: "Pointwise check of Schoenfeld 1976 Theorem 10 eq. (6.2)."
+        )
+      end
+
+      def self.evaluate_theta_bound(x)
+        integer_x = Integer(x)
+        lhs = (ArithmeticFunctions.theta(integer_x) - integer_x).abs
+        rhs = Bounds::Schoenfeld1976.theta_rh_upper_bound(integer_x)
+
+        PointwiseResult.new(
+          theorem_key: THETA_THEOREM_KEY,
+          x_value: integer_x,
+          lhs_value: lhs,
+          rhs_value: rhs,
+          verdict: lhs <= rhs ? "pass" : "fail",
+          notes: "Pointwise check of Schoenfeld 1976 Theorem 10 eq. (6.3)."
+        )
+      end
+
+      def self.evaluate_pi_li_bound(x)
+        integer_x = Integer(x)
+        lhs = (ArithmeticFunctions.prime_pi(integer_x) - SpecialFunctions.li(integer_x)).abs
+        rhs = Bounds::Schoenfeld1976.pi_li_rh_upper_bound(integer_x)
+
+        PointwiseResult.new(
+          theorem_key: PI_LI_THEOREM_KEY,
+          x_value: integer_x,
+          lhs_value: lhs,
+          rhs_value: rhs,
+          verdict: lhs <= rhs ? "pass" : "fail",
+          notes: "Pointwise check of Schoenfeld 1976 Corollary 1 eq. (6.18)."
+        )
+      end
+    end
+  end
+end

data/lib/rh_math/numeric_parser.rb

@@ -0,0 +1,16 @@
+require "bigdecimal"
+
+module RhMath
+  class NumericParser
+    NUMERIC_PATTERN = /\A[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?\z/.freeze
+
+    def self.parse_decimal(value)
+      text = value.to_s.strip
+      return nil unless NUMERIC_PATTERN.match?(text)
+
+      BigDecimal(text)
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/rh_math/pointwise_result.rb

@@ -0,0 +1,11 @@
+module RhMath
+  PointwiseResult = Struct.new(
+    :theorem_key,
+    :x_value,
+    :lhs_value,
+    :rhs_value,
+    :verdict,
+    :notes,
+    keyword_init: true
+  )
+end

data/lib/rh_math/prime_support.rb

@@ -0,0 +1,30 @@
+module RhMath
+  module PrimeSupport
+    def self.primes_up_to(n)
+      limit = Integer(n)
+      return [] if limit < 2
+
+      primes = []
+      (2..limit).each do |candidate|
+        primes << candidate if prime?(candidate)
+      end
+      primes
+    end
+
+    def self.prime?(n)
+      return false if n < 2
+      return true if n == 2
+      return false if n.even?
+
+      divisor = 3
+      while divisor * divisor <= n
+        return false if (n % divisor).zero?
+
+        divisor += 2
+      end
+
+      true
+    end
+    private_class_method :prime?
+  end
+end

data/lib/rh_math/special_functions.rb

@@ -0,0 +1,43 @@
+module RhMath
+  module SpecialFunctions
+    # Offset logarithmic integral li(x) for x > 1, implemented as:
+    # li(x) = li(2) + integral_{2}^{x} dt / log(t)
+    # using composite Simpson's rule on [2, x].
+    #
+    # This routine is intended for moderate x used by pointwise benchmark checks,
+    # not high-precision analytic number theory work.
+    LI_AT_2 = 1.0451637801174928
+
+    def self.li(x, steps: nil)
+      value = Float(x)
+      raise ArgumentError, "x must be >= 2" if value < 2.0
+      return LI_AT_2 if value == 2.0
+
+      n = steps || default_steps_for(value)
+      n += 1 if n.odd?
+
+      h = (value - 2.0) / n
+      sum = integrand(2.0) + integrand(value)
+
+      i = 1
+      while i < n
+        t = 2.0 + i * h
+        weight = i.odd? ? 4.0 : 2.0
+        sum += weight * integrand(t)
+        i += 1
+      end
+
+      LI_AT_2 + (h / 3.0) * sum
+    end
+
+    def self.integrand(t)
+      1.0 / Math.log(t)
+    end
+    private_class_method :integrand
+
+    def self.default_steps_for(x)
+      [[(x / 2.0).to_i, 2_000].max, 40_000].min
+    end
+    private_class_method :default_steps_for
+  end
+end

data/lib/rh_math/version.rb

@@ -0,0 +1,3 @@
+module RhMath
+  VERSION = "0.1.0".freeze
+end

data/lib/rh_math/zeta.rb

@@ -0,0 +1,55 @@
+module RhMath
+  module Zeta
+    DEFAULT_TERMS = 10_000
+
+    # Truncated Dirichlet series approximation for real s > 1:
+    #   zeta(s) ≈ sum_{n=1..terms} 1 / n^s
+    # Convergence is faster for larger s and slower as s approaches 1.
+    # Accuracy is controlled by the selected truncation length (terms).
+    def self.zeta_real(s, terms: DEFAULT_TERMS)
+      validated_inputs = validate_inputs!(s, terms)
+      partial_sum_for(validated_inputs[:s], validated_inputs[:terms])
+    end
+
+    # Truncated Dirichlet series with a classical integral-tail bound for s > 1:
+    #   tail <= integral_N^infinity x^{-s} dx = N^(1-s)/(s-1)
+    # This gives a rigorous upper bound on truncation error when using N terms.
+    def self.zeta_real_with_error(s, terms: DEFAULT_TERMS)
+      validated_inputs = validate_inputs!(s, terms)
+      exponent = validated_inputs[:s]
+      n_terms = validated_inputs[:terms]
+
+      partial_sum = partial_sum_for(exponent, n_terms)
+      tail_bound = (n_terms**(1.0 - exponent)) / (exponent - 1.0)
+
+      {
+        value: partial_sum,
+        error_bound: tail_bound,
+        lower_bound: partial_sum,
+        upper_bound: partial_sum + tail_bound
+      }
+    end
+
+    def self.validate_inputs!(s, terms)
+      exponent = Float(s)
+      n_terms = Integer(terms)
+
+      raise ArgumentError, "s must be > 1 for this truncated real-series routine" unless exponent > 1.0
+      raise ArgumentError, "terms must be >= 1" if n_terms < 1
+
+      { s: exponent, terms: n_terms }
+    end
+    private_class_method :validate_inputs!
+
+    def self.partial_sum_for(exponent, n_terms)
+      sum = 0.0
+      n = 1
+      while n <= n_terms
+        sum += 1.0 / (n**exponent)
+        n += 1
+      end
+      sum
+    end
+    private_class_method :partial_sum_for
+  end
+end

data/lib/rh_math.rb

@@ -0,0 +1,15 @@
+require_relative "rh_math/version"
+require_relative "rh_math/comparison_result"
+require_relative "rh_math/pointwise_result"
+require_relative "rh_math/numeric_parser"
+require_relative "rh_math/prime_support"
+require_relative "rh_math/arithmetic_functions"
+require_relative "rh_math/special_functions"
+require_relative "rh_math/zeta"
+require_relative "rh_math/bounds/schoenfeld1976"
+require_relative "rh_math/evaluators/schoenfeld_pointwise"
+require_relative "rh_math/comparators/exact_text"
+require_relative "rh_math/comparators/absolute_tolerance"
+
+module RhMath
+end

data/rh_math.gemspec

@@ -0,0 +1,27 @@
+require_relative "lib/rh_math/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "rh_math"
+  spec.version = RhMath::VERSION
+  spec.authors = ["Tim Bass"]
+  spec.email = ["tim@unix.com"]
+
+  spec.summary = "Bounded pure-Ruby math routines for rh_llm_benchmark"
+  spec.description = "A research-oriented pure-Ruby math layer for bounded analytic number theory evaluation workflows."
+  spec.homepage = "https://github.com/unixneo/rh_math"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/releases"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir.chdir(__dir__) do
+    Dir["lib/**/*.rb", "README.md", "LICENSE.txt", "CITATION.cff", "rh_math.gemspec"]
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: rh_math
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tim Bass
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A research-oriented pure-Ruby math layer for bounded analytic number
+  theory evaluation workflows.
+email:
+- tim@unix.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CITATION.cff
+- LICENSE.txt
+- README.md
+- lib/rh_math.rb
+- lib/rh_math/arithmetic_functions.rb
+- lib/rh_math/bounds/schoenfeld1976.rb
+- lib/rh_math/comparators/absolute_tolerance.rb
+- lib/rh_math/comparators/exact_text.rb
+- lib/rh_math/comparison_result.rb
+- lib/rh_math/evaluators/schoenfeld_pointwise.rb
+- lib/rh_math/numeric_parser.rb
+- lib/rh_math/pointwise_result.rb
+- lib/rh_math/prime_support.rb
+- lib/rh_math/special_functions.rb
+- lib/rh_math/version.rb
+- lib/rh_math/zeta.rb
+- rh_math.gemspec
+homepage: https://github.com/unixneo/rh_math
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/unixneo/rh_math
+  source_code_uri: https://github.com/unixneo/rh_math
+  changelog_uri: https://github.com/unixneo/rh_math/releases
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Bounded pure-Ruby math routines for rh_llm_benchmark
+test_files: []