rcas 0.2.0

data/lib/rcas/zeilberger.rb

@@ -0,0 +1,358 @@
+# frozen_string_literal: true
+
+module RCAS
+  # Zeilberger's algorithm (creative telescoping): the recurrence a definite
+  # hypergeometric sum S(n) = sum_k F(n, k) obeys.
+  #
+  # Gosper's algorithm decides whether one term has an antidifference.
+  # Zeilberger's runs it on a whole pencil of terms at once: it looks for
+  # constants sigma_0, ..., sigma_r (free of k, rational in n) and a rational
+  # R with
+  #
+  #   sum_j sigma_j*F(n + j, k) = G(k + 1) - G(k),   G(k) = R(k)*F(n, k),
+  #
+  # and then summing over k makes the right-hand side telescope away, so
+  # sum_j sigma_j*S(n + j) = 0. What makes it work is that the whole thing
+  # stays linear: dividing by F(n, k) leaves
+  #
+  #   sum_j sigma_j*a_j(k) = R(k + 1)*r(k) - R(k),
+  #
+  # with a_j(k) = F(n + j, k)/F(n, k) and r(k) = F(n, k + 1)/F(n, k) known
+  # rational functions. Writing sum_j sigma_j*a_j = N(k)/D(k), the term ratio
+  # of the pencil is r(k)*D(k)/D(k + 1) * N(k + 1)/N(k), whose
+  # Gosper-Petkovsek normal form has the sigmas only in the c part: Gosper's
+  # equation a(k)*X(k + 1) - b(k - 1)*X(k) = c_0(k)*N(k) is linear in the
+  # coefficients of X and in the sigmas together, and one null space of one
+  # matrix gives both. The order r is raised until a solution turns up.
+  #
+  # The telescoping identity is verified as a rational identity before it is
+  # returned; the step from it to the recurrence for the sum needs natural
+  # boundaries, that is F(n, k) = 0 outside the range summed over (binomial
+  # coefficients give that by themselves).
+  #
+  # Sources (keys: MANUAL.md, Sources): [Zei91]; [Koe14, ch. 7];
+  # [PWZ96, ch. 6].
+  module Zeilberger
+    MAX_ORDER = 4
+
+    # The recurrence and the proof that goes with it.
+    Certificate = Struct.new(:coefficients, :rational, :order, :term, :n, :k) do
+      # sum_j coefficients[j]*s(n + j) as an expression, for an unknown
+      # sequence named +name+.
+      def recurrence(name)
+        coefficients.each_with_index.map { |c, j| c * Fn.new(name, [(n + j).simplify]) }.reduce(:+).simplify
+      end
+
+      def to_s = "#{recurrence(:S)} = 0"
+      def inspect = to_s
+    end
+
+    module_function
+
+    # The recurrence for S(n) = sum_k F(n, k), as an Equation in the unknown
+    # sequence +s+, which names the sum and its index: sumrecursion(F, k, S(n)).
+    def sumrecursion(term, k, s, max_order: MAX_ORDER)
+      n = index_of(s)
+      k = Expression.lift(k)
+      found = certificate(term, n, k, max_order: max_order)
+      raise RCAS::Unsupported, "sumrecursion: no recurrence of order #{max_order} or less for #{term}" if found.nil?
+      if boundary_terms?(found, n, k)
+        raise RCAS::Unsupported, "sumrecursion: the telescoping identity holds for #{term}, but its " \
+                                   "boundary terms do not vanish, so the sum itself does not obey the recurrence"
+      end
+      Equation.new(found.recurrence(s.name), Num.new(0))
+    end
+
+    # Creative telescoping proves the identity under the summation sign;
+    # carrying it over to the sum needs the boundary terms to vanish, and for
+    # a term such as binomial(n, k)/(k + 1), with its pole at k = -1, they do
+    # not. So sum_{k=0}^{n} F(n, k) is put into the recurrence for the first
+    # few n, and only a residue that is demonstrably non-zero counts against
+    # it: a check that cannot be carried out says nothing either way.
+    #
+    # The sum is taken over the term's natural range: 0..2*n for
+    # binomial(2*n, k), where 0..n cut it off and refused a true recurrence
+    # (third review, S9).
+    def boundary_terms?(found, n, k)
+      term = found.term
+      order = found.coefficients.size - 1
+      upper = natural_upper(term, n, k)
+      (0..(order + 2)).any? do |i|
+        values = (0..order).map { |j| value_at(term, n, k, Num.new(0), upper, i + j) }
+        next false if values.any?(&:nil?)
+        total = values.each_with_index.reduce(Num.new(0)) do |acc, (value, j)|
+          acc + found.coefficients[j].subs(n => i) * value
+        end
+        nonzero?(total)
+      end
+    end
+
+    # The upper end past which the term vanishes: the top of its binomial
+    # coefficients binomial(top, k) when they agree on one, n otherwise.
+    def natural_upper(term, n, k)
+      tops = term.each_node.select { |e| e.is_a?(Fn) && e.name == :binomial && e.args.size == 2 && e.args.last == k }
+                 .map { |e| e.args.first }.uniq
+      tops.size == 1 && tops.first.variables.include?(n.name) ? tops.first : n
+    end
+
+    # Is this expression definitely not zero? Exactly where it can be
+    # decided, at random values for whatever parameters are left otherwise.
+    # Only a decided non-zero counts (Decide.identically_zero?): a float
+    # residue said "non-zero" for rounding noise and refused a true
+    # q-recurrence (third review, S8).
+    def nonzero?(value)
+      Decide.identically_zero?(value.simplify) == false
+    rescue ZeroDivisionError, DomainError, ArgumentError, TypeError
+      false
+    end
+
+    # The certificate that proves it: the rational R with
+    # sum_j sigma_j*F(n + j, k) = G(k + 1) - G(k) and G(k) = R(k)*F(n, k).
+    def sumcertificate(term, k, s, max_order: MAX_ORDER)
+      n = index_of(s)
+      k = Expression.lift(k)
+      found = certificate(term, n, k, max_order: max_order)
+      raise RCAS::Unsupported, "sumcertificate: no recurrence of order #{max_order} or less for #{term}" if found.nil?
+      found.rational
+    end
+
+    def index_of(s)
+      raise ArgumentError, "name the sum and its index, e.g. S(n)" unless s.is_a?(Fn) && s.args.size == 1
+      n = s.args.first
+      raise ArgumentError, "the index must be a symbol, got #{n}" unless n.is_a?(Var)
+      n
+    end
+
+    # => Certificate, or nil when no recurrence of order <= max_order exists.
+    def certificate(term, n, k, max_order: MAX_ORDER)
+      term = Expression.lift(term).simplify
+      n = Expression.lift(n)
+      k = Expression.lift(k)
+      in_k = Summation.term_ratio(term, k)&.first or return nil
+      in_n = Summation.term_ratio(term, n)&.first or return nil
+      (1..max_order).each do |order|
+        found = attempt(term, n, k, in_k, in_n, order)
+        return found if found
+      end
+      nil
+    end
+
+    # The closed form of S(n) = sum_k F(n, k) between bounds that are natural
+    # boundaries: the recurrence creative telescoping gives, solved with as
+    # many initial values as its order and checked against direct summation.
+    # nil when any of that fails, so the sum stays unevaluated instead of
+    # coming out wrong.
+    def closed_form(term, n, k, from, to, max_order: 2)
+      found = certificate(term, n, k, max_order: max_order) or return nil
+      order = found.coefficients.size - 1
+      return nil if order.zero?
+      init = {}
+      (0...order).each do |i|
+        value = value_at(term, n, k, from, to, i) or return nil
+        init[i] = value
+      end
+      equation = Equation.new(found.recurrence(:_S), Num.new(0))
+      closed = Recurrence.rsolve(equation, :_S, n, init: init).rhs
+      return nil if closed.variables.any? { |v| v.to_s.start_with?("C") } # constants left unfixed
+      confirmed?(closed, term, n, k, from, to, order) ? closed.simplify : nil
+    rescue NotImplementedError, RCAS::Unsupported, ArgumentError, DomainError, ZeroDivisionError
+      nil
+    end
+
+    CONFIRMATIONS = 3
+
+    # sum_k F(i, k) for one concrete i, added up term by term.
+    def value_at(term, n, k, from, to, i)
+      bounds = [from, to].map { |bound| bound.subs(n => i).simplify }
+      return nil unless bounds.all? { |b| b.is_a?(Num) && b.value.is_a?(Integer) }
+      Summation.direct_sum(term.subs(n => i), k, *bounds)
+    rescue ZeroDivisionError, DomainError
+      nil
+    end
+
+    # The closed form has to agree with the sum itself past the values that
+    # were fitted: a recurrence derived for natural boundaries says nothing
+    # about a sum whose boundary terms do not vanish.
+    def confirmed?(closed, term, n, k, from, to, order)
+      (order..(order + CONFIRMATIONS)).all? do |i|
+        expected = value_at(term, n, k, from, to, i)
+        next true if expected.nil?
+        actual = closed.subs(n => i).simplify
+        Scalar.zero?((expected - actual).simplify)
+      end
+    end
+
+    # One order: build Gosper's equation for the pencil and solve it.
+    def attempt(term, n, k, in_k, in_n, order)
+      sigmas = (0..order).map { |j| Var.new(:"_z#{j}") }
+      base = [k.name, n.name] | term.variables.to_a
+      ring = QQ[*base]
+      big = QQ[*(base + sigmas.map(&:name))]
+
+      shifted = [Num.new(1)]
+      (1...(order + 1)).each { |j| shifted << (shifted.last * in_n.subs(n => n + j - 1)).cancel }
+      fractions = shifted.map { |a| Fraction.as_fraction(a, base) or return nil }
+      denominator = fractions.map(&:last).reduce(ring.one) { |acc, q| acc.lcm(q) }
+      numerators = fractions.map { |(p, q)| p * denominator.exact_div(q) }
+      pencil = sigmas.each_with_index.reduce(big.zero) do |acc, (s, j)|
+        acc + big.call(s) * numerators[j].to_ring(big)
+      end
+      return nil if pencil.zero?
+
+      pair = Fraction.as_fraction(in_k, base) or return nil
+      p = pair.first * denominator
+      q = pair.last * Summation.shift(denominator, k, 1)
+      common = p.gcd(q)
+      p = p.exact_div(common)
+      q = q.exact_div(common)
+      a, b, c0 = Summation.normal_form(p, q, k)
+      bm = Summation.shift(b, k, -1)
+      c = c0.to_ring(big) * pencil
+      bound = Summation.degree_bound(a.to_ring(big), bm.to_ring(big), c, k.name) or return nil
+
+      xs = (0..bound).map { |i| Var.new(:"_y#{i}") }
+      x_of_k = xs.each_with_index.reduce(Num.new(0)) { |acc, (x, i)| acc + x * k**i }
+      equation = (a.to_expr * x_of_k.subs(k => k + 1) - bm.to_expr * x_of_k - c.to_expr).expand
+      conditions = Solve.polynomial_coefficients(equation, k) or return nil
+      values = solve(conditions, xs, sigmas) or return nil
+
+      coefficients, factor = clear_denominators(sigmas.map { |s| values[s] }, n)
+      return nil if coefficients.all? { |c2| Scalar.zero?(c2) }
+      # The identity is linear in the sigmas, so the certificate is scaled
+      # by whatever clearing the denominators scaled them by.
+      rational = certificate_of(values, xs, factor, bm, c0, denominator, k, ring)
+      found = Certificate.new(coefficients, rational, order, term, n, k)
+      verify(found, in_k, shifted) ? found : nil
+    rescue DomainError, NotImplementedError, RCAS::Unsupported, ZeroDivisionError
+      nil
+    end
+
+    # R(k) = factor*b(k - 1)*X(k) / (c_0(k)*D(k)), kept in the polynomial ring
+    # and reduced once at the end: assembling it as an expression and
+    # cancelling that costs minutes on a sum of three binomial cubes,
+    # because the common denominator is built up by multiplication.
+    def certificate_of(values, xs, factor, bm, c0, denominator, k, ring)
+      pairs = xs.map { |x| Fraction.as_fraction(values[x], ring.vars) || [ring.call(values[x]), ring.one] }
+      common = pairs.map(&:last).reduce(ring.one) { |acc, d| acc.lcm(d) }
+      numerator = pairs.each_with_index.reduce(ring.zero) do |acc, ((p, q), i)|
+        acc + p * common.exact_div(q) * ring.call(k**i)
+      end
+      num = ring.call(factor) * bm.to_ring(ring) * numerator
+      den = c0.to_ring(ring) * denominator.to_ring(ring) * common
+      shared = num.gcd(den)
+      num = num.exact_div(shared)
+      den = den.exact_div(shared)
+      den.constant? ? (num.to_expr / den.to_expr).simplify : num.to_expr / den.to_expr
+    end
+
+    # A null space vector of the homogeneous system in which not every sigma
+    # is zero: that is the recurrence. Vectors with all sigmas zero only say
+    # that Gosper's equation itself has a solution and are of no use here.
+    #
+    # The coefficients are polynomials in n, so PolyMatrix does the kernel by
+    # evaluation and interpolation; row reduction over the rational functions
+    # themselves swells the entries badly (an order-2 system was still
+    # running after a minute).
+    def solve(conditions, xs, sigmas)
+      unknowns = xs + sigmas
+      rows = conditions.map do |condition|
+        unknowns.map { |u| Solve.polynomial_coefficients(condition, u)&.[](1) || Num.new(0) }
+      end
+      vectors = PolyMatrix.kernel(rows) || row_reduce(conditions, unknowns)
+      vectors.each do |vector|
+        values = unknowns.each_with_index.to_h { |u, i| [u, vector[i]] }
+        next if sigmas.all? { |s| Scalar.zero?(values[s]) }
+        return values
+      end
+      nil
+    end
+
+    # The same kernel by plain row reduction, for coefficients PolyMatrix
+    # will not take (a second parameter beside n).
+    def row_reduce(conditions, unknowns)
+      solution = Solve.linear_system(conditions, unknowns).first or return []
+      free = unknowns - solution.keys
+      free.map do |one|
+        assignment = free.to_h { |v| [v, Num.new(v == one ? 1 : 0)] }
+        unknowns.map { |v| (solution[v] || v).subs(assignment).cancel }
+      end
+    end
+
+    # The sigmas come out of the linear algebra as rational functions of n;
+    # the recurrence reads better with polynomial coefficients, so multiply
+    # by the common denominator and drop the content. Returns the
+    # coefficients and the factor they were multiplied by.
+    def clear_denominators(coefficients, n)
+      vars = coefficients.flat_map { |c| c.variables.to_a }.uniq | [n.name]
+      ring = QQ[*vars]
+      common = ring.one
+      coefficients.each do |c|
+        pair = Fraction.as_fraction(c, vars) or return [coefficients, Num.new(1)]
+        common = common.lcm(pair.last)
+      end
+      polynomials = coefficients.map { |c| ring.call((c * common.to_expr).cancel.expand) }
+      factor = common
+      content = polynomials.reduce(ring.zero) { |acc, poly| acc.gcd(poly) }
+      unless content.zero? || content.constant?
+        polynomials = polynomials.map { |poly| poly.exact_div(content) }
+        factor = factor.exact_div(content)
+      end
+      polynomials, scale = integral(polynomials)
+      factor *= scale
+      if negative?(polynomials)
+        polynomials = polynomials.map { |poly| -poly }
+        factor = -factor
+      end
+      [polynomials.map(&:to_expr), factor.to_expr]
+    rescue DomainError, NotImplementedError, RCAS::Unsupported, ZeroDivisionError
+      [coefficients, Num.new(1)]
+    end
+
+    # Integer coefficients without a common divisor: over the rationals the
+    # gcd above is monic and leaves 2*n + 4, n/2 alone.
+    def integral(polynomials)
+      numbers = polynomials.flat_map { |poly| poly.terms.values }.grep(Num).map(&:value).grep(Numeric)
+      return [polynomials, polynomials.first.ring.one] unless numbers.all? { |v| v.is_a?(Integer) || v.is_a?(Rational) }
+      scale = numbers.reduce(1) { |l, v| l.lcm(v.is_a?(Rational) ? v.denominator : 1) }
+      divisor = numbers.map { |v| (v * scale).to_i.abs }.reduce(0) { |g, v| g.gcd(v) }
+      divisor = 1 if divisor.zero?
+      value = Rational(scale, divisor)
+      return [polynomials, polynomials.first.ring.one] if value == 1
+      [polynomials.map { |poly| poly * value }, Polynomial.constant(polynomials.first.ring, value)]
+    end
+
+    # Does the highest coefficient carry a minus sign?
+    def negative?(polynomials)
+      lead = polynomials.reverse.find { |poly| !poly.zero? }&.leading_coefficient
+      lead.is_a?(Num) && lead.value.is_a?(Numeric) && lead.value.real? && lead.value.negative?
+    end
+
+    CHECKS = 4
+
+    # sum_j sigma_j*a_j(k) = R(k + 1)*r(k) - R(k). The linear algebra behind
+    # the certificate is exact and PolyMatrix checks its own kernel vectors,
+    # so this is a check on the derivation rather than on the arithmetic:
+    # both sides are rational, and they are compared at exact rational
+    # points, which is far cheaper than a normal form of the difference.
+    def verify(found, in_k, shifted)
+      k = found.k
+      left = shifted.each_with_index.reduce(Num.new(0)) { |acc, (a, j)| acc + found.coefficients[j] * a }
+      difference = left - (found.rational.subs(k => k + 1) * in_k - found.rational)
+      names = difference.variables.to_a
+      random = Random.new(20140610) # the book's publication date, for a stable seed
+      checked = 0
+      40.times do
+        point = names.to_h { |v| [v, Num.new(Rational(random.rand(5..97), random.rand(2..7)))] }
+        value = begin
+          difference.subs(point).simplify
+        rescue ZeroDivisionError
+          next
+        end
+        return false unless Scalar.zero?(value)
+        checked += 1
+        break if checked >= CHECKS
+      end
+      checked >= CHECKS
+    end
+  end
+end

data/lib/rcas.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# RCAS - a tiny symbolic algebra system that lives inside plain Ruby.
+#
+#   require "rcas"
+#   e = (:x + 1) * (1 - :x)   # => (x + 1)*(1 - x)
+#   e.expand                  # => 1 - x**2
+#   e.diff(:x)                # => -2*x
+#   e.call(x: 3)              # => -8
+require_relative "rcas/version"
+
+require_relative "rcas/expression"
+require_relative "rcas/printer"
+require_relative "rcas/simplify"
+require_relative "rcas/expand"
+require_relative "rcas/differentiate"
+require_relative "rcas/functions"
+require_relative "rcas/domains"
+require_relative "rcas/scalar"
+require_relative "rcas/polynomial"
+require_relative "rcas/coefficients"
+require_relative "rcas/gcd"
+require_relative "rcas/factor"
+require_relative "rcas/integrate"
+require_relative "rcas/integrate_substitutions"
+require_relative "rcas/constants"
+require_relative "rcas/fraction"
+require_relative "rcas/rational_function"
+require_relative "rcas/number_theory"
+require_relative "rcas/groebner"
+require_relative "rcas/interpolate"
+require_relative "rcas/solve"
+require_relative "rcas/ode"
+require_relative "rcas/series"
+require_relative "rcas/summation"
+require_relative "rcas/product"
+require_relative "rcas/complex_parts"
+require_relative "rcas/recurrence"
+require_relative "rcas/poly_recurrence"
+require_relative "rcas/petkovsek"
+require_relative "rcas/zeilberger"
+require_relative "rcas/q_functions"
+require_relative "rcas/q_summation"
+require_relative "rcas/q_difference"
+require_relative "rcas/q_zeilberger"
+require_relative "rcas/fps"
+require_relative "rcas/laplace"
+require_relative "rcas/geometry"
+require_relative "rcas/analysis"
+require_relative "rcas/numerics"
+require_relative "rcas/statistics"
+require_relative "rcas/special"
+require_relative "rcas/precision"
+require_relative "rcas/integral_functions"
+require_relative "rcas/distributions"
+require_relative "rcas/hypothesis"
+require_relative "rcas/combinatorics"
+require_relative "rcas/named_polynomials"
+require_relative "rcas/inequalities"
+require_relative "rcas/piecewise"
+require_relative "rcas/fourier"
+require_relative "rcas/trig"
+require_relative "rcas/algebraic"
+require_relative "rcas/decide"
+require_relative "rcas/finite_field"
+require_relative "rcas/discussion"
+require_relative "rcas/hold"
+require_relative "rcas/lint"
+require_relative "rcas/steps"
+require_relative "rcas/vector"
+require_relative "rcas/matrix"
+require_relative "rcas/matrix_multiply"
+require_relative "rcas/multimodular"
+require_relative "rcas/dixon"
+require_relative "rcas/poly_matrix"
+require_relative "rcas/vector_calculus"
+require_relative "rcas/linear_algebra"
+require_relative "rcas/decompositions"
+require_relative "rcas/lattice"
+require_relative "rcas/van_hoeij"
+require_relative "rcas/linear_program"
+require_relative "rcas/random"
+require_relative "rcas/openmath"
+require_relative "rcas/core_ext"
+require_relative "rcas/latex"
+require_relative "rcas/render"
+require_relative "rcas/plot"
+require_relative "rcas/plot3d"
+require_relative "rcas/background"
+require_relative "rcas/results"
+require_relative "rcas/docs"

data/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "rcas",
+  "private": true,
+  "description": "KaTeX for rcas inline typesetting (lib/rcas/render.rb); run `npm install`",
+  "dependencies": {
+    "katex": "^0.16.11"
+  }
+}

metadata

@@ -0,0 +1,206 @@
+--- !ruby/object:Gem::Specification
+name: rcas
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Peter Horn
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.11'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.11'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: Symbols are indeterminates, the ordinary operators build expression trees,
+  and irb is the REPL. Exact arithmetic first; calculus, solving, polynomial rings,
+  finite fields, linear algebra, differential equations, summation and statistics,
+  with honest unevaluated answers where there is no closed form.
+email:
+executables:
+- rcas
+- rcas-chat
+- rcas-app
+extensions: []
+extra_rdoc_files: []
+files:
+- CITATION.cff
+- DESIGN.md
+- LICENSE
+- MANUAL.md
+- README.md
+- bin/rcas
+- bin/rcas-app
+- bin/rcas-chat
+- lib/rcas.rb
+- lib/rcas/algebraic.rb
+- lib/rcas/analysis.rb
+- lib/rcas/app.rb
+- lib/rcas/app/launcher.rb
+- lib/rcas/app/public/app.css
+- lib/rcas/app/public/app.js
+- lib/rcas/app/public/index.html
+- lib/rcas/app/server.rb
+- lib/rcas/app/window.rb
+- lib/rcas/app/worksheet.rb
+- lib/rcas/background.rb
+- lib/rcas/chat.rb
+- lib/rcas/chat/assistant.rb
+- lib/rcas/chat/picker.rb
+- lib/rcas/chat/repl.rb
+- lib/rcas/chat/session.rb
+- lib/rcas/chat/settings.rb
+- lib/rcas/chat/style.rb
+- lib/rcas/chat/tool.rb
+- lib/rcas/chat/ui.rb
+- lib/rcas/chat/usage.rb
+- lib/rcas/chat/workspace.rb
+- lib/rcas/coefficients.rb
+- lib/rcas/combinatorics.rb
+- lib/rcas/complex_parts.rb
+- lib/rcas/constants.rb
+- lib/rcas/core_ext.rb
+- lib/rcas/decide.rb
+- lib/rcas/decompositions.rb
+- lib/rcas/differentiate.rb
+- lib/rcas/discussion.rb
+- lib/rcas/distributions.rb
+- lib/rcas/dixon.rb
+- lib/rcas/docs.rb
+- lib/rcas/domains.rb
+- lib/rcas/expand.rb
+- lib/rcas/expression.rb
+- lib/rcas/factor.rb
+- lib/rcas/finite_field.rb
+- lib/rcas/fourier.rb
+- lib/rcas/fps.rb
+- lib/rcas/fraction.rb
+- lib/rcas/functions.rb
+- lib/rcas/gcd.rb
+- lib/rcas/geometry.rb
+- lib/rcas/groebner.rb
+- lib/rcas/hold.rb
+- lib/rcas/hypothesis.rb
+- lib/rcas/inequalities.rb
+- lib/rcas/integral_functions.rb
+- lib/rcas/integrate.rb
+- lib/rcas/integrate_substitutions.rb
+- lib/rcas/interpolate.rb
+- lib/rcas/irb.rb
+- lib/rcas/laplace.rb
+- lib/rcas/latex.rb
+- lib/rcas/lattice.rb
+- lib/rcas/linear_algebra.rb
+- lib/rcas/linear_program.rb
+- lib/rcas/lint.rb
+- lib/rcas/matrix.rb
+- lib/rcas/matrix_multiply.rb
+- lib/rcas/multimodular.rb
+- lib/rcas/named_polynomials.rb
+- lib/rcas/number_theory.rb
+- lib/rcas/numerics.rb
+- lib/rcas/ode.rb
+- lib/rcas/openmath.rb
+- lib/rcas/openmath/objects.rb
+- lib/rcas/openmath/phrasebook.rb
+- lib/rcas/openmath/popcorn.rb
+- lib/rcas/openmath/xml.rb
+- lib/rcas/petkovsek.rb
+- lib/rcas/piecewise.rb
+- lib/rcas/plot.rb
+- lib/rcas/plot3d.rb
+- lib/rcas/poly_matrix.rb
+- lib/rcas/poly_recurrence.rb
+- lib/rcas/polynomial.rb
+- lib/rcas/precision.rb
+- lib/rcas/printer.rb
+- lib/rcas/product.rb
+- lib/rcas/q_difference.rb
+- lib/rcas/q_functions.rb
+- lib/rcas/q_summation.rb
+- lib/rcas/q_zeilberger.rb
+- lib/rcas/random.rb
+- lib/rcas/rational_function.rb
+- lib/rcas/recurrence.rb
+- lib/rcas/render.rb
+- lib/rcas/results.rb
+- lib/rcas/scalar.rb
+- lib/rcas/series.rb
+- lib/rcas/simplify.rb
+- lib/rcas/solve.rb
+- lib/rcas/special.rb
+- lib/rcas/statistics.rb
+- lib/rcas/steps.rb
+- lib/rcas/summation.rb
+- lib/rcas/trig.rb
+- lib/rcas/van_hoeij.rb
+- lib/rcas/vector.rb
+- lib/rcas/vector_calculus.rb
+- lib/rcas/version.rb
+- lib/rcas/zeilberger.rb
+- package.json
+homepage: https://github.com/no-dashes/rcas
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/no-dashes/rcas
+  documentation_uri: https://github.com/no-dashes/rcas/blob/main/MANUAL.md
+  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.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: A computer algebra system that lives inside Ruby
+test_files: []