When Paper Starts to Calculate

The starting point is one of utmost simplicity: a square sheet of paper and a pair of hands to fold it. The word origami itself refers to this simple gesture: it comes from the Japanese ori (to fold) and kami (paper). For centuries, origami was understood as an art form tied to rituals, decoration, and play. In all these versions, paper serves as an aesthetic and symbolic medium, something folded to create shapes, not to perform calculations.

However, when we stop looking only at the final result and pay attention to the steps, the scene changes completely. Every origami model is accompanied by a precise sequence of instructions. That sequence is not much different from an algorithm: an ordered series of operations that transform an initial state into a final state.

From a geometric perspective, this intuition becomes sharper. A fold is a concrete transformation of the plane (a piecewise isometry). This perspective introduces a central idea: the state of the paper is not just a pretty shape; it is information. A perfectly flat sheet has a trivial "state"; a sheet with accumulated folds has a much richer geometric state.

The statement guiding this analysis ceases to be poetic and starts to become literal: a sheet of paper, equipped with the right pattern of folds, can behave like a universal computer.

So far, we have spoken of origami in fairly intuitive terms: folds, mountains, valleys, layers that cross. To connect all this with computation, it is necessary to take a more formal step and answer a very specific question: what does "an origami fold" mean in mathematical language? The typical answer in the literature is that a flat origami model can be described as a piecewise isometric map, accompanied by a crease graph and a coherent layer ordering.

The idea of the piecewise isometric map is as follows. We imagine the sheet of paper as a region of the plane, for example, a square. This region is divided into pieces, called faces, which behave rigidly: each face is a polygon (triangle, quadrilateral, etc.) on which the paper does not stretch or compress. On each of these faces, the folding is described by an isometry of the plane: a translation, a rotation, or a reflection. The only "non-smooth" part of the model occurs at the boundaries between faces, which are precisely the crease lines.

Viewed this way, an origami fold is an application that takes each point of the initial sheet and sends it to another position in space, with two important conditions. First, that within each face, distances are preserved: what was a segment of a certain length remains a segment of the same length. Second, that the union of all these folded faces can be realized without the paper passing through itself inconsistently. That second condition is what makes the problem interesting: it's not enough to glue isometries randomly; it must be done in a way that the final object can exist physically.

In this framework, the crease lines play the role of boundaries between faces. Each line separates two regions where the isometry can be different (for example, one face is rotated and the other reflected), but both fit exactly along the common line. If we look only at the "projection" of these lines on the sheet, what we get is a crease pattern: a set of segments and curves that indicate where the paper was folded. This diagram can be seen as a graph: the points where several lines intersect are vertices, the segments of folds between these vertices are edges, and the polygonal faces appear as regions bounded by this graph.

The polygonal faces are important for two reasons. First, they are the basic rigid units of the model: within each, the geometry is simple (a pure isometry). Second, their shape and how they connect to each other determine the combinatorial structure of the folding: which piece of paper is attached to which, how the folds can be "closed," and which configurations are physically realizable. In practice, this allows us to move from a purely visual description ("I see many lines on the sheet") to a precise mathematical description ("I have a planar graph with such vertices, such edges, and such faces").

But a key ingredient is still missing: the layer ordering. When we fold paper, it's not just about where each point ends up on the plane, but also what is on top and what is at the bottom when several layers coincide in the same position. Two different points on the sheet can end up in the same place in space, but one can be physically above the other. To capture this information, the model incorporates a local vertical order: in each area where layers overlap, there is a relationship of "being above" that must be consistent throughout the sheet. This consistency is what prevents paradoxes of the type "this layer is above that one, which in turn is above the first."

This formalization has two advantages. On one hand, it allows translating the language of origami into that of geometry and topology, making it possible to state and prove theorems about what folds can or cannot be made. On the other, it opens the door to reading the same object as an information structure: the crease graph encodes "transition possibilities," the piecewise isometric map describes the current geometric state, and the layer ordering acts as memory. It is precisely this bridge between geometry, combinatorics, and state that will make it possible, in the following sections, to reinterpret a folded sheet as a device capable of implementing logic, cellular automata, and, ultimately, universal computation.

There is a particular axiom that elevates origami to a higher level of power: the H6 axiom.

Informally stated, H6 says: given two points (P, Q) and two lines (L₁, L₂), there exists a fold that brings point P onto line L₁ and, simultaneously, point Q onto line L₂.

In algebraic terms, this implies that the parameters defining the fold must satisfy two conditions at once. The resulting system of equations is neither linear nor quadratic: in general cases, a third-degree equation appears. Finding the H6 fold is formally equivalent to solving a cubic equation.

From this perspective, H6 is the non-linear "hack" of origami. It is the door through which operations that Euclid could never perform enter. Incorporating an axiom capable of solving cubics changes the rules of the game: origami formally becomes more expressive.

To connect origami with computation, it is crucial to understand how a fold can become a bit and a sheet of paper can become memory. It's the transition where geometry begins to speak the language of information.

The starting point is a simple convention: a mountain fold can represent a 1, and a valley fold a 0. A strip of paper with a sequence of these folds becomes a bit tape, analogous to that of a Turing Machine.

But the information is not just in the lines, but also in the order of the layers. Which region is on top of which after a fold is additional information. The paper "remembers" the history of folds, acting as a geometric memory.

A paper pattern where the configuration of possible/impossible folds reproduces the truth table of an OR, AND, or NOT gate is not a metaphor; it is a physical reality.

If we can design origami "gadgets" that function as logic gates, we can combine them to create circuits. The output of one gadget (a fold) becomes the input for the next. Computation becomes a matter of physical consistency: the paper "refuses" to adopt configurations that do not respect the program.

This is where Rule 110 comes in, a very simple cellular automaton that is, surprisingly, Turing-complete. This means it can simulate any computation that a Turing Machine can perform.

The connection is direct: if we can build a crease pattern that reproduces the dynamics of Rule 110, then origami is Turing-complete. The sheet is organized into repeated blocks (cells), where the geometry implements the automaton's update table.

The sheet of paper becomes a physical medium for a universal automaton, where the tape is a strip of folded cells and the dynamics are written into the pattern of optional folds.

Formal mathematical work solidifies this intuition into a precise theorem: there exists a rigorous model of flat origami, with locally defined optional creases, that is Turing-complete. The computation is "hard-wired" into the geometry of the pattern.

The proof relies on constructing geometric "gadgets" that emulate Rule 110. The decisive step is to show that this is a systematic procedure: for any computation expressible by a Turing Machine, there exists a crease pattern that reproduces it.

The theorem invites us to change our perspective: the sheet of paper ceases to be a passive object and becomes a physical programming language. Each origami diagram is more than a recipe; it is a fragment of geometric code that manipulates information, and each fold is an instruction that executes a calculation.