💻 computer science

Types, equations, dimensions and the Pi theorem

The authors propose a dependently typed domain-specific language embedded in Idris to formally capture the "grammar of dimensions" in mathematical physics, thereby enabling the rigorous formalization of key concepts like dimensional analysis and Buckingham's Pi theorem while bridging the gap between computer science and physical modeling.

Original authors: Nicola Botta, Patrik Jansson

Published 2026-03-18

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Nicola Botta, Patrik Jansson

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 a chef trying to bake a cake. You have a recipe that says: "Mix 2 cups of flour with 1 cup of sugar." This works perfectly. But what if someone handed you a recipe that said: "Mix 2 cups of flour with 1 kilogram of sugar"? Or worse, "Mix 2 cups of flour with 1 hour of time"?

You would immediately know something is wrong. You can't mix volume with weight, and you certainly can't mix ingredients with time. In the world of physics and engineering, this is called dimensional analysis. It's the rule that says you can only add or compare things that are "the same kind" (like length with length, or time with time).

For decades, computer scientists and physicists have been speaking different languages.

Physicists use math that is rich with these "kinds" of things (dimensions), but their code often treats everything as just generic numbers. It's like a chef who writes a recipe but forgets to label the ingredients, hoping the oven will figure it out.
Computer Scientists use powerful tools (like Dependent Types) that can prove code is correct before it runs. However, these tools have been terrible at understanding the "kinds" of things. They can tell you that a number is a number, but they can't tell you that a "meter" is different from a "second."

This paper, written by Nicola Botta and Patrik Jansson, is an attempt to build a translator between these two worlds. They created a special "mini-language" (a Domain Specific Language) inside a programming language called Idris that forces the computer to understand the difference between a meter, a second, and a kilogram.

Here is a breakdown of their ideas using simple analogies:

1. The "Grammar of Dimensions"

Think of the laws of physics (like Newton's $F=ma$) not just as math, but as a language with a strict grammar.

In English, you can't say "The apple is blue" if you are talking about the taste of the apple.
In Physics, you can't say "Force equals Mass plus Time."

The authors argue that current programming languages are like a grammar checker that only checks spelling, not meaning. They built a new tool that checks the meaning (the dimensions) of every calculation. If you try to add a "time" to a "length," the computer stops you and says, "Error! You are trying to add apples to oranges."

2. The "Magic Mirror" (The Covariance Principle)

Imagine you have a map of a city.

If you measure the distance between two buildings in meters, you get a number like 100.
If you measure it in feet, you get a number like 328.

The actual distance hasn't changed, only the number we use to describe it. The Covariance Principle is the rule that says: "The laws of physics must work the same way, no matter which ruler (unit) you use."

The authors formalized this in their code. They proved that if you write a physical law correctly, it will hold true whether you are using the metric system, the imperial system, or a system made up of "giant steps." If your code breaks when you switch units, the code is wrong. Their tool ensures the code respects this "magic mirror" rule.

3. The "Dimensional Detective" (Buckingham's Pi Theorem)

This is the most famous part of the paper. Imagine you are trying to figure out how long it takes for a pendulum (a swinging weight) to swing back and forth.

You know it depends on the length of the string.
You know it depends on gravity.
You think it might depend on the mass of the weight.

You could run thousands of experiments to find the formula. But there is a shortcut called Buckingham's Pi Theorem. It's like a detective that looks at your list of ingredients (Length, Gravity, Mass) and says:

"Wait a minute. You can't have Mass in the final answer because Mass doesn't fit with Length and Gravity to make a 'Time' unit. The formula must look like this: $\sqrt{\text{Length} / \text{Gravity}}$ ."

The theorem tells you the shape of the answer before you even do the math. It reduces a complex problem with many variables into a simpler one with fewer variables.

The authors did something amazing: they coded this detective into their language. Now, a computer can look at a list of physical variables and automatically tell you:

Which variables are actually important.
Which ones are redundant.
What the formula must look like to be physically possible.

4. Why This Matters

Why should you care?

For Climate Scientists: We can't build a "real" Earth to test if our climate models are right. We have to rely on computers. If the computer's math is dimensionally inconsistent (mixing up units), the model is garbage. This tool acts as a safety net, catching errors that would otherwise lead to wrong predictions about global warming.
For Engineers: It prevents disasters. If a bridge design has a calculation error where meters were treated as feet, the bridge could collapse. This tool catches that before a single brick is laid.
For Programmers: It makes writing code for physics much easier. Instead of manually checking every unit, the computer does it for you, letting you focus on the big picture.

The Bottom Line

The authors built a smart kitchen for scientists.

Before: A chef (scientist) could accidentally mix flour with time, and the oven (computer) would just bake a weird, inedible cake (a wrong simulation).
Now: The smart kitchen has a sensor that screams, "STOP! You can't mix flour with time!" It forces the chef to follow the laws of physics, ensuring the cake (the scientific result) is actually edible (correct).

They hope this will bring computer scientists and physicists closer together, allowing them to solve the world's biggest problems—like climate change—with code that is not just fast, but fundamentally correct.

1. Problem Statement

The authors identify a significant gap between the languages of mathematical physics/modelling and functional programming (FP).

The "Grammar of Dimensions": Mathematical physics relies on a rich, implicit "grammar of dimensions" (e.g., distinguishing between length, time, and mass) to ensure consistency and correctness. Standard programming languages and even current FP abstractions fail to represent this grammar. They often treat all physical quantities as generic real numbers ( $\mathbb{R}^n \to \mathbb{R}^m$ ), ignoring the semantic difference between a length and a time.
The Failure of Adoption: Despite over a decade of advocacy, climate modellers and physicists have largely rejected FP and dependently typed languages (like Haskell, Agda, Idris). The authors argue this is because standard FP type systems emphasize irrelevant type annotations while failing to highlight critical dimensional differences.
The Challenge of Verification: In fields like climate science and plasma physics, empirical validation of models is often impossible or too dangerous. Therefore, rigorous formal specification is crucial. However, existing tools cannot easily enforce dimensional consistency or formalize fundamental theorems like Buckingham's $\Pi$ Theorem, which reduces the complexity of physical models by identifying dimensionless groups.

2. Methodology

The authors propose a Dependently Typed Domain-Specific Language (DSL) embedded in Idris to capture the grammar of dimensions. Their approach involves:

Formalizing Physical Concepts: They translate informal concepts (dimension functions, physical quantities, homomorphic measurements) into type-theoretic constructs.
Dimension Representation: Instead of using complex real-number exponents, they represent dimension functions as vectors of integers ( $\mathbb{Z}^n$ $Z^{n}$ ). For classical mechanics (Length, Time, Mass), dimensions are vectors of length 3.
- Example: Velocity is represented as $[1, -1, 0]$ (Length $^1$ Time $^{-1}$ Mass $^0$ ).
Homomorphic Measurement: They define a measurement function $\mu$ that maps a physical quantity to a real number. They prove that $\mu$ is a homomorphism with respect to arithmetic operations (addition, multiplication), ensuring that the algebra of physical quantities maps correctly to the algebra of real numbers.
Formalizing Buckingham's $\Pi$ Theorem: They encode the theorem's conditions (dimensional independence and dependence) as types.
- Challenge: The classical proof of the $\Pi$ theorem is non-constructive (it relies on the existence of a function $\Phi$ without providing a way to compute it).
- Solution: They separate the theorem into a non-implementable existence proof and a constructive application method (applyPi) that allows programmers to build dimensionally consistent functions by construction.

3. Key Contributions

A. A Minimal DSL for Dimensionally Consistent Programming

The authors implement a DSL in Idris that includes:

D (Dimension): A type representing dimensions as integer vectors (e.g., Vec 3 Z).
Q (Physical Quantity): A phantom type Q d wrapping a real number, annotated with its dimension d.
Operations: Combinators for Times (multiplication), Over (division), and Pow (exponentiation) that operate on dimensions, ensuring that operations like adding apples to oranges (e.g., adding a length to a time) are type-errors.
Measurement: A function μ that converts physical quantities to real numbers based on a chosen unit system (e.g., SI vs. CGS), proving that the result scales correctly.

B. Formalization of the Covariance Principle

They formalize the Covariance Principle (physical laws are independent of the choice of units) as a homomorphism.

A function $f$ between physical quantities is covariant if there exists a function $\rho$ on real numbers such that measuring the inputs, applying $\rho$ , and measuring the output yields the same result as applying $f$ directly to the physical quantities.
They prove that elementary operations (addition, multiplication, etc.) satisfy this principle.

C. Formalization and Application of Buckingham's $\Pi$ Theorem

Theoretical Formulation: They encode the theorem's premises (independent dimensions of governing parameters) and conclusions (existence of a dimensionless function $\Phi$ ) as dependent types (Pi12, Pi13).
Constructive Application: Recognizing the theorem's non-constructive nature, they introduce a data type PhysFunType and a function applyPi.
- Workflow: The user provides evidence of dimensional independence/dependence and a "shape function" (a standard function on real numbers, e.g., derived from data or theory).
- Result: The system automatically constructs a physical function that is provably dimensionally consistent and satisfies the covariance principle.

D. Case Studies

The authors demonstrate the DSL with:

Stommel's Model: Re-deriving the non-dimensionalization of a climate model (Stommel's 1961 paper), showing how the DSL handles the reduction of parameters.
Simple Pendulum: Constructing a function for the period of a pendulum ( $\tau$ ) based on length ( $l$ ) and gravity ( $g$ ). The system deduces that $\tau^2 \propto l/g$ and constructs the function, leaving only the dimensionless constant (involving $\pi$ ) to be determined empirically.

4. Results

Type Safety: The DSL successfully prevents dimensional inconsistencies at compile-time. For example, it rejects adding a length to a time.
Verification: The authors provide formal proofs in Idris and Agda that their measurement functions are homomorphisms and that the applyPi construction yields covariant functions.
Bridging the Gap: The paper demonstrates that dependently typed languages can express the "grammar of dimensions" in a way that is both rigorous for computer scientists and conceptually aligned with the intuition of physicists.

5. Significance

For Computer Scientists: It introduces a novel application of dependent types to physical modeling, moving beyond simple unit checking to formalizing fundamental theorems like the $\Pi$ theorem.
For Physicists and Modellers: It offers a tool to reduce the "curse of dimensionality" in data analysis and model building. By enforcing dimensional consistency, it helps identify valid physical laws from empirical data and reduces the search space for model parameters.
Interdisciplinary Impact: The work suggests that formalizing "relativity principles" (like the independence of units) via type theory could be extended to other fields (e.g., economics, biology) where similar invariance principles might apply but are currently unformalized.
Future Directions: The authors highlight that while their current DSL uses integer exponents (limiting square roots of arbitrary quantities), the framework can be extended to rational exponents and more complex algebraic structures (tensors, groups) to support broader scientific domains.

In summary, the paper successfully argues that functional programming is not just compatible with mathematical physics but is essential for it, provided the language is extended to natively support the "grammar of dimensions" through dependent types.