Is there a pattern to how the system responds to its own
incompleteness? You say that there is not a pattern to the traces, but
what do you mean by that?

It sounds to me like what you are describing is some version of an
inconsistent set theory that is somehow trying to repair itself.
(Except rather then sets, which are 2-fold distinctions because a
thing can either be a member or not, you are admitting arbitrary
N-fold distinctions, including 1-fold distinctions that fail to
distinguish anything... conceptually interesting, I must admit.)

So the question is, what is the process by which the system attempts
to repair itself?

Here is one option:

The system starts with all its axioms (a possibly infinite set). It
starts making inferences (possibly with infinitistic methods),
splitting when it runs into an inconsistency; the (possibly infinite)
split rejects facts that could have led to the inconsistency.

So, the process makes increasingly consistent versions of the set
theory. Some will end up consistent eventually, and so will stop
splitting. These may be boring (having rejected most of the axioms) or
interesting. Some of the interesting ones will be UDs.

The entire process may or may not amount to more than a UD, depending
on whether we use infinities in the basic setup. You did in your post,
and it seems likely, since set theory is not finitely axiomizable and
your system is an extension of set theory. On the other hand, there
would be some fairly satisfying axiomizations, in particular those
based on naive set theory. This does have an infinite number of
axioms, but in the form of an axiom schema, which can be characterized
easily by finite deduction rules. So, your system could easily be
crafted to be either a UD or more-than-UD, depending on personal
preference. (That is, if my interpretation has not strayed too far
from your intention.)


On Sat, Dec 27, 2008 at 11:38 AM, Hal Ruhl <halr...@alum.syracuse.edu> wrote:
> Hi Bruno:
> Since I have not programmed computers beyond the use of simple spread sheet
> data organizing displays for many years, about the best I can offer these
> days is a kind of flow chart:
> Start with an input space that contains all possible collections of
> distinctions. I call these collections Divisors.  [I wish to avoid the use
> of the word "information".]
> It is then noted that this collection contains itself.
> Next it is noted that at least one of these Divisors is incomplete in a way
> that must be resolved.  This boot straps a dynamic within the input space.
> To avoid adding additional types of components to the input space such as
> labels on divisors it is simplest to describe the dynamic as creating a
> succession of additional copies of divisors and adding them to the input
> space. Since any divisor is already present an infinite number of times,
> this dynamic is not changing the nature of the content of the input space.
> So far the simulating program is self booting and makes copies of portions
> of its input space and outputs the copies to that space. Each of the
> identified incomplete divisors is a seed for an additional such program
> including any new copies of that divisor.
> A particular succession of copies is a trace of a simulation particular
> program.
> The copy process has no restrictions.  Some traces would be computationally
> correct while others would be random and others a blend.  Traces can split.
> The output process generates observer moments based on the outputted
> divisors.
> The output of new copies of the incomplete Divisor and splitting traces
> dovetails the dynamic.
> I think this contains a UD but the unrestricted nature of the traces seems
> to makes it more than that.
> Yours
> Hal
> -----Original Message-----
> From: everything-l...@googlegroups.com
> [mailto:everything-l...@googlegroups.com] On Behalf Of Bruno Marchal
> Sent: Saturday, December 27, 2008 5:36 AM
> To: everything-l...@googlegroups.com
> Subject: Re: Revisions to my approach. Is it a UD?
> Hi Hal,
> To see if your system is a UD, the first thing to do should consist in
> writing a program capable of simulating it on a computer, and then to
> see for which value of some parameters (on which it is supposed to
> dovetail) it simulates a universal Turing machine.
> To simulate it on a computer would help you (and us) to interpret the
> words that you are using in the description of your system.
> Best,
> Bruno
> On 27 Dec 2008, at 03:27, Hal Ruhl wrote:
> >

Abram Demski
Public address: abram-dem...@googlegroups.com
Public archive: http://groups.google.com/group/abram-demski
Private address: abramdem...@gmail.com

You received this message because you are subscribed to the Google Groups 
"Everything List" group.
To post to this group, send email to everything-l...@googlegroups.com
To unsubscribe from this group, send email to 
For more options, visit this group at 

Reply via email to