Re: Comments on tumbler ordering

[Berend van Berkum <berend@xxxxxxxxxx>]

On Sat, Jan 30, 2010 at 12:33:43PM -0800, roger gregory wrote:
> Oh you're saying the python code has a bug, I believe that.  I'll look at the backend C code, I don't expect it to have that bug.  The python code has undergone less scrutiny.

Yes, as described I liked the x88.py implementation better, but I stand
corrected now, Jeff Rush's code (pyxu and minxu) has the correct implementation
to compare tumblers (just tested the below comparison).

> in any case
>   1.0  <1.0.1<1.1<1.1.0.1<1.1.1
> but zeros have semantic meaning in document addresses as a hack, so that restricts their general usage to internals.
> 
> The semantics should allow things to be inserted in any document in any "V" address, don't they?  The nature of V addresses is that they change.  "I" addresses are so hidden that they should be irrelevant.

Yes, which I see is what enfiladics and ents accomplish.

But there is plenty on the Model T and Green enfilades that still eludes me.
Anyway, I was trying to get to the bottom of tumblers and the properties of a
'tumblerline' since I though two of them might do nicely defining a rectangular
'nested' table.

Thanks for the info.

- Berend


> On Jan 30, 2010, at 12:16 PM, Berend van Berkum wrote:
> 
> > On Sat, Jan 30, 2010 at 11:56:55AM -0800, roger gregory wrote:
> >>> 
> >>> Xu88.1's demo frontend orders these tumblers as follows:
> >>> 
> >>> 1.1.1 < 1.1.2 < 1.1.3 < 1.1 < 1.2.1 < 1.2.2 < 1.2 < 1.3.1 < 1.3 < 1.4 < 1 < 2
> >> If so I consider this a bug.  I've always considered tumblers in the mathematical infinitesimal sense, tis is well defined in results in the other ordering.  
> > 
> > Ah, so the idea to use tumblers as 'insert anywhere' is more a of a kludge or syntactic sugar than anything to do with Xanadu i guess.
> > 
> >> How did you determine this ordering from the code?
> >> 
> > 
> > By using the compare implementation in Xu88.1's demo FE (green/pyxi/x88.py)
> > 
> >    line = [
> >        Address(1),
> >        Address(1,1),
> >        Address(1,1,1),
> >        Address(1,1,2),
> >        Address(1,1,3),
> >        Address(1,2),
> >        Address(1,2,1),
> >        Address(1,2,2),
> >        Address(1,3),
> >        Address(1,4),
> >        Address(1,4,1),
> >        Address(2)
> >            ]
> >    line.sort()
> >    line = ' < '.join(map(str,line))
> >    print line
> >    assert line ==  '1.1.1 < 1.1.2 < 1.1.3 < 1.1 < 1.2.1 < 1.2.2 < 1.2 < 1.3 < 1.4.1 < 1.4 < 1 < 2'
> > 
> > vs. the one in minxu/tumbler.py:
> > 
> > if __name__ == '__main__':
> >    line = [
> >        tumbler(1),
> >        tumbler(1,1),
> >        tumbler(1,1,1),
> >        tumbler(1,1,2),
> >        tumbler(1,1,3),
> >        tumbler(1,2),
> >        tumbler(1,2,1),
> >        tumbler(1,2,2),
> >        tumbler(1,3),
> >        tumbler(1,4),
> >        tumbler(1,4,1),
> >        tumbler(2)
> >            ]
> >    line.sort()
> >    line = ' < '.join(map(str,line))
> >    print line
> >    assert line == '1 < 1.1 < 1.1.1 < 1.1.2 < 1.1.3 < 1.2 < 1.2.1 < 1.2.2 < 1.3 < 1.4 < 1.4.1 < 2'
> > 
> > 
> >> On Jan 30, 2010, at 11:30 AM, Berend van Berkum wrote:
> >> 
> >>> 
> >>> Hi list,
> >>> 
> >>> 
> >>> been thinking about a use of tumblers and now bumped into a curiosity.
> >>> 
> >>> I know tumblerlines from online comments, from Jeff Rush's minxu and an LM87.1
> >>> blurb in my revised Dream Machines. But now i see the latter two order 
> >>> tumblers differently from that proposed in e.g. Tumbler Arithmetic [1]. 
> >>> Instead they compare as follows:
> >>> 
> >>> 1 < 1.1 < 1.1.1 < 1.1.2 < 1.1.3 < 1.2 < 1.2.1 < 1.2.2 < 1.3 < 1.3.1 < 1.4 < 2
> >>> 
> >>> And this makes it impossible to insert anything before 1, 1.1, etc.
> >>> (Nevertheless, this is how Nelson illustrates a tumblerline of Xu88 addresses 
> >>> in LM87. Perhaps the ordering was confused with the hierarchical addresses of 
> >>> Udanax Green? It just dawns on me how little the (number of) digits in the 
> >>> components mean.)
> >>> 
> >>> Xu88.1's demo frontend orders these tumblers as follows:
> >>> 
> >>> 1.1.1 < 1.1.2 < 1.1.3 < 1.1 < 1.2.1 < 1.2.2 < 1.2 < 1.3.1 < 1.3 < 1.4 < 1 < 2
> >>> 
> >>> So the infinite set of addresses in space 1 are ordered before address 1. 
> >>> To insert between 1.1 and 1.2.1 you a). append after 1.2 or b). insert before 
> >>> 1.2.1. At new addresses 1.3 or 1.2.1.1. 
> >>> 
> >>> I think this is how tumblers should be ordered, but I find the difference 
> >>> between the addresses curious, and myself thinking how the front-end would 
> >>> interpret the number of digits. 
> >>> One could look at the structure as a list of embedded dynamic arrays, which on
> >>> the other hand is why I think of tumblers often.
> >>> 
> >>> 
> >>> regards,
> >>> 
> >>> Berend
> >>> 
> >>> 
> >>> --
> >>> [1] http://www.udanax.com/green/febe/tumblers.html
> >>> 
> >>> 
> >> 
> > 
> > -- 
> > E: berend@xxxxxxxxxx
> > T: +31(0)6 - 19160770
> > W: http://services.dotmpe.com/
> >    http://www.linkedin.com/pub/13/261/286
> > 
> > 
> 

-- 
 E: berend@xxxxxxxxxx
 T: +31(0)6 - 19160770
 W: http://services.dotmpe.com/
    http://www.linkedin.com/pub/13/261/286