**DISCLAIMERS: I've since thought this idea is stupid, another manic tangent. I'll cease following it. I mean, I realized I was basically creating a useless model again with no discernable use. Still had fun creating it though.**

So I've updated my theory of observation, and I'm entering phenomenology and all these sorts of weird things. It gets very annoying.

Four Axioms

Axiom 1. There exists that which is, hereby called an image.


Image can take to mean phenomena, existence, sense. I use image here as it's easier to visualize. Images exist solely within the present, and when we conceptualize streams of images we'll use {I} to denote presence when needed.

Axiom 2. There can exist multiple images.

I | I

Axiom 3. There can exist difference so that an image of what is can be contrasted with that which it is not.

I1 | I2

Axiom 2 <=> Axiom 3. You can not show multiple images without differences in between them, otherwise it would be homogeneous and thus not a plurality but a singularity. Likewise you can't show difference, without multiple images. Thus they both entail each other.

Axiom 4. Change is the process by which an image turns from that which it is to that which it isn't.

I1 becomes I2



In order to have a stream of information, we need to compare past images with the present one, but be careful because the words are tricky as past images by their nature are present when we think about them. Thus we need to create a process of comparison between past images and present images during an occurrence of being.

Definition. Comparison is the process by which one can increment between two images.

There are only two ways an image can be compared during an occurrence of being. An image is either congruent (the same), or incongruent (different). This is because value does not exist yet in this theory, we only have two things: that which it is and that which it is not. This itself does not do enough to create value.

Corollary. There exists recurrence such that one image is turned to that which it is not, and that which it is not is turned to that which it is. (A1 & A2 & A3 & A4)

We'll need a process by which to display a stream:

A stream for image I, denoted by S(I)

S(I): 1 0 0 0 1 1 0 1 1 1 1 0 1 0 0 1

Read from left to right, change occurs so that

S(I): {1} 0 0 0 1 1 0 1 1 1 1 0 1 0 0 1


S()I: 1 {0} 0 0 1 1 0 1 1 1 1 0 1 0 0 1

This is going to be a pain in the ass to format clearly, but you get the image, this is how we'll write change. When we compare streams with each other however, we forego {}. Now, by nature there have to be three things for something to change, illustrated by the sentence, "at A, compare B to C".

To understand why, we have to understand what time or change is. We can not truly determine change that occurs within a single image stream:


Because without another image to mark the differences of occurrences between them, it may as well be simplified to this:


However, if we introduce a recurrent stream, then there can exist a measure of change such that each increment of image R1 is used to determine the increment at I2

S(R1): 101010101010101010

S(I1): 100101000010001000

An image that determines the increment of another image is called R.

All comparisons require an R to occur first, so that when we're comparing I1 with I2, we don't have this:



turn to this:



This is the reason why it can be thought of as "At A, compare B to C", because it requires a measure of time to exist.

In the end, what we have when comparing to increments is this:

S(R1): 10101010

S(I1): 11010001

S(I2): 10100010

However, we can not compare unless we know when to compare. Do we compare per change? If we did, we'll have to increment the increment to represent the change, and increment that increment, leading to an infinitely large collection of images. A comparison can only occur at a specific instance of being, and so we can compare at either 1 or 0.

If we compare at 1, our images will become during a comparison:

S(I1): 1000

S(I2): 1101

This is what we will take to mean during a comparison. When we actually do a comparison, we'll ignore the R entirely and assume it's at 1. It's only a problem if we get further into theorizing comparisons and time, but as it is, in this section we only care about the process of comparison.

There is also another tangent, how do we know when to compare at 1, if we do not compare between R1 and the images? This is a question for another time.

When two images are compared, they need a third image to know the value of that comparison. This leads to the idea that finding an increment requires a third image once that increment is found. So we can create the syntax for every comparison as

A <= B|C


B|C => A

We can of course have self referencing comparisons.

B <= B|C

We can also compare multiple images.

A <= B|C|D|E|F|G

The fact that there can exist an image that requires the value of another image to exist creates a distinction between types of images. There are external images: images whose change is determined by god, and internal images whose change or state of being is determined by other images.