rcas 0.2.0

data/lib/rcas/openmath/xml.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module RCAS
+  module OpenMath
+    # The XML encoding of OpenMath objects [OM19, ch. 4]: one of the
+    # encodings, not the objects themselves.
+    #
+    #   RCAS::OpenMath::XML.encode(om)          # => "<OMOBJ ...>"
+    #   RCAS::OpenMath::XML.decode(string)      # => an OpenMath::Root
+    #
+    # The reader is written out here rather than taken from REXML, which is
+    # a bundled gem rather than the standard library; the encoding is a
+    # small, attribute-light subset of XML and needs no more than this.
+    # Namespace prefixes are accepted and ignored (every element of the
+    # encoding is in the OpenMath namespace).
+    module XML
+      NAMESPACE = "http://www.openmath.org/OpenMath"
+
+      ESCAPES  = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;", '"' => "&quot;", "'" => "&apos;" }.freeze
+      ENTITIES = { "amp" => "&", "lt" => "<", "gt" => ">", "quot" => '"', "apos" => "'" }.freeze
+
+      Element = Struct.new(:name, :attrs, :children, :text)
+
+      module_function
+
+      # +indent+: a number of spaces per level, or nil for a single line.
+      # +namespace+: write the xmlns attribute on the outermost element.
+      def encode(node, indent: nil, namespace: true, declaration: false)
+        node = Root.new(node) unless node.is_a?(Root)
+        out = +""
+        out << %(<?xml version="1.0" encoding="UTF-8"?>\n) if declaration
+        write(node, out, 0, indent, namespace)
+        out
+      end
+
+      def write(node, out, depth, indent, namespace)
+        pad = indent ? " " * (depth * indent) : ""
+        nl  = indent ? "\n" : ""
+        tag, attrs, text, children = parts(node)
+        attrs = { "xmlns" => NAMESPACE }.merge(attrs) if namespace && depth.zero?
+        attrs = attrs.merge("id" => node.id) if node.id
+        open = "#{pad}<#{tag}#{attributes(attrs)}"
+
+        if node.is_a?(Foreign)
+          out << open << ">" << node.content << "</#{tag}>" << nl
+        elsif text.nil? && children.empty?
+          out << open << "/>" << nl
+        elsif children.empty?
+          out << open << ">" << escape(text) << "</#{tag}>" << nl
+        else
+          out << open << ">" << nl
+          children.each { |c| write(c, out, depth + 1, indent, false) }
+          out << pad << "</#{tag}>" << nl
+        end
+        out
+      end
+
+      # tag, attributes, text content (nil for none), child nodes.
+      def parts(node)
+        case node
+        when Root          then ["OMOBJ", { "version" => node.version }, nil, [node.object]]
+        when Int           then ["OMI", {}, node.value.to_s, []]
+        when Double        then ["OMF", { "dec" => float_text(node.value) }, nil, []]
+        when Text          then ["OMSTR", {}, node.value, []]
+        when Bytes         then ["OMB", {}, [node.value].pack("m0"), []]
+        when Variable      then ["OMV", { "name" => node.name }, nil, []]
+        when ContentSymbol then ["OMS", symbol_attributes(node), nil, []]
+        when Application   then ["OMA", {}, nil, node.children]
+        when BVar          then ["OMBVAR", {}, nil, node.vars]
+        when Bind          then ["OMBIND", {}, nil, node.children]
+        when Attribution   then ["OMATTR", {}, nil, [AttrList.new(node.pairs), node.object]]
+        when AttrList      then ["OMATP", {}, nil, node.pairs.flat_map(&:children)]
+        when Error         then ["OME", {}, nil, node.children]
+        when Reference     then ["OMR", { "href" => node.href }, nil, []]
+        when Foreign       then ["OMFOREIGN", node.encoding ? { "encoding" => node.encoding } : {}, node.content, []]
+        else raise EncodeError, "no XML encoding for #{node.class}"
+        end
+      end
+
+      # The OMATP element: a flat list of key/value pairs inside an OMATTR.
+      # It is not an object of its own in the standard, so it is not one of
+      # the classes in objects.rb - it exists only while encoding.
+      class AttrList < Node
+        attr_reader :pairs
+
+        def initialize(pairs)
+          @pairs = pairs
+          freeze
+        end
+
+        def children = pairs
+      end
+
+      def symbol_attributes(node)
+        attrs = {}
+        attrs["cdbase"] = node.cdbase if node.cdbase
+        attrs["cd"] = node.cd
+        attrs["name"] = node.name
+        attrs
+      end
+
+      def attributes(attrs)
+        attrs.map { |k, v| %( #{k}="#{escape(v.to_s)}") }.join
+      end
+
+      def float_text(value)
+        return "INF" if value == Float::INFINITY
+        return "-INF" if value == -Float::INFINITY
+        return "NaN" if value.nan?
+        value.to_s
+      end
+
+      def escape(string) = string.to_s.gsub(/[&<>"']/) { |c| ESCAPES[c] }
+
+      def unescape(string)
+        string.to_s.gsub(/&(#x?\h+|\w+);/) do
+          entity = Regexp.last_match(1)
+          case entity
+          when /\A#x(\h+)\z/ then Regexp.last_match(1).to_i(16).chr(Encoding::UTF_8)
+          when /\A#(\d+)\z/  then Regexp.last_match(1).to_i.chr(Encoding::UTF_8)
+          else ENTITIES.fetch(entity) { raise ParseError, "unknown entity &#{entity};" }
+          end
+        end
+      end
+
+      # ---- reading ----------------------------------------------------------
+
+      def decode(source)
+        scanner = StringScanner.new(source.to_s)
+        element = read_element(scanner)
+        raise ParseError, "no XML element found" unless element
+        build(element)
+      end
+
+      def skip_junk(scanner)
+        loop do
+          scanner.skip(/\s+/)
+          break unless scanner.scan(/<\?.*?\?>/m) || scanner.scan(/<!--.*?-->/m) || scanner.scan(/<!DOCTYPE[^>]*>/m)
+        end
+      end
+
+      def read_element(scanner)
+        skip_junk(scanner)
+        return nil unless scanner.scan(/</)
+        name = scanner.scan(%r{[^\s/>]+}) or raise ParseError, "expected an element name"
+        attrs = read_attributes(scanner)
+        return Element.new(local(name), attrs, [], "") if scanner.scan(%r{\s*/>})
+        scanner.scan(/\s*>/) or raise ParseError, "unterminated <#{name}>"
+        return read_foreign(scanner, local(name), attrs) if local(name) == "OMFOREIGN"
+        read_content(scanner, local(name), attrs)
+      end
+
+      def read_attributes(scanner)
+        attrs = {}
+        loop do
+          scanner.skip(/\s+/)
+          break if scanner.check(%r{/?>})
+          key = scanner.scan(%r{[^\s=/>]+}) or raise ParseError, "expected an attribute name"
+          scanner.skip(/\s*=\s*/) or raise ParseError, "expected = after #{key}"
+          quote = scanner.scan(/["']/) or raise ParseError, "expected a quoted value for #{key}"
+          value = scanner.scan(/[^#{Regexp.escape(quote)}]*/)
+          scanner.skip(/#{Regexp.escape(quote)}/)
+          attrs[local(key)] = unescape(value)
+        end
+        attrs
+      end
+
+      # OMFOREIGN holds data that is not OpenMath - a presentation-MathML or
+      # LaTeX rendering, an image, a comment - so its content is taken
+      # exactly as it stands, markup and all, and never parsed.
+      OPEN_FOREIGN  = %r{<\s*(?:[\w.-]+:)?OMFOREIGN\b[^>]*>}.freeze
+      CLOSE_FOREIGN = %r{</\s*(?:[\w.-]+:)?OMFOREIGN\s*>}.freeze
+
+      def read_foreign(scanner, name, attrs)
+        raw = +""
+        depth = 1
+        until scanner.eos?
+          chunk = scanner.scan(/[^<]+/)
+          raw << chunk if chunk
+          break if scanner.eos?
+
+          if (close = scanner.scan(CLOSE_FOREIGN))
+            depth -= 1
+            break if depth.zero?
+            raw << close
+          elsif (open_tag = scanner.scan(OPEN_FOREIGN))
+            depth += 1
+            raw << open_tag
+          else
+            raw << scanner.scan(/</)
+          end
+        end
+        raise ParseError, "unclosed <OMFOREIGN>" unless depth.zero?
+        Element.new(name, attrs, [], raw)
+      end
+
+      def read_content(scanner, name, attrs)
+        children = []
+        text = +""
+        loop do
+          raise ParseError, "unclosed <#{name}>" if scanner.eos?
+
+          if scanner.check(%r{</})
+            scanner.scan(%r{</[^>]*>}) or raise ParseError, "unterminated closing tag"
+            break
+          elsif scanner.check(/<!--/)
+            scanner.scan(/<!--.*?-->/m)
+          elsif scanner.check(/</)
+            children << read_element(scanner)
+          else
+            text << unescape(scanner.scan(/[^<]+/))
+          end
+        end
+        Element.new(name, attrs, children, text)
+      end
+
+      # Namespace prefixes carry no information here: every element of the
+      # encoding lives in the OpenMath namespace.
+      def local(name) = name.split(":").last
+
+      def build(element)
+        node = case element.name
+               when "OMOBJ"  then Root.new(build(only_child(element)), version: element.attrs.fetch("version", OBJECT_VERSION))
+               when "OMI"    then Int.new(integer_value(element.text))
+               when "OMF"    then Double.new(float_value(element.attrs))
+               when "OMSTR"  then Text.new(element.text)
+               when "OMB"    then Bytes.new(element.text.unpack1("m") || "")
+               when "OMV"    then Variable.new(attribute(element, "name"))
+               when "OMS"    then ContentSymbol.new(attribute(element, "cd"), attribute(element, "name"), cdbase: element.attrs["cdbase"])
+               when "OMA"    then build_application(element)
+               when "OMBVAR" then BVar.new(element.children.map { |c| build(c) })
+               when "OMBIND" then build_binding(element)
+               when "OMATTR" then build_attribution(element)
+               when "OME"    then build_error(element)
+               when "OMR"    then Reference.new(attribute(element, "href"))
+               when "OMFOREIGN" then Foreign.new(element.text, encoding: element.attrs["encoding"])
+               else raise ParseError, "unknown OpenMath element <#{element.name}>"
+               end
+        id = element.attrs["id"] || element.attrs["xml:id"]
+        id ? node.identified(id) : node
+      end
+
+      def build_application(element)
+        children = element.children.map { |c| build(c) }
+        raise ParseError, "<OMA> needs at least a head" if children.empty?
+        Application.new(children.first, children[1..])
+      end
+
+      def build_binding(element)
+        children = element.children
+        unless children.size == 3 && children[1].name == "OMBVAR"
+          raise ParseError, "<OMBIND> needs a binder, an <OMBVAR> and a body"
+        end
+        Bind.new(build(children[0]), build(children[1]), build(children[2]))
+      end
+
+      def build_attribution(element)
+        pairs_element, object = element.children
+        raise ParseError, "<OMATTR> needs an <OMATP> and an object" unless pairs_element&.name == "OMATP" && object
+        flat = pairs_element.children.map { |c| build(c) }
+        raise ParseError, "<OMATP> needs an even number of children" unless flat.size.even?
+        Attribution.new(flat.each_slice(2).map { |k, v| AttrPair.new(k, v) }, build(object))
+      end
+
+      def build_error(element)
+        children = element.children.map { |c| build(c) }
+        raise ParseError, "<OME> needs a symbol" if children.empty?
+        Error.new(children.first, children[1..])
+      end
+
+      def only_child(element)
+        children = element.children
+        raise ParseError, "<#{element.name}> needs exactly one child" unless children.size == 1
+        children.first
+      end
+
+      def attribute(element, name)
+        element.attrs[name] or raise ParseError, "<#{element.name}> needs a #{name} attribute"
+      end
+
+      # OMI is decimal, or hexadecimal written x1F / -x1F.
+      def integer_value(text)
+        stripped = text.to_s.strip
+        case stripped
+        when /\A(-?)x(\h+)\z/ then (Regexp.last_match(1) == "-" ? -1 : 1) * Regexp.last_match(2).to_i(16)
+        when /\A-?\d+\z/      then stripped.to_i
+        else raise ParseError, "not an integer: #{text.inspect}"
+        end
+      end
+
+      def float_value(attrs)
+        if (dec = attrs["dec"])
+          case dec
+          when "INF"  then Float::INFINITY
+          when "-INF" then -Float::INFINITY
+          when "NaN"  then Float::NAN
+          else Float(dec)
+          end
+        elsif (hex = attrs["hex"])
+          [hex].pack("H*").unpack1("G")
+        else
+          raise ParseError, "<OMF> needs a dec or hex attribute"
+        end
+      end
+    end
+  end
+end

data/lib/rcas/openmath.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "openmath/objects"
+require_relative "openmath/xml"
+require_relative "openmath/phrasebook"
+require_relative "openmath/popcorn"
+
+module RCAS
+  module OpenMath
+    module_function
+
+    # An OpenMath object from its XML encoding, or from an object already
+    # parsed. Use #to_expression on the result for the rcas object.
+    def parse(source)
+      source.is_a?(Node) ? source : XML.decode(source)
+    end
+
+    # The rcas object a piece of OpenMath stands for, unevaluated: the
+    # document says 1 + 2, and 1 + 2 is what comes back, not 3.
+    def read(source) = parse(source).to_expression
+  end
+
+  class Expression
+    # This expression as an OpenMath object; #to_xml writes the encoding.
+    def to_openmath = OpenMath::Phrasebook.to_openmath(self)
+  end
+
+  class Equation
+    def to_openmath = OpenMath::Phrasebook.to_openmath(self)
+  end
+
+  module Functions
+    # openmath(x**2 + 1): the OpenMath object, whose to_xml is the XML
+    # encoding. Equations, intervals, matrices and number sets travel too.
+    def openmath(obj) = OpenMath::Phrasebook.to_openmath(obj)
+
+    # from_openmath(xml): the rcas object an OpenMath document stands for,
+    # held rather than evaluated - "1 + 2" comes back as 1 + 2.
+    def from_openmath(source) = OpenMath.read(source)
+
+    # popcorn(x**2 + 1): the OpenMath object in POPCORN, the notation meant
+    # for people rather than machines - "$x^2 + 1".
+    def popcorn(obj) = OpenMath::Phrasebook.to_openmath(obj).to_popcorn
+
+    # from_popcorn("$x^2 + 1"): the rcas object that notation stands for,
+    # held rather than evaluated.
+    def from_popcorn(source) = OpenMath::Popcorn.parse(source).to_expression
+  end
+end

data/lib/rcas/petkovsek.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module RCAS
+  # Petkovsek's algorithm: the hypergeometric solutions of a linear
+  # recurrence with polynomial coefficients,
+  #
+  #   p_0(n)*u(n) + p_1(n)*u(n + 1) + ... + p_r(n)*u(n + r) = 0.
+  #
+  # A hypergeometric term is one whose ratio u(n + 1)/u(n) is rational, and
+  # Petkovsek's theorem says every such ratio solving the recurrence can be
+  # written
+  #
+  #   u(n + 1)/u(n) = z * a(n)/b(n) * c(n + 1)/c(n)
+  #
+  # with a, b monic, gcd(a(n), b(n + h)) = 1 for every integer h >= 0,
+  # a(n) | p_0(n), b(n) | p_r(n + r - 1), z a constant and c a polynomial.
+  # That turns an infinite search into a finite one: run through the monic
+  # divisors a and b, read the possible z off the leading coefficients (the
+  # top-degree terms have to cancel), and look for c with PolyRecurrence.
+  # Every candidate is verified on the ratio before it is returned.
+  #
+  # Sources (keys: MANUAL.md, Sources): [Pet92]; [Koe14, ch. 9];
+  # [PWZ96, ch. 8].
+  module Petkovsek
+    MAX_DIVISORS = 64
+
+    module_function
+
+    # The ratios u(n + 1)/u(n) of the hypergeometric solutions, as rational
+    # functions of n.
+    def ratios(coeffs, n)
+      coeffs = coeffs.map { |c| Expression.lift(c).expand }
+      r = coeffs.size - 1
+      return [] if r < 1 || Scalar.zero?(coeffs.first) || Scalar.zero?(coeffs.last)
+      # first order: u(n + 1)/u(n) = -p0/p1 is the ratio, hypergeometric by
+      # definition - no search, and no divisor list to run out of (the
+      # search answered [] for (n + 1)...(n + 7): third review, S7)
+      return [(Simplify.negate(coeffs[0]) / coeffs[1]).cancel] if r == 1
+      ring = ring_for(coeffs, n) or return []
+      last = ring.call(coeffs.last.subs(n => n + r - 1).expand)
+      found = []
+      divisors(ring.call(coeffs.first)).each do |a|
+        divisors(last).each do |b|
+          next unless Summation.dispersion(a, b, n.name).empty?
+          candidates(coeffs, a, b, n, r).each do |ratio|
+            found << ratio unless found.any? { |f| Scalar.zero?((f - ratio).cancel) }
+          end
+        end
+      end
+      found
+    rescue TooMany
+      raise
+    rescue DomainError, NotImplementedError, RCAS::Unsupported, ZeroDivisionError
+      []
+    end
+
+    # The solutions themselves: the ratios turned back into terms, in closed
+    # form wherever the product has one (factorials, powers, rationals).
+    def solutions(coeffs, n) = ratios(coeffs, n).map { |ratio| term(ratio, n) }
+
+    # The term with the given ratio, as a product from the first index at
+    # which the ratio is defined and non-zero.
+    def term(ratio, n)
+      i = Var.new(:_i)
+      Products.product(ratio.subs(n => i), i, Num.new(start_index(ratio, n)), (n - 1).simplify)
+    end
+
+    # ---- the search --------------------------------------------------------------
+
+    # The (a, b) pair fixes A_j = a(n)...a(n + j - 1) and B_j = b(n + j)...
+    # b(n + r - 1); what is left is z and the polynomial c in
+    # sum_j p_j(n) z**j A_j(n) B_j(n) c(n + j) = 0.
+    def candidates(coeffs, a, b, n, r)
+      base = (0..r).map do |j|
+        aj = (0...j).reduce(Num.new(1)) { |acc, i| acc * shift(a, n, i) }
+        bj = (j...r).reduce(Num.new(1)) { |acc, i| acc * shift(b, n, i) }
+        (coeffs[j] * aj * bj).expand
+      end
+      zs(base, n, r).flat_map do |z|
+        qs = base.each_with_index.map { |q, j| (q * z**j).expand }
+        PolyRecurrence.basis(qs, n).filter_map do |c|
+          ratio = (z * a.to_expr * c.subs(n => n + 1) / (b.to_expr * c)).cancel
+          ratio if satisfies?(coeffs, ratio, n, r)
+        end
+      end
+    end
+
+    # The constants z for which the top-degree terms of the transformed
+    # equation can cancel: the roots of sum_{j in J} lc(q_j)*z**j, where J
+    # collects the j of maximal degree.
+    def zs(base, n, r)
+      degrees = base.map { |q| Solve.polynomial_coefficients(q, n)&.size }
+      return [] if degrees.any?(&:nil?)
+      top = degrees.each_index.select { |j| degrees[j] == degrees.max }
+      return [] if top.size < 2 # one term alone cannot cancel
+      coefficients = Array.new(r + 1) { Num.new(0) }
+      top.each { |j| coefficients[j] = Solve.polynomial_coefficients(base[j], n).last }
+      Solve.polynomial_roots(coefficients).map(&:simplify)
+           .reject { |z| Scalar.zero?(z) || z.is_a?(RootOf) }
+           .uniq { |z| z.to_s }
+    rescue NotImplementedError, RCAS::Unsupported, DomainError
+      []
+    end
+
+    # Does a term with this ratio satisfy the recurrence? Checked as a
+    # rational identity: sum_j p_j(n) * ratio(n)*...*ratio(n + j - 1) = 0.
+    def satisfies?(coeffs, ratio, n, r)
+      total = Num.new(0)
+      product = Num.new(1)
+      (0..r).each do |j|
+        total += coeffs[j] * product
+        product = (product * ratio.subs(n => n + j)).cancel if j < r
+      end
+      Scalar.zero?(total.cancel)
+    rescue ZeroDivisionError
+      false
+    end
+
+    # ---- polynomials -------------------------------------------------------------
+
+    def ring_for(coeffs, n)
+      vars = coeffs.flat_map { |c| c.variables.to_a }.uniq
+      vars = [n.name] | vars
+      QQ[*vars]
+    end
+
+    def shift(poly, n, h) = poly.to_expr.subs(n => n + h)
+
+    # Every monic divisor of +poly+, the constant 1 included.
+    def divisors(poly)
+      return [poly.ring.one] if poly.constant?
+      factorization = poly.factor
+      list = [poly.ring.one]
+      factorization.factors.each do |factor, multiplicity|
+        list = list.flat_map { |d| (0..multiplicity).map { |i| d * factor**i } }
+        # searching only the divisor 1 would be "no solution" for "too many
+        # to try": that is a refusal
+        raise TooMany, "hyper: #{poly} has more than #{MAX_DIVISORS} monic divisors to search" if list.size > MAX_DIVISORS
+      end
+      list.map(&:monic).uniq { |d| d.to_expr.to_s }
+    rescue DomainError
+      [poly.ring.one]
+    end
+
+    class TooMany < RCAS::Unsupported; end
+
+    # The first index from which the product of the ratio is finite and
+    # non-zero: past every non-negative integer root of numerator and
+    # denominator.
+    def start_index(ratio, n)
+      pair = Fraction.as_fraction(ratio, [n.name]) or return 0
+      roots = pair.flat_map do |poly|
+        coefficients = (0..poly.degree(n.name)).map { |i| poly.coefficient_in(n.name, i).to_expr }
+        next [] unless coefficients.all? { |c| c.variables.empty? }
+        Solve.polynomial_roots(coefficients)
+      end
+      integers = roots.filter_map { |r| r.simplify }
+                      .select { |r| r.is_a?(Num) && r.value.is_a?(Integer) && !r.value.negative? }
+                      .map(&:value)
+      integers.empty? ? 0 : integers.max + 1
+    rescue NotImplementedError, RCAS::Unsupported, DomainError, ZeroDivisionError
+      0
+    end
+  end
+end