Exploring the Simulated Universe: Where Programming Meets Mysticism

Diary Entry 11/23/2024

Foreword

This article talks about ideas which are not clearly defined, and are not meant to be taken as anything more than suggestive. These are very rough ideas which I am still working out. Likewise, they are highly speculative. This article is not to be taken as a technical or empirical work; it is philosophical in nature. It's simply an exploration of the concepts involved.

It would do the reader well to keep this in mind as they read. Also, to keep in mind that I am not a mathematician, physicist, or even a computer scientist; I am a software engineer. I do not have a strong background in the sciences outside of my coursework in physics.

The value of this article is in the questions it raises. I hope the reader will take the concepts herein and explore them further.

The Universe as a Simulation

Let’s imagine that the Universe we live in truly is a simulation. How complicated would it be to properly simulate a conscious, imaginative being such as us? We have the ability to re-create, internally, in our own “data structure” that which exists outside of us. As a programmer, I can envision a handful of ways in which I may go about programming this faculty; we’ll explore them below.

The Nature of the Simulation

The first thing to think about is how efficient a simulation of everything we see would need to be. Truth is… We can’t! All we can say is that we may be in the Universal simulation of an amateur—the grade-schooler’s first attempt at such a task. How could we tell? And by what metric would we be able to determine that whoever is intelligent enough to write such a simulation is sufficiently advanced enough to not make a simple mistake in doing so? In other words, if we live in a simulation, we should expect it to be flawed! At the very least, we should expect that we don’t live in a perfected, late-stage model of such a software!

Modeling the Simulation

Now, we can begin to talk about how we would model such a thing. We cannot reasonably expect that whatever super-intelligence that exists would conform to our stupid standards, but we may draw at least some conclusions in our analysis using human terms. The first idea that springs to mind is object-oriented programming. The universe gives itself readily to such a model. Therefore, to simulate our consciousness in an object-oriented approach would require a good method of “invoking” either the classes which originally construct the objects in our own minds or some sub-class thereof that is a degradation over the superclass. Regardless, the distinction is that whatever we invoke in our minds should be, obviously, LESS THAN the class proper!

Platonism and Object-Oriented Programming

I should stop for a moment and touch on something very interesting that arises from this train of thought. Object-oriented programming, when considered as the methodology for creating our simulated Universe, is the exact same body of knowledge derived under Platonism. In an object-oriented universe simulation, Platonism is the ontological “reality” since what we interact with in the “run-time” of such a simulation truly is “instantiated” from the “classes” (world of forms).

Bugs in the Simulation Hierarchy

Let’s continue where we left off. If my mind truly is programmed to instantiate, invoke, or in any way establish a type of association between the class which is the proper prototype for the object itself and the class of the imaginary creation I make in my mind of such an object; then we are able to also consider what “bugs” may be present in such simulation hierarchy. By “bugs,” I do mean to imply the typical issues that arise in the novice—or even rushed—usage of object-oriented programming, particularly those revolving around leaky abstractions, exploitations on the nature of contiguous memory, and overflows.

Understanding Leaky Abstractions

What does this even mean? Well, let’s start with the concept of a leaky abstraction. Typically, the goal of any class in object-oriented programming is to describe the behavior of any “object” in your program. Classes describe behavior by providing a set of methods that demonstrate that behavior to the rest of the program. There are, however, many things which ARE NOT provided to the rest of the program which are necessary to allow the described behavior to occur. These hidden items are “abstract” in the sense that it is not necessary to know them to understand and interact with the class’s behavior.

However, when the hidden knowledge required to properly allow any class to facilitate the described behavior MUST be known by any other part of the program, the hidden information starts to “leak” out into the rest of the program. The abstraction is no longer doing its job—it is now a leaky abstraction. When this starts to occur, hidden details of the class are necessary to use it properly.

Bugs in Our Minds

We are in a place now to consider how leaky abstractions are a “bug” in the nature of our minds. Or rather, we can now see how leaky abstractions are a very slippery slope that led to bugs, and through thinking about the leaky abstraction, we can also come up with reasonable bugs we expect to see in our minds during imagination processes. If, during visual imagination, I truly am instantiating some kind of associated class which attempts to mimic the class in question, then we should consider that either my degraded version of the class or the original class itself, or something in the chain which forms this link, is a leaky abstraction.

If a leaky abstraction is present, it means that our minds MUST be programmed to have some innate knowledge of the class itself. This is a devilishly astounding conclusion based on the premises. If the class—or inheritance hierarchy between whatever it is that we instantiate in our minds—is leaky, then our minds have to contain some partial knowledge of the internal workings of the thing imagined itself, since to use a leaky abstraction requires you already have knowledge of what is “leaking” in the first place!

Contiguous Memory Exploits

In the context of exploiting such a thing, that’s hard to talk on. If our assumptions hold true, we know little else other than there being some kind of innate knowledge in our minds of all things which we are capable of imagining. Whether this knowledge is actually useful—or something we are programmed to ever become consciously aware of—I know nothing about; nor can I find any good method so far of figuring that bit out! So, we move on to other things. Here, I go back to another thing that is commonly exploited in computer systems: contiguous memory.

Contiguous can be defined as “touching” and so “contiguous memory” is data stored in locations very close, typically right next to each other. When you instantiate any object from a class, its internal data is contiguous in most programming languages. Therefore, an object which is created from a class will have data that is also “very close” together in memory. To see how this can fit into our simulated mind scenario, we can think about how the object which is created in our minds from the inheritance chain would have its data be contiguous in whatever form of memory stores that data in the simulation.

Understanding Object Relationships

Now, we consider how our particular object is different from the real, “true” object; what is the difference, how does our object maintain its relationship to the real thing, and does our object's contiguous memory include a reference to the original object? Why these questions are important arises when thinking about the definition of “instantiated.” Remember, only the data that is necessary for an object of its class is contiguous. If our object is a sub-class of the original, then we have no reason to think our object will have memory which is also contiguous with the original object.

If our object, however, is a “wrapper” around the real thing, or has an aggregate/compositional method of association, then there are things which are contiguous with our object that is data of the original. Regardless of what the case is, there is an insight that comes to mind when you think about the relationship between a class and its subclass. It is common that the subclass has direct access to methods and “hidden” data of its parent class.

In fact, it is reasonable to think that at least once in the inheritance chain between the “true” object and our mind’s version of the object, we are accessing data directly in the parent class of one of the objects in that chain. If it is the case that our minds reference data which is directly in the parent class, it is also exploitable. There are a great deal of scenarios that we can reason about along these lines.

Magick, Mysticism, and Computational Ontology

Something which I must write down—lest I forgot, damned my Soul!—is the relationship between this kind of computational ontology and Magick/Mysticism. A great deal of the things which Magicians do during their practice, especially in Ceremonial Magick and the methods taught by the Hermetic Order of the Golden Dawn, sound an awful lot like these kinds of “exploits” in computer programming.

I will endeavor to fully pen down what I mean on this point, but for now, I think I’ve provided enough effort for someone to see what I mean. One of the first tasks of the Magician is to develop their imagination to its most perfect and complete form. In doing so, they are taught to develop all kinds of “bodies” and “symbols” in their imagination that they can manipulate as if they were physical.

These symbols and images are then later used as a method of “testing” whether something is truly “of the class” that they think it to be—and do not think I am merely confusing the word “class” here! They teach that the symbols are “harmonious” with other things in the Universe, and that bringing them into the internal conscious control of the “Lower Will” allows the Magician to use the symbols to get at and “resonate” with the harmonious portion of those things external to the Magician.

Conclusion

This practice and terminology, when considered from the object-oriented simulation lens I provided, sounds very similar. Perhaps it is beyond my ability to articulate clearly, but I am beginning to see a theory of Magick and Mysticism that is grounded in the theory, technique, and terminology of computer science! Such an insight is fascinating and lends itself in many ways to an understanding and even “spiritual” realization of the role one has in the “Grand Design”. Religions, secret societies, and “sages” from antiquity have spouted such things as “Intelligent Design”, “Harmonious Action”, “Sympathetic Action”, etc., and perhaps I have convinced myself of such things simply by considering how a brain might be nothing more than an amateur’s lab project!