silky / abstract-algorithm

Optimal evaluator of λ-calculus terms.

Lamping's Abstract Algorithm

A cleaned up adaptation of Lamping's abstract algorithm. It evaluates functions optimally by encoding a λ-term as (symmetric) interaction combinators, normalizing the resulting graph, and decoding it back. It asymptotically beats all usual evaluators of functional programs, including Haskell's GHC, Scheme compilers, Google's V8 and so on. Moreover, it is capable of automatically exploiting any inherent parallelizability of your program, since interaction nets are a naturally concurrent model of computation. This implementation consists of two files, a 120-loc reducer for interaction combinators and a 71-loc conversor of λ-terms to and from those. It isn't parallel, but is completely lazy: it doesn't perform any work that won't influence on the normal form. There is an inherent tradeoff between those.

Usage

1. Install

   npm install abstract-algorithm

2. Use

   const A = require("abstract-algorithm");
   const term = "(s.z.(s (s z)) s.z.(s (s z)))"; // church-encoded exponentiation of 2^2
   const termNf = A.netToLam(A.reduceNet(A.lamToNet(term)));
   console.log(termNf);

Bla bla bla

Crappy handwritten examples:

• Numbers

• Pairs

• Either

Here is a working example on how to use this lib to reduce untyped λ-terms. Here is an inlined reducer (less pretty, but faster and with GC - the exported lib actually uses it), and here is a poor attempt at making a WASM reducer (tip: it is not any faster, which is weird, because the C version is 10x faster than the JS one). Here is an attempt to flatten the graph-reduction algorithm to a linear automata, in such a way that it could, in theory, be implemented as a massivelly parallel ASIC where each 128-bit memory cell is actually a nano-CPU capable of updating its state by looking at its neighbors, in such a way that it causes the emergent global behavior of the memory to converge to the normal form of the initial graph.

Note this only works with stratified terms, which roughly means that the algorithm breaks when you have duplications inside of duplications. To make it work with arbitrary terms, you'd need to augment the system with a complex machinery known as oracle. There are many ways to do it, but all of them ruin the performance. I personally prefer to call non-stratified terms defective and ignore them. It is not hard to avoid those terms, you just have to be cautious about the implicit duplication of arguments performed by beta-reduction (which is the root of all evil). Note that the subset of oracle-free terms is still Turing complete.