You won't often see me wax philosophic about the astral plane, but I finally found a reason to do so! After some wanderthink, I found myself looking for modern explanation of 'imaginary' numbers (mostly on YouTube, because that is a good place to easily find a common sense distillation of an idea with graphics - felt like I needed graphics for this). And let me tell you, I left mad.

I was angry because no one had explained imaginary numbers to me as a student. Sure, I had people define them - you know, some form of, 'Well, i is an imaginary number and it is equal to the square root of 1'. Great. I think at some point someone said that imaginary numbers existed on a different axis, but I'm certain at the time I had no real reason to understand how that related to the so-called 'number line' (that is, the number line of real numbers).

Part of the confusion has, I'm sure, always been with nomenclature. 'Real numbers', as though π feels real. 'Imaginary numbers', as though all numbers weren't imaginary. 'Complex numbers', which are spoken of in the same tone you might describe a messy relationship - 'it's complicated'. In other words, nothing to see here, move on, explaining it will definitely be over your head.

When I was a young and eager student this sort of thing didn't usually stymie me. But I found it happened to stymie my teachers. Either they whipped out a proof with sines and cosines (which, I will admit, never made a great deal of intuitive sense to me) that was entirely impenetrable - even to them - or they'd throw up their hands and suggest I didn't need to worry about it. In other words, my teachers had no good way of explaining it.

While I was watching YouTube and having some insights (read: getting angry) about (how I was taught) imaginary numbers, two things occurred to me. The first is that the whole thing suffered a problem of nomenclature - specifically the sin of inequality by omission. The second was that this all made so much more sense after learning about generics in computer science.

Nomenclature. I groused above about how the names of these different types of numbers suck. Let's fix that by calling things by more sensible names. First, the material numbers. These are the traditional numbers that you know about that extend from negative infinity to positive infinity. (I'm going to elide an extension of this whole idea that relates to sign, but know that I thought of it!) They are material because we can point to material things and count them. One person. Two people. Two and a half people. (Ew.) We understand whole units of things, and we understand partial units of things. It's intuitive to think of these things because, if we don't want to use imaginary 'numbers' (again, all numbers are imaginary - abstract), we can gather the items and tick them off (in unary if needed!) We've fixed half our problem because we've tied the numbers to the thing they most relate to - the real, material world. We already kinda-sorta use this definition because we refer to all forms of money as 'material wealth'.

Super! Halfway there. What about the other half? My tongue-in-cheek proposal is that we call them 'Astral numbers'. Why astral? Because 'astral' as a concept speaks to things that are unseen, are attached to material things (wait for it), and behave differently. It also lends itself to a particular explanation of why the square root of 1α (that is the unit number of the astral number line, equivalent to the traditional i) makes any sense at all.

We've already established you can count people. Well, people have souls. (Well, so many religions would have us believe. For our purposes this is a convenient analogy.) Some souls are big. Some are small. When you count a material person, you are also counting a material soul. But how big is that soul? You can't tell because you can't see into the astral plane.

You can't see it because a plane is only two dimensions, and when you're looking at just a material number, it's as though you're looking at the astral plane from the side - where it has no dimensions. If you were able to somehow rise up out of the material plane and look down on the grid created by the axes of the material and astral plane, then you could tell how big a soul was.

Ok, it's a B+ as an analogy.

Still, let's keep on it. I'm a material person, and I have a soul of size one (trust me). If we were to plot this on an (m, α) grid (equivalent to an (x, y) grid), you'd have a point at (1, 1). The projection into the material number line (discarding the astral component) is 1, which is how you'd normally count me. Let's say you clone me - now there are six of me, but still only one soul. We are now at (6, 1) on our grid. We'll return to this later.

The second thing I noticed was that generics offers a great way to think about this. This insight is practically tautological, given that computer science is a reification of math, but I think generics explain some of this much more clearly.

The shorthand is this: a generic is some abstraction that operates over a particular class of things. For instance, if I have a list of cards, my 'list' is the generic abstraction that operates over the class of things known as 'cards'. In my program I can do lots of things with this idea of a 'list'. I can 'draw' the next card off the top of the deck. I can 'shuffle' the deck, randomizing the order. I can 'order' the deck by putting all the cards in a particular sequence.

In typical computer nomenclature, you might say that the 'type' of your list is List<A>, where A represents the thing the list is operating over. It could be anything - cards, houses, people - those operations of looking at the next thing, shuffling all the things or ordering all the things remains the same. The only real requirement is that all the items must all be of a certain type, A. However, for most generic abstractions (which are not just collections of things) there is a limit to what they can handle.

Let's consider the abstraction Drive<A>. If A is a car, or a train, or something else that you can 'drive', this can work. If you give as Drive to operate on a cake you're likely to get frosting all over the floor - or, in computer science words, an error. In this case, A needs to be a 'bounded type' - something with wheels and a steering mechanism, say. How you bound a type or represent bounded types can take up vats of ink, and isn't important. The idea that an abstraction only works on certain types is.

Back to the material and the astral. Let's say I have an abstraction called MaterialMath<N>, that operates over some set of things N. Loosely, we will call these 'numbers'. Now, consider the following:

p: dict = {
  m: 3,
  α: 1,
}

This is a pseudo-code definition of a map, named x, of type dict, that is a set of key-value pairs. The keys, m and α have some scalar values associated with them. By 'scalar' I mean 'without units'. Now, imagine the following function:

double<N>(N) -> N

This is a formal way of saying 'some function that operates on type N, and when it takes a variable of type N it returns some variable also of type N', and in this case we are implying that what we mean is that the output is double the input. That's a bit dense, so let's define this for int (an integer) in Python:

def double(x: int) -> int:
    return 2 * x

Some int x comes in and twice that goes out. Simple enough, and a valid implementation of double() for the N == int. But if I put in my map type dict from above, it will fail. I would need to do this instead:

def double(x: dict) -> dict {
    return {
        m: x.m * 2,
        α: 1,
    }
}

This is where you call a halt. How is that double? I only doubled the m key's value! But lets say that wherever I am using my dict type no matter what else I do I ignore everything that isn't the value in that m key. It doesn't matter, just gets passed through as-is. You might see where I'm going with this: when we are taught math, we are taught a math that ignores a whole bunch of information about a number.

A number isn't composed of just a scalar int value, that's it. Sure, we can treat it that way, but in truth it has all sorts of 'metadata' attached to it that we take for granted. Such as its value in the astral plane. As you can see in my function above, we can double our number and just ignore what's going on in the astral, because the projection on to the material number line is correct.

In truth - and there are many explainers that describe this - when we describe a number it's really a tuple, for which we ignore that vast majority of the information because it isn't pertinent: a '2' on the material number line is really a stand-in for (2 * m, 0 * α), which would map directly into the x-y terms of your typical graph. With this extended representation you can add, subtract, multiply any amount of numbers without the α ever coming into play, because it is 0 and 0 + 0 = 0, 0 * 0 = 0, etc.

And, in truth, if you write a double() function that can handle that you end up having to do something a bit different to make it work. Because movement in the astral plan doesn't work the same as movement  in the material plane.

2α + 2α = 4α
2α * 2α = -4m  # ???

I mean, we know this because we know that that square root of negative one is α (or i if you don't like my astral naming). Lets translate this to the type I defined above:

{ m: 0, α: 2} * { m: 0, α: 2}

Now we just need to define our double() function in a way that works. So how does multiplication work in astral space? Well, in astral space, rather than walking in a straight line, we take a left hand turn (or widdershins, if you're up on ye olde terms) and then walk. So, {m: 0, α: 2} means 'go straight 0 steps, turn left and go straight 2 steps'. This gets a little weird with multiplication though - multiplying one left hand turn by another is the same as taking two left hand turns. 'About face' if you're up on your, um, military jargon?

# Define some constants for the material and astral planes
M_DEGREES = 0
α_DEGREES = 90

def multiply(p: dict, q: dict):
    m_rotation = (p.m + q.m) * M_DEGREES  # Haha trick calculation! 
    α_rotation = (p.α + q.α) * α_DEGREES
    m = (p.m * q.m) * cos(m_rotation) + (p.α * q.α) * cos(α_rotation) 
    α = (p.m * q.m) * sin(m_rotation) + (p.α * q.α) * sin(α_rotation) 
    
    return {m: m, α: α}

(I think the math here is right, but I did this pretty off the cuff and am not fallible.)

(*infallible)

An interesting aside - if you orient yourself to the astral axis / number line as you would the basic material number line, so that the material number line disappears, it means that multiplying along that astral number will cause numbers to jump to zero and re-appear elsewhere without much clue why! Only if you know that number's 'tether' to the material plane will you be able to tell where it will come out - a number that is defined in the astral plane but not the material plane is lost, doomed to drift in madness in the astral seas!

Anyway. That got complicated, and denser than I had started out. The takeaway should be this: numbers have a lot more metadata than we start out learning of. The number line is taught with clean, bare numbers: 1, 2, 3. But those are really {m: 1, α: ?}, {m: 2, α: ?} and so on. Having a concept of generics, and knowing that certain operations work only over bounded numbers (`double()` only works on numbers where α is 0!) makes this easier to understand. But more than anything, we need to name things better.

As a description of my own insights here, maybe this isn't that cogent. Hopefully the short form is: numbers have material and astral components, each with different mechanics. If you have suggestions for better names for the axes in the quaternion and octonion number-spaces, let me know!  (No, not Niflhelm.)