rcas 0.2.0

data/lib/rcas/trig.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module RCAS
+  # Trigonometric and logarithmic rewriting: expand_trig, trigsimp,
+  # expand_log, logcombine.
+  module Trigonometry
+    module_function
+
+    # sin(a + b), cos(a + b) and integer multiples written out.
+    def expand_trig(expr)
+      expr = Expression.lift(expr).map_children { |c| expand_trig(c) }
+      return expr unless expr.is_a?(Fn) && %i[sin cos tan].include?(expr.name) && expr.args.size == 1
+      return (expand_trig(Fn.new(:sin, expr.args)) / expand_trig(Fn.new(:cos, expr.args))).simplify if expr.name == :tan
+
+      arg = expr.args.first.simplify
+      constant, terms = Simplify.termize(arg)
+      addends = terms.map { |factors, coeff| Simplify.rebuild_product(coeff, factors) }
+      addends << Num.new(constant) unless constant.zero?
+      if addends.size >= 2
+        a = addends.first
+        b = addends.drop(1).reduce { |acc, t| acc + t }
+        return addition_formula(expr.name, a, b)
+      end
+      coeff, factors = Simplify.factorize(arg)
+      if coeff.is_a?(Integer) && coeff.abs >= 2 && !factors.empty?
+        return multiple_angle(expr.name, coeff, Simplify.rebuild_product(1, factors))
+      end
+      expr
+    end
+
+    # sin(n*u) and cos(n*u) by de Moivre, (cos u + i sin u)**n [AS64, 4.3.
+    # 29-30]: one binomial sum. Peeling one u at a time and expanding sin
+    # and cos of the rest separately doubled the work per multiple, and
+    # sin(16*x) took nine seconds (third review, section 5).
+    def multiple_angle(name, n, u)
+      s = expand_trig(Fn.new(:sin, [u]))
+      c = expand_trig(Fn.new(:cos, [u]))
+      m = n.abs
+      terms = (0..m).filter_map do |k|
+        next nil if name == :sin ? k.even? : k.odd?
+        sign = (-1)**(k / 2)
+        Num.new(sign * (0...k).reduce(1) { |acc, i| acc * (m - i) } / (1..k).reduce(1, :*)) * c**(m - k) * s**k
+      end
+      total = terms.reduce(:+).expand
+      name == :sin && n.negative? ? Simplify.negate(total).expand : total
+    end
+
+    def addition_formula(name, a, b)
+      sa, ca = expand_trig(Fn.new(:sin, [a])), expand_trig(Fn.new(:cos, [a]))
+      sb, cb = expand_trig(Fn.new(:sin, [b])), expand_trig(Fn.new(:cos, [b]))
+      case name
+      when :sin then (sa * cb + ca * sb).expand
+      when :cos then (ca * cb - sa * sb).expand
+      end
+    end
+
+    # sin and cos repeat every 2*pi, tan and cot every pi, so an added term
+    # that is an integer multiple of the period drops out of the argument:
+    # sin(pi/6 + 2*pi*k) is sin(pi/6) for an integer k. The multiple has to
+    # be *known* to be one, which is what assume(k: ZZ) says - for an
+    # undeclared k nothing happens, because k = 1/2 would be another matter.
+    PERIODS = { sin: 2, cos: 2, tan: 1 }.freeze
+
+    def reduce_period(name, arg)
+      period = PERIODS[name]
+      return nil if period.nil?
+      constant, terms = Simplify.termize(Expression.lift(arg))
+      kept = terms.reject { |factors, coeff| whole_period?(factors, coeff, period) }
+      return nil if kept.size == terms.size
+      Simplify.rebuild_sum(constant, kept)
+    end
+
+    # Is coeff * factors an integer multiple of period*pi?
+    def whole_period?(factors, coeff, period)
+      return false unless factors[PI] == 1
+      return false unless coeff.is_a?(Integer) && (coeff % period).zero?
+      rest = factors.reject { |base, _| base == PI }
+      return true if rest.empty?
+      domain = Infer.domain(Simplify.rebuild_product(1, rest))
+      !domain.nil? && domain <= ZZ
+    end
+
+    # The function whose even powers are replaced when +keep+ is kept, and
+    # what its square becomes: sin**2 + cos**2 = 1, cosh**2 - sinh**2 = 1.
+    SQUARES = {
+      sin: [:cos, ->(p) { Num.new(1) - p**2 }],
+      cos: [:sin, ->(p) { Num.new(1) - p**2 }],
+      sinh: [:cosh, ->(p) { Num.new(1) + p**2 }],
+      cosh: [:sinh, ->(p) { p**2 - Num.new(1) }]
+    }.freeze
+
+    # Shortest form among several rewritings using sin**2 + cos**2 = 1 and
+    # cosh**2 - sinh**2 = 1.
+    def trigsimp(expr)
+      base = tan_to_sin_cos(Expression.lift(expr)).simplify
+      candidates = [Expression.lift(expr).simplify, base, polynomial_cancel(base)]
+      [false, true].each do |expanded|
+        f = expanded ? expand_trig(base) : base
+        SQUARES.each_key do |keep|
+          candidates << polynomial_cancel(reduce_squares(f, keep))
+        end
+      end
+      candidates.compact.map(&:simplify).min_by { |c| [c.each_node.count, c.to_s.size] }
+    end
+
+    def tan_to_sin_cos(expr)
+      expr = expr.map_children { |c| tan_to_sin_cos(c) }
+      expr.is_a?(Fn) && expr.name == :tan ? Fn.new(:sin, expr.args) / Fn.new(:cos, expr.args) : expr
+    end
+
+    # Replace even powers of the function that is not kept: cos**2 => 1 - sin**2.
+    def reduce_squares(expr, keep)
+      num, den = numerator_denominator(expr)
+      (reduce_table(num, keep) / reduce_table(den, keep)).simplify
+    end
+
+    def numerator_denominator(expr)
+      _, table = Expand.table(expr)
+      den_factors = {}
+      table.each_key do |factors|
+        factors.each do |base, exp|
+          next unless exp.is_a?(Integer) && exp.negative?
+          den_factors[base] = [den_factors[base] || 0, -exp].max
+        end
+      end
+      den = Simplify.rebuild_product(1, den_factors)
+      [(expr * den).expand, den]
+    end
+
+    def reduce_table(expr, keep)
+      victim, square = SQUARES[keep]
+      constant, table = Expand.table(expr)
+      result = Num.new(constant)
+      table.each do |factors, coeff|
+        reducible = factors.select { |base, exp| base.is_a?(Fn) && base.name == victim && exp.is_a?(Integer) && exp >= 2 }
+        term = Simplify.rebuild_product(coeff, factors.reject { |b, _| reducible.key?(b) })
+        reducible.each do |base, exp|
+          partner = Fn.new(keep, [base.args.first])
+          term = (term * square.call(partner)**(exp / 2) * base**(exp % 2)).expand
+        end
+        result += term
+      end
+      result.expand
+    end
+
+    # Cancel common factors treating each function application as a variable.
+    def polynomial_cancel(expr)
+      atoms = expr.each_node.select { |n| n.is_a?(Fn) }.uniq
+      return expr.cancel if atoms.empty?
+      names = atoms.each_with_index.to_h { |a, i| [a, Var.new(:"_f#{i}")] }
+      substituted = expr.subs(names)
+      return nil if substituted.each_node.any? { |n| n.is_a?(Fn) }
+      substituted.cancel.subs(names.invert)
+    rescue DomainError, NotImplementedError, RCAS::Unsupported
+      nil
+    end
+
+    # log(a*b**n/c) => log(a) + n*log(b) - log(c), for the factors it holds
+    # for: log(p*u) = log(p) + log(u) and log(p**n) = n*log(p) when p > 0,
+    # which is proved (Decide for a constant, the assumptions for a symbol).
+    # The fifth review's decision: the rules no longer assume an undeclared
+    # argument positive - log(x**2) is 0 at x = -1 and 2*log(x) is 2*i*pi.
+    # A factor whose sign is declared negative is taken by its absolute value
+    # when it is all there is, with the i*pi an odd number of them leaves
+    # (third review, C4, A5). `force: true` is the textbook manipulation,
+    # every argument taken as positive (SymPy's name for MuPAD's
+    # IgnoreAnalyticConstraints).
+    def expand_log(expr, force: false)
+      expr = Expression.lift(expr).map_children { |c| expand_log(c, force: force) }
+      return expr unless expr.is_a?(Fn) && expr.name == :log && expr.args.size == 1
+      coeff, factors = Simplify.factorize(expr.args.first.simplify)
+      return expr if factors.empty? || (factors.size == 1 && factors.values.first == 1 && coeff == 1)
+      pieces = []
+      kept = {}
+      negatives = {}
+      factors.each do |base, exp|
+        sign = base.variables.empty? ? Decide.sign(base) : RCAS.sign_of(base)
+        if sign == :negative && exp.is_a?(Integer)
+          negatives[base] = exp
+        elsif force || sign == :positive
+          pieces << Expression.lift(exp) * Fn.new(:log, [base])
+        else
+          kept[base] = exp
+        end
+      end
+      unless kept.empty?
+        # what is not proved positive stays inside one logarithm, with the
+        # negative factors and a negative coefficient
+        negatives.each { |base, exp| kept[base] = exp }
+        if coeff.is_a?(Numeric) && coeff.real? && coeff.positive?
+          pieces.concat(coefficient_logs(coeff))
+          coeff = 1
+        end
+        pieces << Fn.new(:log, [Simplify.rebuild_product(coeff, kept)])
+        return pieces.reduce { |acc, p| acc + p }.simplify
+      end
+      flips = negatives.values.sum
+      negatives.each { |base, exp| pieces << Num.new(exp) * Fn.new(:log, [Neg.new(base).simplify]) }
+      pieces << I * PI if flips.odd? && !(coeff.is_a?(Numeric) && coeff.real? && coeff.negative?)
+      if flips.odd? && coeff.is_a?(Numeric) && coeff.real? && coeff.negative?
+        coeff = -coeff # two negatives: the product is positive after all
+      end
+      if coeff.is_a?(Numeric) && coeff.real? && coeff.negative?
+        return expr if pieces.empty?
+        pieces << Fn.new(:log, [Num.new(coeff)])
+      else
+        pieces.concat(coefficient_logs(coeff))
+      end
+      pieces.reduce { |acc, p| acc + p }.simplify
+    end
+
+    def coefficient_logs(coeff)
+      return [] if coeff == 1
+      return [Fn.new(:log, [Num.new(coeff)])] unless coeff.is_a?(Rational)
+      logs = []
+      logs << Fn.new(:log, [Num.new(coeff.numerator)]) unless coeff.numerator == 1
+      logs << -Fn.new(:log, [Num.new(coeff.denominator)])
+      logs
+    end
+
+    # a*log(u) + b*log(v) => log(u**a * v**b) for rational a, b - for the
+    # arguments it holds for: positive ones, proved (2*log(-1) is 2*i*pi and
+    # log((-1)**2) is 0, and 3*log(i) is not log(-i): third review, A4).
+    # One argument whose sign is not known may still join the positive
+    # ones with coefficient 1, since log(p*u) = log(p) + log(u) for p > 0.
+    # Undeclared arguments are no longer assumed positive (the fifth
+    # review's decision); `force: true` combines every logarithm.
+    def logcombine(expr, force: false)
+      expr = Expression.lift(expr).simplify
+      constant, terms = Simplify.termize(expr)
+      inside = {}
+      rest = {}
+      loose = nil
+      terms.each do |factors, coeff|
+        log = factors.size == 1 && factors.values.first == 1 && factors.keys.first.is_a?(Fn) && factors.keys.first.name == :log &&
+              (coeff.is_a?(Integer) || coeff.is_a?(Rational))
+        argument = log && factors.keys.first.args.first
+        if log && (force || combinable?(argument))
+          Simplify.add_factor(inside, argument, coeff)
+        elsif log && coeff == 1 && loose.nil? && !argument.each_node.any? { |n| n.is_a?(Num) && n.value.is_a?(Complex) }
+          loose = factors
+        else
+          rest[factors] = coeff
+        end
+      end
+      if loose
+        if inside.empty?
+          rest[loose] = 1
+        else
+          Simplify.add_factor(inside, loose.keys.first.args.first, 1)
+        end
+      end
+      return expr if inside.size < 2 && rest.size + inside.size == terms.size && inside.values.all? { |e| e == 1 }
+      combined = Simplify.rebuild_sum(constant, rest)
+      combined += Fn.new(:log, [Simplify.rebuild_product(1, inside)]) unless inside.empty?
+      combined.simplify
+    end
+
+    def combinable?(u)
+      return Decide.sign(u) == :positive if u.variables.empty?
+      RCAS.sign_of(u) == :positive
+    end
+  end
+end

data/lib/rcas/van_hoeij.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module RCAS
+  module Factor
+    # How the p-adic factors are put back together: :van_hoeij (the lattice),
+    # :zassenhaus (subsets of increasing size, the original method), or
+    # :auto, the subsets for as long as they are cheap and the lattice for
+    # what is left.
+    #
+    # The number of local factors does not say which is faster; the size of
+    # the subsets the true factors need does. Products of small factors
+    # (x**2 - c, cubics, SD(3)) came out about twice as fast by subsets at
+    # every count from 17 to 26 local factors, because they are found among
+    # the pairs and triples and every one found shrinks the problem, while
+    # three SD(4)s (24 local factors, eight to each true factor) took 1.7 s
+    # by subsets and 0.9 s by the lattice, and SD(6) (32, all in one) more
+    # than three minutes against 3 s (24 Sept 2026). So :auto counts the
+    # subsets of the next size, C(r, s), and hands over to the lattice when
+    # that exceeds SUBSET_BUDGET - at about 4 microseconds a subset, the
+    # budget is what the lattice costs at twenty local factors. The old
+    # method stays so that the two can be compared.
+    RECOMBINATIONS = %i[auto van_hoeij zassenhaus].freeze
+    SUBSET_BUDGET = 50_000
+
+    def self.recombination = Thread.current[:rcas_recombination] || :auto
+
+    # The recombination for the calls made inside the block; nil keeps the
+    # one already in force, so an outer choice reaches the inner calls.
+    def self.with_recombination(method)
+      return yield if method.nil?
+      method = method.to_sym
+      raise ArgumentError, "factor: recombination must be one of #{RECOMBINATIONS.join(', ')}, got #{method}" unless RECOMBINATIONS.include?(method)
+      saved = Thread.current[:rcas_recombination]
+      Thread.current[:rcas_recombination] = method
+      yield
+    ensure
+      Thread.current[:rcas_recombination] = saved
+    end
+
+    # The number of subsets the search may try at one size before :auto
+    # hands the rest over to the lattice; nil for no limit.
+    def self.subset_budget = recombination == :auto ? SUBSET_BUDGET : nil
+
+    # Van Hoeij's recombination of the p-adic factors by lattice reduction.
+    #
+    # Zassenhaus tries subsets of the r local factors, and an irreducible
+    # polynomial with many of them - a Swinnerton-Dyer polynomial splits into
+    # quadratics modulo every prime - makes that 2**(r - 1) trials. Van Hoeij
+    # asks instead which 0/1 vectors v (v_i = 1 when f_i is in the factor)
+    # belong to a true factor, and finds them all at once as short vectors
+    # of a lattice: a knapsack problem LLL can solve [vHo02].
+    #
+    # What makes the lattice is a quantity that is additive over the local
+    # factors and small for a true one. The coefficients of the logarithmic
+    # derivative times f serve [HvHN11]: for a factor g of f in ZZ[x],
+    # f*g'/g = (f/g)*g' has integer coefficients, bounded by B_j (the sum
+    # over the roots of g of f/(x - root), each root below the Fujiwara
+    # bound); and f*(g*h)'/(g*h) = f*g'/g + f*h'/h, so modulo p**k the
+    # coefficient of a product of local factors is the sum of theirs. The
+    # lattice spanned by
+    #
+    #   [ e_i | c_i,j / B_j ]    for each local factor f_i
+    #   [ 0   | p**k / B_j  ]    for each coefficient j used
+    #
+    # contains (v, small) for every true factor, with squared length at most
+    # M = r + (number of columns). After LLL, a lattice vector whose top
+    # Gram-Schmidt length exceeds sqrt(M) cannot be one of those, so the
+    # true vectors lie in the span of the first s reduced vectors, where s is
+    # the last index with |b*_s|**2 <= M. Their first r coordinates are the
+    # basis the next round starts from, with more coefficients. When the
+    # reduced echelon form of that basis is a 0/1 matrix with one 1 in every
+    # column, its rows are the candidate factors; each is checked by
+    # division, so a wrong guess costs a round, never a wrong answer. When
+    # the coefficients run out undecided, the precision is raised, and after
+    # that the subsets take over.
+    #
+    # Sources (keys: MANUAL.md, Sources): the algorithm [vHo02]; the
+    # coefficients of the logarithmic derivative and their bounds [HvHN11];
+    # LLL [LLL82], as in lattice.rb; the root bound [Fuj16].
+    module VanHoeij
+      MAX_RAISES = 3 # precision doublings before giving up to the subsets
+      COLUMNS_PER_ROUND = 2
+      SAFETY_BITS = 10 # how far p**k has to stand above B_j * 2**(r/2) for column j
+
+      module_function
+
+      # The irreducible factors of f (primitive, squarefree, positive leading
+      # coefficient), or nil when the lattice did not decide - the caller
+      # then recombines by subsets. `lifted` are the local factors already
+      # lifted to p**k, when the subsets handed over: lifting again from p
+      # cost 0.8 of 3.7 s on SD(6), and is done only when the lattice needs
+      # more precision than the subsets had.
+      def recombine(f, modular, p, k, lifted: nil)
+        r = modular.size
+        bounds = cld_bounds(f)
+        # enough precision for the first few columns, which have the
+        # smallest bounds: the top coefficients
+        wanted = bounds.last(3).max * 2**(r / 2 + SAFETY_BITS)
+        if p**k <= wanted
+          k += 1 while p**k <= wanted
+          lifted = nil
+        end
+        MAX_RAISES.times do
+          lifted ||= Zassenhaus.hensel_lift_leading(f, modular, p, k)
+          found = attempt(f, lifted, p**k, bounds)
+          return found if found
+          k *= 2
+          lifted = nil
+        end
+        nil
+      end
+
+      def attempt(f, lifted, m, bounds)
+        r = lifted.size
+        n = Dense.deg(f)
+        cld = lifted.map { |fi| coefficients(f, fi, m, n) }
+        # the columns whose bound stands well below p**k, smallest bound first
+        usable = (0...n).select { |j| m > bounds[j] * 2**(r / 2 + SAFETY_BITS) }.sort_by { |j| [bounds[j], -j] }
+        basis = Array.new(r) { |i| Array.new(r) { |l| i == l ? 1 : 0 } }
+        until usable.empty?
+          columns = usable.shift(COLUMNS_PER_ROUND)
+          basis = cut(basis, cld, columns, m, bounds)
+          return nil if basis.empty? # nothing short survived: the bounds were wrong
+          subsets = partition(basis)
+          next unless subsets
+          factors = candidates(f, lifted, subsets, m)
+          return factors if factors
+        end
+        nil
+      end
+
+      # f*fi'/fi modulo m, symmetric, as n coefficients.
+      def coefficients(f, fi, m, n)
+        q = Dense.divmod_mod(Dense.mod(f, m), fi, m).first
+        c = Dense.sym_mod(Dense.mul_mod(q, Dense.derivative(fi), m), m)
+        c + Array.new(n - c.size, 0)
+      end
+
+      # One round: the lattice of the current basis with the new columns,
+      # reduced, and cut to the vectors a true factor can lie among.
+      def cut(basis, cld, columns, m, bounds)
+        r = cld.size
+        rows = basis.map do |w|
+          traces = columns.map do |j|
+            t = w.each_index.sum { |i| w[i] * cld[i][j] } % m
+            t -= m if t > m / 2
+            Rational(t, bounds[j])
+          end
+          w.map(&:to_r) + traces
+        end
+        columns.each_with_index do |j, c|
+          rows << Array.new(r, 0r) + Array.new(columns.size) { |d| d == c ? Rational(m, bounds[j]) : 0r }
+        end
+        reduced, = Lattice.reduce(rows, Lattice::DELTA)
+        _, lengths = Lattice.gram_schmidt(reduced)
+        bound = r + columns.size
+        s = lengths.rindex { |b| b <= bound }
+        return [] if s.nil?
+        reduced.first(s + 1).map { |row| row.first(r).map { |e| e.to_i } }
+      end
+
+      # The rows of the reduced echelon form when it is a 0/1 matrix with
+      # exactly one 1 in every column - a partition of the local factors -
+      # as lists of indices; nil otherwise.
+      def partition(basis)
+        echelon = rref(basis.map { |row| row.map(&:to_r) }).reject { |row| row.all?(&:zero?) }
+        return nil unless echelon.flatten.all? { |e| e.zero? || e == 1 }
+        return nil unless echelon.transpose.all? { |column| column.count(1) == 1 }
+        echelon.map { |row| row.each_index.select { |i| row[i] == 1 } }
+      end
+
+      def rref(rows)
+        rows = rows.map(&:dup)
+        lead = 0
+        cols = rows.first&.size || 0
+        rows.each_index do |i|
+          lead += 1 while lead < cols && rows[i..].all? { |row| row[lead].zero? }
+          break if lead >= cols
+          j = (i...rows.size).find { |l| !rows[l][lead].zero? }
+          rows[i], rows[j] = rows[j], rows[i]
+          pivot = rows[i][lead]
+          rows[i] = rows[i].map { |e| e / pivot }
+          rows.each_index do |l|
+            next if l == i || rows[l][lead].zero?
+            factor = rows[l][lead]
+            rows[l] = rows[l].zip(rows[i]).map { |a, b| a - factor * b }
+          end
+          lead += 1
+        end
+        rows
+      end
+
+      # lc(f) times the product of each subset of local factors, made
+      # primitive; the list when every one divides f and they multiply to
+      # its degree, nil otherwise.
+      def candidates(f, lifted, subsets, m)
+        lc = f.last
+        rest = f
+        factors = subsets.map do |indices|
+          product = indices.reduce([lc]) { |acc, i| Dense.mul_mod(acc, lifted[i], m) }
+          g = Dense.primitive(Dense.sym_mod(product, m))
+          g = Dense.scale(g, -1) if g.last.negative?
+          quotient = Dense.div_exact(rest, g)
+          return nil if quotient.nil?
+          rest = quotient
+          g
+        end
+        return nil unless Dense.deg(rest).zero?
+        factors.sort_by { |g| [Dense.deg(g), g] }
+      end
+
+      # B_j: the coefficient of x**j in f*g'/g for any factor g of f is at
+      # most n * sum_{i > j} |f_i| * R**(i - j - 1), with R a bound on the
+      # absolute values of the roots of f.
+      def cld_bounds(f)
+        n = Dense.deg(f)
+        radius = root_bound(f)
+        (0...n).map do |j|
+          n * (j + 1..n).sum { |i| f[i].abs * radius**(i - j - 1) } + 1
+        end
+      end
+
+      # Fujiwara's bound: every root lies within 2*max |a_(n-i)/a_n|**(1/i)
+      # [Fuj16], rounded up to an integer.
+      def root_bound(f)
+        n = Dense.deg(f)
+        lead = f.last.abs
+        terms = (1..n).map do |i|
+          a = f[n - i].abs
+          a = Rational(a, 2) if i == n # the constant term enters halved
+          next 0 if a.zero?
+          ratio = Rational(a, lead)
+          root = Simplify.integer_root(ratio.ceil, i)
+          root += 1 while root**i < ratio
+          root
+        end
+        2 * terms.max
+      end
+    end
+  end
+end

data/lib/rcas/vector.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module RCAS
+  # QQ**3: column vectors of fixed dimension over a domain, and a domain
+  # itself: a vector answers `domain` with the space it lives in, and the
+  # space answers `base` with the domain its entries come from. Over a ring
+  # such as ZZ this is a free module rather than a vector space, but the API
+  # is the same.
+  class VectorSpace < Domain
+    attr_reader :base, :dim
+
+    def initialize(base, dim)
+      raise ArgumentError, "dimension must be a non-negative integer" unless dim.is_a?(Integer) && dim >= 0
+      @base = base
+      @dim = dim
+      freeze
+    end
+
+    # QQ**3 [1, 2, 3]  or  (QQ**3)[1, 2, 3]
+    def [](*entries)
+      entries = entries.flatten(1) if entries.size == 1 && entries.first.is_a?(Array)
+      raise DomainError, "#{self} needs #{dim} entries, got #{entries.size}" unless entries.size == dim
+      entries = entries.map { |e| Scalar.lift(e) }
+      entries = entries.map { |e| base.normalize_coefficient(e) } if base.respond_to?(:normalize_coefficient)
+      entries.each do |e|
+        next if Infer.where_defined { base.include?(e) }
+        hint = e.variables.reject { |v| RCAS.assumption(v) }
+        hint = hint.empty? ? "" : " (declare #{hint.join(', ')} with assume(#{hint.first}: #{base}))"
+        raise DomainError, "#{e} is not in #{base}#{hint}"
+      end
+      Vector.new(self, entries)
+    end
+
+    def unchecked(entries) = Vector.new(self, entries.map { |e| Scalar.lift(e) })
+
+    def include?(obj)
+      obj = self[*obj] if obj.is_a?(Array) && obj.size == dim
+      obj.is_a?(Vector) && obj.dim == dim && obj.entries.all? { |e| base.include?(e) }
+    rescue DomainError
+      false
+    end
+    alias member? include?
+    def ===(obj) = include?(obj)
+
+    def zero = unchecked(Array.new(dim, 0))
+    def basis = (0...dim).map { |i| unchecked(Array.new(dim) { |j| i == j ? 1 : 0 }) }
+
+    # A module, not a ring: vectors have no multiplication between them.
+    def ring? = false
+    def field? = false
+
+    # Vectors are not numbers: no polynomial has them as coefficients.
+    def scalar? = false
+
+    def over(other_base) = VectorSpace.new(other_base, dim)
+
+    # The same dimension over a larger base: (ZZ**3) < (QQ**3).
+    def subset?(other) = other.is_a?(VectorSpace) && other.dim == dim && base.subset?(other.base)
+
+    def join(other)
+      return VectorSpace.new(base.join(other.base), dim) if other.is_a?(VectorSpace) && other.dim == dim
+      raise DomainError, "no common domain for #{self} and #{other}" if other.is_a?(VectorSpace) || other.is_a?(MatrixSpace)
+      VectorSpace.new(base.join(other), dim) # a domain of scalars: what scaling gives
+    end
+
+    def ==(other) = other.is_a?(VectorSpace) && other.base == base && other.dim == dim
+    alias eql? ==
+    def hash = [VectorSpace, base, dim].hash
+
+    def name = "#{base}**#{dim}"
+  end
+
+  class Vector
+    include Algebraic
+    include Enumerable
+
+    attr_reader :space, :entries
+
+    def initialize(space, entries)
+      @space = space
+      @entries = entries.freeze
+      freeze
+    end
+
+    def dim = entries.size
+    alias size dim
+    # The space is where the vector lives, base where its entries come from.
+    def domain = space
+    def base = space.base
+    def [](i) = entries.fetch(i)
+    def each(&block) = entries.each(&block)
+    def to_a = entries.dup
+
+    # ---- arithmetic -------------------------------------------------------
+
+    def +(other) = zip_with(other, :+) { |a, b| Scalar.add(a, b) }
+    def -(other) = zip_with(other, :-) { |a, b| Scalar.sub(a, b) }
+    def -@ = space.unchecked(entries.map { |e| Scalar.neg(e) })
+
+    # Vector * Vector is the dot product, Vector * Matrix a row-vector product,
+    # anything else scales.
+    def *(other)
+      case other
+      when Vector then dot(other)
+      when Matrix then Matrix.row_times(self, other)
+      else scale(other)
+      end
+    end
+
+    def /(scalar)
+      s = Scalar.lift(scalar)
+      space.over(result_domain(s).fraction_field).unchecked(entries.map { |e| Scalar.div(e, s) })
+    end
+
+    def scale(scalar)
+      s = Scalar.lift(scalar)
+      space.over(result_domain(s)).unchecked(entries.map { |e| Scalar.mul(e, s) })
+    end
+
+    def coerce(other) = [ScalarProxy.new(other), self]
+    def rop(op, left) = op == :* ? scale(left) : super
+
+    def dot(other)
+      check_dim!(other)
+      entries.zip(other.entries).map { |a, b| Scalar.mul(a, b) }.reduce { |s, x| Scalar.add(s, x) } || Num.new(0)
+    end
+
+    def cross(other)
+      check_dim!(other)
+      raise ArgumentError, "cross product needs dimension 3" unless dim == 3
+      a, b = entries, other.entries
+      VectorSpace.new(base.join(other.base), 3).unchecked([
+        Scalar.sub(Scalar.mul(a[1], b[2]), Scalar.mul(a[2], b[1])),
+        Scalar.sub(Scalar.mul(a[2], b[0]), Scalar.mul(a[0], b[2])),
+        Scalar.sub(Scalar.mul(a[0], b[1]), Scalar.mul(a[1], b[0]))
+      ])
+    end
+
+    def norm = LinearAlgebra.norm(self) # Hermitian for complex entries
+    def zero? = entries.all? { |e| Scalar.zero?(e) }
+
+    def ==(other)
+      other = space.unchecked(other) if other.is_a?(Array) && other.size == dim
+      other.is_a?(Vector) && other.dim == dim &&
+        entries.zip(other.entries).all? { |a, b| Scalar.zero?(Scalar.sub(a, b)) }
+    end
+    alias eql? ==
+    def hash = [Vector, entries.map(&:simplify)].hash
+
+    def simplify = space.unchecked(entries.map(&:simplify))
+    def subs(*args) = space.unchecked(entries.map { |e| e.subs(*args) })
+    def call(**bindings) = space.unchecked(entries.map { |e| Scalar.lift(e.call(**bindings)) })
+
+    def to_s = "(#{entries.join(', ')})"
+    alias inspect to_s
+
+    private
+
+    def check_dim!(other)
+      raise TypeError, "expected a Vector, got #{other.class}" unless other.is_a?(Vector)
+      raise ArgumentError, "dimension mismatch: #{dim} vs #{other.dim}" unless dim == other.dim
+    end
+
+    def zip_with(other, op)
+      raise TypeError, "can't apply #{op} to Vector and #{other.class}" unless other.is_a?(Vector)
+      check_dim!(other)
+      VectorSpace.new(base.join(other.base), dim).unchecked(entries.zip(other.entries).map { |a, b| yield a, b })
+    end
+
+    def result_domain(scalar)
+      d = Scalar.domain(scalar)
+      d ? base.join(d) : base
+    end
+  end
+end