maybe we should offer a prize?

interesting (?) TX (+ 0X) property - semiotic economy increases with size (as the distances between primes and their ordinates increase), so probably this one would come in at signficantly less than 15,000,000 characters if xenotated

Mersenne primes - as a numeric intersection between binary exponentiation and the prime series - just HAVE to be really important for some of the numbo jumbo developments at issue here
'Thelemic' numbers 31 and 127 both M-primes

nic - "'Thelemic' numbers 31 and 127 both M-primes" - boy, are you on a roll today:

299 = ABYSMAL DARKNESS = MERSENNE PRIMES
156 = M-PRIMES = ABSTRACT = AXIOMATA = CALIPHATE = CTHULHU = OYSTER = THISTLE = M-PRIMES

ps. 156 is also the Thelemic number for Babalon.

(Axis)northanger - you were mighty modest on 299

- nych

nych = 86, what, you want to join the in crowd now?

sorry i've been quiet lately, the ol' connection got sidelined for a bit. should be up and running again soon. gotta go now and watch that moon antares occultation without a telescope. nighty.

>semiotic economy increases with size

this is always the case, as in my comments on google auto-ontology; to determine 'semiotic economy' (ie compression-ratio) of (eg) OX vs VNO you have to take into account the size of the semiotic systems' rulesets 'themselves', in OX case this must include prime-detection and multiplication (it's only economical because it already 'knows' that the xth prime is y and 'knows' how to multiply). The question is how it 'knows' this. Usually, since the ruleset length is a fixed constant, the larger the task the less it will matter, so semiotic economy would always marginally increase with size. The differential between OX and VNO or normal decimals would certainly diverge significantly at some point w/regard to lexicographical tractability, though ;)

Can you define arithmetic with OX without reconversion?

uc - different notions of 'semiotic economy' at work i think - assuming you're referring to Chaitin (program length or compressibility), rather than string length?
VNO of this number (n) would be extremely huge - 2^n x notational clutter (plexing etc).
fairly sure i'm not getting your argument for inevitable increase in economy, since TX economizes specifically through prime-ordination mechanism, which neither conventional modular notations nor VNO share

"Can you define arithmetic with OX without reconversion?" - not a question to be rushed ;)

>uc - different notions of 'semiotic economy' at work i
> think - assuming you're referring to Chaitin (program
>length or compressibility), rather than string length?

they're not _entirely_ separate issues, depending on how you think of it:
1.take OX as a system that translates any number(string) n into OX-code n'

2.Initially define semiotic economy as ratio |n'| / |n| (length of compressed string/length of original string) -- which will hopefully converge as |n| grows.

3.But you must also include the size of the compression program itself |OX| so something like : n' / n + |OX|

4.With very short strings |n|=1,2,3 etc, addition of |OX| will make a disproportionate impact on the outcome, so that in fact despite its being non-compressive, VNO might come out on top. But with successsively longer strings, since |OX| remains constant (the program is always the same length while the 'subject' string grows) semiotic economy will 'automatically' increase.

5.So compression ratio also a function of the type/size of thing you are likely to be compressing and min.program-length of compressor and semiotic economy in the case of a given converted string are different issues, but in terms of global evaluation they're connected

...
Not sure whether you could define semiotic economy other than as compression?
What do you think about my idea of defining ontology as min. program-length to describe max.domain? Stripped of any mystical communion with being (as B-du seems to want to do), what else would it be (ie. if, as B-du says, mathematical physics _is_ ontology)

this may be of no interest but wtf...

just to show that this (initial importance of program-length) is pragmatically not as 'negligible' as may appear, it is very much a practical issue for anyone engaged in programming(and other things, I'm sure); because no-one has a good idea in advance _how_ a system will be used (least of all the client, who tends to be overoptimistic as to their own initiative). So we have ended up creating hugely complicated, flexible, bottom-up systems to allow dynamic online data-editing when it would have been quicker, easier and cheaper for the client if we had just retyped a static page every 7 months (or, more likely, never...) when they bothered to change it. Usually someone loses their job and the whole site gets re-made anyway ;)

So you can only discount the program-length of the compressor if you take a very abstract view (as if it was going to be used infinitely...)

uc - this topic needs a considered response, for now: think that economy of expression usefully distinguishable from Chaitin-type compressibility (which measures negative economy, i.e. compressibility (e.g. with VNOs used as 'practical' numbers, which of course would be ridiculous and misunderstand their proper - demonstrative - function).
Also think 0X arithmetic question of epic significance, so no chance that will get lost either ...

isn't that very distinction between 'economy of expression' and demonstrative power at the root of the ontology/semiotics thing? I'm still not sure how economy of expression is different from 'negative economy' (or why its negative) - compressibility is just a measure of redundancy.

Or is it the case that since 'in use' the program-length of the semiotic is of vanishing importance, we need to use other criteria (surely this intuition at the root of a nietzschean-deleuzian type of thinking [not at all indefensible, despite what B-du says, IMO] - different intersecting 'styles' of ontology not organized according to universal scale of efficiency/systematicity therefore not really a question of 'economy' at all)

My difficulty is that, if economy of expression or inherent 'interestingness' of a given semiotic system cannot be defined 'absolutely' (ie as limit of compressibility vis-a-vis an 'original'), can it only be defined in terms of some vague personal predeliction, or what....trying to wedge myself in-between master-ontology and phenomenological-pottering again here...

uc - "compressibility is just a measure of redundancy" - exactly, negative economy (OK, i'll stick to 'redundancy' too) - surely it's the absence of redundancy in TX/0X that makes them practically economical (but not trying to give this anything more than a 'regional' valorization)

can't help feeling that 'interestingness' something of a deteriorated mode of evaluation compared to functionality on whatever line considered (i.e. not in any way ruling out transcendental/ontological projects as 'criterial' iun their own right)

>functionality on whatever line considered

ok, but what line _is_ being considered WRT TX/OX?

The prime is (2^25964951)-1. Unsuprisingly, in binary notation this takes 25964951 bits (about 24Mb). Given 25964951 bits you can write any of the numbers for 0 to (2^25964951)-1. By the pigeon-hole principle, it is impossible to write that range in less space. (You don't want to mess with the pigeon-hole principle. I mean, just look what happened to the bass-player from Iron Butterfly.)

More specifically, OX may be good for primes, but it's bad for powers of two (for example).

As for arithmetic, well, multiplication and division are easy.

Robin - great to see you back
need to check-out 'pigeon-hole principle' - but what you are saying on economy q. already makes intuitive sense (if something gets a notational PH, something else loses it ...?)
On TX/0X arithmetic, obviously interested in your solutions ...
Temptation is to amalgamate uc's original question with Goedel coding (which already attributed math ops to prime numbers) resulting in an immanent arithmetism with no less operations than values ... this would be most interesting the more it diverged from 're-conversion' ...

... but also realize this tangential at best to matter at stake (if you're feeling generous you'll put it down to sleep deprivation)

[Sorry for the delay.]

Multiplication is string concatenation. This is given by the definition of the notation.

Given that each numeral consists of a (possibly empty) sequence of primes, and each prime has a bracket at each end, finding the prime factors of a number can be done with shallow parsing.

When I said division was easy, I should have said that it was easy when the divisor evenly divides the dividend. It is simply a matter of eliminating the common factors.

The only complication is that you cannot just rely on string equality for spotting common factors, as a number can have more than one form, eg '()(())' = '(())()'. This can be solved by converting the numbers to a canonical form, where the factors in a product are always in some particular order (lexical, say).

#!/usr/bin/perl

sub canonical
{
    my ($chars, $start, $end) = @_;
    $start = 0 if !defined($start);
    $end = scalar(@$chars) if !defined($end);

    my @factors = ();
    my $i = $start;
    while ($i < $end)
    {
        my $j = matching_bracket($chars, $i, $end);
        my $index = join('', canonical($chars, $i+1, $j));
        $index = ' ' if $index eq '';
        push(@factors, '(' . $index . ')');
        $i = $j+1;
    }
    return sort(@factors);
}

sub matching_bracket
{
    my ($chars, $start, $end) = @_;
    $chars->[$start] eq '(' or die "Badly formed number\n";
    my $count = 0;
    for (my $i = $start; $i < $end; $i++)
    {
        $count += ($chars->[$i] eq ')') ? -1 : 1;
        return $i if $count == 0;
    }
    die "Unmatched bracket\n";
}

die "Usage: divide x y\n" if (scalar(@ARGV) != 2);
@x = canonical([split(/[^()]*/, $ARGV[0])]);
@y = canonical([split(/[^()]*/, $ARGV[1])]);

print @x, ' / ', @y, ' = ';

@num = ();
@denom = ();

while (@x && @y)
{
    if ($x[0] lt $y[0])
    {
        push(@num, $x[0]);
        shift @x;
    }
    elsif ($y[0] lt $x[0])
    {
        push(@denom, $y[0]);
        shift @y;
    }
    else
    {
        # Common factor
        shift @x;
        shift @y;
    }
}
push @num, @x;
push @denom, @y;

if (@denom)
{
    print @num, ' / ', @denom, "\n";
}
else
{
    print @num, "\n";
}

thanks for the code Robin: things are progressing nicely in reality-land, and when I return I'll try to make a nice ticxen experimentation machine (along with a surreal number one).