Registered: Feb 2004
Posts: 172

How do you mix two programs to produce a new one which has the major characteristics of both?
For example, if one program 'grows moss "strings" ' and another program 'shifts left or right' then how difficult is it to combine the two 'effects' to get a program that grows moss strings in a left/right direction instead of straight down? There has to be a way to combine/mix programs simply and efficiently.
(Note: i havent read the book yet.... sorry)

__________________
P h i l i p . R . D u t t o n

Report this post to a moderator | IP: Logged

Registered: Oct 2003
Posts: 38

A point that is emphasized in NKS is that when a rule gives complex behavior, you cannot just look at the rule definition and be able to predict what it is able to do.

There is a tangible seperation between the definition of the rule and the behavior it generates-- and so one cannot in general modify or extend the definition to predictably produce 'extra' complex behavior. Its too difficult of a problem from a computational point of view.

__________________
Everything is an expression.

Report this post to a moderator | IP: Logged

Registered: Aug 2003
Posts: 712

You can sometimes rule out combinations of behaviors in the same rule. For instance, close analysis may show that a certain structure can only form when receiving information from two sides. Which a stationary structure may be able to do, or one moving slowly enough that there are multiple possible speeds that can "hit it" within the "light speed" limit of the rule.

But a structure that forms at a pattern edge, part of the pattern moving as fast as information can in that rule, can't receive "outside" information, because it can't be "caught" by slower moving structures. It might send off streaks or whatever into some other structure below itself, of course. But you can rule out influencing it with anything else.

It is a general point, incidentally, that rules that allow structures that move at a variety of speeds are capable of more control over those interactions. You can use "from above" and "from below" - or "from the right" and "from the left" - successive "inputs" to manipulate what a main structure does.

If you analyse how the structure initially forms you might sometimes be able to find a different rule that produces a shifted version of it, in a roughly similar way. Kovas is right that there isn't a single general procedure for doing this. You'd have to get into the details. You can also just search through a large space of similar rules and look for something promising.

Report this post to a moderator | IP: Logged

Registered: Feb 2004
Posts: 172

Assuming the following:
-I sat down to find simple programs which could describe the physics of the universe.
-I found several hundred which modelled a variety of the physics.
-Other people soon found many more.
-Eventually there are thousands of simple programs.

THEN:
If they are simple then most likely they do not have the built in mechanical operations required for them to interact with other
programs (because that means added complexity).

THEREFORE:
If the simple programs are the building blocks then what holds them together and what takes the 'wind' program and combines it with the 'gravity' program to in turn create the 'falling leaf' scenario?

I wish there were simple operator programs wich operated on one or more simple programs.

__________________
P h i l i p . R . D u t t o n

Report this post to a moderator | IP: Logged

Registered: Feb 2004
Posts: 172

(re-statement of my original thoughts)

I just saw the site about the simple program atlas. This is kind of what I am talking about: we have this new collection of simple programs (instead of equations) for which we model physical phenoms...

So now I still do not understand how these simple programs interact or affect themselves (or overlay) with each other.

In mathematics we can create new equations from others by substitution, addition, and other operators.... well what of the simple programs?

__________________
P h i l i p . R . D u t t o n

Report this post to a moderator | IP: Logged

Registered: Oct 2003
Posts: 38

One can make more complicated systems by connected various simple systems, but an important point that NKS makes is that such engineering is often not needed.

To answer your most direct question about how we expect the universe to work, it goes like this: if we find a fundamental theory, then it literally represents the operation of the universe in the finest detail. Yet within the fundamental theory, there will be pieces the universe's evolution that themselves can have theories developed about them.

One can notice that two structures have some complex interaction, for instance - and instead of representing that interaction in the very detailed language of the fundamental model, one can develop a higher level abstraction that only considers the things that actually make a difference.

These higher-level models are somewhat less literal however. They only abstractly represent some aspect of the physical situation you are interested in. And they perhaps represent our understanding of the situation more than actual bits moving around.

And so one does not need to have all of these thousands of programs literally interacting with one another in an input-output type setup. I think of the fundamental theory providing this rich soup of computational interaction, and when we look at it in different ways and are interested in different things, we can see different kinds of programs being born and destroyed within it.

__________________
Everything is an expression.

Report this post to a moderator | IP: Logged

Registered: Jan 2004
Posts: 350

Here is an interesting pair of cellular automata. The first has as rule modulo 3 product. The second has a manipulation of the first rule consisting of a change to two digits in the digit expansion of the rule.

The result accounts for a very clear difference between the two cellular automata. I found this relationship by a process similar to the one mentioned by Jason Cawley in his post where he says:

“If you analyse how the structure initially forms you might sometimes be able to find a different rule that produces a shifted version of it, in a roughly similar way.”

This isn’t a shifted version so much as an augmented version.

Rule 142: modulo 3 product has this digit expansion:

IntegerDigits[142, 3, 9] == {0, 0, 0, 0, 1, 2, 0, 2, 1}.


This is the modification:

FromDigits[{0, 0, 1, 0, 1, 2, 1, 2, 1}, 3] == 880.

Lawrence J. Thaden has attached this image:

__________________
L. J. Thaden

Report this post to a moderator | IP: Logged

Registered: Jan 2004
Posts: 350

The modification is attached.

Lawrence J. Thaden has attached this image:

__________________
L. J. Thaden

Report this post to a moderator | IP: Logged

Registered: Oct 2003
Posts: 103

At the NKS summer school 2003, I gave a lecture on different ways to combine and perturb rules. As Lawrence points out, it is interesting to see what happens to a nested rule, like from modular arithmetic, and change one condition. Attached are the nontrivial cases for mod 3. Some are drastic and some not so drastic.

To put this in context of this thread, the idea of perturbing programs is a possible way for larger systems to interact based on simple programs.

The idea of crossing programs is fairly important, and several of the student projects had something to do with putting together simple programs, for instance Michael Schreiber's project.

Kovas is right that there are many ways to do put together programs, and that there is no general way to do so. But it is a legitimate way to try find good models, and so should be investigated from a pure NKS point of view.

As a rough outline of how to proceed, one would first want to decide how the combined rules will fit into the larger system. Is rule X strictly contained in the larger rule, or does the rule X behavior fall out as an interpretation of the combined rule? Even after making this choice, there are many ways to proceed.

If one is familiar with algebra (or category theory), this question is analogous to whether X->Y or Y->X, where Y is the larger system. Or more concretely, let X be mod 2 arithmetic and Y be mod 4 arithmetic. Then in the first scenario {0->0,1->2} is a map X->Y, where X is in Y. In the second scenario x->Mod[x,2] is a map Y->X, where the X behavior is interpreted from Y.

Given two algebraic rules X1 and X2, one can combine them using an algebraic extension X1->Y->X2. Doing this in the nontrivial way using X1==mod 3 and X2== mod 2, produces Y=S3, and this was investigated in the thread Cellular automata based on groups.

Todd Rowland has attached this image:

Report this post to a moderator | IP: Logged