Initial commit

Author: p-e-w

.gitignore

@@ -0,0 +1,9 @@
+bin
+project/project
+project/target
+target
+.settings
+.classpath
+.project
+.cache
+

README.md

@@ -0,0 +1,78 @@
+# *Sequencer* – purely algorithmic number sequence identification
+
+Sequencer identifies number sequences. That is, given a list of numbers like
+
+```
+(a(n)) = 1, 2, 4, 8, 16, 32, ...
+```
+
+it finds a formula that generates them, in this case
+
+```
+a(n) = 2^(n-1)   for n >= 1
+```
+
+Sequencer employs neither a library of sequences nor a limited set of algorithms to find a closed form. Instead, it generates **all** formulas up to a certain size and then checks them against the provided numbers.
+
+For verification, the system uses a hybrid approach of a fast numerical checker followed by a symbolic verifier powered by the [Symja](https://bitbucket.org/axelclk/symja_android_library/wiki/Home) computer algebra system. Coupled with some tricks and heuristics designed to quickly generate potentially interesting formulas, Sequencer can identify sequences with very complex closed forms in a matter of seconds when run on commodity hardware.
+
+Sequencer is capable of finding closed forms that are beyond any existing system like [OEIS](http://oeis.org/), [Superseeker](http://oeis.org/ol.html) and [Wolfram Alpha](http://www.wolframalpha.com/). It is particularly strong where recurrence relations or unusual combinations of functions are involved. For example, none of the services mentioned above can currently make sense of the sequence
+
+```
+(a(n)) = 1, 1, 1, 3, 5, 15, 43, 273, ...
+```
+
+while Sequencer reveals that it satisfies the recurrence relation
+
+```
+a(1) = 1
+a(2) = 1
+a(3) = 1
+a(n) = a(n-2)^2+a(n-1)+a(n-3)   for n >= 4
+```
+
+and provides the continuation
+
+```
+2137, 76709, 4643751, 5888916569, 21570312343279, ...
+```
+
+## Installation and usage
+
+Sequencer requires [Java](https://www.java.com) to run. Download the latest Sequencer JAR from the [releases page](https://github.com/p-e-w/sequencer/releases) and execute it from a terminal with the numbers to be matched as arguments, i.e.
+
+```
+java -jar sequencer.jar 1 2 3 4 5
+```
+
+Running the program without arguments displays a help text explaining the various command line parameters that can be used to fine-tune how searches are performed.
+
+## Development
+
+Sequencer is written in Scala. To compile Sequencer from source, you need [Git](http://www.git-scm.com/), a [JDK](http://www.oracle.com/technetwork/java/index.html), the [Scala compiler](http://www.scala-lang.org/), and [sbt](http://www.scala-sbt.org/). Once all of these are installed and on your `PATH`, you are ready to build and run Sequencer:
+
+```
+git clone https://github.com/p-e-w/sequencer.git
+cd sequencer
+sbt run
+```
+
+The release JAR can then be created using
+
+```
+sbt assembly
+```
+
+and will be located at `target/scala-X.XX/sequencer.jar`.
+
+To develop Sequencer using a Scala IDE, have sbt generate project files with a plugin like [sbteclipse](https://github.com/typesafehub/sbteclipse) or [sbt-idea](https://github.com/mpeltonen/sbt-idea).
+
+## Credits
+
+Besides its runtime and compilation environment (Java, Scala and sbt), Sequencer depends on the [Symja](https://bitbucket.org/axelclk/symja_android_library/wiki/Home) computer algebra system and the [scopt](https://github.com/scopt/scopt) command line parser. The standalone release JARs are built using the excellent [sbt-assembly](https://github.com/sbt/sbt-assembly) plugin.
+
+## License
+
+Copyright © 2015 Philipp Emanuel Weidmann (<[email protected]>)
+
+Released under the terms of the [GNU General Public License, Version 3](https://gnu.org/licenses/gpl.html)

build.sbt

@@ -0,0 +1,10 @@
+libraryDependencies ++= Seq(
+	"com.github.scopt" %% "scopt" % "3.3.0",
+	"log4j" % "log4j" % "1.2.17",
+	"axelclk" % "symja" % "2015-02-08" from "https://bitbucket.org/axelclk/symja_android_library/downloads/symja-2015-02-08.jar"
+)
+
+resolvers += Resolver.sonatypeRepo("public")
+
+assemblyJarName in assembly := "sequencer.jar"
+

project/assembly.sbt

@@ -0,0 +1,2 @@
+addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.12.0")
+

src/main/scala/com/worldwidemann/sequencer/Expression.scala

@@ -0,0 +1,54 @@
+/*
+ * Sequencer – purely algorithmic number sequence identification
+ *
+ * Copyright (c) 2015 Philipp Emanuel Weidmann <[email protected]>
+ *
+ * Nemo vir est qui mundum non reddat meliorem.
+ *
+ * Released under the terms of the GNU General Public License, Version 3
+ */
+
+package com.worldwidemann.sequencer
+
+trait Expression {
+  def evaluate(arguments: Seq[Double], index: Int, sequence: Seq[Double]): Double
+  def render(arguments: Seq[String]): String
+}
+
+case object EmptyExpression extends Expression {
+  def evaluate(arguments: Seq[Double], index: Int, sequence: Seq[Double]) = 0
+  def render(arguments: Seq[String]) = if (arguments.isEmpty) "O" else "O(" + arguments.mkString(",") + ")"
+}
+
+case class IndexFunction(symbol: String, f: Int => Double) extends Expression {
+  def evaluate(arguments: Seq[Double], index: Int, sequence: Seq[Double]) = f(index)
+  def render(arguments: Seq[String]) = "(" + symbol + ")"
+}
+
+case class PreviousElement(offset: Int) extends Expression {
+  def evaluate(arguments: Seq[Double], index: Int, sequence: Seq[Double]) =
+    if (index > offset)
+      sequence(index - offset - 1)
+    else throw new IllegalArgumentException("Reference to nonexisting element")
+  def render(arguments: Seq[String]) = "(a" + offset + ")"
+}
+
+case class Number(symbol: String, value: Double) extends Expression {
+  def evaluate(arguments: Seq[Double], index: Int, sequence: Seq[Double]) = value
+  def render(arguments: Seq[String]) = "(" + symbol + ")"
+}
+
+case class UnaryPrefixOperator(symbol: String, f: Double => Double) extends Expression {
+  def evaluate(arguments: Seq[Double], index: Int, sequence: Seq[Double]) = f(arguments(0))
+  def render(arguments: Seq[String]) = symbol + "(" + arguments(0) + ")"
+}
+
+case class BinaryInfixOperator(symbol: String, f: (Double, Double) => Double) extends Expression {
+  def evaluate(arguments: Seq[Double], index: Int, sequence: Seq[Double]) = f(arguments(0), arguments(1))
+  def render(arguments: Seq[String]) = "(" + arguments(0) + ")" + symbol + "(" + arguments(1) + ")"
+}
+
+case class BinaryPrefixOperator(symbol: String, f: (Double, Double) => Double) extends Expression {
+  def evaluate(arguments: Seq[Double], index: Int, sequence: Seq[Double]) = f(arguments(0), arguments(1))
+  def render(arguments: Seq[String]) = symbol + "(" + arguments(0) + "," + arguments(1) + ")"
+}

src/main/scala/com/worldwidemann/sequencer/FormulaGenerator.scala

@@ -0,0 +1,130 @@
+/*
+ * Sequencer – purely algorithmic number sequence identification
+ *
+ * Copyright (c) 2015 Philipp Emanuel Weidmann <[email protected]>
+ *
+ * Nemo vir est qui mundum non reddat meliorem.
+ *
+ * Released under the terms of the GNU General Public License, Version 3
+ */
+
+package com.worldwidemann.sequencer
+
+import org.apache.commons.math3.util.CombinatoricsUtils
+
+class FormulaGenerator(configuration: Configuration) {
+  // Note: Rarely used expressions are disabled to increase search speed
+  private val expressions = List(
+    // Atomic expressions
+    List(
+      Number("1", 1),
+      Number("2", 2),
+      Number("3", 3),
+      Number("4", 4),
+      Number("5", 5),
+      //Number("6", 6),
+      //Number("7", 7),
+      //Number("8", 8),
+      //Number("9", 9),
+      Number("10", 10),
+      // Common functions of the index variable are hardcoded as atomic expressions
+      // in order to speed up searches for formulas that contain them
+      IndexFunction("(n)", n => n),
+      IndexFunction("(n)+1", n => n + 1),
+      IndexFunction("(n)-1", n => n - 1),
+      IndexFunction("2*(n)", n => 2 * n),
+      IndexFunction("(n)^2", n => n * n),
+      IndexFunction("2^(n)", n => math.pow(2, n))) ++
+      (if (configuration.recurrenceRelations) List(
+        PreviousElement(1),
+        PreviousElement(2),
+        PreviousElement(3))
+      else List()) ++
+      (if (configuration.transcendentalFunctions) List(
+        Number("Pi", math.Pi) //,
+        //Number("E", math.E)
+        )
+      else List()),
+
+    // Unary operators
+    List(
+      UnaryPrefixOperator("-", x => -x),
+      //UnaryPrefixOperator("Sqrt", x => math.sqrt(x)),
+      UnaryPrefixOperator("Abs", x => math.abs(x)),
+      //UnaryPrefixOperator("Sign", x => math.signum(x)),
+      UnaryPrefixOperator("Floor", x => math.floor(x)) //,
+      //UnaryPrefixOperator("Ceiling", x => math.ceil(x)),
+      //UnaryPrefixOperator("Round", x => math.round(x))
+      ) ++
+      (if (configuration.combinatorialFunctions) List(
+        UnaryPrefixOperator("Factorial", x => {
+          if (x.isWhole && 0 <= x && x <= 10)
+            CombinatoricsUtils.factorialDouble(x.toInt)
+          else throw new IllegalArgumentException("Argument " + x + " is invalid for the Factorial function")
+        }))
+      else List()) ++
+      (if (configuration.transcendentalFunctions) List(
+        //UnaryPrefixOperator("Exp", x => math.exp(x)),
+        //UnaryPrefixOperator("Log", x => math.log(x)),
+        UnaryPrefixOperator("Sin", x => math.sin(x)),
+        UnaryPrefixOperator("Cos", x => math.cos(x)) //,
+        //UnaryPrefixOperator("Tan", x => math.tan(x))
+        )
+      else List()),
+
+    // Binary operators
+    List(
+      BinaryInfixOperator("+", (x, y) => x + y),
+      BinaryInfixOperator("-", (x, y) => x - y),
+      BinaryInfixOperator("*", (x, y) => x * y),
+      BinaryInfixOperator("/", (x, y) => x / y),
+      BinaryInfixOperator("^", (x, y) => math.pow(x, y)) //,
+      //BinaryPrefixOperator("Max", (x, y) => math.max(x, y)),
+      //BinaryPrefixOperator("Min", (x, y) => math.min(x, y))
+      ) ++
+      (if (configuration.combinatorialFunctions) List(
+        BinaryPrefixOperator("Binomial", (x, y) => {
+          if (x.isWhole && 0 <= x && x <= 10 && y.isWhole && 0 <= y && y <= x)
+            CombinatoricsUtils.binomialCoefficientDouble(x.toInt, y.toInt)
+          else throw new IllegalArgumentException("Arguments " + x + ", " + y + " are invalid for the Binomial function")
+        }))
+      else List()))
+
+  private def rollNodeExpression(node: Node) = {
+    val allowedExpressions = expressions(node.children.size)
+    node.expressionIndex = if (node.expressionIndex + 1 >= allowedExpressions.size) 0 else node.expressionIndex + 1
+    node.expression = allowedExpressions(node.expressionIndex)
+    // Indicate whether we rolled over or not
+    node.expressionIndex == 0
+  }
+
+  // The callback pattern is much more efficient than returning a collection
+  // because the number of formulas grows extremely fast with the number of nodes
+  def getFormulas(nodes: Int, formulaCallback: Node => Unit, progressCallback: Double => Unit) = {
+    val trees = new TreeGenerator(expressions.size - 1).getTrees(nodes)
+
+    for ((tree, i) <- trees.view.zipWithIndex) {
+      val nodes = tree.getTreeNodes
+      // Set initial expressions
+      nodes.foreach(node => rollNodeExpression(node))
+
+      var lastRolled = false
+      while (!lastRolled) {
+        // Pass the formula in its current form.
+        // The object is mutable, so any processing has to happen in the callback
+        formulaCallback(tree)
+
+        var j = 0
+        var rolled = true
+        while (j < nodes.size && rolled) {
+          rolled = rollNodeExpression(nodes(j))
+          j += 1
+          if (j == nodes.size && rolled)
+            lastRolled = true
+        }
+      }
+
+      progressCallback((i + 1).toDouble / trees.size)
+    }
+  }
+}

src/main/scala/com/worldwidemann/sequencer/Node.scala

@@ -0,0 +1,56 @@
+/*
+ * Sequencer – purely algorithmic number sequence identification
+ *
+ * Copyright (c) 2015 Philipp Emanuel Weidmann <[email protected]>
+ *
+ * Nemo vir est qui mundum non reddat meliorem.
+ *
+ * Released under the terms of the GNU General Public License, Version 3
+ */
+
+package com.worldwidemann.sequencer
+
+import scala.collection.mutable.ListBuffer
+
+class Node {
+  var expression: Expression = EmptyExpression
+  // Ensures that the initial roll selects the first valid expression (see FormulaGenerator)
+  var expressionIndex = -1
+
+  val children = new ListBuffer[Node]
+
+  def getCopy: Node = {
+    val copy = new Node
+    copy.expression = expression
+    copy.expressionIndex = expressionIndex
+    children.foreach(child => {
+      copy.children += child.getCopy
+    })
+    copy
+  }
+
+  // Returns all nodes in the tree
+  def getTreeNodes: Seq[Node] = {
+    val treeNodes = new ListBuffer[Node]
+    treeNodes += this
+    children.foreach(child => {
+      treeNodes ++= child.getTreeNodes
+    })
+    treeNodes
+  }
+
+  def evaluate(index: Int, sequence: Seq[Double]): Double =
+    expression.evaluate(children.map(child => child.evaluate(index, sequence)), index, sequence)
+
+  override def toString = expression.render(children.map(child => child.toString))
+
+  override def equals(that: Any): Boolean = {
+    that match {
+      // Consider two nodes equal if their associated trees are structurally equal
+      case that: Node => that.isInstanceOf[Node] && that.toString == toString
+      case _          => false
+    }
+  }
+
+  override def hashCode: Int = toString.hashCode
+}

src/main/scala/com/worldwidemann/sequencer/Predictor.scala

@@ -0,0 +1,36 @@
+/*
+ * Sequencer – purely algorithmic number sequence identification
+ *
+ * Copyright (c) 2015 Philipp Emanuel Weidmann <[email protected]>
+ *
+ * Nemo vir est qui mundum non reddat meliorem.
+ *
+ * Released under the terms of the GNU General Public License, Version 3
+ */
+
+package com.worldwidemann.sequencer
+
+import scala.collection.mutable.ListBuffer
+
+object Predictor {
+  def predict(formula: Node, sequence: Seq[Double], elements: Int) = {
+    val sequenceNew = new ListBuffer[Double]
+    sequenceNew ++= sequence
+    val startIndex = Utilities.getStartIndex(formula)
+
+    (sequence.size + 1 to sequence.size + elements).map(index => {
+      var formulaNew = formula.toString.replace("(n)", "(" + index + ")")
+      // Substitute values of previous elements
+      for (offset <- 1 to startIndex - 1)
+        formulaNew = formulaNew.replace("(a" + offset + ")", Utilities.getSymbolicForm(sequenceNew(index - offset - 1)))
+      val result = Utilities.evaluateSymja(formulaNew)
+
+      if (!Utilities.isDouble(result))
+        throw new RuntimeException("Unable to predict sequence for formula " + formulaNew.toString)
+
+      val newElement = result.toDouble
+      sequenceNew += newElement
+      newElement
+    })
+  }
+}