Did I just discover a new mathematical formula?

What a weird way of starting a blog... anyways, please join me in my journey of spending time reasoning about complex stuff I know nothing about for no particular reason.

8 min read × June 14, 2024

Let me start with the disclaimer: I am not sure if this is really unknown, I don’t know if it is useful for something, and I could never give a proper proof for it. I’m just a simple developer and far away from being a mathematician; so be nice. Even if this is not new, I’m glad that I managed to figure this out all by myself.

The history

It all occurred in three fases. The first one started at high school one day when I was in a city bus coming back home. My brain usually never leave me alone, so on that day I was playing with car plates numbers as I saw them through the window. I can’t remember exactly how, but I realized that any $x$ integer squared equals to one below it times one above it plus one.

$A = x^{2}$	$B = (x - 1) \cdot (x + 1)$	$A - B$
$1^{2} = 1$	$0 \times 2 = 0$	$1 - 0 = 1$
$2^{2} = 4$	$1 \times 3 = 3$	$4 - 3 = 1$
$3^{2} = 9$	$2 \times 4 = 8$	$9 - 8 = 1$
$4^{2} = 16$	$3 \times 5 = 15$	$16 - 15 = 1$
$5^{2} = 25$	$4 \times 6 = 24$	$25 - 24 = 1$
$6^{2} = 36$	$5 \times 7 = 35$	$36 - 35 = 1$
$7^{2} = 49$	$6 \times 8 = 48$	$49 - 48 = 1$
$8^{2} = 64$	$7 \times 9 = 63$	$64 - 63 = 1$
$9^{2} = 81$	$8 \times 10 = 80$	$81 - 80 = 1$
$10^{2} = 100$	$9 \times 11 = 99$	$100 - 99 = 1$

Chill out; I know this is basic.

Then a few years later (2016, according to a document I found on my drive in which I was exploring this in more detail) I strived to find out if it could be applied to powers other than two and to describe it as a formula. I ended up with two different equations, one for even and another for odd exponents. For some reason I didn’t see at that moment that the one for even exponents could be used for both cases. This is the one we’ll be considering in this article.

Before we jump right in, let’s walk through some relations that helped me to complete this task.

$A_{x} = x^{2}$	$B_{x} = A_{x} - A_{x - 1}$	$C_{x} = B_{x} - B_{x - 1} = 2!$
$1^{2} = 1$
$2^{2} = 4$	$4 - 1 = 3$
$3^{2} = 9$	$9 - 4 = 5$	$5 - 3 = 2$
$4^{2} = 16$	$16 - 9 = 7$	$7 - 5 = 2$
$5^{2} = 25$	$25 - 16 = 9$	$9 - 7 = 2$
$6^{2} = 36$	$36 - 25 = 11$	$11 - 9 = 2$
$7^{2} = 49$	$49 - 36 = 13$	$13 - 11 = 2$
$8^{2} = 64$	$64 - 49 = 15$	$15 - 13 = 2$
$9^{2} = 81$	$81 - 64 = 17$	$17 - 15 = 2$
$10^{2} = 100$	$100 - 81 = 19$	$19 - 17 = 2$

Nice, right?

Note that when we recursively subtract one value from the previous one, we get at the end the factorial of the exponent. Let’s see another example.

$A_{x} = x^{5}$	$B_{x} = A_{x} - A_{x - 1}$	$C_{x} = B_{x} - B_{x - 1}$	$D_{x} = C_{x} - C_{x - 1}$	$E_{x} = D_{x} - D_{x - 1}$	$F_{x} = E_{x} - E_{x - 1} = 5!$
$1^{5} = 1$
$2^{5} = 32$	$32 - 1 = 31$
$3^{5} = 243$	$243 - 32 = 211$	$211 - 31 = 180$
$4^{5} = 1024$	$1024 - 243 = 781$	$781 - 211 = 570$	$570 - 180 = 390$
$5^{5} = 3125$	$3125 - 1024 = 2101$	$2101 - 781 = 1320$	$1320 - 570 = 750$	$750 - 390 = 360$
$6^{5} = 7776$	$7776 - 3125 = 4651$	$4651 - 2101 = 2550$	$2550 - 1320 = 1230$	$1230 - 750 = 480$	$480 - 360 = 120$
$7^{5} = 16807$	$16807 - 7776 = 9031$	$9031 - 4651 = 4380$	$4380 - 2550 = 1830$	$1830 - 1230 = 600$	$600 - 480 = 120$
$8^{5} = 32768$	$32768 - 16807 = 15961$	$15961 - 9031 = 6930$	$6930 - 4380 = 2550$	$2550 - 1830 = 720$	$720 - 600 = 120$
$9^{5} = 59049$	$59049 - 32768 = 26281$	$26281 - 15961 = 10320$	$10320 - 6930 = 3390$	$3390 - 2550 = 840$	$840 - 720 = 120$
$10^{5} = 100000$	$100000 - 59049 = 40951$	$40951 - 26281 = 14670$	$14670 - 10320 = 4350$	$4350 - 3390 = 960$	$960 - 840 = 120$

It was a lot easier to do it in Excel.

After playing for a little while, I got this (again, this originally is the even power version):

x^{n} = 1 + (x - 1) \times \sum_{i = 0}^{n - 1} x^{i}; x \in ℚ, n \in ℕ

It’s getting interesting.

Let’s see it in action.

\begin{matrix} 4^{3} & = & 1 + (4 - 1) \times \sum_{i = 0}^{3 - 1} 4^{i} \\ 4^{3} & = & 1 + 3 \cdot (4^{0} + 4^{1} + 4^{2}) \\ 4^{3} & = & 1 + 3 \cdot (1 + 4 + 16) \\ 4^{3} & = & 1 + 3 \cdot 21 \\ 4^{3} & = & 1 + 63 \\ 4^{3} & = & 64 \end{matrix}

MathML is cool only until you actually start using it.

However, since we have more exponentiation inside the summation, we can do this recursively ~~just to make it look bigger~~.

\begin{matrix} 4^{3} & = & 1 + (4 - 1) \times \sum_{i = 0}^{3 - 1} 4^{i} \\ 4^{3} & = & 1 + 3 \cdot (4^{0} + 4^{1} + 4^{2}) \\ 4^{3} & = & 1 + 3 \cdot (4^{0} + (1 + 3 \cdot (4^{0})) + (1 + 3 \cdot (4^{0} + 4^{1}))) \\ 4^{3} & = & 1 + 3 \cdot (4^{0} + (1 + 3 \cdot (4^{0})) + (1 + 3 \cdot (4^{0} + (1 + 3 \cdot (4^{0}))))) \\ 4^{3} & = & 1 + 3 \cdot (1 + (1 + 3 \cdot (1)) + (1 + 3 \cdot (1 + (1 + 3 \cdot (1))))) \\ 4^{3} & = & 1 + 3 \cdot (1 + (1 + 3) + (1 + 3 \cdot (1 + (1 + 3)))) \\ 4^{3} & = & 1 + 3 \cdot (1 + 4 + (1 + 3 \cdot (1 + 4))) \\ 4^{3} & = & 1 + 3 \cdot (5 + (1 + 3 \cdot 5)) \\ 4^{3} & = & 1 + 3 \cdot (5 + 1 + 15) \\ 4^{3} & = & 1 + 3 \cdot 21 \\ 4^{3} & = & 64 \end{matrix}

Why do I do these things to myself?!

The final unfolding

As you can see, the formula has limitations; it would be nicer if it could handle fractional exponents. This is what I’ve been addressing after all these years because I only recollected this recently.

The tip lies in the leading $1$ ; we can express it as $x^{0}$ . This zero exponent is the same zero on the sum lower bound, and both actually are the fractional part of $n$ —which has been only integers up to now.

Applying it, we finally have this beauty:

x^{n} = x^{n \mod 1} + (x - 1) \times \sum_{i = n \mod 1}^{n - 1} x^{i}; x \in ℚ, n \in ℚ_{+}

I’m feeling so dang smart.

Or if you are not a fan of using non-integers values in sum bounds (I don’t even know if that is strictly correct to be honest), this one is for you:

x^{n} = x^{n \mod 1} + (x - 1) \times \sum_{i = 0}^{⌊ n ⌋ - 1} x^{i + n \mod 1}; x \in ℚ, n \in ℚ_{+}

But the latter is kinda ugly, so I’ll stick with the former. Judge me.

Let’s put it to the test.

\begin{matrix} 81^{3.25} & = & 81^{3.25 \mod 1} + (81 - 1) \times \sum_{i = 3.25 \mod 1}^{3.25 - 1} 81^{i} \\ 81^{3.25} & = & 81^{0.25} + 80 \cdot (81^{0.25} + 81^{1.25} + 81^{2.25}) \\ 81^{3.25} & = & 3 + 80 \cdot (3 + 243 + 19683) \\ 81^{3.25} & = & 3 + 80 \cdot 19929 \\ 81^{3.25} & = & 3 + 1594320 \\ 81^{3.25} & = & 1594323 \end{matrix}

This is the last time I do this. No, I’m not doing the recursive version. That’s it.

It works when each individual calculation (e.g. $81^{1.25}$ ) renders a fraction; I simply picked one that doesn’t do that in order to keep things easier to read.

Some code

Here you can check out the equation in Go:

package main

import (
  "fmt"
  "math"
  "math/cmplx"
)

var memo = make(map[float64]map[float64]complex128)

func Pow(x, n float64) complex128 {
  if r1 := memo[x]; r1 != nil {
    if xpown := r1[n]; xpown != 0 {
      return xpown
    }
  } else {
    memo[x] = make(map[float64]complex128)
  }
  // n mod 1
  nmod1 := math.Mod(n, 1)
  // x^(n mod 1)
  xpownmod1 := cmplx.Pow(complex(x, 0), complex(nmod1, 0))
  // (x - 1)
  xminus1 := complex(x-1, 0)
  // n - 1
  nminus1 := n - 1
  // sum
  var sum complex128
  for i := nmod1; i <= nminus1; i++ {
    sum += Pow(x, i)
  }
  // x^n
  xpown := xpownmod1 + xminus1*sum
  memo[x][n] = xpown
  return xpown
}

func main() {
  x := float64(-4)
  n := float64(3.5)
  builtin := cmplx.Pow(complex(x, 0), complex(n, 0))
  custom := Pow(x, n)
  fmt.Printf("           (%v^%v)\n", x, n)
  fmt.Printf("built-in = %v\n", builtin)
  fmt.Printf("  custom = %v\n", custom)
}
// prints:
//            (-4^3.5)
// built-in = (-5.4864176601801346e-14-128i)
//   custom = (-7.83773951454305e-15-128i)

And the exact same thing but in C++ (written for confirmation purposes):

#include <iostream>
#include <complex>
#include <unordered_map>

using namespace std;

unordered_map<double, unordered_map<double, complex<double>>> memo;

complex<double> Pow(double x, double n) {
  if (auto r1 = memo.find(x); r1 != memo.end()) {
    if (auto xpown = r1->second.find(n); xpown != r1->second.end()) {
      return xpown->second;
    }
  }
  // n mod 1
  double nmod1 = fmod(n, 1);
  // x^(n mod 1)
  complex<double> xpownmod1 = pow(complex<double>(x, 0), complex<double>(nmod1, 0));
  // (x - 1)
  complex<double> xminus1 = complex<double>(x-1, 0);
  // n - 1
  double nminus1 = n - 1;
  // sum
  complex<double> sum;
  for (double i = nmod1; i <= nminus1; i++) {
    sum += Pow(x, i);
  }
  // x^n
  complex<double> xpown = xpownmod1 + xminus1*sum;
  memo[x][n] = xpown;
  return xpown;
}

int main() {
  double x = -4;
  double n = 3.5;
  complex<double> builtin = pow(complex<double>(x, 0), complex<double>(n, 0));
  complex<double> custom = Pow(x, n);
  cout << "           (" << x << "^" << n << ")\n";
  cout << "built-in = " << builtin << "\n";
  cout << "  custom = " << custom << "\n";
}
// prints:
//            (-4^3.5)
// built-in = (-5.48642e-14,-128)
//   custom = (-7.83774e-15,-128)

Side note: I chose ${- 4}^{3.5}$ on purpose to show this interesting computational behavior, that when the result has anything to do with complex numbers, the imaginary part is correct, but the real part shows a super small value while it should be zero. Also, since built-in and custom methods are calculated in different ways, they end up being different from each other, however they are at least consistent across these two languages.

That guy has something to share with us about it:

Unfortunately it didn’t fit in the previous screenshot.

Jokes aside, this is a good answer indeed. You did it GPT-4o 👌

Final thoughts

Again, it’s been fun to spend some time getting my head around this, no matter what it is. Please let me know what you think about it. I mean it.

See you in the next one!