The World as Information: Part 5

Modeling Continuous Phenomena

Now that we have a notation for representing the structure of the world it would be great to get right into modeling complex systems. However this would be like trying to write a useful app in a new language which does not yet have a standard library. We need to first develop some low-level models.

Continuous models

The first few models we will develop have to do with modeling phenomena that are continuous-like. In reality, a true continuum could store an infinite amount of information in a very small space. There is no such thing. As hard as one might try to imagine a true continuum, the plank scale will break it into individual states. For example, suppose we want to represent the position of an electron. We might allocate a 128 bit integer. Or a 128 bit floating point value. But never an infinity bit value. What we need is a way to map states to a system where we do not know how dense the states are, though we do know there are a finite number of states.

Unknown number of states

We have briefly considered the situation where we are making a model and we do not know how many states our system has. An example might be distance. If we want an infon that represents how far an object has moved, in, say meters. Let’s say we reserve 1000 states so it can go up to 1000 meters. Obviously we need more than 1000. But, whatever number we choose to be the maximum, it could go further than that. Basically, we do not know the maximum.

This is easy to solve. Just leave the size of the infon as unknown:

*_ +_

This infon has an unknown size and unknown value.

Unknown step size

There is another problem we need to solve. Suppose we are modeling the rotation state of a bicycle wheel. We might try to model it as an unknown sized number like this:

*_+_

But this doesn't capture that the wheel eventually cycles back to its starting position. Whereas the infon *_+_ can keep growing and it never returns to its starting position.

What about representing that a wheel rotates through 360 degrees. Like this:

*360 +_

Now we have a rotation- because the state 360 is essentially the same as state 0. But in reality wheels have many more states that 360. Depending on the precision with which you can measure the wheel's position there can be quite a large number of states to model. It isn't infinite, of course. There can be only one infinite infon, namely the whole universe; it doesn't work for there to be a sub-infon with infinite size. So we must stick with “unbounded”. Anyhow, at some point the information content of a system is limited by the plank scale.

Here is how we can a represent a bounded number of states (say 360) where the size between steps is unknown:

(  *360 +_  *_+_ )

Recall that the parentheses mean that we combine the two infons inside them into a single infon. If we knew the size of the right most infon (the minor sub-infon) we could calculate the number of states of the whole system. It’s that size * 360. But we do not know it so we must leave the infon in the parenthetical form.

Now we *could* use that parenthetical form to represent cases where we need to model a for-all-practical-purposes continuous value. But the issue is that since we do not know the maximum value of the right hand side we do not know how far along a value is. For example, suppose the following represents the position of a wheel:

( *360 +45 *_+100 )

We know that the wheel it at an angle slightly greater than 45 degrees plus 100 somethings. But how much is 100? Is 100 a lot? We need a way to assert, for example, that the right side is 1/3rd the way through its values. Then, whether there are a trillion states or merely 30, we know that the wheel is at position 45 and 1/3 degrees.

We can get what we need by applying the inverse of the “ * ” operation. First let us assume that we know there are exactly 1000 states in between each degree of angle. In other words:

( *360+_   *1000+_ )

Evaluated, this would become

*360000 +_

And if we want to get the value in degrees we can say: *360000 +_ / 1000

But we need to look at “ / ” in more detail. Let us look at a simpler example:

*12 +7

Recall that one way to divide this is into a 4 state system and a 3 state system like this:

 (*4+2  *3+1)

Therefore, if we divide that 12 state system by 3 states we get *4+2. We can generalize to any value regardless of how many states the system has. So, for values, ignoring the sizes, we get:

7/3 = 2.

We can try that with a 21 state system and get the same answer:

*21+7 = (*7+2  *3+1)

So *21+7 / *3+1 = *7+2.

Looking at the value, we see that 7/3 = 2

Now in our value where 7 degrees is represented by:

( *360+7  *1000+_ )

The evaluated form would be

*360000+7000

7000 / 3 is 2333. Which is a thousand times closer to the value of 7/3 in a continuum.

Given that, we can solve our problem by having a notation that refers to the major value (the 360) and use state division for the minor value.

So if we want to represent that a wheel’s angle is 2 and a half degrees we can use 5/2 which is 2 and a half. Alternatively, the engine will map “2.5” to 5/2.

We have mapped positive rational number notation to states in a way the engine can reason over using substitution of identicals.

Negative numbers mapped to states

What if we want to refer to the last state in a system? For example, in

*256 +_

The last state is 255. Let us also use the notation -1 for the last state. And -2 for the second to last and so on.

In the case of *_+_, the rule that there are at least enough states for whatever we do means that the negative references will never collide with the positive ones. That is, any positive number we use will not be equal to any negative references. This will lend itself to using negative values in the typical ways.

Defining some words

We have specified that, for example, 123.456 or a fraction made by applying the inverse of * represents a value of the form:

( *_+_ *_+_ )

Where the part before the . is the state of the major sub-infon and the part after the . Specifies the fractional value of the minor infon.

Let us define a name for this type of infon. These are rational values so we can use define:

@rat = (*_+_ *_+_)

If we want to define a limit on the number of states of the major sub-infon we can use a notation like:

( *360+_ *_+_ )

Here are have states from 0 to 359 and some fractional part in between the degrees. This would be great to model the angle of a wheel.

Another type that we will use a lot is a value from 0 to 1. Let us call that a “unit”.

@unit = (*2+_  *_+_ )

So now, if we want to represent a value that has a start and an end, and is continuous-like we can asset it:

unit:123.456

Summary

We have reviewed several methods for representing pseudo-continua by mapping states and representations to a finite but unknown number of states. We also mapped the decimal notation to the same. Using the inverses of ‘ * ’ and ‘ + ’ We defined names for two of the new models:

• rat for rational numbers

• unit for values from 0 to 1

Next

In the next part we begin to make models that will help us to use a more natural notation for making models. We will define simple words like: a, the, some, any, and so on. And we will begin to use these to more easily make models.