rcas 0.2.0

data/lib/rcas/q_functions.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module RCAS
+  # The q-analogues: everything in the q-world is built from the q-Pochhammer
+  # symbol
+  #
+  #   (a; q)_n = (1 - a)(1 - a*q)...(1 - a*q**(n - 1)),
+  #
+  # which plays the part the rising factorial plays for ordinary
+  # hypergeometric terms. On top of it sit the q-bracket [n]_q, the
+  # q-factorial and the q-binomial coefficient:
+  #
+  #   [n]_q = (1 - q**n)/(1 - q)      -> n as q -> 1
+  #   [n]_q! = [1]_q*[2]_q*...*[n]_q = (q; q)_n/(1 - q)**n
+  #   qbinomial(n, k, q) = (q; q)_n/((q; q)_k*(q; q)_(n - k))
+  #
+  # Each is a function of its own so that output stays readable; the
+  # algorithms expand them into q-Pochhammer symbols themselves, the way the
+  # ordinary ones expand binomials into factorials. Integer arguments fold
+  # right away, as everywhere else in rcas.
+  #
+  # Sources (keys: MANUAL.md, Sources): [Koe14, ch. 10]; [GR04, ch. 1].
+  module QFunctions
+    NAMES = %i[qpochhammer qbracket qfactorial qbinomial].freeze
+    MAX_FOLD = 128
+
+    module_function
+
+    # (a; q)_n, the q-Pochhammer symbol.
+    def qpochhammer(a, q, n)
+      a = Expression.lift(a)
+      q = Expression.lift(q)
+      n = Expression.lift(n)
+      m = integer(n)
+      return Fn.new(:qpochhammer, [a, q, n]) if m.nil? || m.negative? || m > MAX_FOLD
+      (0...m).reduce(Num.new(1)) { |acc, i| acc * (1 - a * q**i) }.simplify
+    end
+
+    # [n]_q = 1 + q + ... + q**(n - 1).
+    def qbracket(n, q)
+      n = Expression.lift(n)
+      q = Expression.lift(q)
+      m = integer(n)
+      return Fn.new(:qbracket, [n, q]) if m.nil? || m.negative? || m > MAX_FOLD
+      (0...m).reduce(Num.new(0)) { |acc, i| acc + q**i }.simplify
+    end
+
+    # [n]_q! = [1]_q*[2]_q*...*[n]_q.
+    def qfactorial(n, q)
+      n = Expression.lift(n)
+      q = Expression.lift(q)
+      m = integer(n)
+      return Fn.new(:qfactorial, [n, q]) if m.nil? || m.negative? || m > MAX_FOLD
+      (1..m).reduce(Num.new(1)) { |acc, i| acc * qbracket(Num.new(i), q) }.expand
+    end
+
+    # The Gaussian binomial coefficient: a polynomial in q whose value at
+    # q = 1 is the ordinary one.
+    def qbinomial(n, k, q)
+      n = Expression.lift(n)
+      k = Expression.lift(k)
+      q = Expression.lift(q)
+      top = integer(n)
+      bottom = integer(k)
+      return Fn.new(:qbinomial, [n, k, q]) if top.nil? || bottom.nil? || top.negative? || top > MAX_FOLD
+      return Num.new(0) if bottom.negative? || bottom > top
+      # the quotient is a polynomial: cancel it in a variable of its own and
+      # put q in afterwards, so that q = 1 and q = -1 give its values rather
+      # than 0/0 (third review, S10)
+      t = q.is_a?(Var) ? q : Var.new(:_qb)
+      numerator = ((top - bottom + 1)..top).reduce(Num.new(1)) { |acc, i| acc * (1 - t**i) }
+      denominator = (1..bottom).reduce(Num.new(1)) { |acc, i| acc * (1 - t**i) }
+      polynomial = (numerator / denominator).cancel.expand
+      t.equal?(q) ? polynomial : polynomial.subs(t => q).expand
+    end
+
+    # Constant folding, called by Functions.fold when Simplify meets one of
+    # these nodes: an integer index gives the product, whatever q is.
+    def fold(fn)
+      case fn.name
+      when :qpochhammer then fn.args.size == 3 ? qpochhammer(*fn.args) : nil
+      when :qbracket then fn.args.size == 2 ? qbracket(*fn.args) : nil
+      when :qfactorial then fn.args.size == 2 ? qfactorial(*fn.args) : nil
+      when :qbinomial then fn.args.size == 3 ? qbinomial(*fn.args) : nil
+      end
+    end
+
+    # ---- what the algorithms work with ------------------------------------------
+
+    # Everything rewritten in q-Pochhammer symbols, the way to_factorials
+    # rewrites binomials.
+    def to_pochhammer(expr)
+      expr = expr.map_children { |c| to_pochhammer(c) }
+      return expr unless expr.is_a?(Fn) && NAMES.include?(expr.name)
+      case expr.name
+      when :qbracket
+        n, q = expr.args
+        (1 - q**n) / (1 - q)
+      when :qfactorial
+        n, q = expr.args
+        Fn.new(:qpochhammer, [q, q, n]) / (1 - q)**n
+      when :qbinomial
+        n, k, q = expr.args
+        Fn.new(:qpochhammer, [q, q, n]) /
+          (Fn.new(:qpochhammer, [q, q, k]) * Fn.new(:qpochhammer, [q, q, (n - k).simplify]))
+      else expr
+      end
+    end
+
+    # Every q-Pochhammer symbol of one family written on the lowest index
+    # that occurs, (a; q)_(m + d) = (a; q)_m*(1 - a*q**m)*...*(1 - a*q**(m + d - 1)),
+    # so that a sum of such terms has a common factor and cancel can put it
+    # over one denominator.
+    def align(expr)
+      symbols = expr.each_node.select { |e| e.is_a?(Fn) && e.name == :qpochhammer && e.args.size == 3 }.uniq
+      return expr if symbols.size < 2
+      replacements = {}
+      symbols.group_by { |e| [e.args[0], e.args[1]] }.each_value do |family|
+        family.combination(2).each do |one, other|
+          d = (one.args[2] - other.args[2]).simplify
+          next unless d.is_a?(Num) && d.value.is_a?(Integer) && !d.zero?
+          big, small, steps = d.value.positive? ? [one, other, d.value] : [other, one, -d.value]
+          a, q, m = small.args
+          replacements[big] ||= (0...steps).reduce(small) { |acc, i| acc * (1 - a * q**(m + i)) }
+        end
+      end
+      replacements.empty? ? expr : expr.subs(replacements)
+    end
+
+    # (a; q)_(m + d) / (a; q)_m = (1 - a*q**m)...(1 - a*q**(m + d - 1)):
+    # cancel q-Pochhammer symbols whose indices differ by an integer, so that
+    # a term ratio comes out as a rational function of q**k. Mutates
+    # +factors+ (base => exponent), like Combinatorics.merge_factorials.
+    def merge_pochhammers(factors)
+      loop do
+        symbols = factors.keys.select { |b| b.is_a?(Fn) && b.name == :qpochhammer }
+        pair = nil
+        symbols.combination(2).each do |one, other|
+          next unless one.args[0] == other.args[0] && one.args[1] == other.args[1]
+          d = (one.args[2] - other.args[2]).simplify
+          next unless d.is_a?(Num) && d.value.is_a?(Integer) && !d.zero?
+          pair = d.value.positive? ? [one, other, d.value] : [other, one, -d.value]
+          break
+        end
+        return factors unless pair
+        big, small, d = pair
+        a, q, m = small.args
+        exponent = factors.delete(big)
+        Simplify.add_factor(factors, small, exponent)
+        (0...d).each { |i| Simplify.add_factor(factors, (1 - a * q**(m + i)).simplify, exponent) }
+      end
+    end
+
+    def integer(value)
+      value.is_a?(Num) && value.value.is_a?(Integer) ? value.value : nil
+    end
+  end
+end

data/lib/rcas/q_summation.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+module RCAS
+  # q-summation: Gosper's algorithm in the q-world.
+  #
+  # A term is q-hypergeometric when t(k + 1)/t(k) is a rational function of
+  # q**k, the way an ordinary hypergeometric term has a rational function of
+  # k. Writing x for q**k turns the shift k -> k + 1 into x -> q*x, and
+  # everything Gosper does goes through with that one change: the
+  # q-Gosper-Petkovsek normal form
+  #
+  #   t(k + 1)/t(k) = a(x)/b(x) * c(q*x)/c(x),  gcd(a(x), b(q**h*x)) = 1
+  #
+  # for every integer h >= 0, and then the q-analogue of Gosper's equation
+  #
+  #   a(x)*X(q*x) - b(x/q)*X(x) = c(x)
+  #
+  # for a polynomial X, from which the antidifference is
+  # S(k) = b(x/q)*X(x)/c(x) * t(k). The answer is checked by differencing it.
+  #
+  # Sources (keys: MANUAL.md, Sources): [Koe14, ch. 11]; [Koe93] for the
+  # q-analogue of the algorithm; [GR04] for the notation.
+  module QSummation
+    X = Var.new(:_qx) # stands for q**k while the algorithm runs
+
+    module_function
+
+    # The term ratio t(k + 1)/t(k) as a rational function of q**k (as X), or
+    # nil when the term is not q-hypergeometric.
+    #
+    # A sum of terms is written as one q-hypergeometric term times a rational
+    # function of q**k: the first summand is the core, the others are
+    # measured against it, and the ratio of the whole is the ratio of the
+    # core times R(q*x)/R(x). Terms like q**(k + 1)/(q; q)_(k + 1) -
+    # q**k/(q; q)_k only telescope together, so taking them apart would lose
+    # the answer.
+    def ratio(f, k, q)
+      f = QFunctions.align(Expression.lift(f).simplify)
+      parts = summands(f)
+      core = parts.first
+      base = term_ratio(core, k, q) or return nil
+      return base if parts.size == 1
+      pieces = parts.map { |part| relative(part, core, k, q) }
+      return nil if pieces.any?(&:nil?)
+      total = pieces.reduce(:+).cancel
+      return nil if Scalar.zero?(total)
+      (base * total.subs(X => (q * X).simplify) / total).cancel
+    rescue ZeroDivisionError, DomainError
+      nil
+    end
+
+    # The ratio of a single q-hypergeometric term.
+    def term_ratio(f, k, q)
+      g = QFunctions.to_pochhammer(f)
+      in_x(cancel_q(g.subs(k => k + 1) / g), k, q)
+    end
+
+    # part/core as a rational function of q**k, or nil.
+    def relative(part, core, k, q)
+      in_x(cancel_q(QFunctions.to_pochhammer(part) / QFunctions.to_pochhammer(core)), k, q)
+    end
+
+    # Cancel q-Pochhammer symbols whose indices differ by an integer first,
+    # then the rest as usual.
+    def cancel_q(quotient)
+      coefficient, factors = Simplify.factorize(quotient, simplify: true)
+      QFunctions.merge_pochhammers(factors)
+      Simplify.rebuild_product(coefficient, factors).cancel
+    end
+
+    # q**(a*k + b) becomes q**b * X**a; nil when a k is left over.
+    def in_x(expr, k, q)
+      out = powers_in_x(expr, k, q)
+      out.variables.include?(k.name) ? nil : out
+    end
+
+    def powers_in_x(expr, k, q) = powers_in(expr, k, q, X)
+
+    # q**(a*v + b) becomes q**b * target**a: X stands for q**k, and
+    # q-Zeilberger has a second one standing for q**n.
+    def powers_in(expr, v, q, target)
+      if expr.is_a?(Pow) && expr.base == q
+        cs = Solve.polynomial_coefficients(expr.exponent, v)
+        if cs && cs.size == 2 && cs[1].is_a?(Num) && cs[1].value.is_a?(Integer)
+          return (Simplify.power_node(q, cs[0]) * target**cs[1].value).simplify
+        end
+      end
+      expr.map_children { |c| powers_in(c, v, q, target) }
+    end
+
+    # X back to q**k.
+    def in_k(expr, k, q) = expr.subs(X => q**k)
+
+    # q**n, for a parameter n, is not a polynomial in q: stand such powers in
+    # by variables of their own, so that the coefficients live in
+    # QQ(q, q**n) as they should. Returns the expression and { q**n => var }.
+    def abstract(expr, q)
+      powers = expr.each_node.select do |node|
+        node.is_a?(Pow) && node.base == q && !(node.exponent.is_a?(Num) && node.exponent.value.is_a?(Integer))
+      end.uniq
+      return [expr, {}] if powers.empty?
+      parameters = powers.each_with_index.to_h { |power, i| [power, Var.new(:"_qp#{i}")] }
+      [expr.subs(parameters), parameters]
+    end
+
+    # ---- q-Gosper ----------------------------------------------------------------
+
+    # The q-antidifference: S(k) with S(k + 1) - S(k) = f(k), or nil.
+    def qgosper(f, k, q)
+      single(Expression.lift(f).simplify, k, q)
+    end
+
+    # The summands of a sum, flattened.
+    def summands(f)
+      case f
+      when Add then summands(f.left) + summands(f.right)
+      when Sub then summands(f.left) + summands(f.right).map { |t| Simplify.negate(t) }
+      else [f]
+      end
+    end
+
+    def single(f, k, q)
+      r = ratio(f, k, q) or return nil
+      r, parameters = abstract(r, q)
+      pair = Fraction.as_fraction(r, [X.name, q.name] + parameters.values.map(&:name)) or return nil
+      a, b, c = normal_form(pair.first, pair.last, q)
+      bm = shift(b, q, -1)
+      bound = degree_bound(a, bm, c, q) or return nil
+      xs = (0..bound).map { |i| Var.new(:"_w#{i}") }
+      poly = xs.each_with_index.reduce(Num.new(0)) { |acc, (v, i)| acc + v * X**i }
+      equation = (a.to_expr * poly.subs(X => q * X) - bm.to_expr * poly - c.to_expr).expand
+      conditions = Solve.polynomial_coefficients(equation, X) or return nil
+      solution = linear_solve(conditions, xs) or return nil
+      value = poly.subs(solution).subs(xs.to_h { |v| [v, Num.new(0)] })
+      rational = (bm.to_expr * value / c.to_expr).cancel.subs(parameters.invert)
+      plain = (in_k(rational, k, q) * f).cancel
+      tidied = tidy(plain, k, q)
+      # Cancelling expands, which is worth it when it collapses the answer
+      # and not when it only spreads it out: keep the shorter form.
+      antidifference = tidied.to_s.length <= plain.to_s.length ? tidied : plain
+      telescopes?(antidifference, f, k, q) ? antidifference : nil
+    rescue DomainError, NotImplementedError, RCAS::Unsupported, ZeroDivisionError
+      nil
+    end
+
+    # sum_{k=from}^{to} f(k) for a q-hypergeometric term: the antidifference
+    # at the ends, or nil.
+    def qsum(f, k, from, to, q)
+      g = qgosper(f, k, q) or return nil
+      ends(g, k, from, to, q) || ends(tidy(g, k, q), k, from, to, q)
+    end
+
+    # The antidifference at both ends. A removable zero in the denominator
+    # (the form the answer happens to be written in) makes this nil, and the
+    # caller tries again with the cancelled form.
+    def ends(g, k, from, to, q)
+      (g.subs(k => (to + 1).simplify) - g.subs(k => from)).cancel
+    rescue ZeroDivisionError
+      nil
+    end
+
+    # S(k + 1) - S(k) = f(k), checked at exact points; the linear algebra is
+    # exact, so this is a check on the derivation.
+    def telescopes?(s, f, k, q)
+      difference = s.subs(k => k + 1) - s - f
+      names = difference.variables.to_a
+      random = Random.new(20140610)
+      checked = 0
+      40.times do
+        point = names.to_h { |v| [v, Num.new(v == k.name ? random.rand(3..40) : 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 >= 4
+      end
+      checked >= 4
+    end
+
+    # Cancel an expression that mixes q-Pochhammer symbols with powers of
+    # q**k: stand both in by variables, cancel as a rational function, put
+    # them back. Without it an antidifference keeps the shape of the term it
+    # came from, R(q**k)*f(k), instead of collapsing.
+    def tidy(expr, k, q)
+      expr = QFunctions.align(QFunctions.to_pochhammer(expr.simplify))
+      symbols = expr.each_node.select { |e| e.is_a?(Fn) && QFunctions::NAMES.include?(e.name) }.uniq
+      names = symbols.each_with_index.to_h { |symbol, i| [symbol, Var.new(:"_qa#{i}")] }
+      abstracted = powers_in_x(expr.subs(names), k, q)
+      return expr if abstracted.variables.include?(k.name)
+      cancelled = abstracted.cancel
+      in_k(cancelled, k, q).subs(names.invert).simplify
+    rescue ZeroDivisionError, DomainError
+      expr
+    end
+
+    # ---- linear algebra over the rational functions -------------------------------
+
+    # Solve a small linear system, cancelling every entry on the way.
+    # Elimination.rref leaves entries such as q + q*(q - 1)/(1 - q) standing
+    # and Scalar.zero? does not cancel them, so a consistent system can be
+    # declared inconsistent; here the entries are rational functions of q and
+    # cancelling each one keeps them small as well.
+    # => { unknown => value }, free unknowns standing for themselves, or nil.
+    def linear_solve(conditions, unknowns)
+      width = unknowns.size
+      rows = conditions.map do |condition|
+        row = unknowns.map { |u| Solve.polynomial_coefficients(condition, u)&.[](1) || Num.new(0) }
+        row + [Simplify.negate(condition.subs(unknowns.to_h { |u| [u, Num.new(0)] })).simplify]
+      end
+      pivots = []
+      rank = 0
+      (0...width).each do |column|
+        break if rank == rows.size
+        found = (rank...rows.size).find { |i| !vanishes?(rows[i][column]) }
+        next unless found
+        rows[rank], rows[found] = rows[found], rows[rank]
+        pivot = rows[rank][column]
+        rows[rank] = rows[rank].map { |v| (v / pivot).cancel }
+        rows.each_with_index do |row, i|
+          next if i == rank || vanishes?(row[column])
+          factor = row[column]
+          rows[i] = row.each_with_index.map { |v, j| (v - factor * rows[rank][j]).cancel }
+        end
+        pivots << column
+        rank += 1
+      end
+      return nil if rows.any? { |row| row[0...width].all? { |v| vanishes?(v) } && !vanishes?(row[width]) }
+      solution = {}
+      pivots.each_with_index do |column, i|
+        value = rows[i][width]
+        (0...width).each do |j|
+          next if j == column || vanishes?(rows[i][j])
+          value = (value - rows[i][j] * unknowns[j]).cancel
+        end
+        solution[unknowns[column]] = value
+      end
+      solution
+    end
+
+    def vanishes?(value)
+      return true if Scalar.zero?(value)
+      value.is_a?(Expression) && Scalar.zero?(value.cancel)
+    rescue ZeroDivisionError
+      false
+    end
+
+    # ---- the polynomial side -----------------------------------------------------
+
+    # p(x)/q(x) = a(x)/b(x) * c(q*x)/c(x) with gcd(a(x), b(q**h*x)) = 1 for
+    # every integer h >= 0.
+    def normal_form(p, b, q, var = X)
+      a, c = p, p.ring.one
+      dispersion(a, b, q, var).each do |h|
+        g = a.gcd(shift(b, q, h, var))
+        next if g.constant?
+        a = a.exact_div(g)
+        b = b.exact_div(shift(g, q, -h, var))
+        (1..h).each { |i| c *= shift(g, q, -i, var) }
+      end
+      [a, b, c]
+    end
+
+    # p(q**h * x), in the variable +var+ (X while q-Gosper runs, the equation's
+    # own indeterminate for q-difference equations).
+    def shift(poly, q, h, var = X) = poly.ring.call(poly.to_expr.subs(var => (q**h * var).simplify).expand)
+
+    # The h >= 0 with gcd(a(x), b(q**h*x)) != 1. A shared root means
+    # q**h = beta/alpha for roots alpha of a and beta of b, so h cannot
+    # exceed the degree in q of the resultant of a(x) and b(y*x); within that
+    # bound the gcds are simply tried.
+    def dispersion(a, b, q, var = X)
+      y = Var.new(:_qy)
+      ring = QQ[*(a.ring.vars | [:_qy])]
+      shifted = ring.call(b.to_expr.subs(var => y * var).expand)
+      resultant = ring.call(a.to_expr).resultant(shifted, var.name)
+      return [] if resultant.zero?
+      bound = [resultant.degree(q.name), a.degree(var.name) + b.degree(var.name)].max
+      (0..bound).select { |h| !a.gcd(shift(b, q, h, var)).constant? }
+    rescue DomainError, NotImplementedError, RCAS::Unsupported
+      (0..(a.degree(var.name) + b.degree(var.name))).select { |h| !a.gcd(shift(b, q, h, var)).constant? }
+    end
+
+    # The degree of X in a(x)*X(q*x) - b(x/q)*X(x) = c(x): the leading terms
+    # give (lc(a)*q**d - lc(b))*x**(m + d), so either they do not cancel and
+    # d = deg c - m, or q**d = lc(b)/lc(a) pins d down.
+    def degree_bound(a, bm, c, q)
+      da, db, dc = a.degree(X.name), bm.degree(X.name), c.degree(X.name)
+      candidates = [dc - [da, db].max]
+      if da == db
+        power = power_of_q((bm.leading_coefficient_in(X.name).to_expr / a.leading_coefficient_in(X.name).to_expr).cancel, q)
+        candidates << power if power
+      end
+      bound = candidates.compact.max
+      bound.nil? || bound.negative? ? nil : bound
+    end
+
+    # d with expr = q**d, or nil.
+    def power_of_q(expr, q)
+      coefficient, factors = Simplify.factorize(expr.simplify)
+      return nil unless coefficient == 1 && factors.size == 1 && factors.key?(q)
+      d = factors[q]
+      d.is_a?(Integer) ? d : nil
+    end
+  end
+end

data/lib/rcas/q_zeilberger.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module RCAS
+  # q-Zeilberger: creative telescoping in the q-world.
+  #
+  # For a term F(n, k) that is q-hypergeometric in both indices it finds
+  # coefficients sigma_j, rational in q**n, and a rational R with
+  #
+  #   sum_j sigma_j*F(n + j, k) = G(k + 1) - G(k),   G(k) = R(q**k)*F(n, k),
+  #
+  # so that sum_j sigma_j*S(n + j) = 0 for S(n) = sum_k F(n, k) over natural
+  # boundaries. It is Zeilberger's algorithm with q-Gosper inside: with
+  # x = q**k and y = q**n, the shift in k is x -> q*x and the shift in n is
+  # y -> q*y, and the pencil's Gosper equation
+  #
+  #   a(x)*X(q*x) - b(x/q)*X(x) = c_0(x)*N(x)
+  #
+  # is again linear in the coefficients of X and the sigmas together.
+  #
+  # Sources (keys: MANUAL.md, Sources): [Koe14, ch. 12]; [Zei91] for the
+  # method; [GR04] for the notation.
+  module QZeilberger
+    MAX_ORDER = 2 # the q-world's coefficients are bigger; ask for more with max_order:
+    X = QSummation::X   # q**k
+    Y = Var.new(:_qy1)  # q**n
+
+    Certificate = Struct.new(:coefficients, :rational, :order, :term, :n, :k, :q) do
+      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 +s+ = S(n).
+    def qsumrecursion(term, k, q, s, max_order: MAX_ORDER)
+      n = Zeilberger.index_of(s)
+      k = Expression.lift(k)
+      found = certificate(term, n, k, q, max_order: max_order)
+      raise RCAS::Unsupported, "qsumrecursion: no recurrence of order #{max_order} or less for #{term}" if found.nil?
+      if boundary_terms?(found, n, k)
+        raise RCAS::Unsupported, "qsumrecursion: 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
+
+    # The certificate: R with sum_j sigma_j*F(n + j, k) = Delta_k(R*F).
+    def qsumcertificate(term, k, q, s, max_order: MAX_ORDER)
+      n = Zeilberger.index_of(s)
+      k = Expression.lift(k)
+      found = certificate(term, n, k, q, max_order: max_order)
+      raise RCAS::Unsupported, "qsumcertificate: no recurrence of order #{max_order} or less for #{term}" if found.nil?
+      found.rational
+    end
+
+    # => Certificate or nil.
+    def certificate(term, n, k, q, max_order: MAX_ORDER)
+      term = Expression.lift(term).simplify
+      n = Expression.lift(n)
+      k = Expression.lift(k)
+      q = Expression.lift(q)
+      in_k = ratio_in(term, k, q, n, X) or return nil
+      in_n = ratio_in(term, n, q, k, Y) or return nil
+      (1..max_order).each do |order|
+        found = attempt(term, n, k, q, in_k, in_n, order)
+        return found if found
+      end
+      nil
+    end
+
+    # The ratio in +v+ as a rational function of X and Y: the powers of the
+    # other index have to become the other variable too.
+    def ratio_in(term, v, q, other, target)
+      value = QSummation.ratio(term, v, q) or return nil
+      value = value.subs(X => target) unless target == X
+      QSummation.powers_in(value, other, q, target == X ? Y : X)
+    end
+
+    def attempt(term, n, k, q, in_k, in_n, order)
+      sigmas = (0..order).map { |j| Var.new(:"_qz#{j}") }
+      base = [X.name, Y.name, q.name] | term.variables.to_a.reject { |v| [n.name, k.name].include?(v) }
+      ring = QQ[*base]
+      big = QQ[*(base + sigmas.map(&:name))]
+
+      shifted = [Num.new(1)]
+      (1..order).each { |j| shifted << (shifted.last * in_n.subs(Y => (q**(j - 1) * Y).simplify)).cancel }
+      fractions = shifted.map { |a| Fraction.as_fraction(a, base) or return nil }
+      denominator = fractions.map(&:last).reduce(ring.one) { |acc, d| acc.lcm(d) }
+      numerators = fractions.map { |(p, d)| p * denominator.exact_div(d) }
+      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
+      d = pair.last * QSummation.shift(denominator, q, 1)
+      common = p.gcd(d)
+      p = p.exact_div(common)
+      d = d.exact_div(common)
+      a, b, c0 = QSummation.normal_form(p, d, q)
+      bm = QSummation.shift(b, q, -1)
+      c = c0.to_ring(big) * pencil
+      bound = QSummation.degree_bound(a.to_ring(big), bm.to_ring(big), c, q) or return nil
+
+      xs = (0..bound).map { |i| Var.new(:"_qw#{i}") }
+      poly = xs.each_with_index.reduce(Num.new(0)) { |acc, (v, i)| acc + v * X**i }
+      equation = (a.to_expr * poly.subs(X => (q * X).simplify) - bm.to_expr * poly - c.to_expr).expand
+      conditions = Solve.polynomial_coefficients(equation, X) or return nil
+      values = solve(conditions, xs, sigmas) or return nil
+
+      coefficients, factor = clear_denominators(sigmas.map { |s| values[s] }, q)
+      return nil if coefficients.all? { |value| Scalar.zero?(value) }
+      rational = (factor * bm.to_expr * poly.subs(values) / (c0.to_expr * denominator.to_expr)).cancel
+      found = Certificate.new(coefficients.map { |value| value.subs(Y => q**n).simplify },
+                              rational.subs(Y => q**n, X => q**k).simplify, order, term, n, k, q)
+      verify(coefficients, rational, in_k, shifted, q) ? found : nil
+    rescue DomainError, NotImplementedError, RCAS::Unsupported, ZeroDivisionError
+      nil
+    end
+
+    # As in the ordinary case: the recurrence carries over to the sum only
+    # when the boundary terms vanish, so sum_{k=0}^{n} F(n, k) is put into it
+    # for the first few n and a residue that is demonstrably non-zero counts
+    # against it.
+    def boundary_terms?(found, n, k)
+      order = found.coefficients.size - 1
+      (0..(order + 2)).any? do |i|
+        values = (0..order).map { |j| Zeilberger.value_at(found.term, n, k, Num.new(0), n, 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
+        Zeilberger.nonzero?(total)
+      end
+    end
+
+    # A null space vector in which not every sigma vanishes.
+    def solve(conditions, xs, sigmas)
+      unknowns = xs + sigmas
+      solution = QSummation.linear_solve(conditions, unknowns) or return nil
+      free = unknowns - solution.keys
+      free.each do |one|
+        assignment = free.to_h { |v| [v, Num.new(v == one ? 1 : 0)] }
+        values = unknowns.to_h { |v| [v, (solution[v] || v).subs(assignment).cancel] }
+        next if sigmas.all? { |s| QSummation.vanishes?(values[s]) }
+        return values
+      end
+      nil
+    end
+
+    # Coefficients rational in q**n cleared to polynomials, with the factor
+    # they were multiplied by (the certificate is scaled the same way).
+    def clear_denominators(coefficients, q)
+      vars = [Y.name, q.name] | coefficients.flat_map { |c| c.variables.to_a }
+      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) }
+      content = polynomials.reduce(ring.zero) { |acc, poly| acc.gcd(poly) }
+      factor = common
+      unless content.zero? || content.constant?
+        polynomials = polynomials.map { |poly| poly.exact_div(content) }
+        factor = factor.exact_div(content)
+      end
+      [polynomials.map(&:to_expr), factor.to_expr]
+    rescue DomainError, NotImplementedError, RCAS::Unsupported, ZeroDivisionError
+      [coefficients, Num.new(1)]
+    end
+
+    # sum_j sigma_j*a_j(x) = R(q*x)*r(x) - R(x), at exact points.
+    def verify(coefficients, rational, in_k, shifted, q)
+      left = shifted.each_with_index.reduce(Num.new(0)) { |acc, (a, j)| acc + coefficients[j] * a }
+      difference = left - (rational.subs(X => (q * X).simplify) * in_k - rational)
+      names = difference.variables.to_a
+      random = Random.new(20140610)
+      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 >= 4
+      end
+      checked >= 4
+    end
+  end
+end