modular_forms 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c2b8536ed2846f289afd967456cdd892858ad3af312acffab3e312c57b367a38
+  data.tar.gz: ea900a9133578ce1278141bda388d85fc222419ac2de207c50a10c243176166f
+SHA512:
+  metadata.gz: 7542e5fa3105f3008bdf192c2471e950898567aca9c133ebb50c7e0d65ec1bd0c3b1765c944257c59782bd26f2f849f15d7653652d14844d844a91ab1174b7b9
+  data.tar.gz: 6878c24ff277884ff52aeb3ad54073ae50001b3f0f792b317b1d4ed7caf40151a867124a394eef0731846f1d3732b096f741e4e8c6e2473f9b172eddaed0d237

data/README.md

@@ -0,0 +1,152 @@
+# Modular Forms
+
+A creative toolkit for exploring modular forms and elliptic curves through [Sonic Pi](https://sonic-pi.net/).
+
+![Modular Forms - Image](modular_forms.png)
+
+## Project Status
+
+This is a pre-alpha release of `modular_forms`. At this stage, only a subset of core mathematical definitions and operations is implemented.
+Future updates might include a DSL, depending on how the library is used and the interest from the community.
+
+Contributions are welcome! Feel free to fork, make changes, and submit a pull request.
+
+## Features
+
+- **Accessible to both musicians and coders**: No math expertise required. Create musical patterns, rhythms, timbres, and harmonies by experimenting with mathematical ideas and turning them into sound and effects intuitively.
+- **Interactive Educational Resource**: Use **Sonic Pi** to discover introductory number theory in a hands-on, immersive way, gaining insights into abstract concepts through math in action.
+
+## Purpose and Scope
+
+Given the vastness of the field, this tool intentionally focuses on a limited subset of definitions, without covering all aspects of each. Below is a list of the implemented modules:
+
+- [Eisenstein Series](#eisenstein-series)
+- [Eta Functions and Eta Quotients](#eta-functions-and-eta-quotients)
+- [Theta functions](#theta-functions)
+- [Ramanujan Tau Function](#ramanujan-tau-function)
+- [J-Function](#j-function)
+- [Hecke Operators](#hecke-operators)
+- [SL(2,Z) Group](#sl2z-group)
+- [Dirichlet Characters](#dirichlet-characters)
+- [Elliptic Curves over Rationals](#elliptic-curves-over-rationals)
+- [Elliptic Curves over Finite Fields](#elliptic-curves-over-finite-fields)
+- [Newforms Invariants](#newforms-invariants)
+
+### Not Optimized for Computational Efficiency
+
+This library is designed for creative exploration rather than maximum computational efficiency. It is not intended to replace advanced mathematical software. Instead, it draws inspiration from tools like SageMath, Pari/GP, and the LMFDB database.
+
+### Goal
+The goal is simple: to provide an accessible and creative starting point for those who wish to explore, learn, and uncover new ideas, regardless of their mathematical background.
+
+## Installation
+
+You can install the `modular_forms` gem directly from **RubyGems** or clone it from GitHub.
+
+```bash
+gem install modular_forms
+```
+
+## How to use?
+
+You can dive into the beauty of math, both in Ruby and Sonic Pi, creating music in real-time. Here is a simple example of how to use **modular_forms** to generate a basic musical pattern:
+
+```rb
+# If you are using Ruby, simply load the gem with its name
+# after installing it via 'gem install modular_forms'.
+require 'modular_forms'
+
+# If you are using Sonic Pi, replace <PATH>
+# with the full path to the 'modular_forms.rb' file
+# inside the gem installation on your system.
+require "<PATH>/modular_forms.rb"
+
+# Calculate the Eisenstein series of weight k = 4
+eisenstein_melody = ModularForms.eisenstein_serie(4)
+
+# Play the melody in a loop with a mathematical transformation
+120.times do
+  play eisenstein_melody.next % 12 * 7
+  sleep 0.5
+end
+```
+
+## Implemented Modular Forms, Elliptic Curves, and Related Definitions
+
+### Eisenstein Series
+
+1. `ModularForms.eisenstein_series(weight_k, galois_field = nil)`
+2. `ModularForms.eisenstein_series_product(weight_k1, weight_k2, prec)`
+3. `ModularForms.eisenstein_series_pow(weight_k, power, prec)`
+
+### Eta Functions and Eta Quotients
+
+4. `ModularForms.dedekind_eta_function(m_scale = 1, pentagonal_coefs = false)`
+5. `ModularForms.dedekind_eta_pow(power, prec, m_scale = 1)`
+6. `ModularForms.dedekind_sum(h, k)`
+7. `ModularForms.eta_product(eta1, eta2, prec = nil)`
+8.  `ModularForms.eta_quotient(num_eta, den_eta, prec)`
+
+### Theta functions
+
+9. `ModularForms.jacobi_theta_function(jacobi_index = 3, square_coefs = false)`
+10.  `ModularForms.jacobi_theta_function_pow(jacobi_index, power, prec)`
+
+### Ramanujan Tau Function
+
+11. `ModularForms.ramanujan_tau_function`
+
+### J-Function
+
+12. `ModularForms.j_function(prec)`
+
+### Hecke Operators
+
+13. `ModularForms.hecke_operator_prime_non_cusp(non_cusp_form_arr, prime, weight_k, prec)`
+14. `ModularForms.hecke_operator_prime_cusp(cusp_form_arr, prime, weight_k, prec)`
+
+### SL(2,Z) Group
+
+15. `ModularForms.t_gen_matrix(n_power)`
+16. `ModularForms.s_gen_matrix(n_power)`
+17. `ModularForms.u_gen_matrix(mod_n)`
+18. `ModularForms.st_gen_matrix(n_power)`
+19. `ModularForms.product_gen_mats(gen_mat_a, gen_mat_b)`
+20. `ModularForms.gamma0_index(n)`
+21. `ModularForms.gamma1_index(n)`
+
+### Dirichlet Characters
+
+22. `ModularForms.dirichlet_trivchar(modq, a)`
+23. `ModularForms.conrey_p_pminus1(modp, a)`
+24. `ModularForms.gauss_sum_triv(dirichlet_q, a)`
+25. `ModularForms.gauss_sum_conrey_p_minus1(dirichlet_q, a, parity)`
+
+### Elliptic Curves over Rationals
+
+26. `ModularForms.elliptic_curve_q(coefs)`
+27. `ModularForms.discriminant_q(curve)`
+28. `ModularForms.j_invariant_q(curve)`
+29. `ModularForms.point_on_curve_q?(curve, point)`
+30. `ModularForms.point_addition_q(curve, p, q)`
+31. `ModularForms.scalar_mul_point_q(curve, n, point)`
+32. `ModularForms.isogeny_2deg_q(curve, point_2tor)`
+33. `ModularForms.isogeny_ndeg_q(curve, point_ntor, order)`
+34. `ModularForms.weil_height(x_point)`
+35. `ModularForms.canonical_height(curve, point, prec = 64)`
+
+### Elliptic Curves over Finite Fields
+
+36. `ModularForms.elliptic_curve_fp(p, coefs)`
+37. `ModularForms.point_on_curve_modp?(curve, point)`
+38. `ModularForms.discriminant_modp(curve)`
+39. `ModularForms.j_invariant_modp(curve)`
+40. `ModularForms.point_addition_modp(curve, p_point, q_point)`
+41. `ModularForms.scalar_mul_point_modp(curve, n, point)`
+42. `ModularForms.points_fp(curve, point_at_infinity = false)`
+43. `ModularForms.cardinality_fp(curve)`
+44. `ModularForms.quadratic_twist_fp(curve)`
+
+### Newforms Invariants
+45. `ModularForms.analytic_conductor(level_n, weight_k)`
+

data/lib/modular_forms/core/dedekind_eta_functions.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative '../core/numeric_helpers/numeric_helpers'
+
+module ModularForms
+  module Core
+    # ModularForms::Core::DedekindEtaFunctions
+    #
+    # This module provides a generator for Dedekind eta functions.
+    module DedekindEtaFunctions
+      def self.eta_function(m_scale = 1, pent_coefs = false) # rubocop:disable Style/OptionalBooleanParameter,Metrics/MethodLength,Metrics/AbcSize
+        Enumerator.new do |q|
+          q << 1
+          (m_scale - 1).times do
+            q << 0
+          end
+          (1..Float::INFINITY).each do |tau|
+            pentagonal_num_minus = ((3 * tau**2 - tau) / 2) * m_scale
+            pentagonal_num_plus = ((3 * tau**2 + tau) / 2) * m_scale
+            min_next_pent = ((3 * (tau + 1)**2 - (tau + 1)) / 2) * m_scale
+            sign = (-1)**tau
+            q << (pent_coefs == false ? sign : sign * pentagonal_num_minus)
+            (pentagonal_num_plus - pentagonal_num_minus - 1).abs.times do
+              q << 0
+            end
+            q << (pent_coefs == false ? sign : sign * pentagonal_num_plus)
+            (min_next_pent - pentagonal_num_plus - 1).abs.times do
+              q << 0
+            end
+          end
+        end
+      end
+
+      def self.eta_function_pow(power, precision, m_scale = 1)
+        vec = eta_function(m_scale).take(precision)
+        eta_q_coefs = [1]
+        power.times do
+          eta_q_coefs = NumericHelpers.linear_convolve(eta_q_coefs, vec, precision)
+        end
+        eta_q_coefs
+      end
+
+      def self.eta_product(eta1, eta2, prec = nil)
+        NumericHelpers.linear_convolve(eta1, eta2, prec)
+      end
+
+      def self.eta_quotient(num_eta, den_eta, prec)
+        NumericHelpers.quotient_of_series(num_eta, den_eta, prec)
+      end
+
+      def self.centered_fractional_part(num, den)
+        return 0 if num % den == 0 # rubocop:disable Style/NumericPredicate
+
+        Rational(num, den) - (num / den).floor - Rational(1, 2)
+      end
+
+      def self.dedekind_sum(h, k)
+        raise "#{k} parameter must be greater than 0" if k < 1
+
+        s = 0
+        (1..k - 1).each do |n|
+          s += centered_fractional_part(n, k) * centered_fractional_part(h * n, k)
+        end
+        s
+      end
+    end
+  end
+end

data/lib/modular_forms/core/dirichlet_characters.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../core/numeric_helpers/numeric_helpers'
+require 'bigdecimal'
+
+module ModularForms
+  module Core
+    # ModularForms::Core::DirichletCharacters
+    #
+    # This module provides generators for Dirichlet characters and related topics.
+    module DirichletCharacters
+      PI2 = 2 * Math::PI
+
+      PARITY = {
+        EVEN: 'even',
+        ODD: 'odd'
+      }.freeze
+
+      def self.dirichlet_trivchar(modq, a)
+        NumericHelpers.gcd(a, modq) == 1 ? 1 : 0
+      end
+
+      def self.conrey_p_pminus1(modp, a)
+        raise "#{modp} must be a prime number" if !NumericHelpers.prime_number?(modp) # rubocop:disable Style/NegatedIf
+        return 0 if a % modp == 0 # rubocop:disable Style/NumericPredicate
+        return 1 if NumericHelpers.euler_criterion(a, modp)
+
+        -1 if !NumericHelpers.euler_criterion(a, modp) # rubocop:disable Style/NegatedIf
+      end
+
+      def self.exponential(a, r, q)
+        Complex.polar(1, PI2 * (a * r) / q)
+      end
+
+      def self.gauss_sum_triv(q_char, a)
+        t_a = 0 + 0i
+        (0..q_char - 1).each do |r|
+          t_a += dirichlet_trivchar(q_char, r) * exponential(a, r, q_char)
+        end
+        t_a.real.to_f.round(2)
+      end
+
+      def self.gauss_sum_conrey_p_minus1(q_char, a, parity) # rubocop:disable Metrics/AbcSize
+        raise "Parity '#{parity}' must be either 'even' or 'odd'" if parity != PARITY[:ODD] && parity != PARITY[:EVEN]
+
+        t_a = 0 + 0i
+        (0..q_char - 1).each do |r|
+          t_a += conrey_p_pminus1(q_char, r) * exponential(a, r, q_char)
+        end
+
+        return t_a.real.round(10) if parity == PARITY[:EVEN]
+
+        Complex(0, t_a.imaginary.round(10)) if parity == PARITY[:ODD]
+      end
+    end
+  end
+end

data/lib/modular_forms/core/eisenstein_series.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../core/numeric_helpers/numeric_helpers'
+
+module ModularForms
+  module Core
+    # ModularForms::Core::EisensteinSeries
+    #
+    # This module provides a generator for Eisenstein series.
+    module EisensteinSeries
+      def self.eisenstein_series(k, gal_f = nil) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        raise ArgumentError, 'k must be even and >= 2' if k < 2 || k % 2 != 0 # rubocop:disable Style/EvenOdd
+
+        bernoulli_k = NumericHelpers.bernoulli_numbers_arr(k)[k]
+        normalization_factor = - Rational(2 * k, bernoulli_k)
+        Enumerator.new do |q|
+          q << 1
+          (1..Float::INFINITY).each do |tau|
+            nth_term = (normalization_factor * NumericHelpers.divisor_function_sigma(tau, k - 1)).to_i
+            if gal_f != nil # rubocop:disable Style/ConditionalAssignment,Style/NonNilCheck
+              q << NumericHelpers.galois_field(nth_term, gal_f)
+            else
+              q << nth_term
+            end
+          end
+        end
+      end
+
+      def self.eisenstein_series_product(weight_k1, weight_k2, precision)
+        vec1 = eisenstein_series(weight_k1).take(precision)
+        vec2 = eisenstein_series(weight_k2).take(precision)
+        NumericHelpers.linear_convolve(vec1, vec2, precision)
+      end
+
+      def self.eisenstein_series_pow(weight_k, power, precision)
+        vec = eisenstein_series(weight_k).take(precision)
+        eisenstein_q_coefs = [1]
+        power.times do
+          eisenstein_q_coefs = NumericHelpers.linear_convolve(eisenstein_q_coefs, vec, precision)
+        end
+        eisenstein_q_coefs
+      end
+    end
+  end
+end

data/lib/modular_forms/core/elliptic_curves_fp.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative '../core/numeric_helpers/numeric_helpers'
+require_relative './elliptic_curves_q'
+
+module ModularForms
+  module Core
+    # ModularForms::Core::EllipticCurvesFp
+    #
+    # This module provides methods for generating points on Elliptic Curves over Finite Fields (short Weierstrass form)
+    module EllipticCurvesFp
+      def self.reduction_modp(n, modp)
+        ((n % modp) + modp) % modp
+      end
+
+      def self.elliptic_curve_fp(p, coefs)
+        a, b = coefs
+        raise "#{p} is not a prime number" if NumericHelpers.prime_number?(p) == false
+
+        d = reduction_modp(EllipticCurvesQ.discriminant(a, b), p)
+
+        a_modp = reduction_modp(a, p)
+        b_modp = reduction_modp(b, p)
+        raise "y^2=x^3 #{a_modp}x #{b_modp} defines a singular curve" if d == 0 # rubocop:disable Style/NumericPredicate
+
+        puts "y^2 = x^3 #{a_modp}x #{b_modp} over Finite Field #{p}"
+        { a: a, b: b, p: p }
+      end
+
+      def self.point_on_curve_modp?(curve, point)
+        return true if point == nil # rubocop:disable Style/NilComparison
+
+        a, b, p = curve.values_at(:a, :b, :p)
+        x, y = point
+        x_modp = reduction_modp(x, p)
+        y_modp = reduction_modp(y, p)
+        coordinates = reduction_modp(y**2, p) == reduction_modp(x**3 + x * a + b, p)
+
+        raise "Coordinates [#{x_modp},#{y_modp}] do not define a point on curve" unless coordinates
+
+        true
+      end
+
+      def self.discriminant_modp(curve)
+        a, b, p = curve.values_at(:a, :b, :p)
+        reduction_modp(-16 * (4 * a**3 + 27 * b**2), p)
+      end
+
+      def self.fermat_inverse_modp(a, p)
+        a.pow(p - 2, p)
+      end
+
+      def self.j_invariant_modp(curve)
+        a, b, p = curve.values_at(:a, :b, :p)
+        reduction_modp(1728 * (4 * a**3) * fermat_inverse_modp(4 * a**3 + 27 * b**2, p), p)
+      end
+
+      def self.point_addition_modp(curve, p_point, q_point) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        a, _, p = curve.values_at(:a, _, :p)
+        return p_point if q_point == nil # rubocop:disable Style/NilComparison
+        return q_point if p_point == nil # rubocop:disable Style/NilComparison
+
+        x1, y1 = p_point
+        x2, y2 = q_point
+        return nil if x1 == x2 && reduction_modp(y1 + y2, p) == 0 # rubocop:disable Style/NumericPredicate
+
+        if p_point != q_point
+          num1 = y2 - y1
+          den1 = x2 - x1
+          lambda_m = num1 * fermat_inverse_modp(den1, p)
+        else
+          num2 = 3 * x1**2 + a
+          den2 = 2 * y1
+          lambda_m = num2 * fermat_inverse_modp(den2, p)
+        end
+
+        x3 = lambda_m**2 - x1 - x2
+        y3 = lambda_m * (x1 - x3) - y1
+        [reduction_modp(x3, p), reduction_modp(y3, p)]
+      end
+
+      def self.scalar_mul_point_modp(curve, n, point)
+        n_times_point = nil
+        addend = point
+
+        while n > 0 # rubocop:disable Style/NumericPredicate
+          n_times_point = point_addition_modp(curve, n_times_point, addend) if n.odd?
+          addend = point_addition_modp(curve, addend, addend)
+          n >>= 1
+        end
+
+        n_times_point
+      end
+
+      def self.points(curve, point_at_infinity = false) # rubocop:disable Metrics/MethodLength,Style/OptionalBooleanParameter,Metrics/AbcSize
+        a, b, p = curve.values_at(:a, :b, :p)
+
+        list_of_points = point_at_infinity ? [nil] : []
+        (0..(p - 1)).each do |x|
+          eq_rh = (x**3 + a * x + b) % p
+          (0..((p - 1) / 2)).each do |y|
+            if ((y**2) % p) == eq_rh
+              list_of_points << [x, y]
+              list_of_points << [x, p - y] if p - y < p
+            end
+          end
+        end
+
+        list_of_points
+      end
+
+      def self.cardinality(curve)
+        points(curve, true).length
+      end
+
+      def self.quadratic_twist(curve)
+        a, b, p = curve.values_at(:a, :b, :p)
+
+        d_non_square = NumericHelpers.square_modp_list(p, 2)[1]
+        index = rand(d_non_square.length)
+        d = d_non_square[index]
+
+        elliptic_curve_fp(p, [(a * d**2) % p, (b * d**3) % p])
+      end
+    end
+  end
+end

data/lib/modular_forms/core/elliptic_curves_q.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative '../core/numeric_helpers/numeric_helpers'
+
+module ModularForms
+  module Core
+    # ModularForms::Core::EllipticCurves
+    #
+    # This module provides methods for generating points on Elliptic Curves (short Weierstrass form) over Q
+    module EllipticCurvesQ
+      def self.discriminant(a, b)
+        -16 * (4 * a**3 + 27 * b**2)
+      end
+
+      def self.elliptic_curve_q(coefs)
+        a, b = coefs
+        raise "y^2=x^3 #{a}x #{b} defines a singular curve" if discriminant(a, b) == 0 # rubocop:disable Style/NumericPredicate
+
+        puts "y^2 = x^3 #{a}x #{b}"
+        { a: a, b: b }
+      end
+
+      def self.point_on_curve?(curve, point)
+        return true if point == nil # rubocop:disable Style/NilComparison
+
+        a, b = curve.values_at(:a, :b)
+        x, y = point
+        coordinates = y**2 == x**3 + x * a + b
+        raise "Coordinates [#{x},#{y}] do not define a point on curve" unless coordinates
+
+        true
+      end
+
+      def self.negate_p(point)
+        raise ArgumentError, 'Expected a point with two coordinates [x, y]' unless point.length == 2
+
+        x, y = point
+        [x, -y]
+      end
+
+      def self.discriminant_qq(curve)
+        a, b = curve.values_at(:a, :b)
+        -16 * (4 * a**3 + 27 * b**2)
+      end
+
+      def self.j_invariant(curve)
+        a, b = curve.values_at(:a, :b)
+        return 0 if a == 0 # rubocop:disable Style/NumericPredicate
+        return 1728 if b == 0 # rubocop:disable Style/NumericPredicate
+
+        1728 * Rational(4 * a**3, 4 * a**3 + 27 * b**2)
+      end
+
+      def self.point_addition(curve, p, q) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        return p if q == nil # rubocop:disable Style/NilComparison
+        return q if p == nil # rubocop:disable Style/NilComparison
+
+        x1, y1 = p
+        x2, y2 = q
+        return nil if x1 == x2 && y1 + y2 == 0 # rubocop:disable Style/NumericPredicate
+
+        a, = curve.values_at(:a)
+        if p != q # rubocop:disable Style/ConditionalAssignment
+          lambda_m = Rational(y2 - y1, x2 - x1)
+        else
+          lambda_m = Rational(3 * x1**2 + a, 2 * y1)
+        end
+        x3 = lambda_m**2 - x1 - x2
+        y3 = lambda_m * (x1 - x3) - y1
+        [x3, y3]
+      end
+
+      def self.scalar_mul_point(curve, n, point)
+        n_times_point = nil
+        addend = point
+
+        while n > 0 # rubocop:disable Style/NumericPredicate
+          n_times_point = point_addition(curve, n_times_point, addend) if n.odd?
+          addend = point_addition(curve, addend, addend)
+          n >>= 1
+        end
+
+        n_times_point
+      end
+
+      def self.isogeny_2deg(curve, point_2tor)
+        a, b = curve.values_at(:a, :b)
+        x0 = point_2tor[0]
+        t = 3 * x0**2 + a
+        w = x0 * t
+        a_isog = a - 5 * t
+        b_isog = b - 7 * w
+        elliptic_curve_q([a_isog, b_isog])
+      end
+
+      def self.isogeny_ndeg(curve, point_ntor, order) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        a, b = curve.values_at(:a, :b)
+        t = 0
+        w = 0
+        (1..order - 1).each do |n|
+          x0, y0 = scalar_mul_point(curve, n, point_ntor)
+          t_q = 3 * x0**2 + a
+          u_q = 2 * y0**2
+          w_q = u_q + t_q * x0
+          t += t_q
+          w += w_q
+        end
+        a_isog = a - 5 * t
+        b_isog = b - 7 * w
+        elliptic_curve_q([a_isog, b_isog])
+      end
+
+      def self.weil_height(x_point)
+        return 0 if x_point == nil # rubocop:disable Style/NilComparison
+
+        Math.log(NumericHelpers.q_height(x_point))
+      end
+
+      def self.canonical_height(curve, point, prec = 64)
+        n = prec
+        dim = 1 # To be implemented in a new module for ECurves over extensions of the rationals
+        two_pow_n = scalar_mul_point(curve, n, point)[0]
+        Rational(1, dim) * (weil_height([two_pow_n.numerator,
+                                         two_pow_n.denominator]) * n**-2)
+      end
+    end
+  end
+end

data/lib/modular_forms/core/hecke_operators.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../core/numeric_helpers/numeric_helpers'
+
+module ModularForms
+  module Core
+    # ModularForms::Core::HeckeOperators
+    #
+    # This module provides methods for applying Hecke operators to modular forms.
+    module HeckeOperators
+      def self.hecke_prime_non_cusp(non_cusp_form, p, k, precision) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        raise ArgumentError, 'p must be a prime number' unless NumericHelpers.prime_number?(p)
+
+        q_size = non_cusp_form.length
+        minimum_q_size = (precision - 1) * p + 1
+        raise ArgumentError, "size of q-expansion must be at least #{minimum_q_size}" if q_size < minimum_q_size
+
+        normalization_factor = p**(k - 1)
+        (0..precision - 1).map do |n|
+          if n % p != 0
+            non_cusp_form[p * n]
+          else
+            non_cusp_form[p * n] + normalization_factor * non_cusp_form[n / p]
+          end
+        end
+      end
+
+      def self.hecke_prime_cusp(cusp_form, p, k, precision) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        raise ArgumentError, 'p must be a prime number' unless NumericHelpers.prime_number?(p)
+
+        q_size = cusp_form.length
+        minimum_q_size = precision * p
+        raise ArgumentError, "size of q-expansion must be at least #{minimum_q_size}" if q_size < minimum_q_size
+
+        cusp_form.unshift(0)
+        normalization_factor = p**(k - 1)
+
+        (1..precision).map do |n|
+          if n % p != 0
+            cusp_form[p * n]
+          else
+            cusp_form[p * n] + normalization_factor * cusp_form[n / p]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/modular_forms/core/klein_j_invariant.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../core/numeric_helpers/numeric_helpers'
+require_relative 'eisenstein_series'
+require_relative 'dedekind_eta_functions'
+
+module ModularForms
+  module Core
+    # ModularForms::Core::KleinJInvariant
+    #
+    # This module provides an array of values for the j-invariant function.
+    module KleinJInvariant
+      def self.j_function(precision)
+        e4_cubed = EisensteinSeries.eisenstein_series_pow(4, 3, precision + 1)
+        delta_discriminant = DedekindEtaFunctions.eta_function_pow(24, precision + 1)
+        NumericHelpers.quotient_of_series(e4_cubed, delta_discriminant, precision)
+      end
+    end
+  end
+end

data/lib/modular_forms/core/newform_invariants.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../core/numeric_helpers/numeric_helpers'
+
+module ModularForms
+  module Core
+    # ModularForms::Core::NewFormInvariants
+    #
+    # This module provides methods for NewForm Invariants
+    module NewFormInvariants
+      BERNOULLI = NumericHelpers.bernoulli_numbers_arr(16).reject { |bm| bm == 0 } # rubocop:disable Style/NumericPredicate
+      BERNOULLI_B_2m = BERNOULLI[2..16].each_with_index.map do |b2m, index|
+        Rational(b2m, (2 * (index + 1))).abs # abs => all B2m positive
+      end
+
+      def self.digamma_func(z) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        partial_sum = 0.0
+        while z < 10
+          partial_sum -= Rational(1, z)
+          z += 1
+        end
+        inv_z = Rational(1 / z)
+        inv_z2 = inv_z * inv_z
+        partial_sum += Math.log(z) - Rational(1, 2) * inv_z
+        BERNOULLI_B_2m.each_with_index do |b2m, index|
+          partial_sum += (-1)**(index + 1) * b2m * (inv_z2**(index + 1))
+        end
+        partial_sum
+      end
+
+      def self.analytic_conductor(level_n, weight_k)
+        psi = digamma_func(Rational(weight_k, 2))
+        num = Math.exp(psi)
+        den = 2 * Math::PI
+        (level_n * (num / den)**2).round(12)
+      end
+    end
+  end
+end

data/lib/modular_forms/core/numeric_helpers/numeric_helpers.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module ModularForms
+  module Core
+    # ModularForms::Core::NumericHelpers
+    #
+    # Contains functions used in the definitions of modular forms,
+    # as well as other related numerical operations.
+    module NumericHelpers
+      def self.factorial_iter(num)
+        t = 1
+        (1..num).each do |i|
+          t *= i
+        end
+        t
+      end
+
+      def self.binomial_coefficient(n, k)
+        factorial_iter(n) / (factorial_iter(k) * factorial_iter(n - k))
+      end
+
+      def self.bernoulli_numbers_arr(n, bernoulli_numbers = [1])
+        return bernoulli_numbers[n] if n < bernoulli_numbers.length
+
+        (bernoulli_numbers.length..n).each do |k|
+          sum = Rational(0, 1)
+          (0...k).each do |j|
+            sum += binomial_coefficient(k + 1, j) * bernoulli_numbers[j]
+          end
+          bernoulli_numbers[k] = -sum / (k + 1)
+        end
+        bernoulli_numbers
+      end
+
+      def self.divisor_function_sigma(n, z)
+        total_sum = 0
+        (1..n).each do |d|
+          if n % d == 0 # rubocop:disable Style/NumericPredicate,Style/IfUnlessModifier
+            total_sum += d**z
+          end
+        end
+        total_sum
+      end
+
+      def self.prime_number?(n)
+        if !n.is_a?(Integer) # rubocop:disable Style/IfUnlessModifier,Style/NegatedIf
+          return false
+        end
+        return false if n < 2
+
+        (2..Math.sqrt(n)).each do |i|
+          if (n % i) == 0 # rubocop:disable Style/NumericPredicate,Style/IfUnlessModifier
+            return false
+          end
+        end
+        true
+      end
+
+      def self.galois_field(n, modp)
+        if prime_number?(modp) == false # rubocop:disable Style/IfUnlessModifier
+          raise ArgumentError, 'GF must be a prime number'
+        end
+
+        ((n % modp) + modp) % modp
+      end
+
+      def self.linear_convolve(vec1, vec2, max_degree = nil) # rubocop:disable Metrics/AbcSize
+        max_degree == nil ? max_degree = (vec1.size + vec2.size) / 2 : max_degree # rubocop:disable Style/NilComparison
+        arr_product = Array.new(max_degree, 0)
+        (0..max_degree - 1).each do |n|
+          (0..n).each do |m|
+            if m < vec1.size && (n - m) < vec2.size # rubocop:disable Style/IfUnlessModifier
+              arr_product[n] += vec1[m] * vec2[n - m]
+            end
+          end
+        end
+        arr_product
+      end
+
+      def self.quotient_of_series(num, den, max_degree)
+        arr_coefs = []
+        (0..max_degree).each do |n|
+          sum = num[n] || 0
+          (1..n).each do |k|
+            sum -= (den[k] || 0) * (arr_coefs[n - k] || 0)
+          end
+          arr_coefs << sum / den[0].to_i
+        end
+        arr_coefs
+      end
+
+      def self.euler_criterion(x, pmod)
+        (x**((pmod - 1) / 2)) % pmod == 1
+      end
+
+      def self.square_modp_list(pmod, init = 1)
+        squares_fp = []
+        non_squares_fp = []
+
+        (init..pmod - 1).each do |x|
+          if euler_criterion(x, pmod)
+            squares_fp << x
+          else
+            non_squares_fp << x
+          end
+        end
+
+        [squares_fp, non_squares_fp]
+      end
+
+      def self.gcd(a, m)
+        a, m = m, a % m while m != 0
+        a.abs
+      end
+
+      def self.q_height(q_number)
+        x, y = q_number
+        [x.abs, y.abs].max
+      end
+    end
+  end
+end

data/lib/modular_forms/core/ramanujan_tau_function.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../core/numeric_helpers/numeric_helpers'
+
+module ModularForms
+  module Core
+    # ModularForms::Core::RamanujanTauFunction
+    #
+    # This module provides a generator for Ramanujan tau functions.
+    module RamanujanTauFunction
+      def self.niebur_sigma_formula # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        Enumerator.new do |q|
+          (1..Float::INFINITY).each do |n|
+            sum_term = 0
+            (1..(n - 1)).each do |i|
+              sum_term += i**2 * (35 * i**2 - 52 * i * n + 18 * n**2) *
+                          NumericHelpers.divisor_function_sigma(i, 1) *
+                          NumericHelpers.divisor_function_sigma(n - i, 1)
+            end
+            q << n**4 * NumericHelpers.divisor_function_sigma(n, 1) - 24 * sum_term
+          end
+        end
+      end
+    end
+  end
+end

data/lib/modular_forms/core/sl2z_groups.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative '../core/numeric_helpers/numeric_helpers'
+
+module ModularForms
+  module Core
+    # ModularForms::Core::SL2Zgroups
+    #
+    # This module provides matrices from SL_2(Z) and related algebraic structures.
+    module SL2Zgroups
+      T_MATRIX = [[1, 1], [0, 1]].freeze
+      S_MATRIX = [[0, -1], [1, 0]].freeze
+      NEGATIVE_S_MATRIX = [[0, 1], [-1, 0]].freeze
+      I_MATRIX = [[1, 0], [0, 1]].freeze
+      NEGATIVE_I_MATRIX = [[-1, 0], [0, -1]].freeze
+      ST_MATRIX = [[0, -1], [1, 1]].freeze
+      U_MATRIX = [[1, 0], [1, 1]].freeze
+
+      def self.t_matrix(n_power)
+        [[1, n_power], [0, 1]]
+      end
+
+      def self.s_matrix(n_power)
+        matrix_s_power_map = {
+          1 => S_MATRIX,
+          2 => NEGATIVE_I_MATRIX,
+          3 => NEGATIVE_S_MATRIX,
+          0 => I_MATRIX
+        }
+        matrix_s_power_map[n_power % 4]
+      end
+
+      def self.st_matrix(n_power)
+        matrix_st_power_map = {
+          1 => ST_MATRIX,
+          2 => [[-1, -1], [1, 0]],
+          3 => NEGATIVE_I_MATRIX,
+          4 => [[0, 1], [-1, -1]],
+          5 => [[1, 1], [-1, 0]],
+          0 => I_MATRIX
+        }
+        matrix_st_power_map[n_power % 6]
+      end
+
+      def self.u_matrix(n_power_mod)
+        [[1, 0], [n_power_mod, 1]]
+      end
+
+      def self.product_gen_matrices(gen_mat_a, gen_mat_b) # rubocop:disable Metrics/AbcSize
+        [
+          [gen_mat_a[0][0] * gen_mat_b[0][0] + gen_mat_a[0][1] * gen_mat_b[1][0],
+           gen_mat_a[0][0] * gen_mat_b[0][1] + gen_mat_a[0][1] * gen_mat_b[1][1]],
+          [gen_mat_a[1][0] * gen_mat_b[0][0] + gen_mat_a[1][1] * gen_mat_b[1][0],
+           gen_mat_a[1][0] * gen_mat_b[0][1] + gen_mat_a[1][1] * gen_mat_b[1][1]]
+        ]
+      end
+
+      def self.index_gamma0(n)
+        product = 1
+        (2..n).each do |p|
+          if NumericHelpers.prime_number?(p) && n % p == 0 # rubocop:disable Style/NumericPredicate
+            product *= 1 + Rational(1, p)
+          end
+        end
+        (n * product).to_i
+      end
+
+      def self.index_gamma1(n)
+        product = 1
+        (2..n).each do |p|
+          if NumericHelpers.prime_number?(p) && n % p == 0 # rubocop:disable Style/NumericPredicate
+            product *= 1 - Rational(1, p * p)
+          end
+        end
+        (n * n * product).to_i
+      end
+    end
+  end
+end

data/lib/modular_forms/core/theta_functions.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../core/numeric_helpers/numeric_helpers'
+
+module ModularForms
+  module Core
+    # ModularForms::Core::ThetaFunctions
+    # This module provides a generator for Theta functions.
+    module ThetaFunctions
+      def self.jacobi_theta_function(jacobi_index = 3, square_coefs = false) # rubocop:disable Style/OptionalBooleanParameter,Metrics/MethodLength,Metrics/AbcSize
+        Enumerator.new do |q|
+          q << 1
+          (1..Float::INFINITY).each do |tau|
+            square_num = tau**2
+            square_next_num = (tau + 1)**2
+            sign = jacobi_index == 3 ? 1**tau : (-1)**tau
+            q << (square_coefs == false ? sign * 2 : sign * square_num)
+            (square_next_num - square_num - 1).abs.times do
+              q << 0
+            end
+          end
+        end
+      end
+
+      def self.jacobi_theta_function_pow(jacobi_index, power, precision)
+        vec = jacobi_theta_function(jacobi_index).take(precision)
+        theta_q_coefs = [1]
+        power.times do
+          theta_q_coefs = NumericHelpers.linear_convolve(theta_q_coefs, vec, precision)
+        end
+        theta_q_coefs
+      end
+    end
+  end
+end

data/lib/modular_forms/core.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'core/eisenstein_series'
+require_relative 'core/elliptic_curves_q'
+require_relative 'core/dedekind_eta_functions'
+require_relative 'core/ramanujan_tau_function'
+require_relative 'core/theta_functions'
+require_relative 'core/klein_j_invariant'
+require_relative 'core/hecke_operators'
+require_relative 'core/sl2z_groups'
+require_relative 'core/elliptic_curves_fp'
+require_relative 'core/dirichlet_characters'
+require_relative 'core/newform_invariants'

data/lib/modular_forms/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ModularForms
+  VERSION = '0.0.1'
+end

data/lib/modular_forms.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require_relative './modular_forms/core'
+
+# ModularForms
+#
+# This module provides a set of tools for working with modular forms and elliptic curves.
+# It is designed for use with Sonic Pi, enabling creative exploration
+# of these mathematical structures and their operations through sound.
+
+# NOTE: While the module is designed for creative exploration, it is not optimized for high
+# performance and should not be considered a replacement for specialized mathematical software.
+module ModularForms # rubocop:disable Metrics/ModuleLength
+  module_function
+
+  def eisenstein_series(weight_k, gal_f = nil)
+    Core::EisensteinSeries.eisenstein_series(weight_k, gal_f)
+  end
+
+  def eisenstein_series_product(weight_k1, weight_k2, prec)
+    Core::EisensteinSeries.eisenstein_series_product(weight_k1, weight_k2, prec)
+  end
+
+  def eisenstein_series_pow(weight_k, power, prec)
+    Core::EisensteinSeries.eisenstein_series_pow(weight_k, power, prec)
+  end
+
+  def dedekind_eta_function(m_scale = 1, pentagonal_coefs = false) # rubocop:disable Style/OptionalBooleanParameter
+    Core::DedekindEtaFunctions.eta_function(m_scale, pentagonal_coefs)
+  end
+
+  def dedekind_eta_pow(power, prec, m_scale = 1)
+    Core::DedekindEtaFunctions.eta_function_pow(power, prec, m_scale)
+  end
+
+  def dedekind_sum(h, k)
+    Core::DedekindEtaFunctions.dedekind_sum(h, k)
+  end
+
+  def ramanujan_tau_function
+    Core::RamanujanTauFunction.niebur_sigma_formula
+  end
+
+  def jacobi_theta_function(jacobi_index = 3, square_coefs = false) # rubocop:disable Style/OptionalBooleanParameter
+    Core::ThetaFunctions.jacobi_theta_function(jacobi_index, square_coefs)
+  end
+
+  def jacobi_theta_function_pow(jacobi_index, power, prec)
+    Core::ThetaFunctions.jacobi_theta_function_pow(jacobi_index, power, prec)
+  end
+
+  def j_function(prec)
+    Core::KleinJInvariant.j_function(prec)
+  end
+
+  def hecke_operator_prime_non_cusp(non_cusp_form_arr, prime, weight_k, prec)
+    Core::HeckeOperators.hecke_prime_non_cusp(non_cusp_form_arr, prime, weight_k, prec)
+  end
+
+  def hecke_operator_prime_cusp(cusp_form_arr, prime, weight_k, prec)
+    Core::HeckeOperators.hecke_prime_cusp(cusp_form_arr, prime, weight_k, prec)
+  end
+
+  def gamma0_index(n)
+    Core::SL2Zgroups.index_gamma0(n)
+  end
+
+  def gamma1_index(n)
+    Core::SL2Zgroups.index_gamma1(n)
+  end
+
+  def t_gen_matrix(n_power)
+    Core::SL2Zgroups.t_matrix(n_power)
+  end
+
+  def s_gen_matrix(n_power)
+    Core::SL2Zgroups.s_matrix(n_power)
+  end
+
+  def u_gen_matrix(mod_n)
+    Core::SL2Zgroups.u_matrix(mod_n)
+  end
+
+  def st_gen_matrix(n_power)
+    Core::SL2Zgroups.st_matrix(n_power)
+  end
+
+  def product_gen_mats(gen_mat_a, gen_mat_b)
+    Core::SL2Zgroups.product_gen_matrices(gen_mat_a, gen_mat_b)
+  end
+
+  def dirichlet_trivchar(modq, a)
+    Core::DirichletCharacters.dirichlet_trivchar(modq, a)
+  end
+
+  def conrey_p_pminus1(modp, a)
+    Core::DirichletCharacters.conrey_p_pminus1(modp, a)
+  end
+
+  def gauss_sum_triv(dirichlet_q, a)
+    Core::DirichletCharacters.gauss_sum_triv(dirichlet_q, a)
+  end
+
+  def gauss_sum_conrey_p_minus1(dirichlet_q, a, parity)
+    Core::DirichletCharacters.gauss_sum_conrey_p_minus1(dirichlet_q, a, parity)
+  end
+
+  def elliptic_curve_q(coefs)
+    Core::EllipticCurvesQ.elliptic_curve_q(coefs)
+  end
+
+  def discriminant_q(curve)
+    Core::EllipticCurvesQ.discriminant_qq(curve)
+  end
+
+  def j_invariant_q(curve)
+    Core::EllipticCurvesQ.j_invariant(curve)
+  end
+
+  def point_on_curve_q?(curve, point)
+    Core::EllipticCurvesQ.point_on_curve?(curve, point)
+  end
+
+  def point_addition_q(curve, p, q)
+    Core::EllipticCurvesQ.point_addition(curve, p, q)
+  end
+
+  def scalar_mul_point_q(curve, n, point)
+    Core::EllipticCurvesQ.scalar_mul_point(curve, n, point)
+  end
+
+  def isogeny_2deg_q(curve, point_2tor)
+    Core::EllipticCurvesQ.isogeny_2deg(curve, point_2tor)
+  end
+
+  def isogeny_ndeg_q(curve, point_ntor, order)
+    Core::EllipticCurvesQ.isogeny_ndeg(curve, point_ntor, order)
+  end
+
+  def weil_height(x_point)
+    Core::EllipticCurvesQ.weil_height(x_point)
+  end
+
+  def canonical_height(curve, point, prec = 64)
+    Core::EllipticCurvesQ.canonical_height(curve, point, prec)
+  end
+
+  def elliptic_curve_fp(p, coefs)
+    Core::EllipticCurvesFp.elliptic_curve_fp(p, coefs)
+  end
+
+  def point_on_curve_modp?(curve, point)
+    Core::EllipticCurvesFp.point_on_curve_modp?(curve, point)
+  end
+
+  def discriminant_modp(curve)
+    Core::EllipticCurvesFp.discriminant_modp(curve)
+  end
+
+  def j_invariant_modp(curve)
+    Core::EllipticCurvesFp.j_invariant_modp(curve)
+  end
+
+  def point_addition_modp(curve, p_point, q_point)
+    Core::EllipticCurvesFp.point_addition_modp(curve, p_point, q_point)
+  end
+
+  def scalar_mul_point_modp(curve, n, point)
+    Core::EllipticCurvesFp.scalar_mul_point_modp(curve, n, point)
+  end
+
+  def points_fp(curve, point_at_infinity = false) # rubocop:disable Style/OptionalBooleanParameter
+    Core::EllipticCurvesFp.points(curve, point_at_infinity)
+  end
+
+  def cardinality_fp(curve)
+    Core::EllipticCurvesFp.cardinality(curve)
+  end
+
+  def quadratic_twist_fp(curve)
+    Core::EllipticCurvesFp.quadratic_twist(curve)
+  end
+
+  def eta_product(eta1, eta2, prec = nil)
+    Core::DedekindEtaFunctions.eta_product(eta1, eta2, prec)
+  end
+
+  def eta_quotient(num_eta, den_eta, prec)
+    Core::DedekindEtaFunctions.eta_quotient(num_eta, den_eta, prec)
+  end
+
+  def analytic_conductor(level_n, weight_k)
+    Core::NewFormInvariants.analytic_conductor(level_n, weight_k)
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: modular_forms
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Edgar Armando Delgado Vega
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Modular Forms is an accessible interface for experimenting with modular
+  forms and elliptic curves through algorithmic composition and live coding using
+  Sonic Pi.
+email:
+- edelve91@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- lib/modular_forms.rb
+- lib/modular_forms/core.rb
+- lib/modular_forms/core/dedekind_eta_functions.rb
+- lib/modular_forms/core/dirichlet_characters.rb
+- lib/modular_forms/core/eisenstein_series.rb
+- lib/modular_forms/core/elliptic_curves_fp.rb
+- lib/modular_forms/core/elliptic_curves_q.rb
+- lib/modular_forms/core/hecke_operators.rb
+- lib/modular_forms/core/klein_j_invariant.rb
+- lib/modular_forms/core/newform_invariants.rb
+- lib/modular_forms/core/numeric_helpers/numeric_helpers.rb
+- lib/modular_forms/core/ramanujan_tau_function.rb
+- lib/modular_forms/core/sl2z_groups.rb
+- lib/modular_forms/core/theta_functions.rb
+- lib/modular_forms/version.rb
+homepage: https://github.com/edelveart/modular_forms
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/edelveart/modular_forms
+  source_code_uri: https://github.com/edelveart/modular_forms/
+rdoc_options:
+- "--main"
+- README.md
+- "--line-numbers"
+- "--inline-source"
+- "--quiet"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A creative toolkit for exploring modular forms and elliptic curves through
+  Sonic Pi.
+test_files: []