Disclaimers

This is a stub. I am having exams right now and do not have the time to write the full article. I'll update (not any time soon) after I've resolved the problems in this article.

The original post was supposed to be part of my "Meditations in Ontology" sequence (I planned on starting the sequence next year at earliest, probably later). I'll probably write a few other stubs to address the recent discussion about existence and truth.

I have learned neither computability theory nor information theory; if I make a mistake somewhere, please correct me.

There has been recent discussion about what it means to "exist". I realised that I have an answer to that question, and decided to briefly explain it here.

Useful Concepts

Object

For the purposes of this post it is sufficient to understand an object as "anything".

Structural Equivalence

Two systems are structurally equivalent if they are composed of the same components.

Functional Equivalence

Two systems are functionally equivalent if they have the same domain, the same range and the same image for all inputs.

Two structurally equivalent systems are functionally equivalent, yet two systems can be functionally equivalent and structurally similar. Sometimes, the semantic content of a concept refers to its function (e.g a clock). At other times, the semantic content might refer to its structure (e.g an atom). Yet still, some concepts may be defined according to both form and structure (e.g a gold watch).

Simulation

When we say that one object $X$ simulates another object $Y$, we say that $X$ (or a specific output of $X$ (if $X$ is a computational system) is a perfect fidelity model of $Y$. That is, in all ontologies $X$ (or said output of $X$) and $Y$ are indistinguishable and interchangeable.

A Note on Computation

The output of a computation has no inherent meaning. There is no global semantic content to the output of a given computation. When I run a program, the stream of binary code sent to the output devices have no meaning. Only after they have passed the output device, and have been translated from binary to a language I understand, can I "read" the information therein. If I thought in binary, perhaps my monitor would just display the binary stream directly.

Observer

For a given computational process, the semantic content of the output is defined relative to an observer that would read that output and gain information from it. The output may need to be interpreted to the observer.

An observer is an agent who "reads" (an interpretation of) the output of a computation and extracts information from it.

It is important to note that the observer of a computation is external to that computation. Whatever observes a simulation is not itself inside the simulation (it maybe represented in the simulation, but it is not part of the simulation itself).

Furthermore, it should be noted that there is a set of correct interpretations for each output given and observer pair. Whenever we say "interpretation", we refer to a member of this set.

For a given output, we might imagine how different agents may understand the output of it was interpreted into their language.

Let $A^{\ast }$ be the set of all agents.

$\alpha \in A^{\ast }$.

$\alpha .\text{interpret}\left(V\right)$ is the meaning of V to α. The domain of "$\text{interpret}\left(\right)$" is the set of all objects.

Computational Simulation

According to our definition of simulation, a computational system $X$ simulates an object $Y$ if a given output of $X$ is a perfect fidelity model of $Y$.

$X\left(j\right)$ is a given output of $X$. Let $y$ be the input to $X$ such that $X$ simulates $Y$.

Local Simulation

$X$ locally simulates $Y$ for $\alpha$ if and only if $\alpha .\text{interpret}\left(X\right(y\left)\right)=\alpha .\text{interpret}\left(Y\right)$.

That is $X\left(y\right)$ has the same meaning as $Y$ to $\alpha$.

Global Simulation

$X$ globally simulates $Y$ (or just "$X$ simulates $Y$") if and only if $\forall \alpha \in A^{\ast },\alpha .\text{interpret}\left(X\right(y\left)\right)=\alpha .\text{interpret}\left(Y\right)$

That is $X\left(y\right)$ has the same meaning as $Y$ to all agents.

The output of $X$ becomes the input to the $\text{interpret}\left(\right)$ program which then translates $X\left(y\right)$ into whatever language the agent uses and them "runs" it on the agent's own processor.

Information Theoretic Ontology

Axiom of Computability

The universe is computable. This means that it is possible to simulate this universe on an infinite state universal Turing machine with unbounded processing power. This simulation does not need to be physically realisable, and only needs to be logically realisable. We shall refer to this Turing machine which simulates the Universe as the God Turing machine (abbreviated $\text{God}\left(TM\right)$).

$\text{God}\left(TM\right)$ is capable of simulating every other Turing machine. As for whether $\text{God}\left(TM\right)$ can simulate itself, I think it should be able to. If it is possible without breaking the Turing machine model, $\text{God}\left(TM\right)$ can simulate itself. If it's not, I'll fix that when I'm stronger.

From this axiom, we shall concern ourselves only with computable (not necessarily physically so—if physical infeasibility is the only reason why something cannot be computed, then it is computable) ontologies.

If we accept the above axiom, then some interesting results follow. Two Turing machines may run programs that are structurally dissimilar (different binary representations), but functionally equivalent. As the programs are functionally equivalent, the Turing machines are for all intents and purposes running the same program.

Information content

The Kolmogorov complexity of an object is the length of the shortest program that would produce that object is output.

The information content of an object is that shortest program that produces the object and output.

We shall denote the information content of an object $X$ as $C_V\left(X\right)$. The Kolmogorov complexity of $X\left(K_V\right(X\left)\right)=|C_V\left(X\right)$|.

Where:

'$V$' represents the reference Turing machine (we shall denote $\text{God}\left(TM\right)$ using '$G$').

$|X|$ represents the length of $X$.

Equivalence Class

For a given object $X$, and a given Turing machine $V$, the $V$-program-equivalence class of $X$ is the set of all programs which when run on $V$ produce $X$ as output, this is denoted $E_P^V\left(X\right)$.

Minimal Equivalence Class

For a given program-equivalence class $E_P^V\left(X\right)$ of a given object $X$, the minimal program-equivalence class of $X$ (denoted $M_P^V\left(X\right)$) is the set of all programs in $E_P^V\left(X\right)$ such that there does not exist another program in $E_P^V\left(X\right)$ with length shorter than that program.

Where:

$p_i,p_j$ represent arbitrary programs,

$|p_k|$ is the binary length of $p_k$.

Axiom of Information Equivalence

For any two objects $X$ and $Y$ $\left(C_V\right(X)=C_V(Y\left)\right)⟹X\underset{V}{\equiv }Y$.

'$\underset{V}{\equiv }$' means that in $V\left(TM\right)$ (and any ontology $V$ simulates), $X$ and $Y$ are the same object.

Constraint of Consistency

For a given object $X$, there may exist more than one shortest program ($|M_P\left(X\right)|>1$. Any of these programs in $M_P\left(X\right)$ may be selected as the information content of that object, as long as they satisfy the constraint of consistency:

In English:

If there exists two objects X and Y for whom the set of programs that produce each of them are equal, and more than one program has length that is minimum in specified set, then the information content of the object can be any such program in the set, and the information content of Y would be the same as the information content of X.

Is

Existence

There are two senses in which an object can exist.

1. An object exists in a given model.
2. An object exists in reality.

Let a given output of $V\left(TM\right)$ on input $j$ be denoted $V\left(j\right)$. Let $j$ be the input to $V$ such that the output of $V$ is some model $M$.

Let $q$ be the input to $\text{God}\left(TM\right)$ such that it simulates reality.

Then to answer the above questions:

1. $X$ exists in $M$ if and only if $C_V\left(X\right)$ is a substring of $V\left(J\right)$.
2. $X$ exists in reality if and only if $C_G\left(X\right)$ is a substring of $G\left(q\right)$.

It is possible for two different programs to have the same binary code if they are interpreted differently. This, it is important to specify that all Turing machines we are concerned with each use only one language in their operations.

It is possible to expand this to denote what it means to exist at a particular location (time, space, etc) but I don't know physics, so I don't know how $\text{God}\left(TM\right)$ would represent that.

Problems/Issues

1. Is the universe computable? If the axiom of computability is false, then the ontology is useless.
2. Can the $\text{God}\left(TM\right)$ simulate itself? The relevance of this may not be apparent now, but the answer to this question is relevant to the rest of my ontology.
3. How do we define existing at a particular location? A notion of existence such that $X$ exists if it existed in the distant past is not what we want is it?

Author's Note

This is a stub of the full article (a task I'm far from being able to undertake yet). However, I resolved some non-trivial problems using this ontology, so I feel this is a very handful paintbrush to have.

I don't want to end up making this too long to be a stub, but too short/not rigorous enough to be the full article. Given that I can't write the full article yet, I tried to make the post as short as possible. The focus on brevity (of necessity) sacrificed pedagogical value, and thus a lot of heavy lifting in grokking this is done by my understanding of the concepts.

I'll provide examples, clarifications, deeper explanations, etc in the comments as needed. I'll do my best to address any points you make. However, as I'm currently writing exams, I'm not sure how quickly I would be able to respond.