[Date Prev][Date Next][Thread Prev][Thread Next][Author Index][Date Index][Thread Index]

Re: Presentation on Xanalogical Data Structures

At 11:09 PM 8/11/2004  Wednesday, Jeff Rush wrote:
>On Mon, 2004-08-09 at 14:58, Steve Witham wrote:
>> 3) I think between bignums and tumblers, there is a middle category
>> called multihumbers or something.  These are the transfinite numbers.

Tumbler do what we called "transfinitessimal arithmetic", which is like 
transfinite arithmetic, but with the extensibility being on the left instead 
-- toward ever smaller numbers rather than ever larger ones. Specifically, a 
tumbler is like a polynomial in powers of little-omega (normally shown as 
like a lowercase scripted "w"), the first infinite ordinal:

3.4.1 == 3*w**n + 4*w**(n-1) + 1*w**(n-2)

Given a finite maximal number of digits, we could choose an n large enough 
that we were only raising w to non-negative powers, in which case tumbler 
arithmetic would correspond exactly to the rules of transfinite arithmetic. 
However, we can't meet this condition -- tumblers can grow arbitrarily far 
to the left, and so we chose n to be -1, in which case we have an 
infinitessimal expressed in negative powers of w. But the exact same rules 
continue to apply -- they don't care what n is.

Note that we can't fix the problem by choosing n to be w, since w-1 isn't a 

>> Tumblers have the zeros in them, marking off the main parts
>> (server.0.user.0.document.0.position), and they don't follow
>> transfinite arithmetic at those divisions.  They are really just a
>> way of representing tuples of transfinite numbers, tuples with
>> fixed numbers of parts, like four.

I think that's incorrect. These would just be terms of the form
which can be skipped. The same arithmetic rules apply, and I think you will 
find there's no special case in the arithmetic operators.

>I really need to google for a good reference on transfinite numbers. 
>I've just been lazy, figuring my tumbler understanding is sufficient for
>what I need at the moment.

I think you're probably right -- it's actually easier to understand what 
they do than what they denote. I don't know that any of the above theory 
actually contributes anything useful to figuring out what they are good for.

In any case, if you do find some useful links, please post. Thanks.

>[...] The
>book _Literary Machines_ has some falsehoods about tumblers, such as
>that there is no use for negative values.  Green uses those for WIDs in
>lots of places, especially along the secondary axis for 2-dimensional
>enfilades where you can't avoid them (ie. if you order a 2-d mapping by
>one of the dimensions and allow arbitrary mappings, there are bound to
>be times when the second dimension is not in increasing order).

Interesting. I'm surprised by this as well (and I didn't remember it).

>Definitely magic stuff.  One question - in explaining all of Xanadu, say
>in a book or presentation, would you start at the top and work down to
>the details, or start with the details and assemble the architecture
>piece by piece?  As you see in my presentation, I've been teaching from
>the bottom up but I find I lose students who lack the understanding of
>why we are doing all this.  But I don't yet have a cool GUI demo to
>excite them.  On other projects, I find I personally learn better from
>the bottom up, so that things don't seem so magical at the top.  But
>then I'm a detail-oriented person.  Learning computers it was easier for
>me to learn address spaces, CPU caches, etc. first, then work up to
>operating systems, applications and GUIs.  But I can see how someone
>interesting in GUI design can be really bored learning about address
>spaces, even though they'll need some conceptual basis to understand
>segmentation faults, wild pointers and such.

I find that there tends to be two kinds of people here: bottom uppers (like 
us), and top downers. The style I try to use, that works fairly well for 
both, is a quick introductory top-down trip for motivation, followed by a 
slow detailed bottom up explanation.

>I've also been trying to produce something like the seven-level ISO
>diagram of the Xanadu Green architecture, so I can break down a
>presentation into digestible chunks.  My recoding efforts have been
>working from the bottom up too.

I code mostly bottom up as well, and I recommend it.

>| links
>| docs, versions
>| I, V streams
>| granfilade
>| DSP/WID/enfilade trees | tumbler math
>| CRUMs, LOAFs, subtree persistence
>Basically a roadmap of the concepts that need to be learned to
>understand Xanadu fully, similar to how the TCP/IP protocol tends to be

That's a cool breakdown!

Text by me above is hereby placed in the public domain