rcas 0.2.0

data/lib/rcas/chat/workspace.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module RCAS
+  module Chat
+    # The object and binding that user code and tool code run in. Bare
+    # identifiers that are not yet defined become symbols (and locals), as
+    # in bin/rcas; Functions (sin, sqrt, assume, matrix, show, ...) and the
+    # number sets are in scope.
+    class Workspace
+      IDENTIFIER = RCAS::IDENTIFIER # Unicode names (α, β₁, ∞) included
+
+      module AutoSymbol
+        def method_missing(name, *args, &block)
+          return super unless block.nil? && name.match?(IDENTIFIER)
+          return RCAS.unknown_function(name, args) || super unless args.empty? # u(n + 1): an unknown function
+          __rcas_workspace__.binding.local_variable_set(name, name)
+          name
+        end
+
+        # Deliberately false so Ruby's implicit conversions are unaffected.
+        def respond_to_missing?(_name, _include_private = false) = false
+      end
+
+      attr_reader :binding, :main
+
+      def initialize
+        Object.include(Sets) unless Object.include?(Sets)
+        @main = Object.new
+        workspace = self
+        @main.singleton_class.include(Functions)
+        @main.singleton_class.prepend(AutoSymbol)
+        RCAS.undefine_kernel_printers(@main) # p, pp, j, jj are indeterminates here
+        @main.define_singleton_method(:__rcas_workspace__) { workspace }
+        @main.define_singleton_method(:to_s) { "rcas" }
+        @main.define_singleton_method(:inspect) { "rcas" }
+        # A method body has a fresh local scope, so the binding starts empty.
+        @main.singleton_class.class_eval("def __rcas_binding__ = binding")
+        @binding = @main.__rcas_binding__
+      end
+
+      # Evaluate +code+; returns [value, captured_stdout]. With capture:
+      # false output goes straight to $stdout and the second value is "".
+      def eval(code, capture: false)
+        output = +""
+        value =
+          if capture
+            previous = $stdout
+            $stdout = StringIO.new(output)
+            begin
+              run(code)
+            ensure
+              $stdout = previous
+            end
+          else
+            run(code)
+          end
+        @binding.local_variable_set(:_, value)
+        [value, output]
+      end
+
+      # A line that does not parse raises its SyntaxError, which the REPL
+      # reports; Ruby also printed a warning of its own for some of them,
+      # past the UI and onto stderr (`? hello` without Claude gave "invalid
+      # character syntax; use ?\s" and then the error). Such a line is
+      # evaluated quietly, so the error is still the same one. A line that
+      # parses runs as it is, with whatever warnings its running gives.
+      def run(code)
+        parses = begin
+          Hold.parse(code)
+          true
+        rescue SyntaxError
+          false
+        end
+        parses ? @binding.eval(code, "(rcas)", 1) : Hold.quietly { @binding.eval(code, "(rcas)", 1) }
+      end
+
+      # Run code for its side effects only (used when restoring a session).
+      def replay(code)
+        eval(code, capture: true)
+      rescue StandardError, ScriptError, SystemStackError
+        nil
+      end
+
+      def locals
+        @binding.local_variables.reject { |v| v == :_ }.to_h { |v| [v, @binding.local_variable_get(v)] }
+      end
+
+      def [](name) = @binding.local_variable_get(name)
+
+      # Does +code+ parse as Ruby?
+      def ruby?(code)
+        Hold.parse(code)
+        true
+      rescue SyntaxError
+        false
+      end
+
+      # Does +code+ call, with arguments, a bare name the workspace does not
+      # define (foo(1), x(squared))? Such calls would become unknown functions.
+      def undefined_calls?(code)
+        receiver = @binding.receiver
+        stack = [Hold.parse(code)]
+        until stack.empty?
+          node = stack.pop
+          next unless node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+          return true if node.type == :FCALL && !receiver.respond_to?(node.children.first, true) && !@binding.local_variable_defined?(node.children.first)
+          stack.concat(node.children)
+        end
+        false
+      rescue SyntaxError
+        false
+      end
+
+      # Is +code+ Ruby that merely stops early (open block, string, paren)?
+      def incomplete?(code)
+        Hold.parse(code)
+        false
+      rescue SyntaxError => e
+        e.message.match?(/unexpected end-of-input|unexpected end of input|unexpected end-of-file|unterminated .* meets end of file|embedded document meets end of file/i)
+      end
+
+      # Tab-completion candidates.
+      def complete(prefix)
+        names = locals.keys.map(&:to_s) + Functions.instance_methods(false).map(&:to_s) + Sets::ALL.map(&:to_s)
+        names += %w[simplify expand factor diff integrate subs call evalf to_latex show to_poly variables domain]
+        names.uniq.select { |n| n.start_with?(prefix) }.sort
+      end
+    end
+  end
+end

data/lib/rcas/chat.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "rcas"
+
+module RCAS
+  # A Claude-Code-style terminal front end for rcas (bin/rcas-chat).
+  #
+  # * Ruby is evaluated in a session where bare identifiers are variables,
+  #   like bin/rcas; results are shown as text and, in iTerm2, typeset.
+  # * Anything that is not Ruby is a question for Claude, which answers by
+  #   running rcas code in the same session through the rcas_eval tool.
+  # * /commands configure the session, !cmd runs a shell command, and
+  #   sessions are saved so `rcas-chat --continue` picks up where you left.
+  module Chat
+    class Error < StandardError; end
+
+    # The anthropic gem, loaded on first need: when credentials are present,
+    # or a test hands the assistant a scripted runner. A session nobody asks
+    # Claude in never loads it - it was a thousand files and a fifth of a
+    # second on every start of rcas-chat, and one of its dependencies
+    # (standardwebhooks) warns under -w. true when the gem is there.
+    def self.load_anthropic
+      return true if defined?(EvalTool)
+      return false if @anthropic_missing
+      quietly do
+        require "anthropic"
+        require_relative "chat/tool"
+      end
+      true
+    rescue LoadError
+      @anthropic_missing = true
+      false
+    end
+
+    # $VERBOSE off for the block and back to what it was on every way out.
+    def self.quietly
+      verbose = $VERBOSE
+      $VERBOSE = nil
+      yield
+    ensure
+      $VERBOSE = verbose
+    end
+  end
+end
+
+require_relative "chat/settings"
+require_relative "chat/style"
+require_relative "chat/workspace"
+require_relative "chat/ui"
+require_relative "chat/usage"
+require_relative "chat/assistant"
+require_relative "chat/session"
+require_relative "chat/picker"
+require_relative "chat/repl"

data/lib/rcas/coefficients.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module RCAS
+  # Polynomial structure of expressions: degree, leading and trailing
+  # coefficient, single coefficients, the coefficient list, and collecting
+  # in one indeterminate.
+  #
+  #   degree((x + 1)**3, x)             # => 3
+  #   coeff(a*x**2 + b*x + c, x, 2)     # => a
+  #   collect((x + y)**2 + a*x, x)      # => y**2 + (a + 2*y)*x + x**2
+  #
+  # Everything works on Expand.table, so the input need not be expanded and
+  # the coefficients come back in canonical form. Without an indeterminate
+  # the functions look at all indeterminates of the expression: `degree` is
+  # the total degree, `lcoeff`/`tcoeff` belong to the last/first term of the
+  # canonical sum, `coeffs` lists the coefficients in that order.
+  #
+  # An expression that is not a polynomial in the indeterminate (x inside a
+  # function, in a denominator, with a fractional or symbolic exponent)
+  # raises DomainError rather than guessing.
+  module Coefficients
+    module_function
+
+    # Highest exponent; -1 for the zero polynomial (as Polynomial#degree).
+    def degree(expr, var = nil)
+      terms = terms_in(expr, var)
+      terms.empty? ? -1 : terms.map(&:first).max
+    end
+
+    # Lowest exponent; -1 for the zero polynomial.
+    def ldegree(expr, var = nil)
+      terms = terms_in(expr, var)
+      terms.empty? ? -1 : terms.map(&:first).min
+    end
+
+    # Coefficient of the highest power of var (last term of the canonical sum
+    # when var is nil).
+    def lcoeff(expr, var = nil)
+      terms = terms_in(expr, var)
+      return Num.new(0) if terms.empty?
+      var ? coefficient(terms, terms.map(&:first).max) : terms.last[1]
+    end
+
+    # Coefficient of the lowest power of var (first term of the canonical sum
+    # when var is nil).
+    def tcoeff(expr, var = nil)
+      terms = terms_in(expr, var)
+      return Num.new(0) if terms.empty?
+      var ? coefficient(terms, terms.map(&:first).min) : terms.first[1]
+    end
+
+    # coeff(f, x, k) or coeff(f, x**k): the coefficient of x**k.
+    def coeff(expr, var, k = 1)
+      var, k = split_power(var, k)
+      coefficient(terms_in(expr, var), k)
+    end
+
+    # Coefficients of x**0, x**1, ..., x**degree (zeros included), or the
+    # coefficients of the canonical sum's terms when var is nil.
+    def coeffs(expr, var = nil)
+      terms = terms_in(expr, var)
+      return terms.map(&:last) unless var
+      return [] if terms.empty?
+      (0..terms.map(&:first).max).map { |k| coefficient(terms, k) }
+    end
+
+    # Sum of coeff(f, x, k) * x**k over the exponents that occur, ascending.
+    def collect(expr, var)
+      var = variable(var)
+      terms = terms_in(expr, var)
+      return Num.new(0) if terms.empty?
+      parts = terms.map(&:first).uniq.sort.map { |k| collected_term(coefficient(terms, k), var, k) }
+      Simplify.sum_tree(parts)
+    end
+
+    # ---- internals --------------------------------------------------------
+
+    # With var: [[exponent of var, coefficient expression], ...] sorted by
+    # exponent, one entry per exponent. Without var: one entry per term of
+    # the canonical sum, [total degree, coefficient], in canonical order.
+    def terms_in(expr, var)
+      expr = expr.to_expr if expr.respond_to?(:to_expr)
+      expr = Expression.lift(expr)
+      var = variable(var) if var
+      names = var ? [var.name] : expr.variables
+      constant, table = Expand.table(expr)
+      grouped = Hash.new { |h, k| h[k] = [0, {}] }
+      grouped[var ? 0 : {}] = [constant, {}] unless constant.zero?
+      table.each do |factors, c|
+        exponents = {}
+        rest = {}
+        factors.each do |base, exp|
+          if base.is_a?(Var) && names.include?(base.name)
+            polynomial_exponent!(expr, base, exp)
+            exponents[base] = exp
+          else
+            # exp(x) is e**x: the exponent counts, or exp(x) was the constant
+            # coefficient of itself (third review, A3)
+            offending = (base.variables | (exp.is_a?(Expression) ? exp.variables : [])) & names
+            raise DomainError, "#{expr} is not a polynomial in #{offending.first}" unless offending.empty?
+            rest[base] = exp
+          end
+        end
+        key = var ? exponents.fetch(var, 0) : exponents
+        entry = grouped[key]
+        if rest.empty?
+          entry[0] += c
+        else
+          Expand.add_term(entry[1], rest, c)
+        end
+      end
+      if var
+        grouped.sort.map { |k, (c, t)| [k, Simplify.rebuild_sum(c, t)] }
+      else
+        grouped.sort_by { |exponents, _| Simplify.sort_key(Simplify.rebuild_product(1, exponents)) }
+               .map { |exponents, (c, t)| [exponents.values.sum, Simplify.rebuild_sum(c, t)] }
+      end
+    end
+
+    def polynomial_exponent!(expr, base, exp)
+      return if exp.is_a?(Integer) && exp >= 0
+      raise DomainError, "#{expr} is not a polynomial in #{base}"
+    end
+
+    def coefficient(terms, k)
+      entry = terms.assoc(k)
+      entry ? entry[1] : Num.new(0)
+    end
+
+    def variable(var)
+      v = Expression.lift(var)
+      raise ArgumentError, "#{var} is not an indeterminate" unless v.is_a?(Var)
+      v
+    end
+
+    def split_power(var, k)
+      k = k.value if k.is_a?(Num) # literals arrive as Num inside hold { }
+      v = var.is_a?(Symbol) ? var : Expression.lift(var)
+      if v.is_a?(Pow) && v.exponent.is_a?(Num) && v.exponent.value.is_a?(Integer)
+        [variable(v.base), v.exponent.value]
+      else
+        raise ArgumentError, "coeff: the exponent must be an integer" unless k.is_a?(Integer)
+        [variable(v), k]
+      end
+    end
+
+    # [expression, negative?] for one term of a collected sum.
+    def collected_term(coefficient, var, k)
+      return [coefficient, false] if k.zero?
+      power = { var => k }
+      case coefficient
+      when Add, Sub then [Mul.new(coefficient, Simplify.rebuild_product(1, power)), false]
+      else
+        c, factors = Simplify.factorize(coefficient)
+        negative = Simplify.sign_negative?(c)
+        [Simplify.rebuild_product(negative ? -c : c, factors.merge(power)), negative]
+      end
+    end
+  end
+
+  class Expression
+    def degree(var = nil) = Coefficients.degree(self, var)
+    def ldegree(var = nil) = Coefficients.ldegree(self, var)
+    def lcoeff(var = nil) = Coefficients.lcoeff(self, var)
+    def tcoeff(var = nil) = Coefficients.tcoeff(self, var)
+    def coeff(var, k = 1) = Coefficients.coeff(self, var, k)
+    def coeffs(var = nil) = Coefficients.coeffs(self, var)
+    def collect(var) = Coefficients.collect(self, var)
+  end
+end

data/lib/rcas/combinatorics.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+module RCAS
+  # factorial, binomial and gamma: exact values, the (k+1)!/k! = k+1
+  # cancellation used by simplify and Gosper, and the classical power series
+  # (exp, sin, cos, sinh, cosh, log, atan, the binomial theorem) that turn
+  # infinite hypergeometric sums into closed forms.
+  module Combinatorics
+    module_function
+
+    # Fibonacci numbers by fast doubling; F(-n) = (-1)**(n + 1) F(n).
+    def fibonacci(n)
+      return (n.even? ? -1 : 1) * fibonacci(-n) if n.negative?
+      a, b = 0, 1 # F(k), F(k + 1)
+      n.bit_length.downto(1) do |i|
+        c = a * (2 * b - a) # F(2k)
+        d = a * a + b * b   # F(2k + 1)
+        a, b = n[i - 1] == 1 ? [d, c + d] : [c, d]
+      end
+      a
+    end
+
+    def factorial_value(n)
+      case n
+      when Integer then n >= 0 ? Num.new((1..n).reduce(1, :*)) : nil
+      when Rational then gamma_value(n + 1)
+      when Float then n < 0 && n == n.round ? UNDEFINED : Num.new(Math.gamma(n + 1))
+      end
+    end
+
+    # gamma(n) for integers and half-integers exactly, floats numerically.
+    def gamma_value(v)
+      case v
+      when Integer then v >= 1 ? Num.new((1..v - 1).reduce(1, :*)) : nil
+      when Rational
+        return nil unless v.denominator == 2
+        # gamma(n + 1/2) = (2n)! / (4**n n!) sqrt(pi), extended downwards by gamma(x) = gamma(x + 1) / x
+        n = (v - Rational(1, 2)).to_i
+        if n >= 0
+          c = Rational((1..2 * n).reduce(1, :*), 4**n * (1..n).reduce(1, :*))
+        else
+          c = Rational(1)
+          (n...0).each { |j| c /= (j + Rational(1, 2)) }
+        end
+        (Num.new(c) * RCAS.sqrt(PI)).simplify
+      # a pole (0, -1, -2, ... as a Float) has no value: undefined, not a
+      # Math::DomainError reaching the user (third review, C6)
+      when Float then v <= 0 && v == v.round ? UNDEFINED : Num.new(Math.gamma(v))
+      end
+    end
+
+    def binomial_value(n, k)
+      # a Float that is a whole number is one (evalf floats both arguments)
+      k = Num.new(k.value.to_i) if k.is_a?(Num) && k.value.is_a?(Float) && k.value.finite? && k.value == k.value.round
+      if k.is_a?(Num) && k.value.is_a?(Float) && n.is_a?(Num) && n.value.is_a?(Float) &&
+         [n.value + 1, k.value + 1, n.value - k.value + 1].all?(&:positive?)
+        return Num.new(Math.exp(Math.lgamma(n.value + 1).first - Math.lgamma(k.value + 1).first - Math.lgamma(n.value - k.value + 1).first))
+      end
+      return nil unless k.is_a?(Num) && k.value.is_a?(Integer)
+      kk = k.value
+      return Num.new(0) if kk.negative?
+      return Num.new(1) if kk.zero?
+      return n if kk == 1
+      if n.is_a?(Num) && n.value.is_a?(Integer)
+        nn = n.value
+        return Num.new(0) if nn >= 0 && kk > nn
+        return Num.new((0...kk).reduce(1) { |acc, i| acc * (nn - i) } / (1..kk).reduce(1, :*))
+      end
+      # binomial(1/2, 3) is a number too: the falling factorial over k!
+      if n.is_a?(Num) && (n.value.is_a?(Rational) || n.value.is_a?(Float))
+        falling = (0...kk).reduce(1) { |acc, i| acc * (n.value - i) }
+        return Num.new(Simplify.normalize_number(falling / (1..kk).reduce(1, :*)))
+      end
+      nil
+    end
+
+    # binomial(n, k) with a numeric k as the polynomial n(n-1)...(n-k+1)/k!
+    def expand_binomial(n, k)
+      return nil unless k.is_a?(Num) && k.value.is_a?(Integer) && k.value >= 0
+      kk = k.value
+      product = (0...kk).reduce(Num.new(1)) { |acc, i| acc * (n - i) }
+      (product / (1..kk).reduce(1, :*)).expand
+    end
+
+    # Replace binomials by factorials (for ratios of consecutive terms).
+    def to_factorials(expr)
+      expr = expr.map_children { |c| to_factorials(c) }
+      if expr.is_a?(Fn) && expr.name == :binomial
+        n, k = expr.args
+        return Fn.new(:factorial, [n]) / (Fn.new(:factorial, [k]) * Fn.new(:factorial, [(n - k).simplify]))
+      end
+      expr
+    end
+
+    # Merge factorials whose arguments differ by an integer:
+    # (k + 2)! / k!  =>  (k + 1)(k + 2). Mutates +factors+ (base => exponent).
+    def merge_factorials(factors)
+      loop do
+        facts = factors.keys.select { |b| b.is_a?(Fn) && b.name == :factorial }
+        pair = nil
+        facts.combination(2).each do |a, b|
+          d = (a.args.first - b.args.first).simplify
+          next unless d.is_a?(Num) && d.value.is_a?(Integer) && !d.zero?
+          pair = d.value.positive? ? [a, b, d.value] : [b, a, -d.value]
+          break
+        end
+        return factors unless pair
+        big, small, m = pair
+        e = factors.delete(big)
+        Simplify.add_factor(factors, small, e)
+        (1..m).each { |i| Simplify.add_factor(factors, (small.args.first + i).simplify, e) }
+      end
+    end
+
+    # A closed form built out of gammas and factorials is often a binomial
+    # coefficient wearing a disguise: the sum of binomial(n, k)**2 comes
+    # back as 2**(2*n)*gamma(1/2 + n)/(pi**(1/2)*n!), which is
+    # binomial(2*n, n). The shape is guessed - one of a handful of linear
+    # arguments - and then checked at several integers, which is what makes
+    # guessing safe (fps offers its coefficient in three forms and lets the
+    # same kind of check decide). nil when nothing fits.
+    UPPER = [1, 2].freeze
+    LOWER = [0, 1, 2].freeze
+    SHIFTS = [0, 1, -1, 2, -2].freeze # nearest first, so binomial(2*n, n) wins over 2*binomial(2*n - 1, n - 1)
+    SAMPLES = [3, 4, 5, 6].freeze
+
+    def as_binomial(expr, var)
+      expr = Expression.lift(expr)
+      return nil unless expr.each_node.any? { |n| n.is_a?(Fn) && %i[gamma factorial].include?(n.name) }
+      values = SAMPLES.map { |m| numeric_at(expr, var, m) }
+      return nil if values.any? { |v| v.nil? || v.zero? }
+
+      UPPER.each do |a|
+        LOWER.each do |c|
+          next if c > a
+          SHIFTS.each do |b|
+            SHIFTS.each do |d|
+              ratio = constant_ratio(values, a, b, c, d)
+              next unless ratio
+              form = (Expression.lift(ratio) * Fn.new(:binomial, [(a * var + b).simplify, (c * var + d).simplify])).simplify
+              return form
+            end
+          end
+        end
+      end
+      nil
+    end
+
+    # The same rational multiple of binomial(a*m + b, c*m + d) at every
+    # sample, or nil. A "nice" rational only: a ratio that needs sixty digits
+    # is the numerics talking, not an identity.
+    def constant_ratio(values, a, b, c, d)
+      first = nil
+      SAMPLES.each_with_index do |m, i|
+        top = a * m + b
+        bottom = c * m + d
+        return nil if bottom.negative? || top < bottom
+        binomial = (0...bottom).reduce(1) { |acc, j| acc * (top - j) } / (1..bottom).reduce(1, :*)
+        return nil if binomial.zero?
+        ratio = values[i] / binomial.to_f
+        rational = Rational(ratio).rationalize(Rational(1, 10**9))
+        return nil if rational.numerator.abs > 64 || rational.denominator > 64
+        first ||= rational
+        return nil unless (ratio - first).abs < 1e-9 * [1.0, ratio.abs].max
+      end
+      first
+    end
+
+    def numeric_at(expr, var, m)
+      value = expr.evalf(var.name => m)
+      value = value.value if value.is_a?(Num)
+      value.is_a?(Numeric) && value.real? && value.finite? ? value.to_f : nil
+    rescue StandardError => rescued
+      RCAS.guard!(rescued)
+      nil
+    end
+
+    # sum_k binomial(n, k)*x**k is a polynomial when n is a non-negative
+    # integer and otherwise converges only for |x| < 1. Without the test
+    # sum((-1)**k, k, 0, oo) came back as 1/2 - the value the formula gives
+    # at x = 1, where the series does not converge at all.
+    def binomial_series_converges?(n, x)
+      return true unless n.is_a?(Num) # a symbolic upper index: the terms vanish past k = n
+      return true if n.value.is_a?(Integer) && n.value >= 0
+      value = x.is_a?(Num) ? x.value : (x.variables.empty? ? x.evalf : nil)
+      value = value.value if value.is_a?(Num)
+      return true unless value.is_a?(Numeric) # symbolic: convergence is assumed, as elsewhere here
+      value.abs < 1
+    end
+
+    # |x| <= 1, decided; a symbolic x is assumed inside, as elsewhere here.
+    # A constant whose modulus cannot be compared with 1 is not.
+    def within_radius?(x)
+      return true unless x.variables.empty?
+      re, im = ComplexParts.parts(x)
+      sign = Decide.sign((re**2 + im**2 - 1).simplify)
+      sign == :negative || sign == :zero
+    rescue StandardError => rescued
+      RCAS.guard!(rescued)
+      false
+    end
+
+    # log(0), oo, and atan(+-i): the arctangent series has radius 1 and its
+    # singularities at +-i, where sum 1/(2k + 1) diverges (fourth review).
+    def divergent?(value)
+      value.each_node.any? do |n|
+        (n.is_a?(Fn) && n.name == :log && n.args.first.is_a?(Num) && n.args.first.zero?) || n == OO ||
+          (n.is_a?(Fn) && n.name == :atan && plus_minus_i?(n.args.first.simplify))
+      end
+    end
+
+    def plus_minus_i?(u) = u.is_a?(Num) && u.value.is_a?(Complex) && u.value.real.zero? && u.value.imaginary.abs == 1
+
+    # sqrt(e) when e is a perfect square (x**2, 4*y**2); any sqrt when not exact_only.
+    def root_of(e, exact_only)
+      coeff, factors = Simplify.factorize(e)
+      if factors.values.all? { |x| x.is_a?(Integer) && x.even? } && coeff.is_a?(Integer) && coeff.positive? &&
+         Integer.sqrt(coeff)**2 == coeff
+        return Simplify.rebuild_product(Integer.sqrt(coeff), factors.transform_values { |x| x / 2 })
+      end
+      exact_only ? nil : RCAS.sqrt(e)
+    end
+
+    # ---- classical series ---------------------------------------------------
+
+    # Infinite hypergeometric sums with a known closed form. r is the ratio
+    # f(k+1)/f(k) as a rational function of k; m0 is the natural first index.
+    # Returns [start_index, sum of the series whose first term is 1].
+    def known_series(r, k)
+      one = Num.new(1)
+      two = Num.new(2)
+      candidates = []
+      candidates << [0, ->(x) { Fn.new(:exp, [x]) }, (r * (k + 1)).cancel, :direct]
+      candidates << [0, ->(x) { Fn.new(:cos, [x]) }, (r * (2 * k + 1) * (2 * k + 2)).cancel, :neg_square]
+      candidates << [0, ->(x) { Fn.new(:sin, [x]) / x }, (r * (2 * k + 2) * (2 * k + 3)).cancel, :neg_square]
+      candidates << [0, ->(x) { Fn.new(:cosh, [x]) }, (r * (2 * k + 1) * (2 * k + 2)).cancel, :square]
+      candidates << [0, ->(x) { Fn.new(:sinh, [x]) / x }, (r * (2 * k + 2) * (2 * k + 3)).cancel, :square]
+      candidates << [1, ->(x) { Fn.new(:log, [one + x]) / x }, (r * (k + 1) / k).cancel, :negated, true]
+      candidates << [0, ->(x) { Fn.new(:atan, [x]) / x }, (r * (2 * k + 3) / (2 * k + 1)).cancel, :neg_square, true]
+      [true, false].each do |exact_roots_only|
+        candidates.each do |m0, template, p, kind, radius_one|
+          next if p.variables.include?(k.name)
+          x =
+            case kind
+            when :direct then p
+            when :negated then (-p).simplify
+            when :square then root_of(p, exact_roots_only)
+            when :neg_square then root_of((-p).simplify, exact_roots_only)
+            end
+          next if x.nil? || (x.is_a?(Num) && x.zero?)
+          # log(1 + x) and atan(x) are power series of radius 1: outside it
+          # the terms do not tend to 0 and the sum has no value, whatever
+          # the formula gives there (sum((-2)**k/k) is not -log(3)).
+          next if radius_one && !within_radius?(x)
+          value = template.call(x).simplify
+          next if divergent?(value) # log(1 + x) at x = -1: the harmonic series
+          return [m0, value]
+        end
+      end
+      # binomial theorem: r = (n - k) x / (k + 1)
+      p = (r * (k + 1)).cancel
+      coeffs = Solve.polynomial_coefficients(p, k)
+      if coeffs && coeffs.size == 2
+        x = (-coeffs[1]).simplify
+        n = (coeffs[0] / x).cancel
+        if [n, x].none? { |v| v.variables.include?(k.name) } && binomial_series_converges?(n, x)
+          return [0, ((one + x)**n).simplify]
+        end
+      end
+      _ = two
+      nil
+    end
+  end
+end