rcas 0.2.0

data/lib/rcas/solve.rb

@@ -0,0 +1,2002 @@
+# frozen_string_literal: true
+
+module RCAS
+  # A solution of several unknowns, {x => 2, y => 1}: a Hash keyed by the
+  # indeterminates, which prints and compares as one. In a session a bare
+  # name is a Symbol, so sol[x] asks with :x while the key is Var(:x) - it
+  # answered nil (found on 23 Sept 2026, writing the linear optimization
+  # section). A Symbol is looked up as the indeterminate it names.
+  class Assignment < Hash
+    def [](key) = super(Assignment.key_for(key))
+    def fetch(key, *rest, &block) = super(Assignment.key_for(key), *rest, &block)
+    def key?(key) = super(Assignment.key_for(key))
+    alias has_key? key?
+    alias include? key?
+    alias member? key?
+    def values_at(*keys) = super(*keys.map { |k| Assignment.key_for(k) })
+    def dig(key, *rest) = super(Assignment.key_for(key), *rest)
+    def self.key_for(key) = key.is_a?(Symbol) ? Var.new(key) : key
+  end
+
+  # lhs = rhs. Build with eq(a, b) or a.eq(b); solve with solve(equation, x).
+  class Equation
+    attr_reader :lhs, :rhs
+
+    def initialize(lhs, rhs)
+      @lhs = Expression.lift(lhs)
+      @rhs = Expression.lift(rhs)
+      freeze
+    end
+
+    def to_expr = Sub.new(lhs, rhs)
+    def simplify = Equation.new(lhs.simplify, rhs.simplify)
+    def expand = Equation.new(lhs.expand, rhs.expand)
+    def subs(*args) = Equation.new(lhs.subs(*args), rhs.subs(*args))
+    def swap = Equation.new(rhs, lhs)
+    def variables = (lhs.variables | rhs.variables).sort
+    def solve(var = nil) = Solve.solve(self, var)
+
+    # Does the equation hold for these values? Exactly for exact values; a
+    # Float difference holds when it is within its own rounding error (an
+    # absolute 1e-9 said 1e-10 = 0 holds: fourth review, 2.4).
+    def holds?(**bindings)
+      difference = Expression.lift(lhs - rhs).subs(bindings.to_h { |k, v| [k, Expression.lift(v)] })
+      value = difference.simplify
+      return false unless value.is_a?(Num) || value.variables.empty?
+      return Decide.zero?(value) == true unless difference.each_node.any? { |n| n.is_a?(Num) && n.value.is_a?(Float) }
+      found, error = Decide.float_with_error(difference)
+      !found.nil? && found.abs <= Decide::ERROR_MARGIN * error
+    end
+
+    %i[+ - * /].each do |op|
+      define_method(op) do |other|
+        other.is_a?(Equation) ? Equation.new(lhs.public_send(op, other.lhs), rhs.public_send(op, other.rhs)) : Equation.new(lhs.public_send(op, other), rhs.public_send(op, other))
+      end
+    end
+    def -@ = Equation.new(-lhs, -rhs)
+
+    # hold { integral(x**2, x) == x }.doit is x**3/3 = x: both sides
+    # evaluated, the statement kept (third review, C9)
+    def evaluate = Equation.new(lhs.evaluate, rhs.evaluate)
+    alias doit evaluate
+    alias unhold evaluate
+
+    def ==(other) = other.is_a?(Equation) && other.lhs == lhs && other.rhs == rhs
+    alias eql? ==
+    def hash = [Equation, lhs, rhs].hash
+
+    def to_s = "#{lhs} = #{rhs}"
+    alias inspect to_s
+
+    # to_latex: latex.rb's (the one with wrap:), which replaced this one
+  end
+
+  # {2*pi*k | k in ZZ}: a solution that is a family rather than a number.
+  # An equation with infinitely many solutions has no honest answer as a
+  # list of numbers - sin(x) = 0 is solved by every multiple of pi, not by
+  # 0 and pi - and this is the object MuPAD answers such an equation with.
+  # The parameter carries its domain with it, so the answer says what k is
+  # instead of leaving the reader (and `simplify`) to guess.
+  class ImageSet
+    attr_reader :expr, :parameters, :domain
+
+    def initialize(expr, parameters, domain = ZZ)
+      @expr = Expression.lift(expr)
+      @parameters = Array(parameters).map { |p| p.is_a?(Var) ? p : Var.new(p) }
+      @domain = domain
+      freeze
+    end
+
+    # The member at k = i, with one value per parameter: at(0), at(1), ...
+    def at(*values)
+      bindings = parameters.each_with_index.to_h { |p, i| [p.name, Expression.lift(values[i])] }
+      expr.subs(bindings).simplify
+    end
+
+    # No member on the real line: the step is real and a member is not, so
+    # every member has the same non-zero imaginary part ({pi - acos(2) +
+    # 2*pi*k}, the zeros of 2 + cos(x)). Only an affine family is measured.
+    def nonreal?
+      pair = affine or return false
+      base, step = pair
+      Inequalities.real?(step) && !Inequalities.real?(base)
+    rescue NotImplementedError, RCAS::Unsupported
+      false
+    rescue StandardError => rescued
+      RCAS.guard!(rescued)
+      false
+    end
+
+    # [base, step] when the family is base + step*k, nil otherwise.
+    def affine
+      return nil unless parameters.size == 1
+      coefficients = Solve.polynomial_coefficients(expr, parameters.first)
+      return nil unless coefficients && coefficients.size <= 2 && coefficients.none? { |c| c.variables.include?(parameters.first.name) }
+      [coefficients[0].simplify, (coefficients[1] || Num.new(0)).simplify]
+    end
+
+    # The members between two numbers, when they can be counted out; [] for
+    # a family that never meets the real line; nil when they cannot be
+    # counted - too many, infinitely many, or a family whose shape is not
+    # understood. Counting base + k*step from at(0) and at(1) was right
+    # only for an arithmetic family: sqrt(pi*k), the kinks of |sin(x**2)|,
+    # lost four of seven, and 1/(2*pi*k) divided by zero (fourth review).
+    # Only the indices of the family's own domain count (k >= 0 over NN).
+    def between(lo, hi, limit: 1024)
+      return nil unless parameters.size == 1
+      return [] if nonreal?
+      indices = affine ? affine_indices(lo, hi) : crossing_indices(lo, hi)
+      return nil if indices.nil?
+      first, last = indices
+      first = [first, 0].max if domain == NN
+      return [] if first > last
+      return nil if last - first > limit
+      (first..last).filter_map do |i|
+        member = begin
+          at(i)
+        rescue ZeroDivisionError
+          next
+        end
+        member if (v = numeric(member)) && v >= lo && v <= hi
+      end
+    end
+
+    private
+
+    def affine_indices(lo, hi)
+      base, step = affine.map { |c| numeric(c) }
+      return nil if base.nil? || step.nil? || step.abs < 1e-12
+      [((lo - base) / step).floor, ((hi - base) / step).ceil].minmax
+    end
+
+    # expr(k) is continuous between the edges of its real domain, so it
+    # meets [lo, hi] on the pieces cut out by the solutions of expr = lo and
+    # expr = hi and those edges; one sample decides each piece. nil when a
+    # solution cannot be named, or a piece that reaches to infinity stays
+    # inside (1/(2*pi*k) crowds towards 0: infinitely many members).
+    def crossing_indices(lo, hi)
+      k = parameters.first
+      cuts = [lo, hi].flat_map do |bound|
+        roots = Solve.solve(expr - Num.new(bound.to_r), k, domain: RR)
+        return nil unless roots.is_a?(Array) && roots.all? { |r| r.is_a?(Expression) && r.variables.empty? }
+        roots.filter_map { |r| numeric(r) }
+      end
+      edges = Analysis.real_domain(expr, k).intervals.flat_map { |i| [i.low, i.high] }
+                      .reject { |e| Limits.infinite?(e) }.map { |e| numeric(e) or return nil }
+      points = (cuts + edges).uniq.sort
+      inside = ->(t) { (v = value_at(k, t)) && v >= lo && v <= hi }
+      found = []
+      ([-Float::INFINITY] + points).zip(points + [Float::INFINITY]).each do |a, b|
+        t = if a.infinite? && b.infinite? then 0.0
+            elsif a.infinite? then b - 1
+            elsif b.infinite? then a + 1
+            else (a + b) / 2
+            end
+        next unless inside.call(t)
+        return nil if a.infinite? || b.infinite?
+        found << [a.floor, b.ceil]
+      end
+      points.each { |t| found << [t.floor, t.ceil] if inside.call(t) }
+      return [1, 0] if found.empty?
+      [found.map(&:first).min, found.map(&:last).max]
+    rescue NotImplementedError, RCAS::Unsupported, ArgumentError, ZeroDivisionError
+      nil
+    end
+
+    def value_at(k, t)
+      numeric(expr.subs(k.name => Num.new(t)))
+    rescue ZeroDivisionError
+      nil
+    end
+
+    public
+
+    def variables = expr.variables - parameters.map(&:name)
+    def to_expr = expr
+
+    # The image of the set under a function of its member: the parameter
+    # keeps its domain while the block runs, and the result is simplified
+    # there too, so cos of {2*pi*k | k in ZZ} folds to 1 without anyone
+    # declaring k first - that fold needs the integer. A result that no
+    # longer mentions the parameter is not a family any more and comes back
+    # as the value itself.
+    def map
+      inside = RCAS.assume(**parameters.to_h { |p| [p.name, domain] }) do
+        found = yield(expr)
+        found.is_a?(Expression) ? found.simplify : found
+      end
+      lifted = Expression.lift(inside)
+      (lifted.variables & parameters.map(&:name)).empty? ? lifted : ImageSet.new(lifted, parameters, domain)
+    end
+
+    def ==(other)
+      other.is_a?(ImageSet) && other.expr == expr && other.parameters == parameters && other.domain == domain
+    end
+    alias eql? ==
+    def hash = [ImageSet, expr, parameters, domain].hash
+
+    def to_s = "{#{expr} | #{parameters.join(', ')} in #{domain}}"
+    alias inspect to_s
+
+    def to_latex(wrap: nil)
+      inside = parameters.map { |p| LaTeX.of(p) }.join(', ')
+      "\\left\\{ #{LaTeX.of(expr)} \\mid #{inside} \\in #{LaTeX.of(domain)} \\right\\}"
+    end
+
+    private
+
+    def numeric(value) = RCAS.real_float(value, finite: false)
+  end
+
+  # Equation solving.
+  #
+  #   solve(x**2 - 3*x + 2, x)          # => [1, 2]
+  #   solve(eq(x**2, -1), x)            # => [-i, i]
+  #   solve(exp(2*x) - 3*exp(x) + 2, x) # => [0, log(2)]
+  #   solve([eq(x + y, 3), eq(x - y, 1)], [x, y])   # => [{x => 2, y => 1}]
+  #
+  #   solve(abs(x) - 1, x)              # => [1, -1]
+  #
+  # Polynomials are solved exactly through factorization over QQ, the
+  # quadratic formula, k-th roots for binomials and the quadratic formula
+  # with symbolic coefficients; irreducible factors of degree >= 3 with
+  # numeric coefficients get numeric roots. Transcendental equations are
+  # reduced to polynomials in one atom (exp(x), sin(x), sqrt(x), ...) and
+  # inverted. An equation with abs or sign is split into its cases and each
+  # candidate substituted back. Systems: linear in the unknowns, or two
+  # polynomial equations in two unknowns through resultants.
+  #
+  # Sources (keys: MANUAL.md, Sources): elimination by resultants [GCL92,
+  # ch. 9], [CLO15, §3.6]; numeric roots by the Durand-Kerner (Weierstrass)
+  # simultaneous iteration [Ker66], started at powers of 0.4 + 0.9i.
+  module Solve
+    MAX_DEPTH = 6
+    # abs and sign split the line into cases; 2**n branches, so a small n.
+    CASES = %i[abs sign].freeze
+    MAX_CASES = 3
+
+    module_function
+
+    # Every solution, which for a trigonometric equation means a family per
+    # period: the answer is an ImageSet, {2*pi*k | k in ZZ}, rather than a
+    # selection from it. `principal: true` (or the older `all: false`) asks
+    # for the solutions in one period instead, which is what the analysis
+    # inside rcas wants and what a table of exact values shows.
+    # The unknown's declared domain (assume(x: ZZ), or domain: here) keeps
+    # out the solutions that demonstrably do not lie in it.
+    def solve(target, vars = nil, all: true, principal: false, domain: nil)
+      principal ||= !all
+      if target.equal?(true) || target.equal?(false)
+        raise ArgumentError, "solve: `==` compares structurally in Ruby and this one is already #{target}; " \
+                             "write solve(eq(lhs, rhs), x) or solve(hold { lhs == rhs }, x)"
+      end
+      return Inequalities.solve(target, vars) if target.is_a?(Inequality) || (target.is_a?(Array) && target.any? { |t| t.is_a?(Inequality) })
+      return system(target, vars, domain: domain) if target.is_a?(Array)
+      return piecewise(target, vars) if piecewise?(target)
+      original = to_zero(target)
+      f = original.simplify
+      x = variable(f, vars)
+      # The poles are read off the equation as it was written: simplify
+      # cancels (x - 1)/(x - 1) to 1, and x = 1 is still no solution of
+      # (x - 1)/(x - 1) = 1, where the left side has no value.
+      poles = Analysis.denominators(original, x)
+      # 0 = 0 holds for every value of x. That is an answer, and a set is
+      # what says it; raising made a true statement look like a failure.
+      # Every value *of x*: with x declared an integer, sin(pi*x) vanishes
+      # on ZZ and nowhere else, so the reals would be an overstatement.
+      return everywhere(x, domain, poles, original) if Scalar.zero?(f) || rational_identity?(f, x)
+      found =
+        begin
+          univariate(f, x, 0, all: !principal)
+        rescue Whole => e
+          # squaring gave an identity, and the answer is a set (S18)
+          return e.set
+        rescue NotImplementedError, RCAS::Unsupported
+          constant = trig_constant(f)
+          raise if constant.nil?
+          return Scalar.zero?(constant) ? everywhere(x, domain, poles, original) : []
+        end
+      roots = dedupe(found).map { |root| family(root, x, f) }
+      ordered(dedupe(absorbed(dedupe(restrict(off_poles(merge_families(roots), poles, x), x, domain))).map { |r| normal_family(r) }))
+    end
+
+    # One spelling per set (the fifth review, 3.2): base + step*k with, over
+    # ZZ, a positive real step and the base reduced into [0, step) - the
+    # {pi*(1 + 2*k)/2} that family_off_poles built is {pi/2 + pi*k}, which is
+    # what solve(cos(x)) says. Over NN the direction is part of the set and
+    # only the spelling changes. Anything else is left as it is.
+    def normal_family(set)
+      return set unless set.is_a?(ImageSet)
+      pair = set.affine or return set
+      base, step = pair
+      k = set.parameters.first
+      if set.domain == ZZ && step.variables.empty? && base.variables.empty?
+        sign = Decide.sign(step)
+        return set unless %i[positive negative].include?(sign)
+        step = Neg.new(step).simplify if sign == :negative
+        ratio = (base / step).simplify
+        if ratio.is_a?(Num) && (ratio.value.is_a?(Integer) || ratio.value.is_a?(Rational))
+          base = (base - step * Num.new(ratio.value.floor)).simplify
+        end
+      end
+      ImageSet.new((base + step * k).simplify, set.parameters, set.domain)
+    rescue StandardError => rescued
+      RCAS.guard!(rescued)
+      set
+    end
+
+    # A point that is a member of a family is said by the family: x*sin(x)
+    # listed 0 and {pi*k | k in ZZ} (fourth review, 2.5).
+    def absorbed(list)
+      families = list.select { |s| s.is_a?(ImageSet) && s.affine }
+      sets = list.select { |s| s.is_a?(NumberSet) }
+      return list if families.empty? && sets.empty?
+      list.reject do |point|
+        next false unless point.is_a?(Expression) && point.variables.empty?
+        next true if sets.any? { |set| point.is_a?(Num) && set.include?(point.value) }
+        families.any? do |set|
+          base, step = set.affine
+          next false if Scalar.zero?(step)
+          index = ((point - base) / step).simplify
+          index.is_a?(Num) && index.value.is_a?(Integer) && set.domain.include?(index.value)
+        end
+      end
+    end
+
+    # x/(x + 1) + 1/(x + 1) - 1 is zero as a rational function, which the
+    # normal form of simplify does not show: its cleared numerator is the
+    # zero polynomial, and the root finder answered that with [].
+    def rational_identity?(f, x)
+      return false unless f.each_node.any? { |n| n.is_a?(Div) || (n.is_a?(Pow) && n.exponent.is_a?(Num) && Simplify.negative?(n.exponent.value)) }
+      Scalar.zero?(f.cancel)
+    rescue StandardError => rescued
+      RCAS.guard!(rescued)
+      false
+    end
+
+    # Every value of x is a solution: the declared domain when there is one,
+    # the reals otherwise - less the poles of the equation as written, so
+    # (x**2 - 1)/(x - 1) = x + 1 holds everywhere but at 1, and less the
+    # points where it has no value at all (log(x)/log(x) = 1 is false at
+    # 0: its real domain says so). Poles that come in a family cannot be
+    # taken out of a finite union of intervals, and the reals would claim
+    # them: that is refused. So is a declared ZZ, QQ or CC with a pole in
+    # it, since rcas has no set "the integers but 1" to answer with (the
+    # declared set itself was the answer, pole and all: fourth review).
+    def everywhere(x, domain, poles = [], original = nil)
+      declared = domain || RCAS.assumption(x.name)
+      points = poles.flat_map do |d|
+        found = Solve.solve(d, x)
+        raise RCAS::Unsupported, "every #{x} where #{d} != 0 is a solution; that set is not a finite union of intervals" unless found.is_a?(Array)
+        found
+      end
+      if points.any? { |p| p.is_a?(ImageSet) }
+        raise RCAS::Unsupported, "every #{x} off the zeros of #{poles.join(', ')} is a solution; that set is not a finite union of intervals"
+      end
+      if declared && declared != RR
+        inside = points.reject { |p| Infer.excluded?(p, declared) }
+        return declared if inside.empty?
+        raise RCAS::Unsupported, "every #{x} in #{declared} except #{inside.map(&:to_s).join(', ')} is a solution; rcas has no set to write that with"
+      end
+      real = points.select { |p| Analysis.numeric(p) }
+      set = real.empty? ? RealSet.reals : RealSet.reals - RealSet.new(real.map { |p| Interval.point(p) })
+      return set if original.nil?
+      defined = begin
+        Analysis.real_domain(original, x)
+      rescue NotImplementedError, RCAS::Unsupported, ArgumentError
+        nil
+      end
+      defined.is_a?(RealSet) ? set - (RealSet.reals - defined) : set
+    end
+
+    # Roots and families of the simplified equation that are poles of the
+    # equation as written. A point is dropped when a denominator is shown
+    # to vanish there. A family is checked member by member through its
+    # index: the members where a denominator vanishes form a sub-progression
+    # (or a single index, or nothing), and what is left is written as
+    # families again - sin(2*x)/sin(x) keeps {pi/2 + pi*k} and loses
+    # {pi*k}, sin(x)/x keeps {pi*k} for k >= 1 and k <= -1.
+    def off_poles(roots, poles, x)
+      return roots if poles.empty?
+      roots.flat_map do |root|
+        if root.is_a?(ImageSet)
+          family_off_poles(root, poles, x)
+        elsif root.is_a?(Expression) && root.variables.empty?
+          pole_at?(poles, x, root) ? [] : [root]
+        else
+          [root]
+        end
+      end
+    end
+
+    def pole_at?(poles, x, point)
+      poles.any? do |d|
+        value = begin
+          d.subs(x => point).simplify
+        rescue ZeroDivisionError
+          next true
+        end
+        Decide.zero?(value) == true
+      end
+    end
+
+    # [a + b*k | k in ZZ] minus its poles, as a list of families.
+    def family_off_poles(set, poles, x)
+      return [set] unless set.parameters.size == 1 && set.domain == ZZ
+      k = set.parameters.first
+      step = begin
+        Coefficients.coeff(set.expr, k, 1)
+      rescue StandardError => rescued
+        RCAS.guard!(rescued)
+        return [set]
+      end
+      offset = (set.expr - step * k).simplify
+      return [set] if offset.variables.include?(k.name) || Scalar.zero?(step)
+      # indices to drop: residues r mod n (from a family of poles) and
+      # single indices (from isolated poles)
+      progressions = []
+      singles = []
+      poles.each do |d|
+        zeros = begin
+          Solve.solve(d, x)
+        rescue NotImplementedError, RCAS::Unsupported, ArgumentError
+          next
+        end
+        next unless zeros.is_a?(Array)
+        zeros.each do |z|
+          if z.is_a?(ImageSet)
+            progressions.concat(progression_hit(z, offset, step))
+          elsif z.is_a?(Expression) && z.variables.empty?
+            index = ((z - offset) / step).simplify
+            singles << index.value if index.is_a?(Num) && index.value.is_a?(Integer)
+          end
+        end
+      end
+      return [set] if progressions.empty? && singles.empty?
+      modulus = progressions.map(&:last).reduce(1, :lcm)
+      kept = (0...modulus).reject { |r| progressions.any? { |res, n| r % n == res } }
+      return [] if kept.empty?
+      j = Var.new(k.name)
+      singles = singles.uniq
+      kept.flat_map do |r|
+        # the indices t of this class, member offset + step*(r + modulus*t),
+        # that are poles: all of them go, however many fall in one class
+        # (sin(x)/(x**2 - pi**2) kept -pi after taking out pi: fourth review)
+        holes = singles.select { |i| i % modulus == r }.map { |i| (i - r) / modulus }.sort
+        at = ->(t) { (offset + step * (r + modulus * t)).simplify }
+        next [ImageSet.new(at.call(j), [j], ZZ)] if holes.empty?
+        between = (holes.first + 1...holes.last).reject { |t| holes.include?(t) }
+        next [set] if between.size > 1000
+        [ImageSet.new(at.call(holes.first - 1 - j), [j], NN), *between.map { |t| at.call(t) },
+         ImageSet.new(at.call(holes.last + 1 + j), [j], NN)]
+      end
+    end
+
+    # The residues r mod n of the indices k at which a + b*k is a member of
+    # the family z, as [[r, n], ...], when that is decidable: the steps and
+    # the offsets have a rational ratio. k gives the member of z with index
+    # m = (a - c + b*k)/e, which is an integer or not with period q in k,
+    # q the denominator of b/e - so trying k = 0...q finds every residue.
+    def progression_hit(z, offset, step)
+      return [] unless z.parameters.size == 1 && z.domain == ZZ
+      m = z.parameters.first
+      zstep = begin
+        Coefficients.coeff(z.expr, m, 1)
+      rescue StandardError => rescued
+        RCAS.guard!(rescued)
+        return []
+      end
+      zoffset = (z.expr - zstep * m).simplify
+      return [] if zoffset.variables.include?(m.name)
+      ratio = (step / zstep).simplify
+      shift = ((offset - zoffset) / zstep).simplify
+      rational = ->(v) { v.is_a?(Num) && (v.value.is_a?(Integer) || v.value.is_a?(Rational)) }
+      return [] unless rational.call(ratio) && rational.call(shift)
+      ratio = Rational(ratio.value)
+      shift = Rational(shift.value)
+      q = ratio.denominator
+      (0...q).select { |k| (shift + ratio * k).denominator == 1 }.map { |r| [r, q] }
+    end
+
+    # An identity is an identity however it is written, and no rule in the
+    # chain sees the Pythagorean one: sin(x)**2 + cos(x)**2 - 1 is zero, and
+    # `Scalar.zero?` cannot say so because the identity only shows after
+    # trigsimp. The other side of the same reading is just as much an
+    # answer - a trigonometric expression that reduces to a constant which
+    # is not zero has no solutions at all, so sin(x)**2 + cos(x)**2 + 1 = 0
+    # is [] rather than "can't solve" (20 Sept 2026, the ninth pass of the
+    # review). It is asked only once every rule has failed, because trigsimp
+    # costs milliseconds and `discuss` calls solve for every row it fills.
+    def trig_constant(f)
+      return nil unless f.each_node.any? { |n| n.is_a?(Fn) && Trigonometry::SQUARES.key?(n.name) }
+      reduced = Trigonometry.trigsimp(f).simplify
+      reduced.variables.empty? ? reduced : nil
+    rescue StandardError => rescued
+      RCAS.guard!(rescued)
+      nil
+    end
+
+    # Families of one period that say the same thing twice, or that together
+    # make a finer one: sin(x)**2 = 1 is solved at pi/2, -pi/2 and 3*pi/2
+    # over a period of 2*pi, of which the last two are the same set and all
+    # three together are {pi/2 + pi*k | k in ZZ} - which is what a student
+    # writes. The offsets are compared as fractions of the step, so it works
+    # the same for {2*k} and {1 + 2*k}, whose union is the integers.
+    def merge_families(roots)
+      entries = roots.map { |root| family_shape(root) || [:plain, root] }
+      groups = entries.select { |e| e.first == :family }.group_by { |e| e[1] }
+      done = {}
+      entries.flat_map do |entry|
+        next [entry.last] if entry.first == :plain
+        next [] if done[entry[1]]
+        done[entry[1]] = true
+        merged_family(groups[entry[1]], entry[1])
+      end
+    end
+
+    # [:family, step, offset as a fraction of the step, the set], or nil for
+    # anything this cannot measure - a set whose offset is not a rational
+    # multiple of its step has no residue to compare.
+    def family_shape(root)
+      return nil unless root.is_a?(ImageSet) && root.parameters.size == 1
+      k = root.parameters.first
+      step = begin
+        Coefficients.coeff(root.expr, k, 1)
+      rescue StandardError => rescued
+        RCAS.guard!(rescued)
+        nil
+      end
+      return nil if step.nil? || Scalar.zero?(step)
+      offset = (root.expr - step * k).simplify
+      return nil if offset.variables.include?(k.name)
+      residue = (offset / step).simplify
+      return nil unless residue.is_a?(Num) && (residue.value.is_a?(Integer) || residue.value.is_a?(Rational))
+      [:family, step, Rational(residue.value) % 1, root]
+    end
+
+    def merged_family(group, step)
+      residues = group.map { |e| e[2] }.uniq.sort
+      set = group.first.last
+      count = residues.size
+      if count > 1 && residues.each_cons(2).all? { |a, b| b - a == Rational(1, count) }
+        [rebuilt_family(set, residues.first * step, step / count)]
+      else
+        residues.map { |residue| rebuilt_family(set, residue * step, step) }
+      end
+    end
+
+    # {k | k in ZZ} is the domain itself, and says so.
+    def rebuilt_family(set, offset, step)
+      k = set.parameters.first
+      expr = (Expression.lift(offset) + step * k).simplify
+      expr == k ? set.domain : ImageSet.new(expr, [k], set.domain)
+    end
+
+    # A root carrying a parameter the equation did not have is one period's
+    # worth of solutions repeated for ever: say so as a set, and name the
+    # parameter's domain, so that `simplify` can check the answer and the
+    # reader does not have to assume what k is.
+    def family(root, x, f)
+      return root unless root.is_a?(Expression)
+      parameters = root.variables - f.variables - [x.name]
+      parameters.empty? ? root : ImageSet.new(root, parameters.sort.map { |name| Var.new(name) })
+    end
+
+    # Real roots ascending, then the rest in the order they were found. The
+    # order a method happens to produce is not an answer about the roots.
+    def ordered(roots)
+      keys = roots.each_with_index.to_h do |root, i|
+        value = begin
+          root.is_a?(Expression) ? root.evalf : nil # a family or a set has no value
+        rescue StandardError => rescued
+          RCAS.guard!(rescued)
+          nil
+        end
+        value = value.value if value.is_a?(Num)
+        [root, value.is_a?(Numeric) && value.real? ? [0, value.to_f, i] : [1, 0.0, i]]
+      end
+      roots.sort_by { |root| keys[root] }
+    end
+
+    # Drop the solutions that contradict what the unknown was declared to
+    # be - a number set, a sign, or both. What cannot be decided stays
+    # (Infer.excluded?), so an answer is never lost to a guess.
+    def restrict(roots, x, domain)
+      wanted = domain || RCAS.assumption(x.name)
+      sign = RCAS.signs[x.name]
+      return roots if wanted.nil? && sign.nil?
+      roots.flat_map do |root|
+        # {k | k in ZZ} came back as ZZ itself: the smaller of the two sets
+        # (third review, S17)
+        next [wanted && !root.subset?(wanted) ? wanted : root] if root.is_a?(NumberSet)
+        next restrict_family(root, wanted, sign) if root.is_a?(ImageSet)
+        (wanted && Infer.excluded?(root, wanted)) || (sign && wrong_sign?(root, sign)) ? [] : [root]
+      end
+    end
+
+    # Which members of a family lie in a declared domain. For the families
+    # trigonometry produces this is decidable rather than guessed: a + b*k
+    # with a and b rational multiples of pi is rational only where the pi
+    # part cancels, because pi is transcendental, and that happens for at
+    # most one k. So {2*pi*k | k in ZZ} meets ZZ in 0 alone, and
+    # {pi + 2*pi*k | k in ZZ} not at all. A family of any other shape stays
+    # whole: "some member might qualify" is the honest answer there.
+    def restrict_family(set, wanted, sign, reindexed: false)
+      # a family off the real line has no member in RR: asin(2) + 2*pi*k
+      # under domain: RR (third review, S19)
+      return [] if wanted && wanted <= RR && set.nonreal?
+      if wanted && wanted <= RR && (members = real_members(set))
+        return members.reject { |m| Infer.excluded?(m, wanted) || (sign && wrong_sign?(m, sign)) }
+      end
+      if wanted && wanted <= RR && !reindexed && set.affine.nil? && !real_family?(set)
+        # {(4*log(2) + 8*pi*i*k)**(1/2)/2} was kept whole under domain: RR,
+        # and discuss drew asymptotes at its complex members (the sixth
+        # review's preflight): its real members, or a refusal
+        members = power_real_members(set) or
+          raise RCAS::Unsupported, "can't tell which members of #{set} are real"
+        return members.flat_map do |m|
+          next restrict_family(m, wanted, sign, reindexed: true) if m.is_a?(ImageSet)
+          Infer.excluded?(m, wanted) || (sign && wrong_sign?(m, sign)) ? [] : [m]
+        end
+      end
+      return [set] unless wanted && wanted <= QQ && set.parameters.size == 1
+      k = set.parameters.first
+      slope = begin
+        Coefficients.coeff(set.expr, k, 1)
+      rescue StandardError => rescued
+        RCAS.guard!(rescued)
+        nil
+      end
+      return [set] if slope.nil?
+      rest = (set.expr - slope * k).simplify
+      return [set] if rest.variables.include?(k.name)
+      if rational?(slope) && rational?(rest)
+        return [set] if wanted == QQ
+        return rational_family(set, rest.value.to_r, slope.value.to_r, wanted, sign)
+      end
+      step = Trig.pi_multiple(slope)
+      offset = Scalar.zero?(rest) ? Rational(0) : Trig.pi_multiple(rest)
+      return [set] if step.nil? || offset.nil? || step.zero?
+      turns = -offset / step
+      return [] unless turns.denominator == 1 && set.domain.include?(turns.numerator)
+      member = set.at(turns.numerator)
+      (wanted && Infer.excluded?(member, wanted)) || (sign && wrong_sign?(member, sign)) ? [] : [member]
+    end
+
+    def rational?(e) = e.is_a?(Num) && (e.value.is_a?(Integer) || e.value.is_a?(Rational))
+
+    # The real members of a family whose step is not real: base + step*k is
+    # real where im(base) + im(step)*k = 0, at one k or none - log(2) of
+    # {log(2) + 2*pi*i*k}, nothing of {i*pi + 2*pi*i*k}. This is what
+    # domain: RR makes of the complete answer over CC. nil for a family of
+    # another shape, or when a part is not decided.
+    def real_members(set)
+      pair = set.affine or return nil
+      base, step = pair
+      im_step = ComplexParts.im(step).simplify
+      return nil unless im_step.variables.empty? && Decide.zero?(im_step) == false
+      im_base = ComplexParts.im(base).simplify
+      return nil unless im_base.variables.empty?
+      index = (Neg.new(im_base) / im_step).simplify
+      return nil unless index.is_a?(Num) || Decide.zero?(ComplexParts.im(index)) == true
+      k = index.is_a?(Num) ? index.value : nil
+      return [] unless k.is_a?(Integer) || (k.is_a?(Rational) && k.denominator == 1)
+      return [] unless set.domain.include?(k.to_i)
+      member = set.at(k.to_i)
+      real = ComplexParts.re(member).simplify
+      # the real part of 2*log(2)/(i*pi + log(2)) + 2*i*pi/(i*pi + log(2))
+      # is 2, written over pi**2 + log(2)**2 twice
+      cancelled = cancel_constants(real)
+      [cancelled.each_node.count < real.each_node.count ? cancelled : real]
+    rescue StandardError => rescued
+      RCAS.guard!(rescued)
+      nil
+    end
+
+    # Every member real: sqrt(pi*k) over NN, the kinks of |sin(x**2)|.
+    def real_family?(set)
+      bindings = set.parameters.to_h { |p| [p.name, set.domain] }
+      domain = RCAS.assume(**bindings) { Infer.domain(set.expr) }
+      !domain.nil? && domain <= RR
+    rescue StandardError, NotImplementedError, RCAS::Unsupported => rescued
+      RCAS.guard!(rescued, refused: true)
+      false
+    end
+
+    # c*A(k)**e with c real, A affine in k and e = +-1 or +-1/q: w**(1/q)
+    # real makes w = (w**(1/q))**q real, and a real w has a real principal
+    # root exactly when it is not negative; 1/w is real exactly with w.
+    # (Not so for other exponents: w**(3/2) is real at arg(w) = 2*pi/3.)
+    # A is real at one k or none (real_members). nil for any other shape.
+    def power_real_members(set)
+      return nil unless set.parameters.size == 1
+      k = set.parameters.first
+      coeff, factors = Simplify.factorize(set.expr)
+      constant, moving = factors.partition { |b, _| !b.variables.include?(k.name) }
+      return nil unless moving.size == 1 && coeff.is_a?(Numeric) && coeff.real?
+      scale = Simplify.rebuild_product(coeff, constant.to_h)
+      return nil unless ComplexParts.real_valued?(scale)
+      base, exp = moving.first
+      exp = exp.value if exp.is_a?(Num)
+      exp = exp.to_r if exp.is_a?(Integer)
+      return nil unless exp.is_a?(Rational) && exp.numerator.abs == 1
+      power = ->(b) { (scale * Simplify.power_node(b, exp.denominator == 1 ? exp.to_i : exp)).simplify }
+      inner = ImageSet.new(base, set.parameters, set.domain)
+      if (pair = inner.affine) && real_step?(pair)
+        # 1/(2*pi*k): a real power of a real family is real throughout
+        return exp.denominator == 1 ? [set] : non_negative_part(set, inner, k)
+      end
+      points = real_members(inner) or return nil
+      points.filter_map do |b|
+        next power.call(b) if exp.denominator == 1
+        case Decide.sign(b)
+        when :positive, :zero then power.call(b)
+        when :negative then nil
+        else return nil
+        end
+      end
+    end
+
+    def real_step?(pair)
+      pair.all? { |p| (im = ComplexParts.im(p).simplify).variables.empty? && Decide.zero?(im) == true }
+    end
+
+    # A real affine A(k) = b + s*k under a root: the members are real
+    # exactly where A(k) >= 0, which is k >= -b/s for s > 0 - the
+    # family again, counted from there over NN: {+-sqrt(pi*k) | k in NN}
+    # are the zeros of sin(x**2) on the real line.
+    def non_negative_part(set, inner, k)
+      b, step = inner.affine
+      ratio = (Neg.new(b) / step).simplify
+      direction = Decide.sign(step)
+      return nil unless rational?(ratio) && %i[positive negative].include?(direction)
+      r = ratio.value.to_r
+      if direction == :positive
+        start = r.ceil
+        start = [start, 0].max if set.domain == NN
+        return [ImageSet.new(set.expr.subs(k.name => Num.new(start) + k).simplify, [k], NN)]
+      end
+      last = r.floor
+      return (0..last).map { |i| set.at(i) } if set.domain == NN
+      [ImageSet.new(set.expr.subs(k.name => Num.new(last) - k).simplify, [k], NN)]
+    end
+
+    # cancel works in a polynomial ring, and pi and log(2) are no
+    # indeterminates of one: they stand in as fresh names while it runs.
+    def cancel_constants(e)
+      atoms = e.each_node.select { |n| n.is_a?(Const) || (n.is_a?(Fn) && n.variables.empty?) }.uniq
+      atoms = atoms.reject { |a| atoms.any? { |b| !b.equal?(a) && b != a && b.each_node.any? { |n| n == a } } }
+      return e if atoms.empty?
+      taken = e.variables
+      names = atoms.each_with_index.map { |_, i| Var.new(:"c#{i}") }
+      raise ArgumentError, "names taken" if names.any? { |v| taken.include?(v.name) }
+      forth = atoms.zip(names).to_h
+      e.subs(forth).cancel.subs(forth.invert).simplify
+    end
+
+    # a + b*k with a, b rational is an integer exactly on a residue class of
+    # k: b*k + a in ZZ is s*p*k = -q*r (mod q*s) for b = p/q, a = r/s, a
+    # linear congruence. So {k/2 | k in ZZ} meets ZZ in every integer, and
+    # {1/2 + k | k in ZZ} nowhere (the family was kept whole, offering 1/2
+    # as an integer: fourth review). Over NN the members also start at 0.
+    def rational_family(set, a, b, wanted, sign)
+      return [set] unless set.domain == ZZ && wanted <= ZZ
+      p, q = b.numerator, b.denominator
+      r, s = a.numerator, a.denominator
+      modulus = q * s
+      coefficient = (s * p) % modulus
+      target = (-q * r) % modulus
+      g = coefficient.gcd(modulus)
+      return [] unless (target % g).zero?
+      period = modulus / g
+      k0 = period > 1 ? (target / g) * NumberTheory.invmod(coefficient / g, period) % period : 0
+      base = a + b * k0
+      step = (b * period).abs # the same progression either way round
+      j = Var.new(:k)
+      lower = { positive: 1, nonnegative: 0 }[sign] || (wanted == NN ? 0 : nil)
+      upper = { negative: -1, nonpositive: 0 }[sign]
+      return [] if lower && upper
+      if lower
+        start = base + step * ((lower - base) / step).ceil
+        return [NN] if start.zero? && step == 1
+        return [ImageSet.new((Num.new(start) + Num.new(step) * j).simplify, [j], NN)]
+      end
+      if upper
+        start = base + step * ((upper - base) / step).floor
+        return [ImageSet.new((Num.new(start) - Num.new(step) * j).simplify, [j], NN)]
+      end
+      return [ZZ] if base.denominator == 1 && step == 1
+      [ImageSet.new((Num.new(base) + Num.new(step) * j).simplify, [j], ZZ)]
+    end
+
+    # What each declared sign allows a root to be.
+    ALLOWED_SIGNS = { positive: %i[positive], nonnegative: %i[positive zero],
+                      negative: %i[negative], nonpositive: %i[negative zero] }.freeze
+
+    def wrong_sign?(root, sign)
+      found = root_sign(root)
+      !found.nil? && !ALLOWED_SIGNS.fetch(sign, %i[positive negative zero]).include?(found)
+    end
+
+    # The sign of a constant root, or nil when it is not decided: a root
+    # with a parameter in it, or one that is not real.
+    def root_sign(root)
+      return nil unless root.variables.empty?
+      return :zero if Scalar.zero?(root)
+      value = Analysis.numeric(root)
+      return nil if value.nil?
+      value.positive? ? :positive : :negative
+    end
+
+    # An integer parameter for the periodic solutions, avoiding the names in use.
+    def period_parameter(f, x)
+      taken = f.variables | [x.name]
+      name = %i[k n m j].find { |candidate| !taken.include?(candidate) }
+      name ||= (1..).lazy.map { |i| :"k#{i}" }.find { |candidate| !taken.include?(candidate) }
+      Var.new(name)
+    end
+
+    def to_zero(target) = target.is_a?(Equation) ? Sub.new(target.lhs, target.rhs) : Expression.lift(target)
+
+    def piecewise?(target)
+      return true if target.is_a?(Expression) && target.each_node.any? { |n| n.is_a?(Piecewise) }
+      target.is_a?(Equation) && (target.lhs.each_node.any? { |n| n.is_a?(Piecewise) } || target.rhs.each_node.any? { |n| n.is_a?(Piecewise) })
+    end
+
+    # Every branch is solved on its own piece (piecewise.rb).
+    def piecewise(target, vars)
+      return Piecewises.solve(Piecewises.hoist(target), Num.new(0), vars) unless target.is_a?(Equation)
+      pw = Piecewises.hoist(Sub.new(target.lhs, target.rhs).simplify)
+      return Piecewises.solve(pw, Num.new(0), vars) if pw.is_a?(Piecewise)
+      Solve.solve(pw, vars)
+    end
+
+    def variable(f, vars)
+      return Expression.lift(vars) if vars
+      free = f.variables
+      raise ArgumentError, "solve: which variable? #{f} has #{free.size} variables" unless free.size == 1
+      Var.new(free.first)
+    end
+
+    def depends?(e, x) = e.variables.include?(x.name)
+
+    def dedupe(list)
+      out = []
+      list.each { |s| out << s unless out.any? { |o| o == s } }
+      out
+    end
+
+    # ---- one equation, one unknown ----------------------------------------------
+
+    def univariate(f, x, depth, all: false)
+      return [] if depth > MAX_DEPTH
+      f = f.simplify
+      raise ArgumentError, "every value of #{x} is a solution" if Scalar.zero?(f)
+      return [] unless depends?(f, x)
+
+      cases = case_nodes(f, x)
+      return case_split(f, x, cases, depth, all: all) unless cases.empty?
+
+      num, den = numerator_denominator(f, x)
+      coeffs = polynomial_coefficients(num, x)
+      # a zero numerator is an identity off the poles, not "no roots"
+      raise ArgumentError, "every value of #{x} is a solution" if coeffs&.all? { |c| Scalar.zero?(c) }
+      roots = coeffs ? polynomial_roots(coeffs) : transcendental(num, x, depth, all: all)
+      roots = roots.map(&:simplify).reject { |r| Scalar.zero?(den.subs(x => r).simplify) }
+      verify(f, x, roots)
+    end
+
+    # The distinct abs(u) and sign(u) in f whose u depends on x: the places
+    # where f is one expression to the left of a point and another to the right.
+    def case_nodes(f, x)
+      f.each_node.select { |n| n.is_a?(Fn) && CASES.include?(n.name) && n.args.size == 1 && depends?(n.args.first, x) }.uniq
+    end
+
+    # |u| is u where u >= 0 and -u where u <= 0, and sign(u) is 1, -1 and 0
+    # in the same three places, so an equation with n of them is 2**n
+    # equations without any, together with the points where a sign vanishes.
+    # Every candidate goes back through verify, which drops the roots of a
+    # branch that do not lie in it, so the answer is the case split a
+    # student writes - and |x| - 1 = 0 no longer comes back empty.
+    # A branch that vanishes as a whole - |x| - x is zero on all of x >= 0 -
+    # contributes the set where its cases hold, and the answer is then a
+    # set: the points of the other branches with those sets (the answer was
+    # an ArgumentError naming the set: fourth review, S18).
+    def case_split(f, x, nodes, depth, all: false)
+      raise RCAS::Unsupported, "can't solve #{f} = 0 for #{x}: too many cases" if nodes.size > MAX_CASES
+      sets = []
+      roots = [1, -1].repeated_permutation(nodes.size).flat_map { |signs| branch_roots(f, x, nodes, signs, depth, sets, all: all) }
+      roots += nodes.select { |n| n.name == :sign }.flat_map { |n| univariate(n.args.first, x, depth + 1, all: all) }
+      points = verify(f, x, dedupe(roots.map(&:simplify)))
+      return points if sets.empty?
+      real = points.select { |p| p.is_a?(Expression) && Analysis.numeric(p) }
+      raise Whole, sets.reduce(RealSet.new(real.map { |p| Interval.point(p) })) { |acc, set| acc | set }
+    end
+
+    def branch_roots(f, x, nodes, signs, depth, sets = [], all: false)
+      branch = nodes.zip(signs).map { |node, sign| [node, branch_value(node, sign)] }.to_h
+      univariate(f.subs(branch), x, depth + 1, all: all)
+    rescue ArgumentError => e
+      raise unless e.message.start_with?("every value")
+      conditions = branch_conditions(nodes, signs)
+      set = begin
+        Inequalities.solve(conditions, x)
+      rescue NotImplementedError, RCAS::Unsupported
+        nil
+      end
+      raise ArgumentError, "every #{x} with #{conditions.join(' and ')} solves #{f} = 0" unless set.is_a?(RealSet)
+      sets << set
+      []
+    end
+
+    def branch_value(node, sign)
+      return Num.new(sign) if node.name == :sign
+      sign.positive? ? node.args.first : Neg.new(node.args.first)
+    end
+
+    def branch_conditions(nodes, signs)
+      nodes.zip(signs).map do |node, sign|
+        strict = node.name == :sign
+        op = if sign.positive? then strict ? :> : :>=
+             else strict ? :< : :<=
+             end
+        Inequality.new(node.args.first, op, 0)
+      end
+    end
+
+    # f = num / den with den the product of the x-dependent denominators.
+    def numerator_denominator(f, x)
+      _, table = Expand.table(f)
+      den_factors = {}
+      table.each_key do |factors|
+        factors.each do |base, exp|
+          next unless exp.is_a?(Integer) && exp.negative? && depends?(base, x)
+          den_factors[base] = [den_factors[base] || 0, -exp].max
+        end
+      end
+      # no denominator left once expanded: (x**2 - x)/x is x - 1, and the
+      # unexpanded quotient has no value at 0 (fourth review, S17)
+      return [f.expand, Num.new(1)] if den_factors.empty?
+      constant, table = Expand.table(f)
+      cleared = {}
+      cleared[den_factors.dup] = constant unless constant.zero?
+      table.each do |factors, coeff|
+        merged = factors.dup
+        den_factors.each do |base, k|
+          e = Simplify.add_exponents(merged[base] || 0, k)
+          e.is_a?(Numeric) && e.zero? ? merged.delete(base) : merged[base] = e
+        end
+        cleared[merged] = (cleared[merged] || 0) + coeff
+      end
+      [Simplify.rebuild_sum(0, cleared).expand, Simplify.rebuild_product(1, den_factors)]
+    end
+
+    # Coefficients of f as a polynomial in x (index = degree), or nil.
+    def polynomial_coefficients(f, x)
+      constant, table = Expand.table(f)
+      coeffs = Hash.new { Num.new(0) }
+      coeffs[0] = Num.new(constant)
+      table.each do |factors, coeff|
+        degree = 0
+        c = Num.new(coeff)
+        factors.each do |base, exp|
+          if base == x
+            return nil unless exp.is_a?(Integer) && exp >= 0
+            degree += exp
+          elsif depends?(base, x) || (exp.is_a?(Expression) && depends?(exp, x))
+            return nil
+          else
+            c *= Simplify.power_node(base, exp)
+          end
+        end
+        coeffs[degree] = coeffs[degree] + c
+      end
+      list = (0..coeffs.keys.max).map { |k| coeffs[k].simplify }
+      list.pop while list.size > 1 && Scalar.zero?(list.last)
+      list
+    end
+
+    # Roots (with multiplicity) of the polynomial with these coefficients.
+    def polynomial_roots(coeffs)
+      coeffs = coeffs.dup
+      coeffs.pop while coeffs.size > 1 && Scalar.zero?(coeffs.last)
+      n = coeffs.size - 1
+      return [] if n < 1
+      return exact_roots(coeffs) if coeffs.all? { |c| c.is_a?(Num) && (c.value.is_a?(Integer) || c.value.is_a?(Rational)) }
+      return float_roots(coeffs) if n > 2 && coeffs.all? { |c| c.is_a?(Num) && c.value.is_a?(Numeric) && c.value.real? }
+
+      factored = symbolic_roots_by_factoring(coeffs)
+      return factored if factored
+
+      case n
+      when 1 then [(-coeffs[0] / coeffs[1]).cancel]
+      when 2 then quadratic(coeffs[2], coeffs[1], coeffs[0])
+      else raise RCAS::Unsupported, "can't solve a degree #{n} polynomial with symbolic coefficients exactly"
+      end
+    end
+
+    # (x - a)*(x - 1) = 0 has the roots a and 1: factor over QQ[x, params]
+    # first and read linear factors off; quadratic factors use the formula.
+    def symbolic_roots_by_factoring(coeffs)
+      x = Var.new(:_x)
+      expr = coeffs.each_with_index.reduce(Num.new(0)) { |acc, (c, k)| acc + c * x**k }
+      vars = expr.variables
+      return nil unless vars.include?(:_x)
+      return nil if coeffs.size > 3 && irreducible_image?(coeffs)
+      poly = Polynomial.from_expr(QQ[*vars], expr)
+      factors = poly.factor.factors.map(&:first).reject { |g| g.degree(:_x).zero? }
+      return nil if factors.size <= 1 && factors.first&.degree(:_x).to_i >= 2
+      factors.flat_map do |g|
+        cs = (0..g.degree(:_x)).map { |k| g.coefficient_in(:_x, k).to_expr }
+        case cs.size - 1
+        when 1 then [(-cs[0] / cs[1]).cancel]
+        when 2 then quadratic(cs[2], cs[1], cs[0])
+        else raise RCAS::Unsupported, "can't solve a degree #{cs.size - 1} factor with symbolic coefficients exactly"
+        end
+      end
+    rescue DomainError
+      nil
+    end
+
+    # A factor of f in x, of any degree, survives setting the parameters to
+    # integers where the leading coefficient does not vanish, so an
+    # irreducible image of the full degree proves f has no factor to find:
+    # a quartic with three parameters sat in Kronecker's substitution for
+    # half a minute before the same refusal (third review, section 5).
+    def irreducible_image?(coeffs)
+      params = coeffs.flat_map(&:variables).uniq
+      return false if params.empty?
+      random = Random.new(20260923)
+      2.times do
+        point = params.to_h { |v| [Var.new(v), Num.new(random.rand(2..97))] }
+        values = coeffs.map { |c| c.subs(point).simplify }
+        next unless values.all? { |v| v.is_a?(Num) && (v.value.is_a?(Integer) || v.value.is_a?(Rational)) }
+        next if values.last.value.zero?
+        image = Polynomial.new(QQ[:_x], values.each_with_index.reject { |v, _| v.value.zero? }.to_h { |v, k| [[k], v] })
+        found = image.factor.factors
+        return true if found.size == 1 && found.first.last == 1 && found.first.first.degree == coeffs.size - 1
+      end
+      false
+    rescue StandardError => rescued
+      RCAS.guard!(rescued)
+      false
+    end
+
+    def quadratic(a, b, c)
+      disc = (b**2 - 4 * a * c).expand
+      return [(-b / (2 * a)).simplify] * 2 if Scalar.zero?(disc)
+      root = square_root(disc)
+      [((-b - root) / (2 * a)).simplify, ((-b + root) / (2 * a)).simplify]
+    end
+
+    # sqrt(d) with perfect squares taken out: sqrt((a - 1)**2) => a - 1,
+    # sqrt(4*a) => 2*sqrt(a), sqrt(a**2 + a**4) => a*sqrt(1 + a**2). For
+    # any complex values c*sqrt(w) is one of +-sqrt(c**2*w), so this is
+    # right for the +- pair of the quadratic formula, the one caller, and
+    # for nothing else.
+    def square_root(d)
+      return RCAS.sqrt(d) if d.variables.empty?
+      fact = d.to_poly.factor
+      return RCAS.sqrt(d) if fact.factors.all? { |_, m| m == 1 }
+      outside = Num.new(1)
+      inside = Num.new(fact.unit.value)
+      fact.factors.each do |g, m|
+        outside *= g.to_expr**(m / 2) if m >= 2
+        inside *= g.to_expr if m.odd?
+      end
+      (outside * RCAS.sqrt(inside.simplify)).simplify
+    rescue DomainError, NotImplementedError, RCAS::Unsupported
+      RCAS.sqrt(d)
+    end
+
+    def exact_roots(coeffs)
+      ring = QQ[:_x]
+      poly = Polynomial.new(ring, coeffs.each_with_index.to_h { |c, k| [[k], c] })
+      poly.factor.factors.flat_map do |g, m|
+        roots =
+          if g.degree == 1
+            [Num.new(Simplify.normalize_number(Rational(-g.coeff(0).value, g.coeff(1).value)))]
+          elsif g.degree == 2
+            quadratic(g.coeff(2), g.coeff(1), g.coeff(0))
+          elsif g.terms.size == 2 && g.coeff(0) != 0
+            binomial_roots(g)
+          elsif g.degree == 4 && g.terms.keys.all? { |e| e[0].even? }
+            biquadratic_roots(g)
+          else
+            (0...g.degree).map { |i| RootOf.new(g.primitive_part, i) }
+          end
+        roots * m
+      end
+    end
+
+    # a x^4 + b x^2 + c = 0: x = +-sqrt(r) for the two roots r of a r^2 + b r + c
+    def biquadratic_roots(g)
+      quadratic(g.coeff(4), g.coeff(2), g.coeff(0)).flat_map do |r|
+        root = RCAS.sqrt(r)
+        [Simplify.negate(root).simplify, root]
+      end
+    end
+
+    # a x^k + b = 0  =>  |b/a|^(1/k) times the k-th roots of +-1
+    def binomial_roots(g)
+      k = g.degree
+      c = Rational(-g.coeff(0).value, g.coeff(k).value)
+      radius = Pow.new(Num.new(c.abs), Num.new(Rational(1, k)))
+      (0...k).map do |j|
+        angle = c.positive? ? Rational(2 * j, k) : Rational(2 * j + 1, k)
+        (radius * Fn.new(:exp, [I * PI * angle])).simplify
+      end
+    end
+
+    # Durand-Kerner iteration for an irreducible numeric polynomial.
+    def numeric_roots(g)
+      n = g.degree
+      lc = g.coeff(n).value.to_f
+      a = (0..n).map { |k| g.coeff(k).value.to_f / lc }
+      roots = (0...n).map { |k| Complex(0.4, 0.9)**k }
+      value = ->(z) { a.each_with_index.reduce(0) { |acc, (c, k)| acc + c * z**k } }
+      500.times do
+        moved = 0.0
+        roots = roots.each_with_index.map do |z, i|
+          denom = roots.each_with_index.reduce(1) { |acc, (w, j)| i == j ? acc : acc * (z - w) }
+          nz = z - value.call(z) / denom
+          moved += (nz - z).abs
+          nz
+        end
+        break if moved < 1e-14
+      end
+      # Which roots are real is an exact question: Sturm's theorem counts
+      # them, and that many roots nearest the real axis are the real ones
+      # (an |Im| < 1e-9 test and a rounding to twelve digits decided it
+      # before: fourth review, 2.4). Conjugate pairs are made exact pairs.
+      real = sturm_count(g)
+      nearest = roots.each_with_index.sort_by { |z, _| z.imaginary.abs }.first(real).map(&:last)
+      roots.each_with_index.map do |z, i|
+        Num.new(nearest.include?(i) ? z.real : z)
+      end.sort_by { |r| r.value.is_a?(Complex) ? [r.value.real, r.value.imaginary] : [r.value, 0] }
+    end
+
+    # Float coefficients (a Float matrix's characteristic polynomial, the
+    # fifth review's L10): Durand-Kerner in Floats. A Float polynomial has
+    # no exact real-root count, so a root is real when no other root is its
+    # conjugate - the roots of a real polynomial come in conjugate pairs,
+    # and one left without a partner can only be real.
+    def float_roots(coeffs)
+      lead = coeffs.last.value.to_f
+      a = coeffs.map { |c| c.value.to_f / lead }
+      zero = a.index { |c| !c.zero? } # x**m divides: those roots are exactly 0
+      a = a.drop(zero)
+      roots = durand_kerner(a) + [0.0] * zero
+      unit = [roots.map(&:abs).max, Float::MIN].max
+      k = scaled_size(a, unit)
+      roots = polished_clusters(roots, a, unit, k)
+      noise = 10 * Float::EPSILON * k * unit
+      paired = []
+      roots.each_with_index do |z, i|
+        next if paired.include?(i)
+        partner = roots.each_index.find { |j| j != i && !paired.include?(j) && (roots[j] - z.conj).abs <= 2 * noise && z.imaginary.abs > noise }
+        paired.push(i, partner) if partner
+      end
+      roots.each_with_index.map do |z, i|
+        # a real part at the level of rounding is none: the rotation's +-i
+        # came out as -2e-17 + i
+        z = Complex(z.real.abs <= noise ? 0.0 : z.real, z.imaginary) if paired.include?(i)
+        Num.new(paired.include?(i) ? z : z.real)
+      end.sort_by { |r| r.value.is_a?(Complex) ? [1, r.value.real, r.value.imaginary] : [0, r.value, 0] }
+    end
+
+    def durand_kerner(a)
+      n = a.size - 1
+      return [] if n < 1
+      roots = (0...n).map { |k| Complex(0.4, 0.9)**k }
+      value = ->(z) { a.each_with_index.reduce(0) { |acc, (c, k)| acc + c * z**k } }
+      500.times do
+        moved = 0.0
+        roots = roots.each_with_index.map do |z, i|
+          denom = roots.each_with_index.reduce(1) { |acc, (w, j)| i == j ? acc : acc * (z - w) }
+          step = denom.zero? ? 0 : value.call(z) / denom
+          moved += step.abs
+          z - step
+        end
+        break if moved < 1e-15
+      end
+      roots
+    end
+
+    # The coefficients of the monic polynomial with its roots scaled into
+    # the unit disc: how large they are is how much rounding a root sees.
+    def scaled_size(a, unit)
+      n = a.size - 1
+      [a.each_with_index.map { |c, i| c.abs / unit**(n - i) }.max, 1.0].max
+    end
+
+    # A root of multiplicity m is found only to about (eps*k)**(1/m) of the
+    # scale, as m roots scattered round it: a triple eigenvalue 2 came
+    # back 2.5e-5 to 4.6e-5 apart. So m roots that lie within ten times
+    # that of each other are one root of multiplicity m, and Newton's
+    # method for it, z - m*p(z)/p'(z), polishes their mean; two roots
+    # 1e-6 apart are further apart than a double root can scatter, and
+    # stay two. Largest clusters first. The radius is relative to the
+    # roots, not to 1: eigenvalues 1e-8, 3e-8 and 5e-8 were one triple
+    # root (the sixth review's preflight).
+    def polished_clusters(roots, a, unit, k)
+      value = ->(z) { a.each_with_index.reduce(0) { |acc, (c, i)| acc + c * z**i } }
+      slope = ->(z) { a.each_with_index.reduce(0) { |acc, (c, i)| i.zero? ? acc : acc + i * c * z**(i - 1) } }
+      left = roots.dup
+      found = []
+      roots.size.downto(2) do |m|
+        radius = 10 * (Float::EPSILON * k)**(1.0 / m) * unit
+        loop do
+          cluster = left.lazy.map { |z| left.sort_by { |w| (w - z).abs }.first(m) }
+                        .find { |group| group.size == m && group.combination(2).all? { |p, q| (p - q).abs <= radius } }
+          break unless cluster
+          cluster.each { |z| left.delete_at(left.index(z)) }
+          z = cluster.sum / m
+          30.times do
+            d = slope.call(z)
+            break if d.zero?
+            step = m * value.call(z) / d
+            break if step.abs <= 1e-16 * unit
+            z -= step
+          end
+          found.concat([z] * m)
+        end
+      end
+      found + left
+    end
+
+    # The number of distinct real roots of a polynomial over QQ: the sign
+    # changes of its Sturm sequence at -oo less those at oo.
+    def sturm_count(g)
+      g = g.to_ring(QQ[*g.ring.vars]) unless g.ring.base == QQ # the remainders need a field
+      sequence = [g, g.derivative]
+      until sequence.last.zero? || sequence.last.degree.zero?
+        remainder = sequence[-2] % sequence[-1]
+        break if remainder.zero?
+        sequence << -remainder
+      end
+      at = lambda do |sign|
+        values = sequence.map do |q|
+          lead = q.leading_coefficient.value
+          lead = -lead if sign.negative? && q.degree.odd?
+          lead <=> 0
+        end.reject(&:zero?)
+        values.each_cons(2).count { |a, b| a != b }
+      end
+      at.call(-1) - at.call(1)
+    end
+
+    # ---- transcendental equations -------------------------------------------------
+
+    def transcendental(f, x, depth, all: false)
+      atoms = f.each_node.select { |n| depends?(n, x) && transcendental_atom?(n) }.uniq
+      atoms = atoms.sort_by { |n| -n.each_node.count }
+      common = common_exponential(atoms, x) || common_power(atoms, x)
+      atoms.unshift(common) if common && !atoms.include?(common)
+      t = Var.new(:"_s#{depth}")
+
+      atoms.each do |u|
+        g = replace_atom(f, u, x, t)
+        next if g.nil? || depends?(g, x)
+        inverted = begin
+          univariate(g, t, depth + 1).flat_map { |v| invert(u, v, x, depth, all: all) }
+        rescue NotImplementedError, RCAS::Unsupported, ArgumentError
+          next # another atom, or one of the rules below, may do better
+        end
+        return inverted
+      end
+
+      # x**(p/q): substitute t = x**(1/q)
+      q = root_denominator(f, x)
+      if q > 1 && !depends?(g = replace_root(f, x, q, t), x)
+        # only when t = x**(1/q) replaces every x: sqrt(x)*log(x) keeps an
+        # x inside the log, and "solving for t" there treated it as a
+        # constant (and sqrt(x) = sqrt(2 - x) answered 2 - x)
+        values = univariate(g, t, depth + 1)
+        return values.map { |v| (v**q).simplify }
+      end
+
+      product = product_equation(f, x, depth, all: all)
+      return product if product
+
+      homogeneous = homogeneous_trig(f, x, depth, all: all)
+      return homogeneous if homogeneous
+
+      radicals = radical_equation(f, x, depth, all: all)
+      return radicals if radicals
+
+      logs = logarithmic_equation(f, x, depth)
+      return logs if logs
+
+      raise RCAS::Unsupported, "can't solve #{f} = 0 for #{x}; nsolve(#{f}, #{x}: a..b) finds a root numerically"
+    end
+
+    # A product vanishes where one of its factors does, so a product no
+    # rule can take whole is still three easy equations when it is written
+    # as one: (x + 1)*(x - 2)*sin(x). Every factor has to be solvable, or
+    # the answer would be missing roots without saying so; a factor in the
+    # denominator is not one of them (`numerator_denominator` has already
+    # taken those away, and its zeros are poles rather than roots).
+    def product_equation(f, x, depth, all: false)
+      _, factors = Simplify.factorize(f)
+      pieces = factors.filter_map do |base, exponent|
+        next nil if exponent.is_a?(Numeric) && Simplify.negative?(exponent)
+        # a positive power vanishes exactly where its base does, and a
+        # symbolic exponent is the factor itself: exp(u) is stored as
+        # EXP**u, whose base knows nothing about x
+        piece = exponent.is_a?(Numeric) && exponent.positive? ? base : Simplify.power_node(base, exponent)
+        depends?(piece, x) ? piece : nil
+      end
+      if pieces.size < 2
+        # a product the normal form has already multiplied out:
+        # (x - 2)*log(x)/x arrives as -2*log(x) + x*log(x)
+        common, rest = Simplify.common_factor(f)
+        pieces = [common, rest].compact.select { |piece| depends?(piece, x) }
+        return nil if pieces.size < 2
+      end
+      # A root of one factor is a root of the product only where the rest of
+      # the product is defined: log(x)*(x**2 - 4) does not vanish at -2.
+      defined_roots(f, x, pieces.flat_map { |piece| univariate(piece, x, depth + 1, all: all) })
+    rescue NotImplementedError, RCAS::Unsupported
+      nil # one factor rcas cannot solve: the product is no easier
+    end
+
+    # An equation in which every term has the same total degree in sin(u)
+    # and cos(u) is a polynomial in tan(u): divide through by cos(u)**n.
+    # sin(x) + cos(x) = 0 is tan(x) = -1, which rcas solves, and there was
+    # no rule that saw it. Where the division loses the zeros of cos(u) -
+    # which it does only when no term is a pure power of sin(u) - they are
+    # put back, and a term short of the top degree is raised to it by
+    # `homogenize` first.
+    def homogeneous_trig(f, x, depth, all: false)
+      arguments = f.each_node.filter_map do |node|
+        node.args.first if node.is_a?(Fn) && %i[sin cos].include?(node.name) && depends?(node, x)
+      end.uniq
+      return nil unless arguments.size == 1
+      u = arguments.first
+      sine = Fn.new(:sin, [u])
+      cosine = Fn.new(:cos, [u])
+      f = homogenize(f, sine, cosine)
+      return nil if f.nil?
+      constant, table = Expand.table(f)
+      return nil unless constant.zero? && table.size > 1
+
+      t = Var.new(:"_t#{depth}")
+      degrees = []
+      polynomial = Num.new(0)
+      table.each do |factors, coefficient|
+        sines = factors[sine] || 0
+        cosines = factors[cosine] || 0
+        rest = factors.reject { |base, _| base == sine || base == cosine }
+        return nil unless [sines, cosines].all? { |e| e.is_a?(Integer) && !e.negative? }
+        return nil if rest.keys.any? { |base| depends?(base, x) }
+        degrees << sines + cosines
+        polynomial += Simplify.rebuild_product(coefficient, rest) * t**sines
+      end
+      return nil unless degrees.uniq.size == 1 && degrees.first.positive?
+
+      roots = univariate(polynomial.simplify, t, depth + 1)
+      answers = roots.flat_map { |value| invert(Fn.new(:tan, [u]), value, x, depth, all: all) }
+      # cos(u) = 0 solves it too when there is no pure sin(u)**n term
+      answers += univariate(cosine, x, depth + 1, all: all) if Coefficients.coeff(polynomial.simplify, t, degrees.first).nil? ||
+                                                               Scalar.zero?(Coefficients.coeff(polynomial.simplify, t, degrees.first))
+      answers
+    rescue NotImplementedError, RCAS::Unsupported
+      nil
+    end
+
+    # sin(x)*cos(x) = 1/2 is not homogeneous as written and becomes so when
+    # the 1/2 is read as (sin(x)**2 + cos(x)**2)/2 - the classical trick,
+    # and the reason the identity is taught before the equation is set. A
+    # term short of the top degree by an even number is raised to it that
+    # way; an odd gap (sin(x) = 1/2) has no such reading and the rule
+    # declines, which leaves the equation to the atom substitution that
+    # already answers it.
+    def homogenize(f, sine, cosine)
+      constant, table = Expand.table(f)
+      entries = table.map do |factors, coefficient|
+        powers = [factors[sine] || 0, factors[cosine] || 0]
+        return nil unless powers.all? { |e| e.is_a?(Integer) && !e.negative? }
+        [powers.sum, Simplify.rebuild_product(coefficient, factors)]
+      end
+      entries << [0, Expression.lift(constant)] unless constant.zero?
+      return nil if entries.empty?
+      top = entries.map(&:first).max
+      return f if entries.all? { |degree, _| degree == top }
+      return nil unless top.positive? && entries.all? { |degree, _| ((top - degree) % 2).zero? }
+      pythagoras = Simplify.power_node(sine, 2) + Simplify.power_node(cosine, 2)
+      raised = entries.map { |degree, term| term * pythagoras**((top - degree) / 2) }
+      Expand.expand(raised.inject(:+)).simplify
+    end
+
+    # sqrt(u) = v: the radical on one side, both sides to the q-th power,
+    # and the answers kept only where the original equation is defined.
+    # Raising to a power invents roots, and `verify` drops those.
+    #
+    # Two radicals go one to each side, sqrt(x) = sqrt(2 - x), and the
+    # squared equation has one radical fewer; what is left is squared again
+    # one level down.
+    # The answer of an equation that is a whole set rather than points.
+    class Whole < StandardError
+      attr_reader :set
+
+      def initialize(set)
+        @set = set
+        super("the solutions form the set #{set}")
+      end
+    end
+
+    def radical_equation(f, x, depth, all: false)
+      constant, terms = Simplify.termize(f)
+      with, without = terms.partition { |factors, _| root_index(factors, x) }
+      return nil unless [1, 2].include?(with.size)
+      q = with.map { |factors, _| root_index(factors, x) }.max
+      return nil if q.nil? || q > 3
+      side = Simplify.rebuild_sum(0, with.first(1).to_h)
+      others = with.drop(1) + without
+      rest = Simplify.rebuild_sum(-constant, others.to_h.transform_values { |c| -c })
+      g = (Expand.expand(Simplify.power_node(side, q)) - Expand.expand(Simplify.power_node(rest, q))).simplify
+      if Scalar.zero?(g)
+        # sqrt(x**2) = -x squares to x**2 = x**2, which says nothing: an even
+        # root is the non-negative one, so the equation holds exactly where
+        # the other side is not negative - that set, or a refusal below the
+        # top (an "every value" verdict about the square was wrong: S18)
+        raise RCAS::Unsupported, "squaring #{f} = 0 gives an identity" unless q.even? && depth.zero? && with.size == 1 && side_is_root?(side, x)
+        raise Whole, Inequalities.solve(Inequality.new(rest, :>=, 0), x)
+      end
+      if root_denominator(g, x) > 1 || g.each_node.any? { |n| root_index_of(n, x) }
+        # still a radical: fine if there are fewer radical terms than before
+        remaining = Simplify.termize(g).last.count { |factors, _| root_index(factors, x) }
+        return nil unless remaining < with.size
+      end
+      # all: goes down too - sqrt(exp(x)) = exp(x) squares to a family,
+      # and one period of it was [0] - and the families squaring brings
+      # are checked like the points
+      found = univariate(g, x, depth + 1, all: all)
+      families, points = found.partition { |r| !family_parameters(r, x, f).empty? }
+      defined_roots(f, x, verify(f, x, points) + verified_families(f, x, families))
+    rescue NotImplementedError, RCAS::Unsupported
+      nil
+    end
+
+    # Squaring can add a family as easily as a point: sqrt(exp(x)) =
+    # -exp(x) squares to the same equation as sqrt(exp(x)) = exp(x). A
+    # family is kept when its members at six indices all satisfy f,
+    # decided exactly, dropped when none does, and refused when some do
+    # and some do not - which members those are is not written here.
+    VERIFIED_INDICES = [0, 1, -1, 2, -2, 3].freeze
+
+    # Inside univariate a family is still a root in a name the equation
+    # does not have (`family` makes the ImageSet at the top), and that name
+    # runs over the integers.
+    def family_parameters(root, x, f) = root.is_a?(Expression) ? root.variables - f.variables - [x.name] : []
+
+    def verified_families(f, x, families)
+      families.select do |family|
+        names = family_parameters(family, x, f)
+        verdicts = VERIFIED_INDICES.map do |k|
+          member = family.subs(names.to_h { |name| [name, Num.new(k)] }).simplify
+          residual = f.subs(x => member).simplify
+          Integrate.defined_value?(residual) ? Decide.zero?(residual) : false
+        rescue ZeroDivisionError
+          false
+        end
+        next true if verdicts.all?(true) || verdicts.include?(nil)
+        next false if verdicts.none?(true)
+        raise RCAS::Unsupported, "squaring #{f} = 0 gives the family #{family}, of which only some members solve it"
+      end
+    end
+
+    # log(u) + log(v) = c: one logarithm instead of two, which the atom
+    # substitution can then invert.
+    def logarithmic_equation(f, x, depth)
+      logs = f.each_node.count { |n| n.is_a?(Fn) && n.name == :log && depends?(n, x) }
+      return nil unless logs > 1
+      # every candidate is verified against the equation, so the logarithms
+      # may be combined as if their arguments were positive
+      combined = Trigonometry.logcombine(f, force: true).simplify
+      return nil if combined == f
+      defined_roots(f, x, univariate(combined, x, depth + 1))
+    rescue NotImplementedError, RCAS::Unsupported
+      nil
+    end
+
+    # A single radical with coefficient 1: sqrt(u) itself, so that
+    # sqrt(u) = rest holds exactly where rest >= 0 once the squares agree.
+    def side_is_root?(side, x)
+      coeff, factors = Simplify.factorize(side)
+      coeff == 1 && factors.size == 1 && root_index_of(Simplify.power_node(*factors.first), x)
+    end
+
+    # The denominator of a fractional exponent on a base that involves x.
+    def root_index(factors, x)
+      factors.filter_map { |base, exp| root_index_of(Simplify.power_node(base, exp), x) }.max
+    end
+
+    def root_index_of(node, x)
+      return nil unless node.is_a?(Pow) && node.exponent.is_a?(Num)
+      value = node.exponent.value
+      return nil unless value.is_a?(Rational) && value.denominator > 1 && depends?(node.base, x)
+      value.denominator
+    end
+
+    # A root of the squared equation is a root of this one only where this
+    # one is defined: a logarithm needs a positive argument and an even root
+    # a non-negative one. That is the check a student is told to make.
+    def defined_roots(f, x, roots)
+      conditions = Analysis.domain_conditions(f, x)
+      return roots if conditions.empty?
+      roots.select do |root|
+        # The sign of the condition at the root is decided, not measured
+        # against 1e-9: the root 10**-12 of log(x)*(x - 10**-12) is inside
+        # the domain of log, and a tolerance said it was on the edge.
+        # Undecided keeps the root.
+        next true unless root.is_a?(Expression) && root.variables.empty?
+        conditions.all? do |condition|
+          sign = begin
+            Decide.sign(Expression.lift(condition.lhs - condition.rhs).subs(x => root))
+          rescue StandardError => rescued
+            RCAS.guard!(rescued)
+            nil
+          end
+          next true if sign.nil?
+          case condition.op
+          when :> then sign == :positive
+          when :>= then sign != :negative
+          when :< then sign == :negative
+          when :<= then sign != :positive
+          when :!= then sign != :zero
+          else true
+          end
+        end
+      end
+    end
+
+    def transcendental_atom?(n)
+      (n.is_a?(Fn)) || (n.is_a?(Pow) && !n.base.is_a?(Var) && !(n.exponent.is_a?(Num) && n.exponent.integer?)) ||
+        (n.is_a?(Pow) && !n.exponent.is_a?(Num))
+    end
+
+    # exp(v/l) for the exponentials exp(r_i*v) of f, l the least common
+    # denominator of the r_i: every one of them is a whole power of it
+    # (exp(x/2) and exp(x/3) are powers of exp(x/6)). nil when they are not
+    # rational multiples of one argument.
+    def common_exponential(atoms, x)
+      exps = atoms.select { |n| n.is_a?(Fn) && n.name == :exp }
+      return nil if exps.size < 2
+      first = exps.first.args.first
+      ratios = exps.map do |e|
+        r = (e.args.first / first).simplify
+        return nil unless r.is_a?(Num) && (r.value.is_a?(Integer) || r.value.is_a?(Rational))
+        r.value.to_r
+      end
+      numerator = ratios.map(&:numerator).reduce(:gcd)
+      denominator = ratios.map(&:denominator).reduce(:lcm)
+      Fn.new(:exp, [(first * Num.new(Rational(numerator, denominator))).simplify])
+    end
+
+    # r**(v/l) for the powers b_i**w_i of f with positive rational bases
+    # that are powers of one r (4 = 2**2, 1/8 = 2**-3), l the least common
+    # denominator of the exponents e_i*w_i measured against the first:
+    # every one of them is then a whole power of it, and 4**x - 3*2**x + 2
+    # is t**2 - 3*t + 2 in t = 2**x. A whole power is safe over CC, since
+    # b**w is exp(w*log(b)) with a real log(b). nil when the bases have no
+    # common root or the exponents are not rational multiples of one another.
+    def common_power(atoms, x)
+      powers = atoms.select { |n| n.is_a?(Pow) && power_base(n.base) && depends?(n.exponent, x) }
+      return nil if powers.size < 2
+      roots = powers.map { |n| power_base(n.base) }
+      return nil unless roots.map(&:first).uniq.size == 1
+      exponents = powers.zip(roots).map { |n, (_, e)| (n.exponent * e).simplify }
+      first = exponents.first
+      ratios = exponents.map do |w|
+        r = (w / first).simplify
+        return nil unless r.is_a?(Num) && (r.value.is_a?(Integer) || r.value.is_a?(Rational))
+        r.value.to_r
+      end
+      numerator = ratios.map(&:numerator).reduce(:gcd)
+      denominator = ratios.map(&:denominator).reduce(:lcm)
+      Pow.new(Num.new(roots.first.first), (first * Num.new(Rational(numerator, denominator))).simplify)
+    end
+
+    # A positive rational base b as [r, e] with b = r**e, r > 1 and not
+    # itself a perfect power; nil for any other base.
+    def power_base(base)
+      return nil unless base.is_a?(Num) && (base.value.is_a?(Integer) || base.value.is_a?(Rational))
+      b = base.value.to_r
+      return nil unless b.positive? && b != 1
+      sign = b > 1 ? 1 : -1
+      b = 1 / b if sign.negative?
+      e = [b.numerator, b.denominator].max.bit_length.downto(2).find do |k|
+        [b.numerator, b.denominator].all? { |n| Simplify.integer_root(n, k)**k == n }
+      end || 1
+      r = Rational(Simplify.integer_root(b.numerator, e), Simplify.integer_root(b.denominator, e))
+      [Simplify.normalize_number(r), sign * e]
+    end
+
+    # Replace the atom u by t. exp(k*v) becomes t**k for every whole k, and
+    # so does b**w when b = r**e and e*w is k times the exponent of u = r**v.
+    def replace_atom(f, u, x, t)
+      if u.is_a?(Pow) && power_base(u.base) && depends?(u.exponent, x)
+        r, e = power_base(u.base)
+        v = (u.exponent * e).simplify # u is r**v
+        constant, table = Expand.table(f)
+        rebuilt = {}
+        table.each do |factors, coeff|
+          new_factors = {}
+          factors.each do |base, exp|
+            root = exp.is_a?(Expression) && depends?(exp, x) && power_base(Expression.lift(base))
+            if root
+              return nil unless root.first == r
+              ratio = (exp * root.last / v).simplify
+              return nil unless ratio.is_a?(Num) && ratio.value.is_a?(Integer) # whole powers only, as for exp
+              new_factors[t] = (new_factors[t] || 0) + ratio.value
+            else
+              new_factors[base] = exp
+            end
+          end
+          rebuilt[new_factors] = (rebuilt[new_factors] || 0) + coeff
+        end
+        Simplify.rebuild_sum(constant, rebuilt)
+      elsif u.is_a?(Fn) && u.name == :exp
+        v = u.args.first
+        constant, table = Expand.table(f)
+        rebuilt = {}
+        table.each do |factors, coeff|
+          new_factors = {}
+          factors.each do |base, exp|
+            if base == Simplify.exp_base && exp.is_a?(Expression) && depends?(exp, x)
+              ratio = (exp / v).simplify
+              # a whole power only: exp(x) as exp(2*x)**(1/2) takes the
+              # principal root and forgets the branch, and over CC that put
+              # x = i*pi among the zeros of exp(2x) - 3*exp(x) + 2
+              return nil unless ratio.is_a?(Num) && ratio.value.is_a?(Integer)
+              new_factors[t] = (new_factors[t] || 0) + ratio.value
+            else
+              new_factors[base] = exp
+            end
+          end
+          rebuilt[new_factors] = (rebuilt[new_factors] || 0) + coeff
+        end
+        Simplify.rebuild_sum(constant, rebuilt)
+      else
+        f.subs(u => t)
+      end
+    end
+
+    def root_denominator(f, x)
+      _, table = Expand.table(f)
+      table.each_key.flat_map { |factors| factors.select { |b, e| b == x && e.is_a?(Rational) }.map { |_, e| e.denominator } }.reduce(1, :lcm)
+    end
+
+    def replace_root(f, x, q, t)
+      constant, table = Expand.table(f)
+      rebuilt = {}
+      table.each do |factors, coeff|
+        new_factors = factors.to_h do |base, exp|
+          base == x ? [t, Simplify.normalize_number(Rational(exp) * q)] : [base, exp]
+        end
+        rebuilt[new_factors] = (rebuilt[new_factors] || 0) + coeff
+      end
+      Simplify.rebuild_sum(constant, rebuilt)
+    end
+
+    # A target the function never takes is not an equation with complex
+    # solutions, it is an equation with none. rcas can name one such gap:
+    # tan(z) = (exp(2*i*z) - 1)/(i*(exp(2*i*z) + 1)) is i only where
+    # exp(2*i*z) + 1 vanishes in the denominator, so the tangent omits
+    # exactly +i and -i from the complex plane - which is also why atan(i)
+    # does not evaluate. Without this, sin(x)**2 + cos(x)**2 = 0 came back
+    # as two families built on atan(-i) and atan(i) (20 Sept 2026, the ninth
+    # pass of the review). cos(u) = 2 is not of this kind and keeps its
+    # answers: the cosine does reach 2, at i*log(2 + 3**(1/2)).
+    def tangent_gap?(v)
+      value = Expression.lift(v)
+      return false unless value.is_a?(Num)
+      number = Complex(value.value)
+      number.real.zero? && number.imaginary.abs == 1
+    rescue StandardError => rescued
+      RCAS.guard!(rescued)
+      false
+    end
+
+    # Solutions of u = v for x, where u is a single atom containing x. With
+    # all: true the period of sin, cos and tan is added, with an integer
+    # parameter, so that every solution is covered and not just one period.
+    def invert(u, v, x, depth, all: false)
+      case u
+      when Fn
+        arg = u.args.first
+        period = all ? period_parameter(arg - v, x) : nil
+        turn = ->(multiple) { period ? multiple * PI * period : Num.new(0) }
+        targets =
+          case u.name
+          # complete over CC (the fifth review's decision, as MuPAD and
+          # solveset): exp(x) = 2 is log(2) + 2*pi*i*k; domain: RR keeps k = 0
+          when :exp  then [period ? Fn.new(:log, [v]) + 2 * PI * I * period : Fn.new(:log, [v])]
+          when :surd then [v**u.args.last] # the real root: surd(u, n) = v is u = v**n, checked by verify
+          when :log  then [Fn.new(:exp, [v])]
+          when :sin  then [Fn.new(:asin, [v]) + turn.call(2), PI - Fn.new(:asin, [v]) + turn.call(2)]
+          when :cos  then [Fn.new(:acos, [v]) + turn.call(2), -Fn.new(:acos, [v]) + turn.call(2)]
+          when :tan  then tangent_gap?(v) ? [] : [Fn.new(:atan, [v]) + turn.call(1)]
+          when :atan then [Fn.new(:tan, [v])]
+          when :asin then [Fn.new(:sin, [v])]
+          when :acos then [Fn.new(:cos, [v])]
+          when :sinh then [Fn.new(:log, [v + RCAS.sqrt(v**2 + 1)])]
+          when :cosh then [Fn.new(:log, [v + RCAS.sqrt(v**2 - 1)]), -Fn.new(:log, [v + RCAS.sqrt(v**2 - 1)])]
+          else cannot_invert!(u, v)
+          end
+        # all: goes down with the equation: exp(sin(x)) = 1 is sin(x) = 0,
+        # and that has a family, not two points
+        targets.flat_map { |w| univariate((arg - w).simplify, x, depth + 1, all: all) }
+      when Pow
+        if depends?(u.base, x) && !depends?(u.exponent, x)
+          return [] if principal_power_reaches?(u.exponent, v) == false
+          univariate((u.base - v**(1 / u.exponent)).simplify, x, depth + 1, all: all)
+        elsif !depends?(u.base, x)
+          # b**u = exp(u*log(b)) = v: u*log(b) = log(v) + 2*pi*i*k, so
+          # (-1)**x = 2 has the solutions 2*k - i*log(2)/pi (it answered [])
+          turn = all ? period_parameter(u.exponent - v, x) : nil
+          logarithm = turn ? Fn.new(:log, [v]) + 2 * PI * I * turn : Fn.new(:log, [v])
+          roots_of_unity(u, v, x, depth, all: all) ||
+            univariate((u.exponent - logarithm / Fn.new(:log, [u.base])).simplify, x, depth + 1, all: all)
+        else
+          cannot_invert!(u, v)
+        end
+      else
+        cannot_invert!(u, v)
+      end
+    end
+
+    # w**e = exp(e*log(w)) with the principal log, whose imaginary part is
+    # in (-pi, pi]: for 0 < |e| < 1 the power reaches only the sector
+    # |arg| < |e|*pi, and one of its two edges. sqrt(exp(x)) = -1 has no
+    # solution, and inverting it as exp(x) = (-1)**2 found the family
+    # 2*pi*i*k - a family, so verify never saw it (the sixth review's
+    # preflight). true, false, or nil when it cannot be decided.
+    def principal_power_reaches?(e, v)
+      return true unless e.is_a?(Num) && e.value.is_a?(Rational) && e.value.abs < 1 && !e.value.zero?
+      return nil unless v.variables.empty?
+      return e.value.positive? if Decide.zero?(v) == true
+      arg = ComplexParts.arg(v).simplify
+      bound = Num.new(e.value.abs) * PI
+      case Decide.sign((bound - RCAS.abs(arg)).simplify)
+      when :positive then true
+      when :negative then false
+      when :zero then Decide.sign(arg) == (e.value.positive? ? :positive : :negative)
+      end
+    rescue StandardError => rescued
+      RCAS.guard!(rescued)
+      nil
+    end
+
+    # No inverse is known for u (x**x, erf, gamma, floor, an unknown
+    # function): that is "can't", never "no solution" - x**x = 4 has the
+    # root 2.
+    def cannot_invert!(u, v)
+      raise RCAS::Unsupported, "can't solve #{u} = #{v}: rcas knows no inverse of #{u.is_a?(Fn) ? u.name : u}"
+    end
+
+    # Largest order of a root of unity we look for: (-1)**x is the one that
+    # turns up, from cos(pi*x) with x an integer.
+    MAX_ORDER = 12
+
+    # b**u = v where b is a root of unity: the logarithm is no use, because
+    # the solutions repeat. (-1)**x = 1 holds for every even x and
+    # (-1)**x = -1 for every odd one, and answering with one of them - which
+    # is what log gave - drops all the rest. nil when b is not one, so that
+    # 2**x = 4 keeps the ordinary route.
+    def roots_of_unity(u, v, x, depth, all: false)
+      base = u.base
+      return nil unless base.is_a?(Num) && v.is_a?(Num)
+      order = (2..MAX_ORDER).find { |n| unity?(Simplify.pow_number(base.value, n), 1) }
+      return nil if order.nil?
+      turn = all ? period_parameter(u.exponent - v, x) : nil
+      found = (0...order).filter_map do |j|
+        next nil unless unity?(Simplify.pow_number(base.value, j), v.value)
+        target = Num.new(j)
+        target = (target + Num.new(order) * turn).simplify if turn
+        univariate((u.exponent - target).simplify, x, depth + 1)
+      end.flatten
+      # a value the powers of b never take: not "no solution" but the
+      # logarithm's (complex) ones
+      found.empty? ? nil : found
+    end
+
+    def unity?(value, target) = Scalar.zero?(Expression.lift(Simplify.normalize_number(value - target)))
+
+    # Drop the candidates that demonstrably fail the equation: the roots a
+    # squaring or a case split invented. The residual f(r) is decided by
+    # Decide, so a root is dropped only when the residual is shown to be
+    # non-zero - a residual of 4e-5 at exp(x) = 10**10 is rounding, and
+    # an unknown x is not always called x (the old check substituted the
+    # literal keyword x: and was a no-op for every other name). A root with
+    # a parameter in it cannot be checked by a number and stays.
+    def verify(f, x, roots)
+      roots.select do |r|
+        next true unless r.is_a?(Expression)
+        next false unless Integrate.defined_value?(r) # log(0) is no number, let alone a root
+        next true unless r.variables.empty?
+        next float_residual_small?(f.subs(x => r)) if floaty?(f) || floaty?(r)
+        residual = begin
+          f.subs(x => r).simplify
+        rescue ZeroDivisionError
+          next false
+        rescue StandardError => rescued
+          RCAS.guard!(rescued)
+          next true
+        end
+        Integrate.defined_value?(residual) && Decide.zero?(residual) != false
+      end
+    end
+
+    # A Float root, or an equation with Float coefficients, is checked the
+    # way Equation#holds? checks one: against the running error bound of
+    # the substituted equation, not by Decide.zero? of a residual that is
+    # already a single Float - that was 1e-16 of noise decided "not zero",
+    # and solve(1.0*x**3 - 6.0*x**2 + 12.0*x - 8.0, x) answered [] (the
+    # sixth review's preflight). The root is itself a few ulp out, which
+    # the bound does not know, hence the slack; a residual whose error
+    # cannot be bounded keeps the root.
+    FLOAT_SLACK = 1e3
+
+    def floaty?(e) = e.each_node.any? { |n| n.is_a?(Num) && (n.value.is_a?(Float) || (n.value.is_a?(Complex) && n.value.real.is_a?(Float))) }
+
+    def float_residual_small?(difference)
+      found, error = Decide.float_with_error(difference)
+      found.nil? || found.abs <= FLOAT_SLACK * Decide::ERROR_MARGIN * error
+    end
+
+    # ---- systems ---------------------------------------------------------------------
+
+    def system(targets, vars, domain: nil)
+      fs = targets.map { |t| to_zero(t).simplify }
+      unknowns = Array(vars).map { |v| Expression.lift(v) }
+      raise ArgumentError, "solve: list the unknowns, e.g. solve([...], [x, y])" if unknowns.empty?
+
+      solutions =
+        if fs.all? { |f| linear_in?(f, unknowns) }
+          linear_system(fs, unknowns)
+        elsif (found = polynomial_system(fs, unknowns))
+          found
+        elsif fs.size == 2 && unknowns.size == 2
+          polynomial_pair(fs, unknowns)
+        else
+          raise RCAS::Unsupported, "only linear systems and polynomial systems with rational coefficients are supported"
+        end
+      restrict_system(solutions, unknowns, domain).map { |sol| sol.is_a?(Hash) ? Assignment[sol] : sol }
+    end
+
+    # A solution of a system survives when every unknown in it does.
+    def restrict_system(solutions, unknowns, domain)
+      wanted = unknowns.to_h { |x| [x, domain || RCAS.assumption(x.name)] }.compact
+      return solutions if wanted.empty?
+      solutions.reject do |solution|
+        next false unless solution.is_a?(Hash)
+        solution.any? { |x, value| wanted[x] && Infer.excluded?(value, wanted[x]) }
+      end
+    end
+
+    # Polynomial systems over QQ by a lex Gröbner basis [CLO15, ch. 2 §8, ch. 3 §1]:
+    # the basis is triangular, so the last unknown has a univariate polynomial;
+    # its roots are substituted into the rest. Parameters make the
+    # coefficients rational functions, and the basis is taken over
+    # Frac(QQ[params]) - the generic answer, as for a linear system, which
+    # may differ where a leading coefficient in the parameters vanishes.
+    # nil when a coefficient is not rational (sqrt(2), sin(a)), so that the
+    # resultant route can try.
+    def polynomial_system(fs, unknowns)
+      names = unknowns.map(&:name)
+      params = fs.flat_map(&:variables).uniq - names
+      ring = params.empty? ? QQ[*names] : QQ[*params].fraction_field[*names]
+      polys = fs.map do |f|
+        ring.call(f)
+      rescue DomainError
+        return nil
+      end
+      basis = Groebner.basis(polys, :lex)
+      return [] if basis.size == 1 && basis.first.constant?
+      unless Groebner.zero_dimensional?(basis, :lex)
+        raise RCAS::Unsupported, "the system has infinitely many solutions; its Gröbner basis is #{basis.map(&:to_s).join(', ')}"
+      end
+      # over Frac(QQ[params]) the coefficients are fractions such as
+      # 1/(1/a**2 + 1); the numerator is the same equation, generically
+      basis = basis.map { |g| params.empty? ? g.to_expr : RationalFunction.numer(g.to_expr) }
+      triangular(basis, unknowns, {}).map { |sol| unknowns.to_h { |u| [u, sol[u]] } }
+    end
+
+    def triangular(basis, unknowns, known)
+      return [known] if unknowns.empty?
+      x = unknowns.last
+      rest = unknowns[0...-1].map(&:name)
+      substituted = basis.map { |g| g.subs(known).simplify }.reject { |g| Scalar.zero?(g) }
+      univariate = substituted.select { |g| (g.variables & rest).empty? }
+      return [] if univariate.any? { |g| g.variables.empty? } # a non-zero constant: no solution on this branch
+      raise RCAS::Unsupported, "no univariate polynomial in #{x} after substituting #{known}" if univariate.empty?
+      pivot = univariate.min_by { |g| polynomial_coefficients(g, x)&.size || Float::INFINITY }
+      coeffs = polynomial_coefficients(pivot, x) or raise RCAS::Unsupported, "#{pivot} is not a polynomial in #{x}"
+      roots = dedupe(polynomial_roots(coeffs).map(&:simplify))
+      roots = roots.select { |r| univariate.all? { |g| Scalar.zero?(g.subs(x => r).simplify) } }
+      roots.flat_map { |r| triangular(basis, unknowns[0...-1], known.merge(x => r)) }
+    end
+
+    def linear_in?(f, unknowns)
+      names = unknowns.map(&:name)
+      _, table = Expand.table(f)
+      table.each_key.all? do |factors|
+        degree = 0
+        factors.each do |base, exp|
+          if base.is_a?(Var) && names.include?(base.name)
+            return false unless exp.is_a?(Integer) && exp >= 0
+            degree += exp
+          elsif (base.variables & names).any? || (exp.is_a?(Expression) && (exp.variables & names).any?)
+            return false
+          end
+        end
+        degree <= 1
+      end
+    end
+
+    def linear_system(fs, unknowns)
+      n = unknowns.size
+      rows = fs.map do |f|
+        constant, table = Expand.table(f)
+        row = Array.new(n) { Num.new(0) }
+        rhs = Num.new(-constant)
+        table.each do |factors, coeff|
+          c = Num.new(coeff)
+          index = nil
+          factors.each do |base, exp|
+            if base.is_a?(Var) && (i = unknowns.index(base))
+              index = i
+            else
+              c *= Simplify.power_node(base, exp)
+            end
+          end
+          index ? row[index] = Scalar.add(row[index], c.simplify) : rhs = Scalar.sub(rhs, c.simplify)
+        end
+        row + [rhs]
+      end
+      reduced, pivots = Elimination.rref(rows)
+      return [] if pivots.include?(n)
+      solution = {}
+      pivots.each_with_index do |p, i|
+        value = reduced[i][n]
+        (0...n).each do |j|
+          next if j == p || Scalar.zero?(reduced[i][j])
+          value = Scalar.sub(value, Scalar.mul(reduced[i][j], unknowns[j]))
+        end
+        solution[unknowns[p]] = value.cancel
+      end
+      [solution]
+    end
+
+    # Two equations whose coefficients are not rational - sqrt(2), or a
+    # parameter next to one - by the resultant in x [GCL92, ch. 9]: its
+    # roots in y are substituted back, and a root of the first equation is
+    # kept where the second vanishes too. Parameters are indeterminates of
+    # the ring, so the coefficients in y are read with coefficient_in.
+    def polynomial_pair(fs, unknowns)
+      x, y = unknowns
+      names = [x.name, y.name]
+      params = fs.flat_map(&:variables).uniq - names
+      ring = [QQ, RR, CC].map { |k| PolynomialRing.new(k, params + names) }.find do |r|
+        fs.all? { |e| Infer.where_defined { r.include?(e) } }
+      end
+      raise RCAS::Unsupported, "only linear systems and polynomial systems are supported: #{fs.map(&:to_s).join(', ')}" unless ring
+      f, g = fs.map { |e| ring.call(e) }
+      res = f.resultant(g, x.name)
+      raise RCAS::Unsupported, "the equations share a common factor" if res.zero?
+      ys = polynomial_roots((0..res.degree(y.name)).map { |k| res.coefficient_in(y.name, k).to_expr })
+      dedupe(ys.map(&:simplify)).flat_map do |y0|
+        xs = univariate(fs[0].subs(y => y0), x, 1)
+        xs.select { |x0| vanishes_at?(fs[1], x => x0, y => y0) }.map { |x0| { x => x0, y => y0 } }
+      end
+    end
+
+    def vanishes_at?(f, point)
+      value = f.subs(point).simplify
+      value.variables.empty? ? Equation.new(value, 0).holds? : Scalar.zero?(value)
+    end
+  end
+end