Calculus Invariance Framework

Core Modules

derivatives.py

GeometricDerivative, BigeometricDerivative, MetaDerivative, UnifiedDerivative

generators.py

Identity, Exponential, Log, Power, Reciprocal, ScaleDependent

integration.py

MetaIntegral, UnifiedIntegral, verify_fundamental_theorem

weights.py

horizon_weight, information_weight_qubit, decoherence_weight

Geometric Derivative

Measures multiplicative rates of change. Exponential functions have constant geometric derivative.

Limit Definition

D_G[f](a) = \lim_{x \to a} \left[\frac{f(x)}{f(a)}\right]^{1/(x-a)}

Explicit Formula

D_G[f](a) = \exp\left(\frac{f'(a)}{f(a)}\right)

Key Property

For exponential functions f(x) = e^(kx):

D_G[e^{kx}] = e^k \quad \text{(constant)}

Bigeometric Derivative

Measures scale-invariant rates of change. Power functions have constant bigeometric derivative.

Limit Definition

D_{BG}[f](a) = \lim_{x \to a} \left[\frac{f(x)}{f(a)}\right]^{1/\ln(x/a)}

Explicit Formula (Elasticity)

D_{BG}[f](a) = \exp\left(\frac{a \cdot f'(a)}{f(a)}\right)

Power Law Theorem (Grossman & Katz, 1972)

For any power function f(x) = x^n:

D_{BG}[x^n] = e^n \quad \text{(constant)}

Constraint identity in local tests; not independent evidence

Important Limitation

D_BG[constant] = 1, not 0. This breaks linearity and makes full bigeometric GR incompatible with tensor calculus. Use as diagnostic tool, not for field equations.

CASCADE Singularity Connection

k=-1 (bigeometric) is optimal for power-law singularities:

L_{BG}[1/r] = -1,\quad D_{BG}[1/r] = e^{-1}\quad (r>0)

61.9% local benchmark win rate across 21 cases; not independent validation.See CASCADE local benchmark

Meta-Derivative

Uses weight functions to change how we measure intervals without changing arithmetic structure.

Definition

[\hat{D} f](a) = \frac{v(a)}{u(a)} \cdot f'(a)

where u(x) weights the independent variable and v(x) weights the dependent variable.

Project Chart-Weighted Derivative

With identity charts this reduces to Grossman's published meta-derivative. The nonlinear alpha/beta extension is a project definition.

[D^*_w f](a) = \frac{v(a)}{u(a)} \cdot \beta'(f(a)) \cdot \frac{f'(a)}{\alpha'(a)}

alpha: Generator for argument arithmetic (how we measure x-changes)

beta: Generator for value arithmetic (how we measure f(x)-changes)

u(x): Weight for arguments (meta-measure density)

v(x): Meta-change weight on the argument

Generator Functions

Generators transform standard calculus into alternative frameworks.

Generator	alpha(x)	alpha prime (x)	Use Case
Identity	x	1	Classical calculus
Exponential	exp(x)	exp(x)	Multiplicative processes
Log	ln(x)	1/x	Power laws
Power(p)	x^p	p*x^(p-1)	Polynomial transforms

Python Usage

from meta_calculus.core import (
    BigeometricDerivative,
    UnifiedDerivative,
    Identity, Log
)
import numpy as np

# Power function
f = lambda x: x ** 3

# Bigeometric derivative: D_BG[x^3] = e^3
D_BG = BigeometricDerivative()
x = np.array([1.0, 2.0, 5.0])
result = D_BG(f, x)
print(f"D_BG[x^3] = {result}")  # All ~20.09 (e^3)

# Unified derivative
alpha = Log()
beta = Log()
D_unified = UnifiedDerivative(alpha, beta)
result = D_unified(f, x)  # Returns elasticity