The Formula Forge: An Algorithmic Discovery Engine for Physics

 

By J. Rogers, SE Ohio, 15 Jun 2025, 1815

Program is here: https://github.com/BuckRogers1965/Physics-Unit-Coordinate-System/blob/main/examples/buckingham_pi_group.py

Abstract

We present the "Formula Forge," a computational tool that automates the derivation of physical formulas from first principles. The engine operates as a practical implementation of the Buckingham Pi Theorem, leveraging the insight that all physical laws can be expressed as relationships between dimensionless quantities. By postulating a simple, intuitive relationship at the fundamental Planck scale, the engine uses symbolic algebra to mechanistically derive the final, complex formula in standard SI units. This paper describes the engine's architecture, demonstrates its power by deriving several cornerstone formulas of physics, and provides instructions for users to extend its capabilities by adding new examples.

1. Introduction: From Art to Algorithm

The derivation of a new physical law is often seen as a black art, requiring deep, domain-specific knowledge and complex mathematical maneuvering. However, the Buckingham Pi Theorem suggests a more systematic structure: that all valid physical equations are fundamentally relationships between dimensionless groups.

The Formula Forge is a Python program that operationalizes this principle. It treats the derivation of an SI formula as a two-step process:

1. The Physical Intuition: A human user postulates a simple relationship between the dimensionless "Pi groups" of the relevant quantities.

2. The Algebraic Engine: The program takes this simple postulate and algorithmically translates it into the final SI formula by substituting the definitions of the Planck units and simplifying the result.

This separates the creative act of physical intuition from the mechanical act of algebraic unit conversion.

2. The Engine's Architecture

The program is built using the sympy symbolic mathematics library and consists of two main parts:

• The Knowledge Base: A "configuration file" for physics. This section defines all the necessary mathematical objects:

  1. Symbolic Variables: For physical quantities (M, T, F, etc.) and the fundamental constants (h, c, G, k_B). These are defined as positive=True, real=True to allow for correct algebraic simplification.

  2. Planck Unit Definitions: The Planck units (m_P, l_P, T_P, etc.) are defined symbolically in terms of the fundamental constants. These act as the "basis vectors" for converting between dimensionless ratios and SI quantities.

• The Derivation Function ( This is the core engine. It takes a dimensionless postulate and a target variable as input and performs a deterministic, four-step process:

  1. Parse: It converts a human-readable string postulate into a formal sympy equation.

  2. Solve: It algebraically solves the equation for the target variable, expressing it in terms of other variables and Planck units.

  3. Substitute: It replaces all Planck unit symbols in the solution with their full definitions from the Knowledge Base.

  4. Simplify: It uses sympy's powerful simplification engine to cancel out the complex terms and reveal the final, clean SI formula.

3. Demonstration: Deriving 

Let's trace how the engine derives the mass-energy equivalence.

• Step 1: The Intuition & Postulate:
  The core physical intuition is that Energy is directly proportional to Mass. In a dimensionless system, this means their ratios are equal.
  Postulate: "E/E_P, M/m_P"

• Step 2: The Engine's Process:

  1. Parse: The engine creates the equation Eq(E/E_P, M/m_P).

  2. Solve: It solves for E, yielding E = M * (E_P / m_P).

  3. Substitute: It replaces E_P with sqrt(hc⁵/G) and m_P with sqrt(hc/G).

  4. Simplify: It calculates the ratio E_P / m_P, which simplifies exactly to c².

• Step 3: The Result:
  The engine outputs the final, correct formula: Eq(E, M*c**2).

The engine successfully derived the formula without any pre-programmed knowledge of Special Relativity, only the definitions of the units and the initial dimensionless postulate.

4. How to Add a New Example: Deriving the Ideal Gas Law Pressure

Let's say we want to derive the relationship for pressure in a gas, P = n k_B T, where n is the number density (1/Volume). Our intuition is that Pressure is proportional to Number Density times Temperature.

Step 1: Identify the Quantities and Define Symbols

We need symbols for Pressure (P), Number Density (n), and Temperature (T). We also need the Boltzmann constant k_B. These should already be in the Knowledge Base, but if not, we add them:

# Add to the symbol definition section
P, n = sympy.symbols('P n', positive=True, real=True)

Step 2: Formulate the Dimensionless Postulate

We need to express our intuition P ~ n * T in terms of dimensionless Planck ratios.

• Pressure Ratio: P / P_P

• Number Density Ratio: n / n_P. Number density has units of 1/L³, so the Planck number density is 1 / l_P³. The ratio is n * l_P³.

• Temperature Ratio: T / T_P

Our postulate is P_ratio = n_ratio * T_ratio.
So, P / P_P = (n * l_P³) * (T / T_P).

We convert this to the string format for our function:
postulate_gas = "P/P_P, (n * l_P**3) * (T/T_P)"

Step 3: Add the Test Case to the Main Block

We add a new call to the derive_formula function at the end of the script:

# --- Test Case 8: Ideal Gas Law Pressure ---
# Postulate: P_ratio = n_ratio * T_ratio
postulate_gas = "P/P_P, n * l_P**3 * T / T_P"
derive_formula(postulate_gas, P, all_symbols)

(Note: You'll also need to add the new symbols 

Step 4: Run the Script and Analyze the Output

The engine will now perform the derivation. It will substitute the definitions for P_P, l_P, and T_P, and after simplification, it will arrive at the final result.

• Expected Result: >>> Eq(P, n*k_B*T)

The engine will have successfully derived the Ideal Gas Law from a simple statement of proportionality, demonstrating its power and extensibility once again.

5. Conclusion

The Formula Forge is more than a calculator; it is a new lens through which to view physical law. It proves that the complex formulas we see in textbooks are not the fundamental reality, but are emergent properties of a much simpler, dimensionless reality being projected onto our arbitrary human measurement systems. By providing a tool to automate this projection, we can accelerate discovery, enhance education, and gain a deeper, more intuitive understanding of the beautiful, simple logic that governs our universe.