🔢 mathematics

Computing with Continued Logarithms

This paper presents an algorithm for performing arithmetic and transcendental function computations (such as trigonometric, exponential, and logarithmic functions) directly within the domain of continued logarithms, providing a more efficient alternative to continued fractions that avoids floating-point arithmetic.

Original authors: Michael J. Collins

Published 2026-02-10

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Michael J. Collins

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to describe the size of the universe to someone. If you use standard numbers (like 1,000,000,000), you eventually run out of zeros and need scientific notation ( $10^9$ ). But what if you wanted a system that could handle numbers so massive they make galaxies look like atoms, or numbers so tiny they make subatomic particles look like mountains, all without ever needing to switch formats?

This paper introduces a mathematical "super-tool" called Continued Logarithms (CLs). Here is the breakdown of how it works and why it matters.

1. The Concept: The "Zoom Lens" of Numbers

Most math uses a "ruler" (decimal points). If you want to measure something bigger, you need a bigger ruler.

Continued Logarithms work more like a camera zoom lens. Instead of saying "this number is 1,000,000," a CL says: "Start at magnitude 20 (which is $2^{20}$ ), then adjust it by this much, then adjust that result by this much..."

It’s a recursive way of describing a number. You describe the "neighborhood" the number lives in, then you zoom in to describe its "street," then its "house," and so on. Because it works by "zooming" (using powers of 2), it is incredibly efficient for computers to handle extremely large or small values.

2. The Arithmetic: The "Recipe" Method

The most impressive part of the paper is how it performs math (addition, multiplication, etc.) using these "zoom" descriptions.

Imagine you have two complex recipes for a cake. One recipe is written in "grams" and the other in "ounces." Usually, you’d have to convert everything to a single standard (like decimals) to add them. But converting to decimals can lead to "rounding errors"—tiny mistakes that snowball into big ones.

The authors use an algorithm that allows you to add the recipes without ever converting them to a standard weight. They use something called Bihomographic Expressions. Think of this as a "mathematical translator." Instead of converting the ingredients, the translator looks at the patterns in the two recipes and predicts what the combined recipe will look like, one step at a time.

As you read more of the first recipe, the translator instantly tells you the first few steps of the final result. It’s like watching two people walk toward each other and being able to predict exactly where they will meet before they even arrive.

3. Transcendental Functions: The "Infinite Mirror"

The paper goes a step further. It shows how to calculate complex functions like Sine, Cosine, and Logarithms using this system.

In standard math, calculating $\sin(x)$ involves long, messy formulas (Taylor series). The authors treat these functions like an infinite hall of mirrors. They set up a mathematical loop where the function is defined by itself. Because the "zoom lens" (the CL system) is so good at narrowing down ranges, the computer can "zoom in" on the answer to a sine wave or an exponential curve just as easily as it can for simple addition.

4. The "Stall" Problem: The "Foggy Window"

The authors admit one tricky problem: Termination.

Imagine you are looking through a foggy window at a distant object. You can see it's getting closer, but you can't quite tell if it's exactly 2 feet away or 2.000001 feet away. In math, if a number is right on the edge of a boundary, the algorithm might "stall"—it keeps reading more and more information but can't decide whether to call the next number a "0" or a "1."

The authors suggest that while this is a challenge, it's a small price to pay for a system that is so much faster and more compact for hardware (like computer chips) to use.

Summary: Why should we care?

If we ever need to build computers that simulate the entire history of the universe or calculate the physics of black holes, standard decimal math will break. This paper provides a blueprint for a "Scale-Invariant" math—a way for computers to think in terms of "orders of magnitude" rather than just "digits," making them much more powerful at handling the extremes of reality.

Technical Summary: Computing with Continued Logarithms

Authors: Michael J. Collins (Daniel H. Wagner Associates)
Subject Area: Computational Number Theory / Algorithmic Arithmetic

1. Problem Statement

Traditional arithmetic on real numbers typically relies on floating-point representations, which are limited by fixed precision and can struggle with extremely large or small magnitudes. While Continued Fractions (CFs) provide an alternative for representing real numbers, they are often computationally intensive.

The paper addresses the challenge of performing efficient, high-precision arithmetic on Continued Logarithms (CLs). CLs are a variant of continued fractions designed to represent numbers of extreme magnitude more efficiently and are particularly well-suited for hardware implementation. The core problem is to develop an algorithm that can perform arithmetic and evaluate transcendental functions (trigonometric, exponential, and logarithmic) entirely within the CL domain, without ever converting to floating-point numbers.

2. Methodology

The paper utilizes a "digit-by-digit" approach, similar to Gosper’s algorithm for continued fractions. The methodology is built upon several key mathematical frameworks:

CL Representation: A real number $x > 1$ is represented as a sequence of integers $[a_0, a_1, \dots]$ derived from the recursive relation $x = 2^k(1 + 1/y)$ , where $k = \lfloor \log_2(x) \rfloor$ .
Dynamical System Representation: To simplify computation, the authors map the CL process to a dynamical system using a sequence of bits (0s and 1s) representing the operations $x/2$ and $1/(x-1)$ .
Bihomographic Transformations: The fundamental engine of the arithmetic algorithm is the use of bihomographic expressions of the form:
$M(x, y) = \frac{axy + bx + cy + d}{exy + fx + gy + h}$
where $x$ and $y$ are the unread input terms. The algorithm maintains a matrix $M$ that represents the relationship between inputs and outputs.
Matrix Operations: The authors define specific matrix transformations to handle the "production" of output terms (determining the next CL term) and the "consumption" of input terms (reading the next term from the input sequence).
- prod0 and prod1: Used when the current bounds of $M(x, y)$ determine the next output term.
- conx,0 and conx,1: Used to narrow the range of the expression by consuming terms from the input $x$ .

3. Key Contributions

The paper provides three major algorithmic advancements:

Arithmetic Algorithm for CLs: A formalization of how to perform addition, subtraction, multiplication, and division on CLs using bihomographic matrices. This allows for "streaming" arithmetic, where output terms are produced as soon as they are mathematically determined.
Transcendental Function Algorithms: The authors extend the bihomographic method to compute:
- Exponentials ( $e^x$ ): Using a recursive Taylor series approach via Horner’s rule.
- Inverse Trigonometric Functions ( $\arcsin x$ ): Using power series and bounding techniques.
- Trigonometric Functions ( $\sin, \cos, \tan$ ): Utilizing the relationship between $\cos(x)$ and alternating series.
- Logarithms ( $\log x$ ): Using a series expansion that converges for all $x > 0$ .
Convergence and Termination Analysis: The paper provides a theoretical basis for why these recursive, infinitely nested expressions will eventually yield every term of the output (termination), provided sufficient input is consumed.

4. Results and Implementation

Implementation: The algorithms were successfully implemented in Haskell, demonstrating the feasibility of the theoretical approach.
Efficiency: The authors note that CL algorithms are, in fact, simpler than their CF counterparts. The representation is highly compact, and the "streaming" nature of the algorithm allows for real-time computation.
Complexity Note: The authors acknowledge a "termination problem" where an output term might not be determined if the bounds become too tight (e.g., $2 - \epsilon < M(x, y) < 2 + \epsilon$ ). While their current implementation does not solve this, they suggest a parallel error channel for hardware detection.

5. Significance

This work is significant for the fields of high-precision computing and hardware design. By providing a method to compute transcendental functions entirely within the CL domain, the paper paves the way for:

Hardware-level arithmetic units that can handle numbers of vastly different scales without the overhead of floating-point logic.
New methods for symbolic and high-precision numerical analysis where traditional precision limits are a bottleneck.
A bridge between dynamical systems and number theory, showing how iterative maps can be used to drive complex mathematical computations.