Welcome to Part 2 of our journey to know how to represent the World in all its complexity by describing the information structure of state systems. To do this we will talk about a low-level component of structured information that can be combined with other ones using operations related to multiplication and addition. We will be able to combine these or take them apart in order to construct models of simple or complex systems. In advanced mathematics there is a similar concept called Group Theory. The name Group is only vaguely related to the regular meaning of the word. There are groups that represent every possible structure that doesn't lose information. For example, numbers can be defined as a group. There is also a group that mirrors the structure of a Rubix Cube. Groups cannot do what we need here. For one thing, groups can describe the possible states of something and how they might change, but they do not represent what state a system is in. It is like saying what a Rubix Cube is but not being able to tell what state a particular cube is in. Also, the Rubix Cube group says nothing about a 6 sided cube where, when solved, each side is a different color. But perhaps the most important issue is that it is very awkward to combine a bunch of groups to make something really complex. It is too hard to represent something like an automobile with group theory. And forget representing something like democracy or a real legal system. In future parts of this series we will describe a rubix cube and how it changes, including that it can be taken apart. It will have colors and be a cube. In fact, there will be enough detail that the software can draw it.
This is my favorite of the articles as it provides the foundation for all that is to come. However, it is also the most abstract. So while this does provide the basis for the rest of the series, none of the other articles require an understanding of this one. The advantage of understanding this article is that most of what is to come will not seem like it is pulled out of a hat. In the other articles of the series I give little justification for why something is done a certain way — I just present it. If you are comfortable with that then this article can be skipped.
This chapter gives names and notation to things anyone who has programmed a computer likely knows intuitively. So, for example, I’m not going to formally define information or mention Claude Shannon.
Our foundational components are actually just pieces of information. Indeed, we will be talking at length about pieces of information. Without a word for a piece of information it will be cumbersome. So I follow the mathematician Keith Devlin in using the term infon to mean a “piece of information”. The term does not imply any magic or that information is a type of particle. It's just a short hand for “piece of information”
Infons have a size and a value. For example we might have an infon of 256 states and it is in state 200. The size is 256 and the value is 200. Let us notate infons like this:
*256 +200So in general we write:
*<size> +<value>If we do not know the value or size we can write an underscore (‘_’). So
*_ +20is an infon with at least 21 states and it is in state 20. (Assuming we label the states numerically starting at 0)
Likewise,
*256 +_represents an infon with 256 states but the state is not known here. Note that ‘_’ does not mean ‘void’ or ‘null’ the way a database or programming language might use those terms. It means that there is a value, it just isn’t given here. We can say it is unknown.
This notation using * and + will be useful shortly.
Infons are immutable. So for example, one’s age cannot be a simple infon because age can change as time progresses. But one’s age on a specific date is a simple infon.
If we have two infons, let’s call them A and B, they are possibly the same piece of information. In programming, A and B could be from two pointers of the same type pointing to the same address in memory. Or it could be that one is a copy of the other. Or perhaps they were both copied from some third infon. However it happened, we say that A and B are identical and we can write that like A = B. To be pedantic, let’s have it mean that A and B are the same size and not scrambled in some way. It could be that only parts of A are identical to parts of B or that A is a sub-infon of B. In those cases A != B.
It is important to note that for infons, equality does not imply identity. For example, if I am asked for my shoe size and I give a number, and I’m asked how many miles I biked today, and I give a number, it is possible that the two numbers I gave were both 9. But though they are equal they are not the same piece of information.
For the purpose of making inferences, if two infons are identical, you can substitute one for the other and there won't be a logical difference. Substitution of identicals is the primary way of making inferences here.
Incidentally, one could use infons to define equals, if, for example, there is a need to be compatible with regular math with numbers.
In academic papers we do not usually mention how and why we used a certain technique. But this is not really academic and I believe that knowing some context about why it is done a certain way will help with understanding. When I was in college I was trying to create a computer notation that could be used to store knowledge in a way that software could use it. I wanted it to be complete. After I realized that what I was modeling was information I started making progress. Early attempts were similar to the JSON + expressions + time system that I discussed in the previous article. But nothing worked for everything. Some attempts could represent objects but not abstract entities or the class system couldn’t handle time changes or it could not express mathematical concepts. After dozens of attempts some quick calculations showed that there were millions of possibilities and that trying them one at a time would not work. After several months I came up with a methodology that I hoped would direct me to the correct solution. Shockingly, it worked. It produced a theory that solved all the problems I was having. I use the method to this day to solve theory problems. Here is how it works:
First, assume that we have a system with some number of states. I usually imagine a system with 12 states. We suppose that this system is isolated, nothing external to it affects it. Now we can ask a question we have. Perhaps we ask how it can be divided into sub-states or if combining two parts must be associative or commutative. The rule is that nothing can cause there to be more than 12 states, because that violates our assumption that we have 12 states.
Let’s look at an example. Consider that we isolate 12 (or some number) states in some system. These are states that are not affected in the instant by external things. Now suppose we do the same with a different system — we isolate 12 states. If these two 12 state systems are different from each other then that means there can be two different kinds of isolated 12 state system. Thus we would be able to talk about the kind of 12 states that come from the first system vs. the kind that comes from the second one. But if there are two different kinds then we could use what kind to store a new bit of information: 0 if type A and 1 if type B. So we would be able to store 24 states in a 12 state system. So we conclude by “stays the same size” that for completely isolated systems, all 12 state systems work the same way. Obviously we can generalize that for any whole number n, all isolated n state systems work the same way.
You may be surprised that the “stays the same size” method works. But it is actually very restrictive. As far as I can tell (and it’s just a conjecture), there is only 1 way that a system following the rule can work.
If you think about programming, we get Turing completeness with just conditionals (if’s), repetitions (loops), assignment (A = B), sequences of actions and functions. But the only one of these that really does something is assignment. The others all establish patterns of assignments but the assignments are what really does something. A cute way of thinking about this is that the assembly instruction MOV (which does assignment) can be Turing complete. See MOV is Turing complete.
So we can think of asserting that two infons are identical as a declarative way of representing assignment.
We have already given that two infons have a certain relationship to each other. Namely, that they are either identical or not identical. As we shall see, Identities among an infon’s sub-parts can be used to fully describe what state it is in. If there is another relation that could be used to describe infons, it cannot carry more information than that stored in the Identities; otherwise we could use that relation to store more information in the system than it holds. For example, soon we will see that Identities among an infon’s sub-parts can tell you what state it is in. If we could also say that two of the sub-parts have some other relationship to each other — a relationship that doesn't reduce to Identities — then we could use that to store more information. So for isolated infons, we discuss only relations that are Identity or map to patterns of identity.
Here are the main point of this section:
Infons are immutable pieces of information. They have a size that can be measured as the number of states. And they have a value which is what state they are in.
A notation for infons is such that *256+123 means an infon with 256 states that is in a state labeled 123.
Infons can have sub-infons
The properties of an infon, for example what state it is in, can be fully spelled out in terms of Identity relations or patterns of identity relations among sub-parts.
To validly process information, for example, to make inferences, substitution of identicals or patterns of substitutions is the foundational operation.
In this chapter we go over some standard theory of how infons can divide into sub-infons. We also add some notation that will be useful and lastly we discuss a problem that motivates the next chapter.
Obviously, infons can have sub-infons. But let us walk through it because we are going to push on the concepts a little so it will be good to have it fresh in your head.
An example of dividing an infon into sub-infons is dividing a 32 bit word of computer memory into 4 bytes. Or dividing a byte into 8 bits.
The size of an infon can be measured in states. So the size must be an integer greater than 0. So there are not many combinations of how infons can be divided. The rule is:
Multiplying the sizes of the sub-parts must result in the size of the whole.
This is review so I’m just going to give an example instead of a wall of text.
How would we get the sub-infons of a 12 state system?
First we get the factors or 12: 1, 2, 3, 4, 6, 12.
Then for each factor, we can pair it with an infon that will make the total size multiply to 12. Here are the possible combinations for dividing a 12 state infon:
1 state x 12 states
2 states x 6 states
3 states x 4 states
4 states x 3 states
6 states x 2 states
12 states x 1 state
NOTE: Obviously 6 and 4 state infons can be further divided but we aren’t concerned with that here.
We need to set the values of the sub-parts correctly so that they line up with the parent infon. Continuing with examples instead of a wall of math text, what would the values be when we divide it into 3 x 4? What about 4 x 3?
Values for 3 x 4
Think of this as an odometer with a 3-state wheel and a 4 state wheel. Or like a number where each digit is in a different base: base 3 for one, base 4 for the other.
So to divide *12 + 5 into 3 and 4 state infons, the 3 state needs to be *3+1 and the 4 state infon needs to be *4+1.
If we instead divided *12 + 5 into 4 x 3, we would have *4+1 and *3+2.
This illustrates that what order the sub-parts are in matters. That’s cool because it means we have a list like structure. Or, as will be described in future articles, in a temporal context this list can describe a sequence of events. Let us add this to our notation.
We looked at how *12+5 could be divided into *4+1 and *3+2.
Let us write that like this
{ *4+1 *3+2 }We can easily calculate what the combined infon would be. Assume we start with 0. Then do the arithmetic operations from right to left:
To get the value of the whole:
0 * 4 = 0
0 + 1 = 1
1 * 3 = 3
3 + 2 = 5
So 5 is the value. The size is 4 * 3 = 12
So { *4+1 *3+2 } == *12 +5If we want to combine the parts into a whole we use ( ) instead of { }
So ( *4+1 *3+2) evaluates to *12+5
We can put as many components in the brackets or parentheses as we need.
If we only concatenate one item it is just itself. That means we can also use ( ) in the traditional way to control the order of evaluation.
The main points of this chapter are:
Infons can be divided into sub-infons as long as the product of the sub-infon sizes is the same as the size of the parent infon. The values of the sub-infons can be determined with division and modulus.
The ordering of the sub-infons matters. Different arrangements imply different values for the sub-infons.
We can use that fact to define lists or sequences by listing the sub-parts in { }.
We can find the value of the whole infon by applying the * and + operations from right to left across the list.
Where { } are used to access the sub-parts of an infon, the inverse of that, concatenation, can be notated by giving the parts to be combined in ( ).
With no extra work, that means ( ) can also be used, in the traditional way, to control the order of evaluation.
If infons did not have identity then we would be done. But since they do have identity there are valid questions that we cannot yet answer. For example, consider *12+5 again. Let us divide it in two different ways, like this:
*12+5 == {*4+1 *3+2}
*12+5 == {*6+2 *2+1}Now we if take, for example, the left most items from both lists how do they overlap?
We can know they overlap because since the whole system is in state 5, then, given the *4+1 component what possibilities are there for the *6+2 component? In fact, given any three of the four components on the left side, we would be able to fully reconstruct the missing one. So how do we characterize the overlap?
Some information from *4+1 is identical to some information in *6+2. This is important because the algorithm for processing infons involves substitution of identicals. If there are some identicals that we do not know then there are inferences we cannot make. In particular some Diophantine inferences cannot be made as easily.
We need a different way of breaking infons into parts if we want to untangle the overlapping infon.
Namely, we need to be able to reference individual states.
A single state can be written:
*1+0Single states do not carry information.
1 state = 0 bits informationA non-programming example of a single state is when Henry Ford stated that customers can have any color car that want as long as it is black. In programming, the NULL type is a single state type. It could also be an enum with only one item.
So could we write *12+5 like this?
{*1+0 *1+0 *1+0 *1+0 *1+0 *1+0 *1+0 *1+0 *1+0 *1+0 *1+0 *1+0 }The problem is, how would we know that it is in state 5? All the states will look the same. If you calculate it out it the result is always 0. We know that the items in the list have an ordering. But with all the states being the same value (though not the same identity), how could we tell what order the items are in?
The solution is to compare it to another infon that has the same states though perhaps in a different order. This “reference infon” or “observing infon” is held to be “in order”. The way that it’s individual states map to the non-reference infon defines its value.
Most of the time we do not have to think about reference infons. And doing so may seem complex or odd but it actually makes sense. If an isolated, fundamental infon could store a state absolutely then it would be an object not an infon. Information does not have any absolute interpretation. Instead, for isolated infons, their state is relative to a reference copy.
OK, let’s go through how it works.
This chapter is the result of decades of work trying to reconcile information theory, number theory and some mathematics called group theory. At some point I became unable to easily access academic journals and anyhow it can take me weeks to fully understand an article written in math-speak. So it is quite possible that someone has done this before me. If so, I humbly acknowledge that. For me, the goal of having a better understanding of reality is more important than getting acknowledgement. Also, I have written this in full-on math-speak which more formally reduces all this to the “stays the same size” rule. But the audience for that has very little overlap with who I’d like to share it with which is curious people who want to make the world better — like myself. I have also written it in code. Feel free to request it.
As mentioned above, in order to describe an infon in terms of individual states we must compare it to a reference infon that we assume is “in order” and has the same (identical) states as the infon we want to describe, though it may not be in the same order. An example will help. Let’s go with 6-state infons for now. If we draw the states as squares all in a row then an infon compared to a reference infon will look something like this:
The arrows mean “is identical to”.
The next step is to determine how an infon’s states can be mapped to the reference infon in a way that only allows 6 (or n) states.
Suppose any mapping at all is allowed. Then our 6 state infon could store 6 factorial states or 720, violating “stays the same size”. The fact is that if we want to pass that rule and also maintain the structure described above, where infons can divide into sub-infons, there is only one way to do it. In group theory such mappings are called endomorphisms. The pattern of arrows for making endomorphisms is simple but explaining it in words requires a wall of text. Instead let us look at some examples.
Let us look at all 6 states of a 6 state infon. We will start with *6+5 because it is pretty simple.
Here we have labeled the states from 0 to 5. To get the pattern of arrows, we start iterating the top infon from left to right, that is from 0 to 5. But for the reference infon we iterate counting by 5 steps. (or n steps for state n). So we start, as always, by setting state 0 of the top one to state 0 of the reference. When we get to the end of the reference states we wrap around. In other words we iterate modulus 6 where 6 is the number of states. So we map 1 of the top to 5 on the reference. Then 2 goes to 4, 3 to 3, 4 to 2 and 5 to 1. Each time we counted 5 steps. We end up getting all 6 states mapped this way.
Now we look at *6+4. Here we will not get all the states mapped so we will have to do an extra step.
We start, as always, mapping 0 to 0. Then we move forward by 1 on the top infon and 4 on the reference. So state 1 points to state 4 of the reference. Counting 4 more steps, we map state 2 of the top to state 2 of the reference. When we count 4 more steps we find that we are back to where we started at state 0. When this happens, we go forward by one step of the reference. Since we moved forward to avoid a loop I changed the color of the squares to green so that we can see the pattern. Continuing then, we map 3 to 1, 4 to 5 and 5 to 3. Now we have mapped all the states. The 3 red squares are a “coset” and the green ones are another coset.
So the new rule is that when we return to a state we have already mapped, if there are still more states to map, then we move forward by one cell on the reference. This makes a new coset. All the cosets will be the same size.
Now we apply this to *6+3:
Working though the pattern, we see that there are 3 cosets in *6+3.
*6+2 is similar to *6+4. You can tell what state an infon is in by looking at how many steps are taken in the reference when going from 0 to 1 on the top.
The last two, *6+1 and *6+0 look similar but there is an important difference.
For *6+1 we have a single coset where each state maps to the corresponding state of the reference. For *6+0 each state is it’s own coset. That is because when we “move forward by zero steps” we land on the starting state and thus have to start a new coset and move up 1 cell in the reference.
Cosets in an infon all contain the same information — they are identical infons.
Now you can make the identities for any isolated infon. Next we need to find their sub-parts among the states. We will stick to lists with only two items but the process can be repeated to get lists of any size.
For this let us use 12 state infons so that we have more examples to study.
Here is a 12 state infon in state 8:
We want to divide it up. We can divide it into chunks of size 2 and 6, 3 and 4, 4 and 3, 6 and 2. We can also divide it into 1 and 12 or 12 and 1 but we ignore those for now. Here are the non-trivial possible ways we can divide it:
1. *12+8 = {*2+1 *6+2}
2. *12+8 = {*3+2 *4+0}
3. *12+8 = {*4+2 *3+2}
4. *12+8 = {*6+4 *2+0}Let us divide it into a 3-infon and a 4-infon as in choice #2.
First we find the 3-infon component. For this we simply take the first 3 states and discard the others.
Re-aligning and relabeling the selected states we get *3+2:
Now we find the 4-infon component by selecting every 3rd item. Every third because we want 4 states and 12 / 4 = 3.
Re-aligning and relabeling the selected states we get *4+0:
There we go: *12+8 = {*3+2 *4+0}
Let us try it with the 4-infon and the 3-infon swapped. This will illustrate the full rules for doing this because of an anomaly.
First we get the 4-infon by selecting the first 4 states:
Notice that the last item is from a new coset in a way that breaks the pattern. This cannot happen with the quotients but it can with the divisor. All we do is move the last state to the end. So we have *4+2:
Lastly we get the 3-infon by selecting every 4th state (12/3):
Which reorganizes to *3+2:
This method of decomposing infons works for any isolated infon. It doesn’t matter if the size or value of any part or of the whole is prime or not.
By looking at the decompositions of a 12 state infon that we just went over, notice that there were two different components that were *3+2. But they are not identical because they are comprised of different states.
The primary algorithm for doing anything with infons is substitution of identicals. So it is important to know all the identicals implied in an infon. In this chapter we went over the main identity assertions that define an infon’s state. There are others as well. Namely, the various cosets hold the same information.
In the articles to come, we develop this into a complete system for representing reality. We will be able to represent extremely complex systems and concepts including natural languages. Remember, if you did not completely understand this article you will still be able to understand what is to come. I hope to see you there!
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.