←2010-05-02 2010-05-03 2010-05-04→ ↑2010 ↑all
00:00:30 <oerjan> nooga: so you are black all over now?
00:01:01 * oerjan likes making obvious conclusions
00:01:03 <nooga> i'm making circuit boards for my modem and 8088 computer
00:01:28 <SgeoN1> My laptop's receiving power now!
00:01:32 <Phantom_Hoover> Now, we just need to find interesting patterns in the results.
00:01:33 <nooga> using chalk paper and laserjet
00:01:57 <Phantom_Hoover> There's an obvious pattern in the lengths.
00:02:41 <alise__> also, bifrocation; too good a coincidence
00:02:44 <alise__> it splits bf into two parts? sorta?
00:03:10 <Phantom_Hoover> Anyway, it's midnight and I have to revise tomorrow. Perhaps you could put the code on the wiki?
00:03:29 -!- Phantom_Hoover has quit (Quit: Phantom_Hoover).
00:03:59 * oerjan recalls a nice bitbased algorithm for [Integer] -> Integer
00:04:27 <alise__> oerjan: the important thing was that all nats were covered
00:04:40 <oerjan> basically, convertFromBinary . intercalate "1" . map convertToFibonacciBase
00:04:40 <alise__> $ echo ',[.,]' | ./bifro encode | ./bifro decode
00:04:41 <alise__> ,[.,]
00:04:50 <alise__> $ echo 123456789 | ./bifro decode | ./bifro encode
00:04:51 <alise__> 123456789
00:04:52 <oerjan> er [Nat] -> Nat
00:05:06 -!- ais523 has quit (Remote host closed the connection).
00:05:07 <oerjan> this covers all Nats, or nearly so
00:05:19 <alise__> http://pastie.org/942869.txt?key=vvwlyvvpwhxulduzur3q
00:05:22 <alise__> behold.
00:05:24 <oerjan> although i probably messed up the exact definition
00:05:34 <fax> alise__ why are you so horrible to me
00:05:42 <alise__> fax: because you were a jerk to me.
00:05:47 <fax> alise__ what did I do?
00:06:07 <nooga> alise__ is generally horrible
00:06:14 <alise__> well we were just talking about a program and you started going all on about how it's trivial and pointless for no reason... also, you do your fair share of ignoring /me/
00:06:17 <fax> other than like teach you everything I know about dependent types
00:06:48 * SgeoN1 should learn dependent types at some point.
00:06:52 <nooga> 01:05 < alise__> well we were just talking about a program and you started going all on about how it's trivial and pointless for no reason... also, you do your fair share of ignoring /me/
00:06:53 <nooga> maybe he's adapting your methods, alise__ ? :>>
00:07:24 <alise__> <fax> WHY? <fax> just use binary for fucks sake <fax> lame and trivial <fax> alise__ lol okay maybe not for you <fax> alise__: fuck you <fax> alise__: You're a cunt <fax> lol @ alise getting all upset because he thought his trivial program was difficult to write
00:07:51 <fax> stop fabricating IRC logs
00:07:55 <fax> we all know that didn't happen
00:08:00 <alise__> ... ...
00:08:04 <nooga> ...
00:08:04 <alise__> you just said it right now.
00:08:05 <nooga> lol
00:08:10 <fax> no I did not
00:08:12 <alise__> wow so fax has some /serious/ denial issues.
00:08:13 <fax> you're doing this again
00:08:18 <alise__> fax: please, look it up on tunes.org
00:08:23 <fax> you did this just a min ago and now you are doing it /again/
00:08:24 <alise__> the lines are there plain as day i forged not a single one
00:08:37 <alise__> seriously if you cannot believe that you wrote those lines -- which you DID --
00:08:42 <fax> that's really funny alise good trick what are you trying to gett hough
00:08:46 <alise__> well you have serious issues
00:08:56 <oerjan> fax: i am considering banning you now
00:09:06 <alise__> guys I think fax might actually be legitimately insane... I don't think he's trolling he's acted weirdly like this before
00:09:53 * alise__ considers whether feeding mandelbrot.b to his program is a good idea
00:09:53 <fax> oerjan: I will be missing out on Phantom_hoover ignoring me and alise flipping out at me and telling me to fuck off because I said a program was trivla
00:10:07 <SgeoN1> I think fax is joking
00:10:14 <alise__> SgeoN1: no, i wish he was though
00:10:26 <fax> I don't know why people are being so nasty to me
00:10:50 <oerjan> fax: well at the moment you are either joking or insane.
00:11:09 <SgeoN1> Fax: phantom_hoover left
00:11:16 <alise__> even encoding http://esoteric.sange.fi/brainfuck/bf-source/prog/rot13.bf hangs my program
00:11:23 <alise__> these are some /seriously/ large numbers
00:11:25 <oerjan> it's hard to tell, alise__ isn't exactly unbiased in her judgements
00:11:28 <fax> alise__, welcome to haskell programming
00:11:31 <alise__> oerjan: i'm not sure your recursive-crushing was such a good idea
00:11:41 <oerjan> alise__: of course, 2^n isn't very effective
00:11:44 <alise__> fax: you think it might be the unimaginably huge growth in numbers instead?
00:11:46 <pikhq> alise__: Glee.
00:12:06 <alise__> eh, it's more fun for number -> program
00:12:22 <pikhq> alise__: I'd be very amused if your encoding method ended up being a Brainfuck compression program. :P
00:12:29 <pikhq> Actually.
00:12:33 <alise__> $ echo 1234567891011121314151617181920 | ./bifro decode
00:12:33 <alise__> ----->-->+++--+---[<][]++--<++----,-+[+]-++<--+++-.
00:12:37 <alise__> it sure does produce useless programs
00:12:38 <pikhq> ... It kinda *is*.
00:12:53 <alise__> yeah it compresses it into an integer many many times bigger than the program.
00:12:54 <alise__> :P
00:12:56 <pikhq> It's only being asked to produce valid ones. Not useful ones.
00:13:11 <alise__> it really shies away from loops, since the numbers are so big
00:13:14 <alise__> gimme a big prime guys
00:13:14 <pikhq> "1234567891011121314151617181920" is smaller than "----->-->+++--+---[<][]++--<++----,-+[+]-++<--+++-.".
00:13:30 <alise__> you know it is funny, because we are almost deserialising for num->prog
00:13:31 <fax> 1234567891011121314151617181920 <-- base 10
00:13:34 <alise__> pikhq: yeah but
00:13:36 <alise__> [dfgdfg]
00:13:39 <alise__> instantly EXPLODES your program
00:13:44 <alise__> with multiple nested serialisations
00:13:46 <alise__> er
00:13:46 <fax> ----->-->+++--+---[<][]++--<++----,-+[+]-++<--+++-. <-- base 7 (or something)
00:13:49 <alise__> you know it is funny, because we are almost factorising for num->prog
00:13:57 <alise__> fax: no because of balanced loops
00:14:01 <alise__> that's the whole reason I did this
00:14:19 <pikhq> Oooh! Oooh!
00:14:20 <pikhq> 34790! − 1
00:14:26 <oerjan> alise__: incidentally i think if the order of tuples were reversed, then even programs without loops would get enormous
00:14:27 <alise__> jane@jane-desktop:~/code$ echo 1111111111111111111111111111111111111111111111 | ./bifro decode
00:14:27 <alise__> >-->-->-->-->-->-->-->+.+--<---------+--+>-<.<<++<+<----<+,++--->>+-+>--<
00:14:27 <alise__> jane@jane-desktop:~/code$ echo 1111111111111111111111111111111111111111111112 | ./bifro decode
00:14:27 <alise__> ---+->-->-->-->-->-->-->+.+--<---------+--+>-<.<<++<+<----<+,++--->>+-+>--<
00:14:31 <alise__> Hey, it... prepended to the start.
00:14:45 <alise__> pikhq: no :P
00:15:03 <alise__> $ echo '[[[[]]]]' | ./bifro encode
00:15:04 <alise__> [hang]
00:15:08 <pikhq> http://en.wikipedia.org/wiki/Illegal_prime
00:15:09 <alise__> maybe the parser is broken???
00:15:11 <oerjan> it's only the head of a cons that is so enormously encoded
00:15:17 <alise__> no wait lol
00:15:20 <alise__> jane@jane-desktop:~/code$ echo '[]' | ./bifro encode
00:15:21 <alise__> 63
00:15:21 <alise__> jane@jane-desktop:~/code$ echo '[[]]' | ./bifro encode
00:15:21 <alise__> 590295810358705651711
00:15:21 <alise__> amazing
00:15:30 <alise__> then one more breaks it
00:15:36 <alise__> this is the most hideously inefficient numbering system ever
00:15:43 <pikhq> Glee.
00:15:52 <alise__> oerjan: ah you are right.
00:15:55 <alise__> grr
00:15:59 <alise__> so the bijection is imperfect
00:16:05 <alise__> -- and having nested crushed loops is imperfect too
00:16:07 <alise__> but dammit, I did it
00:16:12 <alise__> and whenever we talk about a brainfuck program
00:16:18 <alise__> we can just say, instead of pastebinning
00:16:21 <alise__> oh, it's #xkcd in the list
00:16:55 <fax> I wish people would be nicer to me
00:17:24 <alise__> I wish you would be nicer to people.
00:17:36 <fax> okay
00:18:13 <oerjan> alise__: the triangular N x N <-> N encoding is much more balanced, i should think
00:18:21 <alise__> oerjan: does it cover all nats?
00:18:25 <alise__> it's very important we cover all nats :P
00:18:37 <oerjan> sure, if you get the off-by-one shifts right...
00:18:39 <fax> this is what i was talking about earlier
00:18:45 <fax> but phantom_hoover didn't want to hear it
00:19:02 <alise__> well i'm all ears.
00:19:03 <oerjan> fax: it was mentioned (credited somewhat to you) even before you arrived
00:19:10 <alise__> yes, i did credit it to you.
00:19:13 <alise__> multiple times
00:19:22 <oerjan> but for some reason they didn't like it. hard to reverse was it?
00:19:23 <fax> it's not due to me
00:19:31 <fax> I just re-explained it in terms of finite-calculus
00:20:00 <oerjan> needs a square root approximation, is the problem...
00:20:02 <alise__> oerjan: yeah
00:20:08 <alise__> /but/
00:20:15 <alise__> i suspect that sqrt(n) may have been integer for all relevant ns
00:20:26 <oerjan> um no
00:20:50 <oerjan> you need a square root approximation to find one of the tuple coordinates
00:20:52 <oerjan> iirc
00:21:13 <oerjan> s/approximation/floor/
00:21:30 <alise__> well sqrt floor should always be right in haskell methinks.
00:21:46 <oerjan> except it's not bignum compatible
00:22:06 <oerjan> well without some hackage probably
00:22:50 <alise__> ah
00:23:26 <pikhq> alise__: You have still created a compression scheme for Brainfuck. However, this compression scheme is not very *useful*, as it only appears to actually compress a large number of fairly stupid programs.
00:23:41 <fax> everyone in the world is horrible
00:23:46 <pikhq> Actually. Think you could try running it on a "Hello, world!" program without any loops?
00:23:59 <oerjan> alise__: try reversing the tuple order and see what programs you get _then_ :D
00:24:11 <alise__> oerjan: hell no
00:24:15 <alise__> pikhq: it'd not be too big
00:24:17 <oerjan> (i bet then loops would be _over_-represented
00:24:18 <oerjan> )
00:24:37 <alise__> Ssh, we're about to make a publication.
00:24:39 <oerjan> alise__: just to test for fun of course
00:24:56 <fax> whats a publication
00:25:22 <alise__> oerjan: not even gonna THINK about it :D
00:25:27 <alise__> fax: THOU SHALT SEE
00:25:49 <oerjan> alise__: i meant to run it in the Integer -> Program direction, fwiw
00:25:57 <alise__> *slow pastie is slow*
00:26:09 <fax> ?
00:26:11 <alise__> oerjan: ah.
00:26:11 <fax> wdat
00:26:13 <alise__> ok then
00:26:15 <fax> what is going on
00:26:18 <alise__> Your paste cannot be larger than 100 kb. Sorry.
00:26:19 <alise__> oh well
00:26:22 <alise__> The Bifro Society of the United Kingdom are pleased to announce their latest
00:26:22 <alise__> research result: the first 10002 brainfuck programs, in order.
00:26:25 <alise__> guess nobody will miss it
00:26:33 <fax> Bifro?
00:26:51 <fax> what is 'in order' about them
00:27:06 <alise__> they're the decodings of 0,1,2,etc
00:27:07 <alise__> :P
00:27:11 <alise__> and bifro is the name of my program
00:27:15 <pikhq> :)
00:27:19 <fax> cool
00:27:28 <alise__> oerjan: lol, with that modification
00:27:41 <alise__> "1" becomes an infinite amount of -s
00:27:43 <alise__> I shit you not
00:27:52 <alise__> decrush :: Integer -> [Integer]
00:27:53 <alise__> decrush 0 = []
00:27:53 <alise__> decrush n = let (xsn,x) = biFro n in x : decrush xsn
00:27:53 <alise__> --decrush n = let (x,xsn) = biFro n in x : decrush xsn
00:27:54 <oerjan> um that's impossible
00:27:59 <alise__> Precisely
00:28:06 <alise__> 2 becomes the rather more mundane +
00:28:28 <oerjan> oh wait maybe not
00:28:33 <alise__> 3 -+; 4 <; 5 +(infinite -s)
00:28:42 <alise__> 6 >
00:28:47 <alise__> 7 --+
00:28:52 <alise__> 100 [[[+]]]
00:28:58 <oerjan> oh yes it must be
00:29:04 <alise__> [[[[.-------------------------------------------------------------------------------------------...
00:29:06 <alise__> ^ 1000
00:29:08 <fax> write a program that deletes everything on your computer
00:29:29 * SgeoN1 deletes fax
00:29:36 <alise__> i'm all ears for the triangular thing
00:32:52 <oerjan> is biFro 1 == (0,1) ?
00:33:06 <oerjan> or (1,1)
00:33:15 <SgeoN1> Earbuds aren't supposed to hurt, are they?
00:33:23 <alise__> erm i forget
00:33:28 <oerjan> or wait it cannot be (1,1) then it would have been infinite before
00:33:35 <SgeoN1> Because these hurt.
00:34:04 <alise__> (1,0)
00:34:12 <alise__> actually
00:34:19 <oerjan> ic
00:34:23 <alise__> biFro 0 = (0,0)
00:34:44 <oerjan> well in that case wtf do you get infinite -s?
00:34:46 <alise__> then it just goes everywhere:
00:34:52 <alise__> *Main> map biFro [0..20]
00:34:53 <alise__> [(0,0),(1,0),(0,1),(2,0),(0,2),(1,1),(0,3),(3,0),(0,4),(1,2),(0,5),(2,1),(0,6),(1,3),(0,7),(4,0),(0,8),(1,4),(0,9),(2,2),(0,10)]
00:35:06 <alise__> oerjan: obvious
00:35:08 <alise__> decrush n = let (x,xsn) = biFro n in x : decrush xsn
00:35:11 <alise__> here we don't decrease on x
00:35:17 <alise__> the secret is that recursing biFro on x
00:35:21 <alise__> doesn't smallify x
00:35:26 <alise__> so the recursion never reaches a base case
00:35:31 <alise__> i.e. biFro is biased towards latters
00:35:34 <fax> guess what I wrote today
00:35:35 <alise__> this is just a hunch
00:35:46 <alise__> like maybe biFro stays constant, or oscillates, or grows
00:35:46 <fax> A program that expresses any number as the sum of two squares mod p
00:35:49 <oerjan> um wait
00:36:05 <SgeoN1> Trolltastic insults?
00:36:06 <alise__> biFro :: Integer -> (Integer,Integer)
00:36:07 <alise__> biFro n = (m, (((n `div` (2^m)) - 1) `div` 2) + 1)
00:36:08 <alise__> where n' = n + 1
00:36:08 <alise__> m = toInteger . length . takeWhile (\n'' -> mod n'' 2 == 0) $ iterate (`div` 2) n'
00:36:10 <alise__> "hope this helps"
00:36:25 <fax> SgeoN1 what did you just say
00:36:26 <oerjan> alise__: if you use 0 for nil, the bifro should be a bijection between [1..] and [0..] x [0..]
00:36:34 <oerjan> *then
00:36:45 <alise__> oh you are right
00:36:53 <alise__> crush :: [Integer] -> Integer
00:36:53 <alise__> crush [] = 0
00:36:54 <alise__> crush (x:xs) = biTo (x, crush xs)
00:36:57 <alise__> this is how it works so umm
00:37:02 <alise__> eventually we get to biTo (something, 0)
00:37:16 <alise__> which can be a bit big.
00:37:17 <alise__> *Main> biTo (1000, 0)
00:37:17 <alise__> 10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069375
00:37:41 <alise__> *Main> map (\n -> biTo (n, 0)) [0..20]
00:37:42 <alise__> [0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535,131071,262143,524287,1048575]
00:37:49 <alise__> every time you think you've figured out the sequence, it fucks with you
00:37:59 <alise__> no wait
00:38:02 <alise__> it's powers of two minus one
00:38:05 <alise__> that's so stupid i love it
00:38:34 <alise__> (0,n) is multiples of two
00:38:40 <alise__> this thing contains the secrets of the universe
00:38:49 <alise__> 1,n is odd numbers
00:39:10 <alise__> aha, then it keeps getting graduall more spaced apart, i think
00:39:56 <pikhq> Hahahah.
00:40:15 <alise__> *gradually
00:40:35 <alise__> *Main> map (\n -> biTo (n, 1)) [0..20]
00:40:36 <alise__> [2,5,11,23,47,95,191,383,767,1535,3071,6143,12287,24575,49151,98303,196607,393215,786431,1572863,3145727]
00:40:38 <alise__> the retarded theme continues
00:40:49 <alise__> *Main> map (\n -> biTo (n, n)) [0..20]
00:40:49 <alise__> [0,5,19,55,143,351,831,1919,4351,9727,21503,47103,102399,221183,475135,1015807,2162687,4587519,9699327,20447231,42991615]
00:40:52 <alise__> what is this i don't even
00:41:04 -!- Sgeo has joined.
00:41:20 <SgeoN1> Would be fun if it was all and only primes
00:42:03 <oerjan> SgeoN1: and quite impossible to calculate efficiently. not that this 2^n thing helps...
00:42:20 <alise__> hey biTo is constant time dude.
00:42:27 <alise__> it's that biFro you wanna look out for
00:43:20 * Sgeo was thinking more of "incredibly impressive and an incredible discovery"
00:43:36 <fax> Sgeo you shouldn't just sit back and throw insults at people that's actually really not cool
00:43:54 <alise__> so how's that triangular stuff oerjan
00:44:03 <alise__> Sgeo: an impossible discovery
00:44:08 <alise__> it's been proven that you can't do primes like that :P
00:44:23 <oerjan> it's been mentioned several times, i don't remember it any better...
00:44:24 * Sgeo isn't even sure what the algorithm is, so
00:44:26 <fax> can't do primes like what?
00:44:57 <Sgeo> Or are you saying, can't do primes in polynomial time?
00:45:19 <alise__> like there's no algebraic expression that generates primes and only primes.
00:45:34 <fax> there is one that gives primes for alj positive values
00:45:43 <fax> the negative values are garbage though
00:45:49 <oerjan> alise__: i don't think powers are included in that
00:46:00 <oerjan> it's polynomials i've heard about
00:46:05 <alise__> oerjan: then consider it proven by plot
00:46:17 <alise__> fax: all primes, though?
00:46:21 <fax> yes
00:46:26 <alise__> whoa
00:46:42 <fax> it's not practical if you actually want to compute primes with it tohugh
00:46:43 <alise__> so um how come we aren't discovering new primes in 0 time
00:46:59 <fax> because it is hyperdimension and there is a lot of garbage
00:47:05 <fax> (negative values)
00:47:36 <oerjan> presumably most random parameters give either tiny or negative numbers...
00:48:14 <Sgeo> Oh, thought that by negatives you meant input, or something
00:48:32 <alise__> oh me too lol
00:48:33 <fax> Sgeo you should learn
00:48:50 <fax> to hold you tongue sometimes, and to speak other times
00:49:17 <alise__> fax
00:49:21 <alise__> you should learn
00:49:24 <alise__> that you are not a dispenser of zen koans
00:49:29 <alise__> ready to enlighten the life of another
00:49:38 <alise__> at their fine line'd wisdom
00:49:51 <alise__> seriously that's very condescending.
00:49:53 <oerjan> oh hm!
00:50:07 <oerjan> alise__: we could use ternary!
00:50:16 <alise__> oerjan: yowzers! uh, why?
00:50:34 <oerjan> for less explosive list encoding?
00:50:59 <fax> what about tertiary
00:51:09 <fax> or balanced becimal?
00:51:22 <oerjan> fromTernary . intercalate "2" . map toBinary
00:51:26 <oerjan> oh wait
00:51:29 <Sgeo> becimal?
00:51:32 <oerjan> darn initial 0s
00:51:34 <alise__> oerjan: howso
00:51:41 <alise__> how about balanced binary coded negative phinary
00:51:49 <alise__> i think that would be good
00:51:51 <oerjan> wth is that
00:51:56 <alise__> oerjan: still need [[[nesting]]]
00:52:00 <fax> that sounds PHINE.
00:52:03 <fax> :3
00:52:24 <fax> alise__: status of finding the a brainfuck program called n which prints n
00:52:28 <oerjan> alise__: well duh but this wouldn't be that much enlargement per level
00:52:31 <alise__> well
00:52:39 <alise__> balanced ternary is with the -, 0, + thing i think
00:52:40 <nooga> huh
00:52:47 <alise__> binary coded decimal is just segregating bits of binary to work as decimal digits
00:52:56 <fax> is it possible no quine exists?
00:52:58 <alise__> so it's just like segregating bits of binary to use as negative phinary digits
00:52:59 <fax> it seems possible to me
00:53:00 <nooga> i wonder how to implement sets and set hashing in C
00:53:02 <alise__> except there's negatives too
00:53:12 <alise__> fax: ooh, interesting
00:53:16 <alise__> of course it depends on the numbering...
00:53:18 <pikhq> alise__: I think I'm the one here with the most right to dispense zen koans.
00:53:27 <alise__> but my intuition leads me to believe that there are usually quines
00:53:32 <alise__> i mean when in doubt add tons of +-s :P
00:53:34 <fax> obviously the numbering should make a special accountance so that 666 is a quine - or something
00:53:42 <alise__> pikhq: no
00:53:45 <pikhq> As I know how to write "zen". :P
00:53:46 <alise__> no 42
00:54:30 <alise__> Xen koan
00:54:38 <oerjan> fax: a brainfuck program can obviously calculate the encoding. i should think the usual quine-construction theorems apply
00:54:51 <alise__> fax: now consider a BF program #n, outputting m such that BF program #m outputs n
00:54:52 <pikhq> They do.
00:54:54 <alise__> IS YOUR MIND BLOWN YET
00:55:08 <fax> oerjan - I don't see that working myself but that might be my problem
00:55:14 <pikhq> It'd be a major *pain* to implement, but yes, the usual quine-construction theorems apply.
00:55:40 <alise__> fax: why not?
00:55:47 <alise__> we have very strong, well-tested quiney wimey theorems
00:55:58 <alise__> that let us construct any sort of ridiculous multi-polyglot-quine-chain
00:56:07 <alise__> all this is is an additional function, plus more fluff in the code to get the number right
00:56:09 * Sgeo wants/needs to read about these
00:56:11 <alise__> the number is just an encoding of the source basically
00:56:12 <fax> let us consider the contrapositive,
00:56:14 <alise__> so instead of matching source
00:56:18 <alise__> we match this transformation on the source
00:56:26 <fax> The claim is that there is no computable numbering of brainfuck programs that avoids quines
00:56:46 <oerjan> indeed, probably
00:56:59 <Sgeo> Wouldn't the digits just make a programming language?
00:57:00 <alise__> yes that seems very likely
00:57:09 <Sgeo> *turing-complete programming language?
00:57:12 <alise__> consider that all numberings are essentially a transformation on the source
00:57:21 <alise__> and that the source can already be considered to be in some arbitrary encoding
00:57:27 <alise__> and if it can be encoded/decoded
00:57:27 <bsmntbombdood> chrome is using 215% cpu :D
00:57:29 <alise__> then we can quine it.
00:57:30 <fax> okay I see it now, quines do exist
00:57:32 <pikhq> fax: Yes, that is the fixed point theorem.
00:57:38 <alise__> `addquote <fax> okay I see it now, quines do exist
00:57:40 <HackEgo> 156|<fax> okay I see it now, quines do exist
00:57:41 <alise__> nice out of context :D
00:58:38 <pikhq> This is true for... Every TC language with sufficient IO capabilities to output the text of such a quine, I'm pretty sure.
00:59:33 <fax> is this theorem effective enough that you can actually calculate this quine
00:59:35 <nooga> eeh
01:00:24 <alise__> fax: well we can certainly construct it with ingenuity, we've handled harder tasks before
01:00:24 <oerjan> `addquote <fax> we all know that didn't happen
01:00:30 <HackEgo> 157|<fax> we all know that didn't happen
01:00:36 <alise__> we all know that didn't happen, oerjan
01:00:41 * oerjan whistles innocently
01:00:48 <alise__> `quote
01:00:49 <HackEgo> 29|IN AN ALTERNATE UNIVERSE: <bsmntbombdood> there is plenty of room to get head twice at once
01:00:51 <alise__> `quote
01:00:52 <HackEgo> 46|<ehird> Or the brutal rape of the English language! <pikhq> That wasn't rape. English is always willing.
01:00:56 <alise__> `quote
01:00:57 <HackEgo> 23|<fizzie after embedding some of his department research into fungot> Finally I have found some actually useful purpose for it.
01:01:00 <alise__> `quote
01:01:01 <HackEgo> 14|<reddit user "othermatt"> So what you're saying is that I shouldn't lick my iPhone but instead I should rub it on my eyes first and then lick my eyeballs?
01:01:03 <bsmntbombdood> wait what
01:01:04 <alise__> `quote
01:01:05 <HackEgo> 99|<coppro> things are more awesome when written by someone in here
01:01:11 <alise__> bsmntbombdood: note alternate universe qualifier
01:01:13 <alise__> `quote
01:01:14 <HackEgo> 146|<Gregor> I don't know that I've ever heard apocalypi described in terms of depth ...
01:01:17 <fax> `quote
01:01:18 <alise__> `quote
01:01:20 <HackEgo> 72|<ehird> ignore me, i'm full of bullshit
01:01:22 <fax> lol
01:01:27 <alise__> that was then THIS IS NOW
01:01:27 <pikhq> fax: No, but they're generally easy to write.
01:01:28 <alise__> `quote
01:01:30 <HackEgo> 117|<Sgeo> I'd imagine that it already has, and no one noticed
01:01:31 <HackEgo> 153|* Warrigal refuses to say goodbye to Quas NaArt, as he is coming closer, not going farther.
01:01:32 <alise__> `quote
01:01:34 <HackEgo> 118|<apollo> Actually, he still looks like he'd rather eat her than have sex with her.
01:01:39 <alise__> `quote
01:01:40 <HackEgo> 103|<oklofok> i use dynamic indentation, i indent lines k times, if they are used O(n^k) times during a run of the program
01:01:45 <alise__> `quote
01:01:46 <HackEgo> 104|<AnMaster> I'm 100% of what sort of magic was involved in it
01:01:50 <Sgeo> There is a thingy
01:01:52 <alise__> `quote
01:01:53 <HackEgo> 54|<lacota> I guess when you're immortal, mapping your fonts isn't necessary
01:01:56 <alise__> Sgeo: yeah i know
01:01:57 <alise__> `quote
01:01:58 <HackEgo> 98|<fungot> ehird: every set can be well-ordered. corollary: every set s has the same diagram used from famous program talisman with fnord windows to cascade, someone i would never capitalize " i"
01:02:06 <alise__> i like that corollary, a lot
01:02:19 <pikhq> You pretty much just need a way of computing the source code of your program and a way of mapping your source code into your preferred numbering.
01:02:21 <alise__> `quote
01:02:23 <HackEgo> 78|<GregorR> ??? <GregorR> Are the cocks actually just implanted dildos? <GregorR> Or are there monster dildos and cocks? <GregorR> Or are both the dildos and cocks monster?
01:02:29 <Sgeo> http://normish.nomictools.com/sgeo/quotes.txt
01:02:34 <alise__> `quote
01:02:34 <fax> wow
01:02:35 <HackEgo> 13|* ehird has joined #lobby <Madelon> hmmm clean me
01:02:40 <alise__> `quote
01:02:41 <fax> `quote fax
01:02:41 <HackEgo> 61|<fizzie> Seconds. 30 of them. Did I forget the word?
01:02:43 <HackEgo> 96|<fax> im the worst person in the world 140|<fax> oklopol geez what are you doing here <oklokok> ...i
01:02:50 <alise__> it gets cut
01:02:52 <alise__> grep http://normish.nomictools.com/sgeo/quotes.txt
01:02:59 <alise__> 140|<fax> oklopol geez what are you doing here <oklokok> ...i don't know :< <oklokok> i actually ate until now, although i guess i also did other things...
01:03:02 -!- oerjan has quit (Quit: Good night).
01:03:03 <alise__> 154|<fax> sekuoir: that's just gay sex <sekuoir> I am learning though!
01:03:10 <alise__> then the stuff we've seen
01:03:14 <alise__> `quote
01:03:14 <Sgeo> alise__, what's with the spamminess
01:03:15 <HackEgo> 151|<Miya> I perceived it so hard I actually went away :O
01:03:21 <alise__> Sgeo: boredom, going to bed soon, etc
01:03:22 <fax> `quote ehird
01:03:23 <alise__> `quote
01:03:25 <HackEgo> 13|* ehird has joined #lobby <Madelon> hmmm clean me 24|<oerjan> ehird has gone insane, clearly. 30|<oerjan> In an alternate universe, ehird has taste 31|IN AN ALTERNATE UNIVERSE: <oerjan> In an alternate universe, I would say In an alternate universe, ehird has taste 32|<ehird> so i can only conclude that it is flawed, or the
01:03:25 <nooga> usual boring mess
01:03:32 <fax> `quote ehird
01:03:34 <HackEgo> 42|<ais523> after all, what are DVD players for?
01:03:34 <HackEgo> 13|* ehird has joined #lobby <Madelon> hmmm clean me 24|<oerjan> ehird has gone insane, clearly. 30|<oerjan> In an alternate universe, ehird has taste 31|IN AN ALTERNATE UNIVERSE: <oerjan> In an alternate universe, I would say In an alternate universe, ehird has taste 32|<ehird> so i can only conclude that it is flawed, or the
01:03:42 <Sgeo> `quote Sgeo
01:03:42 <alise__> `quote ais
01:03:44 <HackEgo> 60|<Sgeo>
01:03:52 <HackEgo> 42|<ais523> after all, what are DVD players for? 138|<ais523> so a.b.c.d.e.f.g.h.i.j.k.com might be self-relative, but a.b.c.d.e.f.g.h.i.j.k.l.com always means a.b.c.d.e.f.g.h.i.j.k.l.com.? 139|<ais523>
01:03:54 <alise__> 60|<Sgeo> Mafia's addictin
01:03:58 <nooga> `quote nooga
01:03:58 <alise__> 76|<Sgeo_> I had an idea for an AskReddit, but I forgot
01:03:59 <HackEgo> No output.
01:04:02 <nooga> :D
01:04:02 <alise__> 89|<Sgeo> What else is there to vim besides editing commands?
01:04:05 <alise__> 117|<Sgeo> I'd imagine that it already has, and no one noticed
01:04:06 <fax> what's a round square copula
01:04:09 <alise__> 120|<Sgeo|web> Where's the link to the log? <lament> THERE'S NO LOG. YOUR REQUEST IS SUSPICIOUS AND HAS BEEN LOGGED.
01:04:16 <alise__> 130|<virtuhird> Sgeo_: Gregorr: and someone could, by mistake, rewrite psox to be a weak erection if it is... A filename.
01:04:33 <alise__> `quote virtu
01:04:34 <HackEgo> 130|<virtuhird> Sgeo_: Gregorr: and someone could, by mistake, rewrite psox to be a weak erection if it is... A filename.
01:04:39 <alise__> `quote
01:04:40 <HackEgo> 117|<Sgeo> I'd imagine that it already has, and no one noticed
01:04:42 <alise__> `quote
01:04:43 <HackEgo> 46|<ehird> Or the brutal rape of the English language! <pikhq> That wasn't rape. English is always willing.
01:04:50 <nooga> yawn
01:05:04 <alise__> `quote 97
01:05:05 <HackEgo> 97|<fungot> i am sad ( of course by analogy) :) smileys)
01:05:19 * Sgeo should rewrite PSOX to be a weak erection
01:05:20 <fax> alise
01:05:22 <alise__> Sometimes I think that bot has developed cogence.
01:05:34 <fax> im listening a philosophy lecture about existentialism
01:05:43 <alise__> i'm spamming bots
01:05:46 <alise__> pleased to meet you
01:05:48 <alise__> `quote
01:05:49 <HackEgo> 52|<ehird> Apple = Windows.
01:05:51 <Sgeo> I'm Sgeo.
01:05:52 <alise__> `quote
01:05:53 <HackEgo> 84|<Warrigal> Porn. <Warrigal> There, see?
01:05:53 <fax> thank you
01:05:55 <alise__> `quote
01:05:56 <HackEgo> 121|<fedoragirl> My mascot is a tree of broccoli.
01:05:59 <alise__> `quote
01:06:00 <HackEgo> 44|<zzo38> I am not on the moon.
01:06:02 <alise__> `quote
01:06:03 <HackEgo> 45|<PoPSiCLe> ah... the biggest problem with great Norwegian hip hop lyrics is that they're completely impossible to translate
01:06:06 <alise__> `quote
01:06:07 <HackEgo> 42|<ais523> after all, what are DVD players for?
01:06:09 <alise__> `quote
01:06:10 <HackEgo> 1|<Aftran> I've always wanted to kill someone. >.>
01:06:12 <alise__> `quote
01:06:14 <HackEgo> 70|<pikhq> Gregor is often a scandalous imposter. It's all the hats, I tell you.
01:06:16 <alise__> `quote
01:06:18 <nooga> i'm trying to invent even more hairy syntax for regular expressions
01:06:18 <HackEgo> 70|<pikhq> Gregor is often a scandalous imposter. It's all the hats, I tell you.
01:06:21 <alise__> `quote
01:06:22 <HackEgo> 17|<GKennethR-L> :d <(I can lick my nose!)
01:06:24 <alise__> `quote
01:06:25 <HackEgo> 149|<ais523> theory: some amused deity is making the laws of physics up as they go along
01:06:28 <alise__> `quote
01:06:29 <HackEgo> 41|<Madelon> :D * Madelon has quit (Ping timeout: 121 seconds)
01:06:31 <alise__> `quote
01:06:33 <HackEgo> 98|<fungot> ehird: every set can be well-ordered. corollary: every set s has the same diagram used from famous program talisman with fnord windows to cascade, someone i would never capitalize " i"
01:06:35 <alise__> `quote
01:06:36 <HackEgo> 42|<ais523> after all, what are DVD players for?
01:06:38 <alise__> `quote
01:06:39 <HackEgo> 76|<Sgeo_> I had an idea for an AskReddit, but I forgot
01:06:42 <alise__> shitty rng
01:06:43 <alise__> `quote
01:06:44 <HackEgo> 61|<fizzie> Seconds. 30 of them. Did I forget the word?
01:06:46 <alise__> `quote
01:06:47 <HackEgo> 145|<apollo> Why couldn't we have just kept STD?
01:06:58 <alise__> `quote 77
01:06:58 <HackEgo> 77|<ehird> no Deewiant <Deewiant> No?! <Deewiant> I've been living a lie <ehird> yep. <Deewiant> Excuse me while I jump out of the window ->
01:06:59 <nooga> can you please stop?
01:07:07 <alise__> `quote 91 92
01:07:08 <HackEgo> No output.
01:07:08 <alise__> no, never!
01:07:11 <alise__> `quote 91
01:07:11 <alise__> `quote 92
01:07:12 <HackEgo> 91|<oklopol> actually just ate some of the dog food because i didn't have any human food... after a while they start tasting like porridge
01:07:18 <nooga> okay, continue
01:07:19 <alise__> not unless something interesting happens
01:07:20 <HackEgo> 92|<oklopol> if a girl is that cute, i don't care how many penises she has
01:07:20 <nooga> forever
01:07:22 <alise__> `quote 92
01:07:23 <HackEgo> 92|<oklopol> if a girl is that cute, i don't care how many penises she has
01:07:33 <alise__> `quote 80
01:07:34 <HackEgo> 80|<Warrigal> I think hamsters cannot be inert.
01:07:44 <pikhq> oklopol is somewhat crazy apparently.
01:07:50 <alise__> "somewhat"
01:07:51 <Sgeo> `quote alise__ is actually getting on MY nerves now.
01:07:53 <HackEgo> No output.
01:07:58 <alise__> lol fail
01:08:04 <alise__> `quote 94
01:08:05 <HackEgo> 94|* oerjan swats FireFly since he's easier to hit -----### <FireFly> Meh * FireFly dies
01:08:09 <alise__> `quote 93
01:08:10 <HackEgo> 93|<Oranjer> oohhh <Oranjer> ha <Oranjer> heh <madbrain> and what are your other characteristics? <Oranjer> oh, many, madbrain <Oranjer> but it's hardly worth it to go on with listing that list here
01:08:19 <Oranjer> :(
01:08:23 <pikhq> alise__: ... By our standards.
01:08:28 <fax> lul
01:08:34 <alise__> `quote 95
01:08:35 <HackEgo> 95|<fungot> Oranjer: the taylor's series is also alternately fnord as follows ( i'm using the latex notation here): david ben gurion signed the compensation agreement with germany when there was considerable division over these issues, because these are speculations without " any historical basis".
01:08:36 <fax> this neiztche thing is like a fucking self help
01:08:38 <fax> LOL
01:08:40 <alise__> worst say of fnording a taylor series
01:08:42 <Sgeo> `run echo -e "alise__, stop\nalise__, stop\nalise__, stop"
01:08:43 <HackEgo> alise__, stop \ alise__, stop \ alise__, stop
01:08:44 <fax> I didn't expect that
01:08:45 <alise__> EVAR
01:08:50 <Sgeo> Dammit
01:08:50 <alise__> *way
01:08:55 <fax> alise
01:09:05 <fax> do you know about NARWHALISM?
01:09:09 <alise__> lol wut
01:09:14 <Sgeo> `run yes alise__ stop
01:09:15 <HackEgo> alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop \ alise__ stop
01:09:19 <alise__> Sgeo: no
01:09:20 <pikhq> 43|<ehird> pikhq: A lunar nation is totally pointless. <fungebob> ehird: consider low-gravity porn <ehird> fungebob: OK. Now I'm convinced.
01:09:25 <pikhq> Classic.
01:10:01 <alise__> 126|<Warrigal> Ah, vulva. <Warrigal> What is that, anyway?
01:10:17 <alise__> 128|<Slereah> I can do everything a Turing machine can do, except love
01:10:21 <fax> I would like to go to the moon
01:10:43 <alise__> 135|<scarf> and an AMICED literal would presumably /add/ info to the source <scarf> whatever info gets added, that's the value that the AMICED doesn't contain <scarf> it's all falling into place
01:10:54 <nooga> !show sadbf
01:10:54 <EgoBot> sadol :M$0 :d:i,45000@>i-01(2]M0:i-i1:S$0:C;3:l#C-01:p:m0@<pl(2?=#Cp"1+:#Mm%+#Mm1,3255?=#Cp"1-:#Mm?<-#Mm10,3254-#Mm1?=#Cp"1>:m%+m1d?=#Cp"1<:m?<-m10-s1-m1?=#Cp"1.!'2#Mm?=#Cp"1,:#Mm'1;0?=#Cp"1[]S-p1?=#Cp"1]?=#Mm00:p[S0:p+p1
01:10:57 <nooga> wow
01:11:01 <nooga> it's still here
01:11:59 <alise__> 18|<fungot> GregorR-L: i bet only you can prevent forest fires. basically, you know.
01:11:59 <fungot> alise__: sounds similar to what you're doing
01:12:00 <alise__> Basically.
01:12:07 <alise__> Really? I'm flattered.
01:12:49 <alise__> sleep time now bye
01:13:11 <fax> hello
01:13:14 <fax> alise don't go
01:13:22 <pikhq> alise__: You sleep?
01:13:30 <pikhq> Only... Midnight there.
01:13:33 -!- alise__ has quit (Remote host closed the connection).
01:16:37 -!- nooga has quit (Ping timeout: 264 seconds).
01:46:28 <pineapple> pikhq: off by one. it was 1am
01:47:00 <Sgeo> Oh, alise is still.. I think I forgot that I already saw that conversation
01:55:35 <Gregor> MOO
01:56:46 <fax> moo
02:08:01 <Sgeo> Lambda?
02:08:43 <Gregor> Lamb-baa.
02:29:19 -!- adu has joined.
02:40:46 -!- Axtens has joined.
02:55:14 -!- fax has quit (Quit: Lost terminal).
03:47:38 -!- Sgeo_ has joined.
03:48:50 -!- Sgeo has quit (Ping timeout: 245 seconds).
04:26:20 -!- Oranjer has left (?).
04:30:22 -!- Alex3012_ has joined.
04:33:10 -!- Alex3012 has quit (Ping timeout: 265 seconds).
04:33:12 -!- Alex3012_ has changed nick to Alex3012.
04:46:40 -!- adu has left (?).
04:47:59 -!- Oranjer has joined.
05:04:29 -!- bsmntbombdood_ has joined.
05:06:26 -!- bsmntbombdood has quit (Ping timeout: 240 seconds).
05:26:27 -!- jcp has joined.
05:39:15 -!- SgeoN1 has quit (Ping timeout: 245 seconds).
06:06:35 -!- Oranjer has left (?).
06:17:13 -!- jcp has quit (Read error: Connection reset by peer).
06:22:55 -!- MizardX has joined.
06:34:57 -!- FireFly has joined.
06:44:18 <pikhq> 右翼 and 左翼 in Japanese are, literally, "right wing" and "left wing". And figuratively... "right wing" and "left wing".
06:44:26 <pikhq> Who's responsible for that calque and can I please punch them?
06:45:44 <pikhq> (I should note that 翼 means "wing" as in the body part on various flying animals, not as in a wing of a building)
07:03:56 <myndzi> it's probably a transliteration of the phrases from english
07:04:13 <myndzi> doubt they had equivalent words so it's just a literal translation that depends on understanding the figurative meaning
07:05:01 <myndzi> also lol @ moo/lambda, am i the only one who got it? :P
07:07:06 <pikhq> myndzi: Yes, that's what a calque *is*.
07:10:40 -!- bsmntbombdood__ has joined.
07:11:06 -!- bsmntbombdood__ has changed nick to bsmntbombdood.
07:14:34 -!- bsmntbombdood_ has quit (Ping timeout: 264 seconds).
07:37:29 -!- adu has joined.
07:50:38 <coppro> http://www.theonion.com/articles/geologists-we-may-be-slowly-running-out-of-rocks,17341/
07:51:01 <coppro> pikhq: I assume that the figurative meaning is in relation to politics?
07:51:13 <pikhq> coppro: Yes.
07:51:19 <coppro> ouch
07:57:11 -!- FireFly has quit (Quit: null).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:18:34 -!- bsmntbombdood has quit (Remote host closed the connection).
08:41:31 -!- Axtens has quit (Read error: Connection reset by peer).
08:56:04 -!- adam_d has joined.
09:10:32 -!- coppro has quit (Quit: I am leaving. You are about to explode.).
09:18:34 -!- Tritonio_GR has joined.
09:19:01 -!- Phantom_Hoover has joined.
09:19:10 <Phantom_Hoover> Grrr...
09:19:43 <Phantom_Hoover> I tried alise's bijector and now it seems to have taken all of the hard disc space.
09:20:01 <Phantom_Hoover> For "[[[]]]"!
09:20:15 <fizzie> You've been... bijected!
09:20:52 <Phantom_Hoover> Aah!
09:21:30 <Phantom_Hoover> I assume that this happened because there was a massive bignum in virtual memory.
09:21:51 <Phantom_Hoover> But OS X seems to have resolved not to reclaim it.
09:27:18 <Phantom_Hoover> ",[.,]" is 42860344287450692837937001962400072422456192468221344297750015534814042044997444899727935152627834325103786916702125873007485811427692561743938310298794299215738271099296923941684298420249484567511816728612185899934327765069595070236662175784308251658284785910746168670641719326610497547348822672277487
09:27:39 <Phantom_Hoover> Perhaps I shouldhave pastebinned that. Oops.
09:28:20 -!- Phantom_Hoover has quit (Quit: Page closed).
09:40:05 <fizzie> What is 1?
09:45:52 -!- adu has quit (Quit: adu).
09:57:54 -!- Phantom_Hoover has joined.
09:58:12 <Phantom_Hoover> alise's program isn't a proper bijection.
09:58:21 <Phantom_Hoover> It encodes ++- and ++ the same.
09:58:34 <Phantom_Hoover> Don't know if that came up last night.
10:01:03 <Phantom_Hoover> I'm not sure that it can be fixed.
10:02:54 <Phantom_Hoover> Well, that sucks.
10:04:07 <Phantom_Hoover> It also means that there is no number for which it decodes ++-.
10:07:04 <Phantom_Hoover> And it was so elegant...
10:07:18 -!- Phantom_Hoover has left (?).
10:08:30 <fizzie> The NxN -> N part is still good, though; I guess you just need some sort of fixup for non-loopy strings? Admittedly I didn't follow to what the final result ended up as.
10:23:32 -!- Tritonio_GR1 has joined.
10:24:10 -!- Tritonio_GR has quit (Ping timeout: 264 seconds).
10:29:27 -!- Tritonio_GR has joined.
10:32:45 -!- Tritonio_GR1 has quit (Ping timeout: 276 seconds).
10:39:56 -!- oerjan has joined.
10:40:05 -!- Phantom_Hoover has joined.
10:40:23 <Phantom_Hoover> I *think* that the BF-Nat bijection can be salvaged
10:40:36 <oerjan> um what was wrong with it?
10:40:39 <Phantom_Hoover> It depends on the properties of the NxN->N bijection.
10:40:48 <oerjan> wait i was just thinking about that
10:40:54 <Phantom_Hoover> oerjan: It encodes ++- and ++ the same.
10:40:57 <oerjan> oh
10:41:10 <Phantom_Hoover> Looking at the code I don't think it handles - at all.
10:41:23 <Phantom_Hoover> Basically, I have two ideas.
10:41:55 <Phantom_Hoover> The first is to include the length of the tuple in the outer NxN.
10:42:07 <Phantom_Hoover> This obviously works, but it isn't a bijection.
10:42:18 <oerjan> i cannot help, someone is doing carpentry work outside the window, which is enough to turn my brain off instantly
10:42:18 <Phantom_Hoover> And it has some horrible problems.
10:42:50 -!- adam_d has quit (Ping timeout: 240 seconds).
10:42:53 <Phantom_Hoover> Because f(0, v) = 2v, so all of the even numbers are the null tuple.
10:43:27 <Phantom_Hoover> Alternately, you could make it f(<flattened tuple>, <length>)
10:43:35 <oerjan> i don't see how it can be wrong in that way you describe
10:43:44 <Phantom_Hoover> Which only gives null for 2^k-1.
10:43:58 <oerjan> _What_?
10:44:25 <Phantom_Hoover> I'm not explaining this well, am I?
10:45:15 <oerjan> no. i don't recall that the code i saw previously had that problem, assuming you fixed the lack of a 1+ in the list encoding
10:45:17 <Phantom_Hoover> OK, so we're injecting a tuple {1, 2, 3, 4} as {1, {2, {3, {}}}}
10:45:26 <oerjan> you are missing a 4
10:45:29 <Phantom_Hoover> Then flattening that, taking {} as 0.
10:45:34 <Phantom_Hoover> Forget it±
10:45:37 <oerjan> no!
10:45:49 <Phantom_Hoover> s/{1, 2, 3, 4}/{1, 2, 3}/
10:45:52 <oerjan> ok
10:45:52 <Phantom_Hoover> There?
10:46:12 <Phantom_Hoover> OK, so then we have f(1, f(2, f(3, 0)))
10:46:13 <oerjan> yes. the thing is, you must add 1 to each tuple
10:46:22 <oerjan> i thought that had been corrected
10:46:40 <oerjan> because tuple bijection is between [0..] x [0..] <-> [0..]
10:46:41 <Phantom_Hoover> And use 0 as the terminator?
10:47:09 <oerjan> the point is you must not let {} have the same representation as a cons cell, duh
10:47:20 <Phantom_Hoover> Yeah, OK.
10:47:25 <Phantom_Hoover> That was my second idea.
10:47:45 <Phantom_Hoover> But that relies on the way f behaves if you use it over and over.
10:48:06 <Phantom_Hoover> f^-1, rather.
10:48:18 <oerjan> um no that's a different problem
10:48:40 <Phantom_Hoover> But we want all nats to map to a BF program, fight?
10:48:45 <Phantom_Hoover> s/fight/right/
10:48:45 <oerjan> yes.
10:48:58 <oerjan> now look. it's a list, an algebraic data type
10:49:01 <Phantom_Hoover> OK, but this encoding uses 0 as the end of the list?
10:49:30 <oerjan> data [a] = [] | a:[a], in haskell
10:49:41 <Phantom_Hoover> OK.
10:49:43 <oerjan> (incorrect but enlightening)
10:50:01 -!- cheater2 has quit (Ping timeout: 246 seconds).
10:50:05 <oerjan> that has _two_ branches, one for [] and one for :
10:50:19 <oerjan> they must be mapped to _disjoint_ sets
10:50:39 <oerjan> if [] is mapped to 0, then _no_ cons cell must be mapped to 0
10:50:42 <Phantom_Hoover> But we need to demonstrate that if x_n+1 = cdr(f^-1(x_n)), the sequence hits 0 for all x_0.
10:50:49 <Phantom_Hoover> Yeah, I get that.
10:51:18 <oerjan> right. but your problem at the moment was that you couldn't represent all lists. this fixed that.
10:51:28 <Phantom_Hoover> But we need to prove that every nat decrushes into a valid list.
10:51:29 <oerjan> incidentally it also fixes the other thing, though
10:51:36 <Phantom_Hoover> i.e. one that has 0 in it.
10:51:57 <oerjan> yes. i have a proof, which is what i was thinking about before i came here now
10:52:02 <Phantom_Hoover> Yay!
10:52:05 -!- cheater2 has joined.
10:52:13 <oerjan> first, note that f(x,y) >= x and y
10:52:33 <oerjan> (i assume. it is easy to make an f with that property if you don't)
10:52:39 <Phantom_Hoover> Obviously.
10:52:48 <Phantom_Hoover> You remember what f is?
10:52:57 <oerjan> the tuple encoding, i presume
10:53:10 <Phantom_Hoover> Yeah, but its value.
10:53:24 <Phantom_Hoover> f(u, v) = 2^u(2v+1)-1
10:53:28 <oerjan> 2^x * (2*y+1), or possibly that triangle thing - both are fine for this
10:53:34 <oerjan> oh -1
10:53:41 <Phantom_Hoover> Yeah, so it works for 0.
10:54:11 <Phantom_Hoover> I think that what you said is correct; f(u, v) >= u and v.
10:54:37 <oerjan> in which case, 1 + f(u,v) > u and v, right?
10:55:11 <Phantom_Hoover> ... I think so.
10:55:50 <oerjan> well it is.
10:55:58 <Phantom_Hoover> OK.
10:56:00 -!- Rugxulo has joined.
10:56:05 <Phantom_Hoover> Yes, obviously!
10:56:20 <oerjan> now then, when you recurse, you get a strictly smaller number at each step. thus the recursion must terminate. QED:
10:56:23 <oerjan> *QED.
10:56:43 <Rugxulo> <alise__> x264 is amazing
10:56:47 <Rugxulo> they can encode Blu-Ray now
10:57:15 <Rugxulo> and didn't you see the big whining about how Jobs claims even Theora is going to be attacked over patents?
10:57:22 * Rugxulo is sorry, logreading
10:57:39 <Phantom_Hoover> oerjan: Hang on , why 1+f?
10:58:25 <oerjan> i said that, you need to assign [] and u:v as _disjoint_ sets.
10:58:31 <Phantom_Hoover> Oh, yeah.
10:58:50 * Rugxulo wonders why alise was messing with QBasic
10:58:52 <oerjan> the easiest way to do that and still use all Nats is to do [] -> 0 and shift (u,v) by 1
10:59:33 <fizzie> Rugxulo: It's a habit of his; we had one.. well, maybe not channel-wide, but multiple-people QBasic evening one day a while ago.
10:59:34 <Phantom_Hoover> Well, I don't think you'd get 0, using alise's encoding...
10:59:42 <fizzie> Rugxulo: The HTMLized QBasic manual is from that time.
10:59:46 <Phantom_Hoover> If you set the instructions correctly.
11:00:06 <Rugxulo> dumb question, but why not use FreeBASIC instead?
11:00:34 <fizzie> Rugxulo: For me, it was the semi-nostalgick aspect. Though possibly GW-Basic would have been even more so.
11:00:42 <fizzie> Rugxulo: Who knows why alise does anything?
11:00:46 <oerjan> you cannot get 0 from a finite list, naturally. you have (0,0) -> 0, after all, so it obviously gets infinite if you don't do the 1+ thing
11:00:56 <Rugxulo> ever heard of Jeff Vavasour?
11:00:57 <fizzie> It is an enigma wrapped in old newspapers, and smells of fish.
11:01:02 <Rugxulo> www.vavasour.ca (I think)
11:01:07 <oerjan> oh wait
11:01:17 <Rugxulo> Digital Eclipse, etc.
11:01:22 <oerjan> um no
11:01:38 <Rugxulo> he wrote a (partial?) Breakout emulator in BASICA/GWBASIC/QBASIC
11:01:40 <Phantom_Hoover> So, map '-'..'.' to 1..6, then if it's a loop flatten it and add either 7 or 6?
11:01:51 <Phantom_Hoover> IDK which.
11:02:12 <Rugxulo> Breakout (arcade game, which I think Steve Wozniak and Steve Jobs worked on for Atari [!])
11:02:18 <oerjan> Phantom_Hoover: no, map '-' .. '.' to 0..6, and add 6
11:02:35 <Phantom_Hoover> But if - is 0...?
11:02:55 <Phantom_Hoover> Or is the whole thing in an implicit loop?
11:03:05 <Rugxulo> QB is okay, kinda old, but some impressive stuff was written in it
11:03:18 <Rugxulo> it's actually on MS' FTP site in OLDDOS.EXE, I think
11:03:21 <oerjan> well the encoding of the whole program is the same as the encoding of a single loop, minus the 6
11:03:39 <Phantom_Hoover> OK, but if - is mapped to 0 we get alise's problem.
11:03:43 * Rugxulo finds it odd that they *still* ship DEBUG.EXE, EDIT.EXE, EDLIN.EXE, but no QBasic
11:03:54 <oerjan> oh, hm
11:04:07 <oerjan> Phantom_Hoover: ok right. that is a problem.
11:04:45 <Rugxulo> <ais523> probably in the future, storage will be voluminous and fast enough that people won't bother compressing at all
11:04:49 <Rugxulo> highly doubt it
11:05:18 <oerjan> - is equivalent to the empty program.
11:05:33 <oerjan> oh wait!
11:06:03 <Phantom_Hoover> What?
11:06:12 <oerjan> Phantom_Hoover: no it's not. the empty program is 0. - is 1, because we _still_ do the 1+ thing
11:06:42 <Phantom_Hoover> OK, so what tuple is ",+.", say?
11:06:42 <Rugxulo> <fizzie> Even the digital movies they distribute to real theaters aren't lossless; according to one article, they encode each frame as a separate JPEG2000 file
11:06:45 <Rugxulo> JPEG can do lossless
11:07:11 <Phantom_Hoover> {5, 2, 6, 0}?
11:07:40 <fizzie> Rugxulo: Yes, and JPEG2000 can do lossless too; I just don't think they use it like that.
11:07:43 <Phantom_Hoover> And ",-." is {5, 1, 6, 0}?
11:07:49 <oerjan> 1+f(5,1+f(2,1+f(6,1+f(0,0))))
11:07:50 <Rugxulo> <ais523> 12 I think, that's 640x480 (highest QBasic res, probably due to BIOS limit, but VESA can do higher)
11:08:34 <Phantom_Hoover> oerjan: So if we decons n and the cdr is one then we stop?
11:08:34 <fizzie> Rugxulo: I guess they might. "Motion JPEG 2000 (often referenced as MJ2 or MJP2) is the leading digital cinema standard currently supported by Digital Cinema Initiatives (a consortium of most major studios and vendors) for the storage, distribution and exhibition of motion pictures. -- each frame is an independent entity encoded by either a lossy or lossless variant of JPEG 2000."
11:08:45 <oerjan> no if the cdr is 0
11:09:05 <Rugxulo> and yet my (low-end) digital cam only uses .JPG format (not lossless, either, variable compression)
11:09:06 <Phantom_Hoover> f(0, 0) = 0.
11:09:20 <Phantom_Hoover> So 1+f(0, 0) is 1.
11:09:26 <Rugxulo> <AnMaster> ais523, know of any easy way to disassemble a file that is isn't an object file, just raw x86 instructions
11:09:28 <Rugxulo> ndisasm
11:09:38 <oerjan> yes. 1 <-> - as a program
11:09:42 <Phantom_Hoover> We don't need to decons 0.
11:09:52 <fizzie> Rugxulo: You're a bit late, since I suggested ndisasm there. :p
11:09:56 <Rugxulo> or distorm or BIEW (now called BEYE), IDA Free, etc. etc.
11:10:10 <oerjan> it is the command 1, followed by the program 0 which is empty
11:10:19 <Rugxulo> <ais523> AnMaster: The Windows program DEBUG.COM could do it
11:10:20 <fizzie> Rugxulo: He's partial to the AT&T syntax anyway.
11:10:30 <Rugxulo> first of all, not Windows, pure DOS, secondly it's 8086 only
11:10:33 <Rugxulo> objdump, then
11:10:41 <Phantom_Hoover> OK, I'll modify the code alise posted on the wiki.
11:10:48 <fizzie> Rugxulo: Yes, but it needed some flags. Say, shouldn't you read to the end before commenting?-)
11:10:55 <Rugxulo> objdump -d
11:10:56 <Phantom_Hoover> In a while, though.
11:11:13 <Rugxulo> perhaps need objcopy to binary first ("-Obinary"? I forget)
11:11:20 <Rugxulo> shouldn't I read to end? nah ;-)
11:11:25 <fizzie> Rugxulo: It needs objdump -b binary -m i386:x86-64 -d; that's not completely trivial.
11:11:54 <Rugxulo> well, he *could* run DOSEMU and any DOS-based tool there (including ndisasm)
11:12:34 <fizzie> I don't see why he'd run ndisasm in DOSEMU/dosbox, when it's available packaged in most Linux distributions. Anyway, it produces the wrong syntax.
11:12:46 <Rugxulo> right, forgot
11:12:59 <Phantom_Hoover> oerjan: Why is the +1 even necessary?
11:13:01 <Rugxulo> although shame on him for not understanding / preferring Intel syntax
11:13:17 <fizzie> As for JPEG 2000, I don't think I've heard of any other real uses for it than digital cinema; it's very much different from plain JPEG, you know, being a wavelet-based thing.
11:13:19 <oerjan> Phantom_Hoover: so that the representation of an empty list is different from a nonempty one
11:13:53 <oerjan> a nonempty list is essentially a tuple of car and cdr, but the tuple encoding has no extra room for the [] a list can have
11:13:55 <Phantom_Hoover> Make the empty list 0.
11:14:12 <Rugxulo> <AnMaster> didn't have nasm around on that computer (so get it, pre-built even, at http://www.nasm.us)
11:14:44 <oerjan> Phantom_Hoover: the _tuple_ encoding is [0..] x [0..]. if you don't add 1, there _is_ a tuple which encodes to 0.
11:14:53 <Phantom_Hoover> I suppose.
11:16:55 <Phantom_Hoover> So, to make sure:
11:16:56 * Rugxulo wonders why such a violently DOS-hating crowd would use QBASIC
11:18:00 <fizzie> Rugxulo: Where did you get the "violently DOS-hating" part from?
11:18:13 <Phantom_Hoover> 1. Swap the instructions '-'..'.' in BF with the numbers 0..6, and put any loops into their own tuples.
11:18:22 <Rugxulo> from experience ;-)
11:18:49 <oerjan> Phantom_Hoover: an _empty_ loop is not a tuple
11:19:04 <Phantom_Hoover> Is it just null?
11:19:39 <oerjan> Phantom_Hoover: the thing is, the encoding for single commands is different from the encoding for sequences of commands
11:19:43 <Ilari> Motion JPEG2000? Might not yield the smallest files for given quality...
11:20:00 <Phantom_Hoover> So, wait, when we're uncrushing n, do we stop on 0-as-cdr?
11:20:02 <fizzie> Rugxulo: You must be talking about some other people than us, then. Admittedly a lot of us couldn't consider using DOS for usual day-to-day computing, but that's pretty far from doing "DOS-hating".
11:20:08 <oerjan> as a single command, a loop is just 6+whatever the sequence inside is
11:20:12 <Phantom_Hoover> Yes.
11:20:49 <oerjan> if that sequence is not empty, then it is 1+whatever its car,cdr tuple is
11:21:02 <Phantom_Hoover> OK.
11:21:04 <fizzie> Ilari: It might be good for the particular quality level they're interested in. Or alternatively it could be just an accident of history that they settled on that format.
11:21:12 <oerjan> the car is encoded as a single command, but the cdr is encoded as a command sequence
11:21:52 <oerjan> the whole program is encoded as a command sequence
11:21:53 <Phantom_Hoover> So for "++" you would take {1, 1}, then add one to get {2, 2}, then stick a 0 on the end to get {2, 2, 0}, then cons it?
11:21:58 <Rugxulo> fizzie: I get a fair bit of flack for ever mentioning (Free)DOS to some people
11:22:19 <oerjan> + is 1 as a command iirc
11:22:33 <Ilari> And if its lossless, the files are going to be very large... And as resolutions are high, the movies would be huge...
11:22:55 <Phantom_Hoover> oerjan: Is that correct?
11:23:01 <oerjan> and no. adding 1 to the car before consing is not the same as adding 1 to the cons afterwards, which is what you should do
11:23:17 <Phantom_Hoover> Ooh.
11:23:28 <oerjan> note that there is _no_ empty single command, so you _don't_ need to add 1 for those
11:23:40 <oerjan> instead you add 6 for embedded loops
11:23:41 <fizzie> Ilari: I seem to recall the article mentioning file sizes of around 200-500 gigabytes; I presume that was for the common 2K resolution (2048×1080), so you can guesstimate whether it's lossless or not from that. Probably not.
11:23:44 <Ilari> Trying to make mapping of bf programs to integers without gaps?
11:23:56 <Phantom_Hoover> So we take {1, 1, 0}, then take {1, f(1, 0)}?
11:24:04 <Phantom_Hoover> Plus one.
11:24:26 <oerjan> i don't recommend confusing the notation like that :D
11:24:38 <Phantom_Hoover> {1, 1+f(1, 0)}, then 1+f(1, f(1, 0))?
11:24:44 <oerjan> {1,0} (the list) is 1+f(1,0)
11:24:45 <oerjan> yes
11:24:47 <Phantom_Hoover> Ilari: Yes.
11:25:11 <Phantom_Hoover> It started yesterday evening.
11:26:31 <Ilari> fizzie: 200 gigs for sightly less than 2 hour movie would yield ~270Mbps. Which would be near-lossless with good codec.
11:26:33 <fizzie> Ilari: "Briefly, the specification calls for picture encoding using the ISO/IEC 15444-1 "JPEG2000" (.jp2) standard and use of the CIE XYZ color space at 12 bits per component encoded with a 2.6 gamma applied at projection, and audio using the "Broadcast Wave" (.wav) format at 24 bits and 48 kHz or 96 kHz sampling, controlled by an XML-format Composition Playlist, into an MXF-compliant file at a maximum data rate of 250 Mbit/s." 250 Mbps doesn't sound quite loss
11:26:33 <fizzie> less; that's only around 1.3 megabytes per frame.
11:26:54 <fizzie> I don't believe there's such a thing as "near-lossless".
11:26:57 <Phantom_Hoover> And ",[.,]" -> {5, {4, 5}}, then work the {4, 5} out as if it was a standalone program, then add 6?
11:27:21 <Rugxulo> presumably the part that the human eye can't detect very well (which is JPEG's strong suit, right?)
11:27:27 <oerjan> yeah
11:27:45 <oerjan> this is all very elegant if you think of it as algebraic data types
11:28:06 <fizzie> Rugxulo: It's still JPEG 2000, not JPEG. But yes, that's the idea.
11:28:43 <Phantom_Hoover> oerjan: I find the whole thing to be the most elegant.
11:28:56 <Ilari> Sometimes one sees compression @ 270Mbps in order to pack HD video data for sending over SDI link. And that's with low latency requirements -> not as good compression.
11:29:05 <Phantom_Hoover> I've never seen any bijections between structured text and the nats before.
11:30:07 <oerjan> mhm
11:30:20 <Phantom_Hoover> I wonder if we can generalise it...
11:30:58 <oerjan> certainly, any algebraic data type should work, although the (0,0) <-> 0 infinite recursion problem _might_ crop up again if you're not careful
11:31:50 <oerjan> basically, whenever you have a type that consists of alternatives, you encode each alternative and then do something to the resulting numbers to make the results disjoint
11:32:03 <Phantom_Hoover> The behaviour of f is fairly interesting by itself.
11:32:07 <Ilari> Well, 250Mbps with Motion JPEG2000 is probably better quality than 270Mbps VC-2, since one doesn't have to lose quality for less latency. And 270Mbps is used for studio streams that must be of extremely high quality.
11:32:25 <oerjan> if one alternative is finite, put it first and the (0,0) problem disappears for that choice
11:32:29 <fizzie> Ilari: I don't know if they specify higher data rates for resolutions like 4K (4096x2160 or around that), though. That's a lot of pixels per frame.
11:32:39 <Phantom_Hoover> f(0, x) = 2x, and f(x, 0) = 2^x-1
11:33:17 <Phantom_Hoover> Which leads to the interesting if undesirable quality that all of the even numbers are in one column of the table.
11:33:37 <oerjan> heh
11:34:15 <Phantom_Hoover> I have a nice little table of the first few conses.
11:35:07 <oerjan> as we noted before, that f encoding is really biased to blow up cars
11:35:15 <Phantom_Hoover> Yes.
11:35:35 -!- tombom has joined.
11:35:47 <Phantom_Hoover> But unless someone can think of an elegant deconsing of the triangular one, it's the best we've got.
11:35:54 <oerjan> yeah
11:36:27 <fizzie> Ilari: Now look what you did: you made me go peek at the DCI spec.
11:36:43 <Phantom_Hoover> The rows are all that other type of sequence where u_n+1=ru_n+a
11:36:49 <Phantom_Hoover> Algebraic?
11:37:07 <fizzie> Ilari: "However in the exclusive case to accommodate a 2K, 48 FPS, 12 bit DCDM to use [SMPTE 372M Dual Link HD-SDI] as an interface, it is acceptable, but not recommended, to allow 10 bit color sub-sampling to create the DCDM* at the output of the Image Media Block decoder. This bit depth reduction and color subsampling is only allowed in the single combination of a DCDM at 2K, 48 FPS being transported over a link encrypted SMPTE 372M connection."
11:37:07 <oerjan> um what?
11:37:20 <Phantom_Hoover> I can't remember what it's called.
11:37:35 <oerjan> linear recursive?
11:37:35 <fizzie> oerjan: Sounds like a riotous function there.
11:37:50 <Ilari> "The data size of two hours movie amounts to 8TB."
11:37:53 <oerjan> fizzie: i _may_ have slightly punnified that sentence
11:38:02 <fizzie> Oh, that's just "may"?
11:38:02 <Phantom_Hoover> Actually, it seems that all of the rows have the same r and a.
11:38:18 <oerjan> i admit nothing. NOTHING. ok, maybe a little.
11:39:00 <oerjan> Phantom_Hoover: is this still the 2^u*(2*v+1)-1 encoding?
11:39:04 <Phantom_Hoover> Yes.
11:39:16 <Phantom_Hoover> But it still blows up incredibly quickly.
11:39:32 <Phantom_Hoover> [[[]]] took up the entire hard drive with VM.
11:39:39 <fizzie> If someone wants to worry about the triangular version, you could start with one of the formulas at http://www.research.att.com/~njas/sequences/A000217 -- that's the "first row" of the table of the triangular thing, so if you can easily map n into the largest one of those numbers, it's trivial to then get the actual coordinates.
11:39:52 <Phantom_Hoover> Admittedly there was only ~500M left on the HD, but still.
11:40:04 <fizzie> (After the references there's a big list of ways to compute them numbers.)
11:40:21 <oerjan> fizzie: it's the reversal that is the problem
11:40:37 <fizzie> oerjan: Yes, but it gives many different things to attempt to reverse.
11:40:43 <Phantom_Hoover> fizzie: What about the classic n(n+1)/2?
11:40:46 -!- hiato has joined.
11:40:48 <oerjan> it needs a square root, essentially
11:40:57 <Phantom_Hoover> And oerjan's right.
11:40:58 <oerjan> Phantom_Hoover: that's the one we're talking about
11:41:43 <oerjan> i suppose we could do newton's method approximated with bignum ints
11:42:09 <Phantom_Hoover> It's a trade-off between elegance and practicality.
11:43:37 <oerjan> An exponential generating function for the inverse of this sequence is given by ... and then something horrible
11:44:49 <fizzie> Yes, it's always a bad sign when functions start to get names of people.
11:45:09 <Phantom_Hoover> Bleugh.
11:45:46 <oerjan> this sequence by Triangle (and a bit Robert)
11:46:38 <fizzie> There's a book about generating functions with the title "generatingfunctionology" (all lowercase); I liked it because of the name already.
11:46:40 <fizzie> http://www.amazon.com/reader/1568812795?_encoding=UTF8&ref_=sib_dp_pt#reader-link
11:46:53 <fizzie> I guess the official name is maybe not lowercased, but that's the way the cover's printed.
11:47:20 <fizzie> (It was course literature on a discrete maths thing.)
11:47:54 <fizzie> Funny product description there. "One of the most important and relevant recent applications of combinatorics lies in the development of Internet search engines whose incredible capabilities dazzle even the mathematically trained user."
11:48:08 <oerjan> some concatenatingwordology there
11:48:19 <fizzie> It's like the numerical matrix course where the instructor started by talking about the Google matrix. Everyone wants to get on the Internet wagon.
11:48:22 <fizzie> Even mathists.
11:48:35 <fizzie> Or is it "mathologists"?
11:49:11 <Phantom_Hoover> Is "mathematicians" too inaccurate?
11:49:23 <fizzie> Pathological mathologists.
11:49:25 <oerjan> mathophysics
11:49:33 <fizzie> Mathocalypsists.
11:50:00 <oerjan> the mathocalypse will not be nice. it will be very pretty, though.
11:51:19 <oerjan> hm if you want an f encoding that is balanced between x and y, you essentially get approximately square root demanded automatically
11:51:44 <oerjan> because [1..x] x [1..x] has size x^2
11:52:14 <oerjan> on the other hand, hm
11:52:14 <Phantom_Hoover> sqrt is at this point a lesser evil.
11:52:26 <oerjan> if you don't need it _that_ balanced...
11:53:45 <Phantom_Hoover> The current cons causes us to get a 38218-digit number for the cat program.
11:53:50 -!- cheater3 has joined.
11:54:33 <Phantom_Hoover> A 7-char program.
11:55:37 <Phantom_Hoover> That's FOUR ORDERS OF MAGNITUDE.
11:55:56 <Ilari> What cat program? Presumably something more complicated than ',[.,]'...
11:56:11 <Phantom_Hoover> ,[.[-],]
11:56:27 <Phantom_Hoover> The no-change-on-EoF version.
11:56:38 -!- cheater2 has quit (Ping timeout: 240 seconds).
11:57:04 <oerjan> compatible with 0 on eof
11:57:23 <Phantom_Hoover> ,[.,] still gives a number two orders of magnitude greater.
11:57:32 <Ilari> Hmm... Structure [[]], 5 segments...
11:58:08 <Phantom_Hoover> A 22 digit num,ber.
11:58:13 <oerjan> each loop nesting blows up things with 2^... essentially
11:59:29 <Phantom_Hoover> It's particularly irksome because I can't tell what could be in the lower numbers. It's basically all junk, I think.
11:59:36 <Phantom_Hoover> Valid junk, though.
11:59:39 -!- cheater2 has joined.
12:03:15 -!- cheater3 has quit (Ping timeout: 276 seconds).
12:04:00 <Phantom_Hoover> Is it that hard to reverse the function? We've already *got* a mathematically elegant one, so can we just live with using sqrt?
12:04:32 <oerjan> well we can, it's just that sqrt on bigints isn't a common builtin function afaik
12:04:51 <Phantom_Hoover> Oh.
12:05:11 <fizzie> oerjan: GMP at least does square roots.
12:05:18 <Phantom_Hoover> Haskell?
12:05:29 <oerjan> there's probably a haskell package for it
12:05:52 <oerjan> but basic sqrt in haskell is for floating point types only
12:06:06 <Phantom_Hoover> Appalling!
12:06:57 <fizzie> http://www.haskell.org/haskellwiki/Generic_number_type says "The most efficient way is to call the native implementation of the square root of GNU's multiprecision library. (How to do that?) The most portable way is to implement a square root algorithm from scratch." and implements something iterative.
12:07:06 <fizzie> The "How to do that?" isn't especially helpful.
12:10:11 <oerjan> well i guess stealing that code may be an option :D
12:12:19 <oerjan> right that is newton's method
12:12:38 -!- Phantom_Hoover has quit (Ping timeout: 252 seconds).
12:14:01 <fizzie> There's also http://gmplib.org/manual/Square-Root-Algorithm.html but that's a bit specific to their particular representation of integers.
12:14:11 -!- Phantom_Hoover has joined.
12:14:46 <Phantom_Hoover> oerjan: So how do we represent null lists, again?
12:14:53 <oerjan> 0
12:15:32 <Phantom_Hoover> Oh, yeah.
12:16:03 <oerjan> http://www.haskell.org/haskellwiki/Generic_number_type#squareRoot but i wonder why the heck they recurse on squareRoot itself...
12:16:14 <Phantom_Hoover> And do we add 1 to the f(0, 0) at the end?
12:16:28 <Phantom_Hoover> I'm sorry, I'm just forgetful.
12:17:02 <oerjan> there is no f(0,0) at the end unless you actually have a car that is 0 there
12:17:30 <oerjan> (that - from before i presume)
12:17:31 <Phantom_Hoover> OK, so at the end you decons and find that the car is the last element and the cdr is 0?
12:17:41 <oerjan> yep
12:18:03 <oerjan> you _do_ subtract 1 before that decons, naturally
12:18:06 <Ilari> I think I figured out a way to reduce enumerating brainfuck programs to enumerating non-empty (ordered) trees... But how to enumerate ordered trees...
12:18:39 <Phantom_Hoover> This method works fine *in theory*.
12:18:49 <Phantom_Hoover> The numbers are enormous in practice.
12:18:50 <oerjan> Ilari: why non-empty? the empty bf program is perfectly legal
12:20:00 <oerjan> i suspect that recursive squareRoot in there was added by someone who didn't know what they were doing
12:22:02 <Ilari> Actually, reducing problem of...
12:22:05 <Phantom_Hoover> Recursion seems appropriate in this context.
12:22:24 <Ilari> oerjan: Encoding empty brainfuck program would need encoding of tree containing just one node...
12:24:01 <oerjan> Phantom_Hoover: no, because the lowerRoot is supposed to be the initial estimate for the newton's method. if you use squareRoot to refine that estimate you never actually _finish_ afaict. not that i have run it.
12:24:31 <oerjan> but i am arrogant enough to edit that page, now
12:24:45 <Ilari> Well, if empty tree is included in enumeration, then one would need to know enumeration of it so one can skip it.
12:25:01 <oerjan> or wait it may hit squareRoot 1
12:25:07 <oerjan> let me check that again
12:25:46 <oerjan> oh!
12:25:52 <oerjan> now i understand it. scratch that.
12:26:04 * oerjan whistles innocently.
12:26:05 <Phantom_Hoover> Ilari: Don't we basically use trees?
12:26:31 <Phantom_Hoover> With the nested tuples?
12:26:59 <Phantom_Hoover> Not that I would know.
12:27:45 <oerjan> it doesn't immediately divide by the highest 2^n, it divides by the highest 2^2^n, so it makes perfect sense to recurse to find lower powers of 2 that still divide it
12:28:52 <Phantom_Hoover> Wait, what are the algorithms for the triangular bijection?
12:29:26 * Phantom_Hoover will have to say that to a layman.
12:29:46 <Ilari> Ordered trees meaning that 'x <- {x <- x, x}' and 'x <- {x, x <- x}' are different.
12:29:46 <oerjan> triang(u+v)+u where triang n = n*(n+1)`div`2; plus or minus any off-by-one errors
12:29:50 <oerjan> Phantom_Hoover: ^
12:30:39 <Phantom_Hoover> OK, and do we have an inverse?
12:30:47 <oerjan> supposedly yes
12:30:55 <Phantom_Hoover> What is it?
12:31:07 <oerjan> finding u+v is approximately a square root
12:31:40 <oerjan> multiply by 2 then take square root, except there might be some adjusting for that +1 in the product
12:32:27 <oerjan> lessee
12:33:12 <Rugxulo> all those quotes (recent log), too bad my B93 proggie only randomly prints 4 :-P
12:33:17 <oerjan> 1 -> 1, 2 -> 2, 3 -> 2, 4 -> 2, 5 -> 3, 6 -> 3, there has to be an off-by-something error in there
12:33:54 <oerjan> 1 3 6 10 15 21 ... are the triangular numbers
12:33:56 <Ilari> How many ordered trees of n nodes are there anyway?
12:34:41 -!- Rugxulo has quit (Quit: math no fun).
12:34:50 <oerjan> 0 1 3 6 10 15 21 ... are the triangular numbers
12:35:05 <Phantom_Hoover> Ilari: How do you represent ",[.[-],]"?
12:35:50 <oerjan> 0:(0,0), 1:(0,1), 2:(1,0), 3:(0,2), 4:(1,1), 5:(2,0), 6:(0,3)
12:35:51 <Phantom_Hoover> For our method it seems to be {4, {5, {0}, 4}}.
12:36:09 <Phantom_Hoover> Sans terminators.
12:36:53 <Ilari> Phantom_Hoover: The tree part of it would be 'x <- x <- x'.
12:36:56 <oerjan> ok that direction looks correct
12:37:43 <Phantom_Hoover> Ilari: What is x?
12:37:53 <Ilari> Phantom_Hoover: Depicts node.
12:38:08 <Phantom_Hoover> And what are the contents of the nodes?
12:39:55 <Ilari> Ah, number of ordered trees with n nodes is C(n-1) (Catalan numbers)...
12:40:02 <Phantom_Hoover> !
12:40:12 <Phantom_Hoover> That's what got me started on this±
12:40:28 <oerjan> wait, what
12:40:40 <oerjan> Phantom_Hoover: you're not secretly clive gifford are you?
12:40:47 <Phantom_Hoover> Stephen Morley used the Catalan numbers to work out the no. of bits needed for a BF program of length n.
12:41:04 <Phantom_Hoover> Which set me thinking whether it would be possible to use that.
12:41:06 * oerjan sent a message involving catalan numbers to him last week
12:41:46 <Phantom_Hoover> Clive Gifford the journalist?
12:42:27 <oerjan> i know nothing about him being a journalist, it's the guy with eigenratios of self-interpreters
12:43:33 <oerjan> and i did a very crude estimate of such a ratio which ended up being the catalan numbers in one column
12:43:50 * Phantom_Hoover has no idea what an eigenratio is
12:44:18 <Ilari> There are no contents in these nodes. It is representation of structure of the program.
12:44:35 <oerjan> i'm still waiting to hear back about my next refined estimate, i'm afraid it ruins one of his hypotheses so i hope he's not angry at me
12:45:02 <oerjan> Phantom_Hoover: basically if you have a self-interpreter for a programming language
12:45:28 <oerjan> and then you give it itself as argument, so it runs itself
12:45:43 <oerjan> and you give _that_ the self-interpreter as argument, etc.
12:46:06 <Phantom_Hoover> OK...
12:46:29 <oerjan> then for some self-interpreters as you nest this, the running time gets slower in the limit by a constant factor each step
12:46:51 <oerjan> growing approximately like r^n
12:47:47 <oerjan> then r is the eigenratio. clive gifford has a blog about this: http://eigenratios.blogspot.com/
12:48:00 <Phantom_Hoover> OK/
12:48:13 <Phantom_Hoover> Maths is never as cool once you learn it.
12:48:29 <Phantom_Hoover> Well, for a given value of "cool"
12:48:42 <oerjan> he's used matrices to calculate this ratio for some interpreters, the "eigen-" is because the ratio turns out to be an eigenvalue of that matrix
12:50:22 <oerjan> Phantom_Hoover: back to the bijection; i think multiplying by 2 and then taking square root gives either the floor of u+v or 1 more than it - i don't see a way to get either directly so there needs to be a postcheck for which one is right
12:50:50 <Phantom_Hoover> And how do we derive u and v from u+v?
12:51:15 <oerjan> well we start with n = triang(u+v)+u
12:51:25 <Phantom_Hoover> Yep.
12:51:30 <oerjan> so once we have u+v, u = n-triang(u+v)
12:51:40 <Phantom_Hoover> Oh.
12:51:40 <oerjan> and then v = (u+v)-u
12:52:20 <Phantom_Hoover> Any progress on the sqrt?
12:52:35 <oerjan> that haskell link should work fine enough?
12:52:53 <oerjan> (i was wrong about that recursion being a problem btw)
12:53:31 <oerjan> http://www.haskell.org/haskellwiki/Generic_number_type#squareRoot
12:55:06 -!- FireFly has joined.
12:55:16 <Phantom_Hoover> Oh, OK.
12:56:44 <Phantom_Hoover> Ilari: http://safalra.com/programming/esoteric-languages/bf/program-density/ is safalra's page on the lowest number of bits needed to represent a BF program. The use of the Catalan numbers in both can't be a coincidence.
12:57:20 <oerjan> probably not
12:57:51 <Phantom_Hoover> Probably not a coincidence or probably not not a coincidence?
12:58:18 <oerjan> xkcd is picking up these past couple of times...
12:58:28 <oerjan> probably not *ducks*
12:59:33 <Phantom_Hoover> That one was pretty good.
13:06:02 -!- oerjan has quit (Quit: Later).
13:07:38 -!- Phantom_Hoover has left (?).
13:09:46 -!- lereah_ has joined.
13:26:54 <Ilari> Assuming x <- x <- x encodes to 2 (and choosing operation enumeration order to be '+-<>,.'), i get that enumeration of ",[.[-],]" is 144 877 580...
13:47:22 -!- nooga has joined.
13:47:52 <nooga> hey
14:03:41 <nooga> who was norwegian?
14:04:16 <fizzie> oerjan, at least.
14:04:20 <fizzie> He just left an hour ago.
14:04:28 <fizzie> Or maybe "an hour" is not "just".
14:05:21 <nooga> heh
14:05:31 <nooga> maybe he's sleeping
14:06:38 <fizzie> I'm sure you can find some Norwegians in a shop or something.
14:11:12 <nooga> right
14:15:39 <nooga> Norwegians in Poland, in a shop
14:15:46 <nooga> -,-
14:17:39 <fizzie> Well, maybe a local people-store can order them in?
14:18:56 <Deewiant> I think they don't have those
14:20:54 <augur> i am reminded why Java is a horrible programming language
14:22:42 <fizzie> Deewiant: Slave markets or some-such.
14:22:43 -!- hiato has quit (Quit: underflow).
14:24:37 <nooga> augur, amen
14:24:56 <augur> javanauts are a bunch of douches, basically.
14:25:05 <nooga> JAVANAUTS OMFG\
14:25:25 <nooga> o\
14:25:46 <fizzie> Nautical Java, for ship automation.
14:26:02 <fizzie> What did Java do now that was so awful?
14:27:04 <Ilari> 0 -> '', 1 -> '[]', 2 -> '+', 3 -> '+[]', 4 -> '-
14:27:06 <Ilari> '
14:30:16 <fizzie> Ilari: I think you're going to have to give us a bit more detail on how exactly that goes.
14:31:48 <Ilari> I still need to figure out a way to enumerate non-empty ordered trees (so far the numbers are based on assumptions on that enumeration)...
14:32:28 <fizzie> Yes, but as a sneak-preview you could let us know how it goes, assuming you can enumerate those gaplessly and efficiently.
14:35:52 -!- alise has joined.
14:36:03 <alise> <pikhq> alise__: You sleep?
14:36:03 <alise> <pikhq> Only... Midnight there.
14:36:03 <alise>
14:36:04 <alise> didn't sleep night past
14:36:15 <alise> s/all that colour junk (if you got it) and the blank line//g
14:36:55 -!- augur has quit (Remote host closed the connection).
14:37:08 -!- augur has joined.
14:41:14 <AnMaster> <Rugxulo> well, he *could* run DOSEMU and any DOS-based tool there (including ndisasm) <-- there is an issue here, why DOS at all. Also it seems likely that most DOS based tools are older than x86_64 with SSE4.1 (this code turned out to contain such instructions)
14:42:10 <AnMaster> btw, I wonder if it would be feasible to make an x86 program that were valid even when you remove the first byte, (and not making the first byte a nop or other such trivial variants)
14:42:49 <AnMaster> basically it would mean that both the program and a not-whole-instruction offset should be valid
14:43:38 <AnMaster> presumably would be easy for small programs, but preferably this should be some non-trivial thing that does something that isn't complete nonsense
14:44:33 <alise> DOS for QBasic.
14:44:42 <AnMaster> (and preferably it shouldn't just branch to different, unshared, parts of the code right away)
14:44:44 <AnMaster> alise, hm?
14:44:50 <alise> I was using DOS for QBasic.
14:44:56 <alise> Or was that another DOS conversation?
14:46:00 <alise> 01:19:10 <Phantom_Hoover> Grrr...
14:46:01 <alise> 01:19:43 <Phantom_Hoover> I tried alise's bijector and now it seems to have taken all of the hard disc space.
14:46:01 <alise> 01:20:01 <Phantom_Hoover> For "[[[]]]"!
14:46:03 <alise> Yes.
14:46:06 <AnMaster> alise, the thing rugxulo said? It was right in the context of quoting me on disassembling a file that wasn't in ELF or any other format (just "raw" instructions)
14:46:08 <alise> 01:27:39 <Phantom_Hoover> Perhaps I shouldhave pastebinned that. Oops.
14:46:09 <alise> it probably got cut off
14:46:19 <alise> 01:58:12 <Phantom_Hoover> alise's program isn't a proper bijection.
14:46:19 <alise> 01:58:21 <Phantom_Hoover> It encodes ++- and ++ the same.
14:46:24 <alise> I saw that, yes.
14:46:28 <alise> I will fix it, I think.
14:46:33 <alise> I am going to change the bijection.
14:46:36 <AnMaster> alise, bijection to what?
14:46:45 <alise> Bifro.
14:46:51 <AnMaster> doesn't ring a bell at all
14:47:47 <AnMaster> google indicates it is a hair style(?), which seems quite improbably in this context
14:48:03 <alise> jane@jane-desktop:~/code$ echo '++' | ./bifro encode
14:48:04 <alise> 10
14:48:04 <alise> jane@jane-desktop:~/code$ echo '++-' | ./bifro encode
14:48:04 <alise> 26
14:48:05 <alise> fix'd
14:48:16 <alise> AnMaster: A program I wrote last night; it well-orders the set of valid brainfuck programs.
14:48:19 <AnMaster> ah
14:48:24 <alise> Which also means every valid BF program has a corresponding number.
14:48:28 <alise> It can give you the number, and decode any number.
14:48:30 <AnMaster> alise, are they sparse?
14:48:41 <alise> Sparse howso?
14:48:53 <alise> The encoding is somewhat suboptimal:
14:48:55 <alise> jane@jane-desktop:~/code$ echo '[]' | ./bifro encode
14:48:56 <AnMaster> alise, as in, not all numbers are mapped
14:48:56 <alise> 64
14:48:56 <alise> jane@jane-desktop:~/code$ echo '[[]]' | ./bifro encode
14:48:56 <alise> 1180591620717411303424
14:49:01 <AnMaster> right
14:49:02 <alise> and [[[]]] I don't think is calculable in this universe
14:49:04 <alise> AnMaster: all numbers are mapped
14:49:07 <alise> that's basically the entire point
14:49:11 <alise> otherwise it's "quite easy"
14:49:18 <AnMaster> alise, yep, ascii code
14:49:22 <AnMaster> as a bignum
14:49:23 <alise> well, no
14:49:24 <alise> that doesn't handle []
14:49:31 <alise> which is the other "difficult" part
14:49:34 <alise> as in
14:49:35 <alise> you can have [
14:49:36 <alise> and ]
14:49:37 <alise> unmatched
14:49:44 <alise> all I have to do is fix my NxN -> N bijection, anyway, and the numbers will be more reasonable
14:49:49 <AnMaster> alise, true, but those are not in the domain the function is defined in
14:49:54 <alise> but, I don't think oerjan has given me the inverse algorithm either :-)
14:49:57 <AnMaster> (problem solved in a cheating kind of way)
14:49:59 <alise> AnMaster: Well, yes, true.
14:50:08 <alise> jane@jane-desktop:~/code$ echo ',[.,]' | ./bifro encode
14:50:09 <alise> 1581267603963364205878869896241541461324661326282360299663291859589299527874963647593440497667477535118649045814975093057732880760826511538023542187037019608761854877160674698159897716735103252665935684988068320848140683464255411707953932466009059033912578566502802887127604801681488301032705683661296923932091466727292944
14:50:21 <alise> This mess is caused because
14:50:22 <alise> biTo :: (Integer, Integer) -> Integer
14:50:22 <alise> biTo (u,v) = ((2^u) * ((2*v) + 1)) - 1
14:50:26 <alise> so obviously u gets very big
14:50:26 <alise> and
14:50:36 <AnMaster> alise, it isn't like it is a continuous function anyway, it is only defined for the integers
14:50:40 <alise> we encode loops with 6 + their crushing (6 is the number of non-loop instructions)
14:50:47 <AnMaster> (right?9
14:50:48 <alise> so we have some 2^ magic in every element of the loop
14:50:49 <alise> and get a huge number
14:50:50 <alise> THEN
14:50:54 <AnMaster> s/9/)/
14:50:57 <alise> we do 2^huge
14:50:58 <alise> "ouch"
14:51:03 <alise> AnMaster: naturals :P
14:51:07 <AnMaster> alise, right
14:51:13 <AnMaster> alise, what is the bf program 195722?
14:51:29 <alise> With the new fixed encoding that nobody else has seen before?
14:51:35 <AnMaster> well, either
14:51:46 <alise> Well, the previous one is broken because it encodes ++ and ++- the same.
14:51:50 <AnMaster> right
14:51:53 <AnMaster> and the with the new one?
14:51:57 <alise> This one is broken because it's too huge but I need oerjan or someone to give me the inverse function first :P
14:52:01 <alise> $ echo 195722 | ./bifro decode
14:52:02 <alise> ++><-----+
14:52:07 <AnMaster> heh nice
14:52:11 <alise> Loops are very rare; to understand why, consider that they take the form of 2^huge.
14:52:22 <alise> And even adding one instruction to a loop makes it unimaginably bigger.
14:52:36 <AnMaster> ah
14:52:51 <AnMaster> alise, so [-] is?
14:52:53 <alise> To wit, consider the two progams ,[.,] and ,[.,,]
14:53:03 * alise pasties
14:53:09 <AnMaster> ouch that bad...
14:53:12 <alise> [-] is 128, nicely enough
14:53:17 <alise> AnMaster: http://pastie.org/943535.txt?key=wyaxhf87u5uvgzblwuxa
14:53:28 <AnMaster> alise, tell me what lostking is in this. I mean, number of digits in it
14:53:32 <AnMaster> rather than the whole thing
14:53:44 <alise> AnMaster: Calculating the log would be very hard, the expression would be very big
14:53:53 <AnMaster> alise, true
14:54:01 <alise> Considering even very small programs probably cannot fit into the universe and I run out of 2GB on even very very trivial programs,
14:54:06 <alise> I doubt it is feasible.
14:54:16 <alise> Anyway, with the triangular NxN -> N bijection it should be okay.
14:54:25 <alise> But I need to figure out (a) a canonical formula for it; and (b) its inverse.
14:54:26 <AnMaster> alise, what sort of programs use more than 2GB?
14:54:30 <AnMaster> I mean, how trivial
14:54:58 <alise> Let's see.
14:55:10 <alise> $ echo ',[>>>>>.]+[<<<<<<<<<<]' | ./bifro encode
14:55:13 <alise> I am pretty sure this will run out of memory.
14:55:15 <alise> Not certain, though.
14:55:22 <alise> I know that a <1kb rot13 did it.
14:55:26 <fizzie> alise: There in the logs is one oerjan-guess for how you can derive the inverse, assuming you can do sqrt on your bignums.
14:55:29 <alise> Oh, you want an EASY one?
14:55:34 <AnMaster> alise, what about nested loops? lets take something trivial [[-]-] or such
14:55:39 <alise> Certainly. Second.
14:55:43 <alise> AnMaster: yes, that's what i'm saying
14:55:45 <alise> it grows very quickly
14:56:13 <AnMaster> alise, yes, but what order of size is something like [[-]-]. ,I would guess it is still pastebinable
14:56:14 <alise> $ echo '[[-]-]' | ./bifro encode
14:56:15 <alise> 2521728396569246669585858566409191283525103313309788586748690777871726193375821479130513040312634601011624191379636224
14:56:15 <alise> Disadvantage; - is the lowest.
14:56:18 <AnMaster> ah
14:56:23 <alise> Not much more at all than that.
14:56:27 <AnMaster> right, still quite large
14:56:29 <alise> echo '[[[-]-]-]' | ./bifro encode
14:56:29 <alise> hands
14:56:31 <alise> *hangs
14:56:33 <AnMaster> ouch
14:56:34 <alise> AnMaster: Do you want the code?
14:56:42 <alise> It has a proper CLI to use it and everything
14:56:46 <alise> Well, I don't know that it hangs forever
14:56:48 <AnMaster> alise, not really, it isn't a very useful bijection ;)
14:56:57 <alise> Hey, as long as you avoid nested loops...
14:57:03 <alise> http://pastie.org/942869.txt?key=vvwlyvvpwhxulduzur3q, anyway, one patch to make:
14:57:09 <AnMaster> alise, well, ',[>>>>>.]+[<<<<<<<<<<]' isn't nested
14:57:10 <alise> crush (x:xs) = biTo (x, crush xs)
14:57:11 <alise> becomes
14:57:14 <alise> crush (x:xs) = biTo (x, crush xs) + 1
14:57:15 <alise> and
14:57:17 <alise> decrush n = let (x,xsn) = biFro n in x : decrush xsn
14:57:17 <alise> becomes
14:57:18 <AnMaster> two loops sure, but not nested
14:57:20 <alise> decrush n = let (x,xsn) = biFro (n-1) in x : decrush xsn
14:57:36 <alise> ,[>>>>>.]+[<<<<<<<<<<] -- running now
14:58:12 <alise> Amusingly, decoding is very quick and encoding is very slow, even though the decoding iterates /2 on a number until it does not divide two any more, and the encoder is O(1) for a single instruction!
14:58:44 <AnMaster> hah
14:58:58 <AnMaster> alise, aren't most things O(1) for a single input operand
14:59:09 <alise> biTo :: (Integer, Integer) -> Integer
14:59:10 <alise> biTo (u,v) = ((2^u) * ((2*v) + 1)) - 1
14:59:10 <alise> but
14:59:10 <AnMaster> well, assuming you measure in the right way
14:59:14 <alise> biFro :: Integer -> (Integer,Integer)
14:59:15 <alise> biFro n = (m, (((n `div` (2^m)) - 1) `div` 2) + 1)
14:59:15 <alise> where n' = n + 1
14:59:15 <alise> m = toInteger . length . takeWhile (\n'' -> mod n'' 2 == 0) $ iterate (`div` 2) n'
14:59:15 <alise> you decide
14:59:17 <alise> the m is basically
14:59:48 <alise> m = 0; while n' % 2 == 0 { m += 1; n' = n' div 2 }
15:00:05 <AnMaster> alise, I might be more interested when you come up with a mapping that gives "usable" results. With that I mean that lostkng should be possible to encode on something in this universe. Preferably something that isn't a super computer too ;)
15:00:39 <alise> 02:57:15 <Rugxulo> and didn't you see the big whining about how Jobs claims even Theora is going to be attacked over patents?
15:00:46 <alise> no, he claimed apple themselves are going after theora, iirc
15:00:56 <alise> AnMaster: LostKng - forget it, I imagine.
15:01:03 <alise> rot13? quines? sure.
15:01:15 <alise> AnMaster: One very interesting thing to do is to come up with an encoding-quine.
15:01:39 <AnMaster> alise, hm?
15:01:45 <alise> Make a program P such that P calculates (and preferably outputs) N, and number(P) = N.
15:01:51 <AnMaster> ah
15:01:56 <alise> Like a name tag!
15:01:58 <alise> A name tag for itself.
15:02:11 <AnMaster> alise, does such a program even exist?
15:02:22 <alise> By the fixed-point theorem, yes.
15:02:27 <alise> (The same theorem that guarantees that quines exist.)
15:02:42 <alise> Proof that such a program exists:
15:02:45 <alise> number(P) is certainly a computable function; therefore Brainfuck can compute it.
15:02:51 <alise> Fixed-point theorem; Q.E.D.
15:03:31 <alise> 03:00:06 <Rugxulo> dumb question, but why not use FreeBASIC instead?
15:03:38 <alise> No peeking 'n poking madness; no nostalgia; no good-ole-days-feeling.
15:03:56 <alise> 03:00:42 <fizzie> Rugxulo: Who knows why alise does anything?
15:03:57 <alise> 03:00:57 <fizzie> It is an enigma wrapped in old newspapers, and smells of fish.
15:03:59 <alise> The answer is "fish and chips"
15:04:02 <alise> "Old fish and chips"
15:06:29 <AnMaster> hm
15:06:33 <alise> 03:16:56 * Rugxulo wonders why such a violently DOS-hating crowd would use QBASIC
15:06:38 <alise> DOS is an interesting toy.
15:06:50 <alise> It is well-architecture for running programs in a simple language with full hardware access.
15:06:56 <alise> And compiling them (with QuickBasic).
15:06:58 <alise> No more, however.
15:07:05 <AnMaster> no more?
15:07:47 <alise> Yes; for things like basic office applications it works but it badly architectured.
15:07:49 <alise> I guess games, it's good for, too.
15:07:52 <alise> But that's it.
15:07:56 <alise> *but is badly
15:08:02 -!- BeholdMyGlory has joined.
15:08:11 <AnMaster> alise, idea: DOS C compiler + some asm routines, called peek and poke
15:08:21 <alise> lol.
15:08:23 <alise> basic ftw
15:08:40 <AnMaster> sure, but you have to admit that basic has it's downsides (so do C but meh)
15:08:41 <alise> it's even an advanced editor, factors procedures out into a menu and doesn't show them in the main program source (imagine it is called "main" and it all makes sense!)
15:08:55 <alise> QuickBasic doesn't have all that many disadvantages for DOS.
15:09:09 <alise> It's fast, it compiles proper programs, and it's a fucking awesome language for peeking and poking and whatnot.
15:09:14 <AnMaster> alise, and 640 kB is enough for everyone?
15:09:24 <alise> Hey, I'm explicitly meaning FOR TINKERING here.
15:09:37 <AnMaster> right, but sometimes you want to tinker with hundred of MB
15:09:44 <AnMaster> or is that no longer tinkering then?
15:10:36 <Ilari> alise: '[[[[[[[[]]]]]]]]' is totally out of reach, right?
15:10:50 <fizzie> AnMaster: On x86-32, the bytes "05 00 00 00 00" are "addl 0, %eax", while "66 05 00 00 00 00" are "addw 0, %ax; addb %al, (%eax)". If you can make sure %eax points to something sensible and the lowest byte is nonzero, you can determine which variant was executed based on whether the byte at %eax was changed or not.
15:10:52 <fizzie> AnMaster: Since the only thing that can possibly be different is that first instruction, I don't think you can get much more of an effect than that; then it's up to you how to make the code do different stuff, by branching or by some less-cheaty means.
15:10:53 <nooga> beh
15:11:12 <alise> Ilari: Yes. It blows up loops and it blows up instructions even more.
15:11:20 <alise> Ilari: No fear; it'll be triangularised soon.
15:11:35 <AnMaster> fizzie, couldn't you get instructions that end in different places too
15:12:22 <alise> 03:40:48 <oerjan> it needs a square root, essentially
15:12:27 <alise> Won't floor(sqrt(n)) do?
15:12:34 <AnMaster> fizzie, of course, once they end in the same place they will be merged, no way around it
15:13:34 <AnMaster> (at least unless there is some strange flag you can set which might cause it to work out as different things)
15:13:37 <fizzie> AnMaster: I have a feeling that sort of stuff tends to get synchronized sooner or later. At least in my experience, even if you start a disassembly at a random spot, they tend to converge pretty fast. But yes, maybe if you're really really careful about selecting the instructions.
15:14:01 <AnMaster> hm
15:14:06 <fizzie> Any flag will cause the corresponding conditional branch/set/such do different things, but maybe that doesn't again count. :p
15:14:34 <AnMaster> fizzie, indeed doesn't. I was more thinking about x86 vs. x86_64, where iirc INC → REX prefix and such things
15:15:06 <AnMaster> I think they either threw away or reused some of the BCD instructions too
15:15:21 <Ilari> Program starting with 'EB EB EA'. Jumps to offset 0xED from start even with first byte removed...
15:15:46 <AnMaster> Ilari, EB?
15:16:00 <AnMaster> I don't have a reverse lookup table handy
15:16:03 <Ilari> JMP SHORT imm8
15:16:07 <AnMaster> ah
15:16:21 <AnMaster> Ilari, and with first byte removed?
15:16:38 <Ilari> Oops 'EB EB EB'.
15:16:42 <fizzie> http://ref.x86asm.net/coder.html is sorted by opcode if you need it.
15:16:45 <AnMaster> ah thought so
15:16:57 <fizzie> And anyway, it was supposed to do a different thing when the first byte removed, not the same. :p
15:17:16 <AnMaster> indeed what fizzie said
15:17:28 <AnMaster> also it doesn't need to be exactly 1 byte
15:17:50 <AnMaster> but some small whole-byte offset (less than the size of the first instruction)
15:17:54 <alise> 05:26:54 <Ilari> Assuming x <- x <- x encodes to 2 (and choosing operation enumeration order to be '+-<>,.'), i get that enumeration of ",[.[-],]" is 144 877 580...
15:17:59 <alise> but does it have a program for each nat?
15:19:12 <Ilari> That 144 877 580 is likely wrong... And each nat is guarenteed to map to some program. And I don't think any two map to same program. I don't have finalized ordered tree to nat mapping.
15:19:38 <alise> ya'll crazy bitches
15:20:29 <fizzie> Ilari: You also haven't told us how you map to ordered trees, so we can't look for bugs in that. :p
15:23:09 <Ilari> Recomputed, and got 144 744 582 this time...
15:23:15 <alise> It's nondeterministic!
15:23:20 <AnMaster> Ilari, and if you recompute again?
15:23:23 <fizzie> I can see how the structure gives the shape of the tree, but it's not immediately clear how you deal with what instructions are where.
15:23:25 <AnMaster> alise, damn, beat me to it
15:23:33 <alise> AWESOME
15:23:41 <alise> Does it actually depend on the phase of the moon's minute changes?
15:24:13 <fizzie> The moon-men's minutes are a lot shorter than our human minutes.
15:24:21 <alise> Oh, Milner died! Sad.
15:25:25 <alise> data Nested a = Nil | Cons a (Nested a) | Nest (Nested a) (Nested a)
15:25:26 <alise> data Ref a = Val a | Ref Int
15:25:26 <alise> deblimp :: Nested a -> [[Ref a]]
15:25:35 <alise> I'mma finally getting down to the theory of deblimpification
15:28:47 -!- fax has joined.
15:28:51 <fax> hey alise how come you are here
15:29:05 <alise> what
15:29:39 <fizzie> "Who told you you can be here, huh?!"
15:29:42 <alise> heh I hate deblimping it's basically all one big corner case.
15:29:42 <fax> monday
15:29:47 <alise> day off
15:29:49 <alise> bank holiday
15:29:51 <alise> \m/
15:30:12 <fizzie> You Britons and your made-up holidays.
15:30:18 <alise> banks need holidays too!!
15:31:40 <alise> actually grr this is irritating.
15:31:40 <fizzie> We've got May 1st as a holiday, but this year it was on Saturday.
15:31:48 <alise> like seriously.
15:32:25 <alise> fizzie: whenever that happens to us we end up with a ridiculously-titled "holiday in place of [what we missed]" day
15:32:30 <alise> or whatever it is called.
15:32:46 <fizzie> How uncommonly fair of you.
15:32:49 <Ilari> I get that 144 877 580 decodes to '.[++[-].]'. I computed segment nats for ',' and '.' wrong.
15:33:08 <alise> fizzie: yes we brits are wonderful people.
15:34:14 <fizzie> Around here, whenever we miss a holiday because it lands on a weekend, we get a "sucks to be you" day, which is otherwise just like a regular workday, only worse in that you're annoyed because you've just missed a holiday earlier.
15:34:16 <nooga> we've got may 1st and 3rd
15:35:14 <alise> fizzie: how finnish
15:35:15 <nooga> alise: then explain 2 taps
15:35:25 <nooga> and windows that open TO THE OUTSIDE
15:35:33 <alise> Wait, you guys DON'T have 2 taps?
15:35:37 <alise> ...Why not?
15:35:45 <alise> And why on earth would you want a window opening INTO your room?
15:35:54 <fax> alise, your data type can be expressed as the fixed point, X[a] = a + X[a] + X[a]*X[a] ?
15:36:04 <alise> yes it can
15:36:05 <nooga> you can clean the window
15:36:13 <alise> nooga: from the inside?
15:36:14 <alise> why
15:36:16 <nooga> without leaving the room
15:36:26 <fax> this gives you a way to subdivide the isomorphism problem
15:36:28 <alise> windows don't exactly get all that dirty to need urgent cleaning so often that going outside is a pain.
15:36:41 <nooga> how about 2 taps
15:36:48 <alise> fax: wut :P
15:36:58 <alise> basically I'm trying to theoreticise my underload compiler's main bit
15:37:00 <nooga> how am i supposed to wash a plate in boiling OR icy water
15:37:06 <alise> Underload has functions like (a(b(c)))
15:37:11 <alise> and we need to make these into cross-referencing functions
15:37:13 <alise> so this becomes
15:37:21 <alise> [ (a1) (b2) (c) ]
15:37:29 <alise> ((a)(bc)(d(e)f))g becomes
15:37:49 <alise> [ (1g) (234) (a) (bc) (d5f) (e) ]
15:38:34 <alise> for a long time we weren't really sure an underload compiler was possible -
15:38:42 <alise> this trick, + the "function data structure" made it possible
15:39:18 <alise> (function data structure = if you did (a)(b)* i.e. append b to a, then this got stored with the function pointers to a and b's code, as a cons list of sorts)
15:39:26 <alise> (same for (x)a -> ((x)), etc)
15:39:37 <alise> fax: so now I'm trying to writ out that blimp algorithm
15:39:40 <alise> which flattens the list
15:39:46 <alise> each number-pointer is a "blimp"
15:39:53 <alise> which means my function should be called blimp
15:39:55 <alise> not deblimp...
15:40:11 <alise> or, wait, no
15:40:17 <alise> each little () is a blimp
15:40:18 <alise> w/e
15:40:20 <alise> fax: you get the idea
15:41:55 <fax> what
15:42:08 <fax> sorry I totally don't know anything probably best just leave me
15:42:26 <alise> fax: wut
15:42:30 <alise> what didn't you get :(
15:43:31 -!- Phantom_Hoover has joined.
15:43:59 <Phantom_Hoover> alise: Did you fix your Haskell program?
15:44:07 <alise> Phantom_Hoover: yes; but did not triangularise it.
15:44:16 <alise> it is easy to fix
15:44:18 <Phantom_Hoover> Can I see the fixed version?
15:44:18 <alise> s/ $//
15:44:26 <alise> will a patch do? only two changes
15:44:48 <alise> Change the two lines almost identical to these to the ones shown here:
15:44:49 <alise> crush (x:xs) = biTo (x, crush xs) + 1
15:44:51 <alise> decrush n = let (x,xsn) = biFro (n-1) in x : decrush xsn
15:45:02 <alise> Then recompile (ghc -O2 --make bifro.hs -o bifro)
15:45:15 <Phantom_Hoover> Wait, did you fix the problem in the algorithm that caused it to return the same number for ++- and ++?
15:45:22 <alise> Yes; that is that fix.
15:45:44 <alise> Of course, since this ends up doing 2^(1+stuff) in for loops instead of just 2^stuff, everything is even more ginormous. :-)
15:46:23 <alise> 1, 3, 7, 15, 31, 63, 127 -- result of - | -- | --- | etc
15:46:25 <Phantom_Hoover> For heaven's sake, does no-one have an algorithm for the inverse of the triangular bijection?
15:46:31 <alise> looks like odd numbers at first :-)
15:46:39 <alise> Phantom_Hoover: yes, almost
15:46:54 <alise> 04:50:22 <oerjan> Phantom_Hoover: back to the bijection; i think multiplying by 2 and then taking square root gives either the floor of u+v or 1 more than it - i don't see a way to get either directly so there needs to be a postcheck for which one is right
15:46:56 <alise> 04:50:50 <Phantom_Hoover> And how do we derive u and v from u+v?
15:46:56 <alise> 04:51:15 <oerjan> well we start with n = triang(u+v)+u
15:46:56 <alise> 04:51:25 <Phantom_Hoover> Yep.
15:46:56 <alise> 04:51:30 <oerjan> so once we have u+v, u = n-triang(u+v)
15:46:57 <alise> 04:51:40 <Phantom_Hoover> Oh.
15:46:58 <alise> 04:51:40 <oerjan> and then v = (u+v)-u
15:47:04 <alise> just a matter of coding this up
15:47:10 <alise> now the question is, how do we do the post-check accurately?
15:47:17 <Phantom_Hoover> By hand!
15:47:59 <alise> what, for every single program :)
15:48:05 <alise> oh, I know
15:48:07 <alise> it is easy to check
15:48:10 <alise> x^2 == right
15:48:12 <alise> (x+1)^2 == right
15:48:18 <alise> but this is wrong
15:48:25 <alise> because x^2 won't be precisely the answer we need, will it
15:48:31 <alise> like, we can't check that way
15:48:34 <alise> we really need oerjan to help us here
15:49:02 <Phantom_Hoover> Wait, so f(u, v) = (u+v)(u+v+1)/2+u?
15:49:54 <alise> triang(u+v)+u where triang n = n*(n+1)`div`2
15:50:03 <Phantom_Hoover> Yes.
15:50:14 <alise> so ((u+v)*(u+v+1) `div` 2) + u
15:50:19 <alise> so (((u+v)*(u+v+1)) `div` 2) + u
15:50:26 <alise> We /will/ use precise parenthesisation!
15:50:37 <alise> "plus or minus any off-by-one errors"; says oerjan
15:51:30 <Phantom_Hoover> How can the numbers get so big for simple programs?! Every number maps to a valid program!
15:51:42 <alise> loops
15:51:48 <alise> [0,1,3,6,10,15,21,28,36,45,55]
15:51:49 <alise> [2,4,7,11,16,22,29,37,46,56,67]
15:51:49 <alise> [5,8,12,17,23,30,38,47,57,68,80]
15:51:49 <alise> [9,13,18,24,31,39,48,58,69,81,94]
15:51:49 <alise> [14,19,25,32,40,49,59,70,82,95,109]
15:51:50 <alise> [20,26,33,41,50,60,71,83,96,110,125]
15:51:51 <alise> [27,34,42,51,61,72,84,97,111,126,142]
15:51:53 <alise> [35,43,52,62,73,85,98,112,127,143,160]
15:51:55 <alise> [44,53,63,74,86,99,113,128,144,161,179]
15:51:57 <alise> [54,64,75,87,100,114,129,145,162,180,199]
15:51:59 <alise> [65,76,88,101,115,130,146,163,181,200,220]
15:52:00 <Phantom_Hoover> Yes...
15:52:01 <alise> here horizontal = increase second argument
15:52:03 <alise> vertical = increase first argument
15:52:05 <alise> that's the triangular
15:52:09 <alise> which exhibits quite good growth I think
15:52:12 <alise> I will plug it into my program
15:52:15 <alise> without fixing the other way around
15:53:10 <alise> *Main> crush (fst (parse ",[.,]"))
15:53:11 <alise> 312012695
15:53:12 <alise> much better
15:53:26 <Phantom_Hoover> Reversibility!
15:53:30 <alise> *Main> crush (fst (parse "[[[[[]]]]]"))
15:53:30 <alise> 213154541901809831953
15:53:35 <alise> Phantom_Hoover: It can't be reversed /yet/.
15:53:42 <alise> I need to ask oerjan about the sqrt stuff first.
15:53:45 <alise> But wow, those are good results!
15:53:51 <Phantom_Hoover> Wait.
15:54:27 <alise> UNFORTUNATELY
15:54:30 <alise> hello world is still huge
15:54:34 <alise> [3,1,1,1,1,1,1,1,1,1,5354164073076684878196228396564020578803679189102849778525663731938902525444515224420427138133134637920836890782453088665839948145820092076713415549434307727405966835227032540083505526997209611299464854680212856949448028235011323804396384569956482164446390459797750748251474085517169113816957984439650500125963237364050624907522513416960323815412898338127406868607518044494986367473299784801918842103825814040773826020133025992246889415795
15:54:35 <alise> 35777677808436141814,2,5,3,1,1,1,1,1,1,1,89693062033816922605205825944,2,1,5,1,1,1,1,1,1,1,5,5,1,1,1,5,3,3,3,1,1,1,1,1,1,1,1,89693062033816922605205825944,2,5,3,3,3,1,1,1,1,1,1,1,1,1,1,14333536460712558084283567410257460820133224763596344172314303799578193610093108205094456521650228199838472126415141884581995334932340129379148477559707459959545576999778527755763656033545930008690570401539469908519542923093293866773152151477794528497181690063188383395045995
15:54:35 <alise> 1557447373818212334868702619287904919346690680502733198242627295679574194061355035703752923594385067469018029706561653941015792877680406733587246784406411632470943569135223195170725555329691921703375500895996752850629092483314008449940432238690371512189308188659696451544516606747397349661314807321205718172628988242893865139529255491147596410168400964451760816675236538504914109773983094253795888709666794010571089587049752395012003064486642816360910937797056
15:54:41 <alise> 693740451617167478378383875365441979920592376562008886469597656791896708701802207527665390314320715361945598862239045424492744590207542409271756177422324294118894451516811455159755859,2,0,0,0,5,2,2,2,2,5,1,1,1,5,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,5,3,3,1,5]
15:54:44 <alise> and that's just the list
15:54:47 <alise> we need to crush it after that
15:54:51 <Phantom_Hoover> :O
15:54:58 <alise> SO I PROPOSE that one, or both, of these things are true:
15:55:10 <alise> (1) Our list-crushing is crappy, and could be made better.
15:55:17 <Phantom_Hoover> Unlikely.
15:55:21 <alise> (b) Our representing-loops-as-crushed-lists-at-the-start is crappy, and could be made better.
15:55:28 <alise> Yes, 1 and b.
15:55:33 <alise> I think (b) is more likely than (1).
15:55:48 <alise> Phantom_Hoover: I dunno man
15:55:50 <Phantom_Hoover> But then we need to imply an encoding in the list...
15:55:52 <alise> crush (x:xs) = biTo (x, crush xs) + 1
15:55:52 <alise> 3
15:55:53 <alise> er
15:55:55 <alise> drop that 3
15:55:58 <alise> I think maybe cons-cell is wrong here
15:56:02 <alise> Maybe we could get it more efficient
15:56:05 <alise> One issue is
15:56:08 <alise> the +1s add up
15:56:12 <alise> the crush xs in the second biTo
15:56:14 <alise> is +1+1+1+1 a lot
15:56:17 <alise> depending on nesting
15:56:20 <AnMaster> <Phantom_Hoover> How can the numbers get so big for simple programs?! Every number maps to a valid program! <-- a) lots of possible programs b) define "simple" c) maybe some complex programs have a really simple number?
15:56:20 <alise> Phantom_Hoover: that's the issue :(
15:56:30 <alise> (c) is very false
15:56:30 <AnMaster> and yes loops
15:56:32 <alise> trivially can be checked
15:56:47 <AnMaster> alise, well, depends on how you define complex.
15:57:02 <alise> Non-retardedly.
15:57:03 <AnMaster> in number of bytes? in terms of loops?
15:57:06 <AnMaster> alise, true
15:57:53 <AnMaster> alise, a nice bijection would be if you ended up with unpredictable number.
15:57:54 <Phantom_Hoover> alise: What about the idea you had before crushing loops?
15:58:06 <alise> crush [-5] == crush 2; interesting to see the behaviour for (not-meant-to-work) negative arguments.
15:58:07 <AnMaster> not sure how feasible it is
15:58:21 <alise> Phantom_Hoover: You mean put a nop instruction to signify []?
15:58:28 <alise> Yes, that would mean that all loops are additions, rather than crazies.
15:58:32 <Phantom_Hoover> ][, actually, but yeah.
15:58:34 <alise> The translation would be harder, though :-)
15:58:36 <alise> Yeah, ][.
15:58:45 <alise> [] would be nop+N
15:58:50 <alise> [][] would be nop+N, nop, nop+N
15:59:18 * alise loads bifroexp.hs, and experiments
15:59:59 <alise> Phantom_Hoover: Of course this means I need my own nested list structure, bleh.
16:00:00 <alise> But okay.
16:00:19 <Phantom_Hoover> Just keep adding 6?
16:00:29 <alise> Oh wait I do not require that
16:00:30 <alise> I am happy now
16:00:36 <alise> Happy like a bee
16:00:50 <Phantom_Hoover> Wait, what does +++<noop>+++ correspond to?
16:01:05 <Phantom_Hoover> If noop is an instruction, it ruins the bijection.
16:01:11 <fax> sup
16:01:12 <alise> ugh; you are correct.
16:01:22 <Phantom_Hoover> Unless it is kept only inside loops.
16:01:24 <alise> Phantom_Hoover: we could map it to +++X+++, because X is technically a "valid" bf instruction
16:01:26 <alise> (but that is cheating)
16:01:29 <Phantom_Hoover> I think that's possible.
16:01:34 <alise> and it would always be just after a loop, or just at the start/end of a loop
16:01:36 <alise> like [x]nop
16:01:37 <alise> or [nop]
16:01:44 <alise> or even [nop]nop[nop]
16:01:47 <alise> for [][]
16:01:50 <Phantom_Hoover> Make the instruction set only include nop when we're in a loop?
16:01:54 <fax> whats the point in turning programs into numbers?
16:02:18 <Phantom_Hoover> fax: If you need to ask the point, you haven't gotten it.
16:02:27 <Phantom_Hoover> There *is* no point.
16:02:28 <fax> Phantom_Hoover: go listen to jazz
16:02:29 <alise> We have nops outside of loops
16:02:34 <alise> [] -> nop
16:02:37 <alise> aha
16:02:38 <alise> !!
16:02:39 <alise> no wait
16:02:40 <alise> [] -> nop+N
16:02:47 -!- Tritonio_GR has quit (Read error: Connection reset by peer).
16:02:49 <alise> [][] -> nop+N, nop, nop+N
16:02:50 <Phantom_Hoover> N being the nesting?
16:02:54 <alise> [x][y] -> x+N, nop, y+N
16:02:57 <alise> yeah
16:03:14 <Phantom_Hoover> And nop+N, nop+N?
16:03:45 <alise> [nopnop]
16:03:51 <alise> which is, basically, the issue.
16:03:56 <alise> nop+N, nop+N = []
16:04:08 <alise> we /could/ have tons of restrictions, but writing the bijection would be /very hard/
16:06:10 <Phantom_Hoover> nop+N, nop+N = [][]?
16:06:27 <Phantom_Hoover> Ugh, this is horrible.
16:06:30 <alise> no
16:06:33 <alise> nop+N, nop+N = []
16:06:36 <alise> nop+N, nop, nop+N = [][]
16:06:41 <alise> it is
16:08:16 <Phantom_Hoover> How about changing the instruction set once we're in a loop, so that it's '-'..'.' in the base level and '-'..'.'+nop once N is greater than 0, then changing the increment of N accordingly.
16:08:22 <Phantom_Hoover> It's ugly, admittedly.
16:09:06 <alise> because
16:09:09 <alise> like I have told you a million times
16:09:11 <alise> nop is valid outside
16:09:16 <alise> [x][y] = x+N, nop, y+N
16:09:23 <Phantom_Hoover> Why does it have to be?
16:09:24 <alise> nop also works as an adjacent loop separator
16:09:31 <alise> because [x][y] = x+N, y+N = [xy]
16:09:33 <alise> does not work
16:09:37 <Phantom_Hoover> That's what it always was.
16:09:50 <alise> then how the fuck do you encode [x][y] and [xy] differently what's why introduced nop in the first place
16:09:51 <alise> duh
16:09:53 <fax> hi
16:10:00 <alise> that's the whole issue
16:10:14 <Phantom_Hoover> But make [x][y] x+N, nop+N, y!
16:10:21 <Phantom_Hoover> s/y/y+N/
16:10:24 <alise> what?!
16:10:28 <alise> that makes no sense whatsoever!
16:10:28 <Phantom_Hoover> Ugh.
16:10:31 <alise> like, at all
16:10:35 <Phantom_Hoover> I suck at explaining...
16:10:36 <alise> it's semantic junk
16:10:57 <Phantom_Hoover> I'll try to explain it to myself, first.
16:10:59 <alise> i mean i get it
16:11:04 <alise> i just think it's a really silly idea
16:11:06 <alise> and doesn't help at all
16:11:11 <alise> because allowing nop in a loop anywhere
16:11:25 <alise> then nop+N,nop+N,nop+N = [] or [][]
16:12:46 <fax> alise be my friend
16:12:51 <alise> ok
16:13:19 <alise> hey oerjan log-reading
16:13:21 <alise> istriangular:=proc(n) local t1; t1:=floor(sqrt(2*n)); if n = t1*(t1+1)/2 then RETURN(true) else RETURN(false); fi; end; (N. J. A. Sloane, May 25 2008)
16:13:25 <alise> we need a bijectin to all nats yo
16:13:29 <alise> *bijection
16:13:30 <alise> s/ $//
16:13:32 <alise> or does the +u fix that
16:13:36 <alise> or w/e
16:13:50 -!- augur has quit (Remote host closed the connection).
16:14:56 <fax> T(n) = nC2
16:15:29 <fax> http://upload.wikimedia.org/wikipedia/commons/f/f6/Pascal%27s_triangle_5.svg
16:15:30 <alise> coo.
16:15:45 <alise> so T(u+v)+u = (u+v)C2 + u :P.
16:16:39 <fax> do you know an efficient way to invert that
16:16:42 <fax> (I don't)
16:16:52 <fax> http://upload.wikimedia.org/math/f/d/8/fd8253a78f5f19c216b74278cd847bfc.png
16:17:01 <alise> 04:50:22 <oerjan> Phantom_Hoover: back to the bijection; i think multiplying by 2 and then taking square root gives either the floor of u+v or 1 more than it - i don't see a way to get either directly so there needs to be a postcheck for which one is right
16:17:01 <alise> 04:50:50 <Phantom_Hoover> And how do we derive u and v from u+v?
16:17:01 <alise> 04:51:15 <oerjan> well we start with n = triang(u+v)+u
16:17:01 <alise> 04:51:25 <Phantom_Hoover> Yep.
16:17:02 <alise> 04:51:30 <oerjan> so once we have u+v, u = n-triang(u+v)
16:17:02 <fax> that n^_k_ is from finite calucus
16:17:03 <alise> 04:51:40 <Phantom_Hoover> Oh.
16:17:07 <alise> 04:51:40 <oerjan> and then v = (u+v)-u
16:17:11 <alise> requires square root; so computing it requires checking the root is right and stuff
16:17:19 <alise> but, it's pretty computable
16:17:24 <fax> what about isqrt
16:17:30 <alise> I think oerjan planned on that
16:17:31 <alise> not sure though
16:17:38 <alise> 04:52:20 <Phantom_Hoover> Any progress on the sqrt?
16:17:38 <alise> 04:52:35 <oerjan> that haskell link should work fine enough?
16:17:39 <alise> 04:52:53 <oerjan> (i was wrong about that recursion being a problem btw)
16:17:39 <alise> 04:53:31 <oerjan> http://www.haskell.org/haskellwiki/Generic_number_type#squareRoot
16:17:42 <alise> it's a matter of checking;
16:17:51 <alise> is this floor(sqrt(x)) or sqrt(x)+1
16:17:57 <alise> we need an algorithm to precisely do that
16:19:25 <fax> alise: http://www.reddit.com/r/programming/comments/bzfwz/fellow_programmers_even_if_your_vision_is_solid/
16:20:24 <alise> lol
16:20:32 <alise> i have like 20/300000000000000000000000000000004 :|
16:20:36 <alise> 8)
16:20:58 -!- augur has joined.
16:21:15 <fax> hi augur 8D
16:22:21 <alise> augur 8D; that's some versioning scheme
16:22:40 <fax> oh a good day augur can exceed 8D
16:22:46 <fax> on*
16:22:47 <alise> fax: anyway admire oerjan's lovely inversion
16:22:58 <fax> me too, i jut want to invert oerjan all day
16:23:01 <alise> it's totally elegant if you have an accurate floor(sqrt(x)) :P
16:23:03 <alise> O_O
16:23:12 <alise> okay :P
16:23:23 <fax> alise - the bijection that uses unique factorization is much more clever though
16:24:50 <alise> no wait
16:24:52 <fax> of course it is quite useless computationally because 2^k grows so fast
16:24:53 <alise> i think multiplying by 2 and then taking square root gives either the floor of u+v or 1 more than it - i don't see a way to get either directly so there needs to be a postcheck for which one is right
16:24:59 <alise> so how do we know whether it's u+v is the question
16:25:47 <Phantom_Hoover> OK, have you solved the noop problem?
16:25:58 -!- augur has quit (Ping timeout: 264 seconds).
16:27:40 <alise> Phantom_Hoover: no.
16:28:33 <Phantom_Hoover> BtW, I don't like the name noop.
16:28:37 <Phantom_Hoover> It doesn't noop.
16:28:54 <Phantom_Hoover> It separates lists, or is the empty list.
16:29:02 <Phantom_Hoover> s/list/loop/
16:29:14 <alise> but it does nothing :P
16:29:53 <Phantom_Hoover> []? Of course it does something!
16:30:08 <fax> so what's the story
16:30:43 <Phantom_Hoover> Incidentally, how often is the phrase "You need a (life|girlfriend)" uttered here?
16:33:56 <alise> not often, because nobody here has one
16:33:59 <alise> [] does something
16:34:00 <alise> +[] hangs
16:34:05 <alise> but nopt itself
16:34:06 <alise> doesn't
16:34:07 <alise> *nop itself
16:34:12 <alise> it's the loop "around" it that does
16:34:23 <Phantom_Hoover> It's not an instruction. It's just a syntactic marker.
16:34:54 * alise uploads a pdf explaining our triangular dilemma
16:34:57 <alise> http://filebin.ca/ogtqw/bij.pdf
16:34:57 <Phantom_Hoover> Why can't we have [][] as nop, nop?
16:35:07 <alise> Phantom_Hoover: what's [x][y]
16:35:11 <alise> hmm
16:35:19 <alise> I guess we could encode that as [x][][y] because it's equiv
16:35:20 <alise> but that's not 1:1.
16:35:25 <alise> anyway, read the pdf guyz.
16:35:33 <Phantom_Hoover> x+N, nop+N, y+N?
16:36:12 <alise> that's [x][][y]
16:36:16 <alise> you fail at bijecting
16:36:17 <alise> try again
16:36:20 <Phantom_Hoover> Umm...
16:36:22 <alise> because [x][][y] is a valid program too
16:36:29 <alise> and it's not the same~ (semantically yes, but syntactically no)
16:36:37 <alise> Phantom_Hoover: wait, no
16:36:40 <alise> that's [x[]y]
16:36:42 <Phantom_Hoover> Wait, why can't nop mean different things?
16:36:43 <alise> because you said nop = []
16:36:53 <Phantom_Hoover> Based on context?
16:36:58 <alise> because you have to KNOW WHAT IT MEANS IN EACH CONTEXT; and be able to CONTROL which meaning it has at any time
16:37:05 <alise> because we have to /do all programs/, even equivalent ones, separately.
16:37:50 <fax> im listening to hungry eyes
16:38:31 <Phantom_Hoover> How about one for ][ and one for []?
16:38:47 <alise> let's think about the more interesting bijection! :P
16:38:51 <alise> and less frustrating
16:38:55 <alise> http://filebin.ca/ogtqw/bij.pdf
16:39:02 <Phantom_Hoover> I saw it!
16:39:11 <fizzie> alise: If you didn't get the triangular one in functions correctly yet, here's one version courtesy of computers; it's a bit unsimplified, but you can rectify that: http://pastebin.com/8zH1iNS9
16:39:27 <alise> fizzie: Oh, so it figured out which will work?
16:39:40 <fizzie> (Mathematica does the table in a bit mirrored way, but other than that it seems to be working.)
16:39:40 <alise>
16:39:40 <alise>
16:39:40 <alise> Either ⌊ 2n ⌋ = u + v or ⌊ 2n − 1⌋ = u + v. So to implement ι(n), we need an accurate
16:39:40 <alise> algorithm to decide which to use, and calculate it, given only integers, rationals (without sqrt, I
16:39:40 <alise> think), and a pre-implemented sqrt for floating-point numbers.
16:39:43 <alise> urgh
16:39:46 <alise> either floor(sqrt(2n)) = u+v
16:39:49 <alise> or floor(sqrt(2n)-1) = u+v
16:40:06 <alise> fizzie: oh, you did not work out the inverse.
16:40:17 <alise> or, wait
16:40:19 <alise> is d the inverse?
16:40:23 <fizzie> alise: How so? u[x] and v[x] give the inverse for x = f[u, v].
16:40:28 <alise> omg, it worked it out!
16:40:32 <alise> fizzie: I love you.
16:40:58 <fizzie> d[x] gives the index for how many'th diagonal x is from; that's what I asked it to Solve[] for me. u[x] and v[x] were written manually based on d[x]; those are simple when that is known.
16:41:02 <alise> d is crazy
16:41:05 <fax> ⌊ 2n − 1⌋
16:41:07 <fax> I like these brackets
16:41:11 <alise> so floor(sqrt(2n)) is not even close!
16:41:16 <Phantom_Hoover> OK, so now we have the sane bijection we can work on the BF<->tuple of natural
16:41:21 <alise> fizzie: Wait wait
16:41:25 <Phantom_Hoover> Ugh, didn't mean to press enter.
16:41:26 <alise> Does that work with integer sqrt?
16:41:31 <alise> i.e. normal integer sqrt
16:41:43 <fizzie> alise: Yes, I think so. I tried it with another Floor[] around the Sqrt[] itself.
16:42:00 <alise> and it gave the same results?
16:42:24 <fizzie> Yes, unless I screw up something.
16:42:29 <fizzie> In[7]:= d[x_] := Floor[(Floor[Sqrt[8*x+1]]-1)/2]
16:42:29 <fizzie> In[8]:= {u[#], v[#]}& /@ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
16:42:29 <fizzie> Out[8]= {{0, 0}, {1, 0}, {0, 1}, {2, 0}, {1, 1}, {0, 2}, {3, 0}, {2, 1},
16:42:29 <fizzie>
16:42:29 <fizzie> > {1, 2}, {0, 3}, {4, 0}, {3, 1}, {2, 2}, {1, 3}, {0, 4}, {5, 0}}
16:42:34 <fax> lol mathematica
16:42:55 <alise> from(n) = (u, v)
16:42:57 <alise> where m = (floor(sqrt(8*x+1)) - 1) `div` 2
16:42:57 <alise> u = m - (n - to(n, 0))
16:42:57 <alise> v = n - to(m, 0)
16:43:04 <alise> fax: Hey, mathematica worked out d for him.
16:43:06 <alise> So it's coo in my book.
16:43:24 <fizzie> to(m, 0) also in u.
16:43:48 <alise> #
16:43:49 <alise> u[x_] := d[x] - (x-f[d[x], 0])
16:43:52 <alise> To I, beg differ.
16:43:58 <fizzie> d[x] is m, isn't it?
16:44:02 <alise> Oh, right.
16:44:02 <alise> Sorry.
16:44:48 <alise> will Double work better for the sqrts?
16:44:50 <alise> more predictable...
16:45:59 <fax> hello
16:46:01 <fax> what should I do
16:46:10 <alise> dance
16:46:17 <Deewiant> \o\ \o/ /o/
16:46:18 <myndzi> | | |
16:46:18 <myndzi> /`\ /< /<
16:46:24 <fax> WOW!!!!!!
16:46:38 <fax> \o/ \o/ \o/ \o/ \o/ \o/ \o/ \o/ \o/
16:46:48 <fax> myndzi
16:46:50 <fax> do it
16:47:01 <fax> `fungot style
16:47:01 <fungot> fax: indeed. the ability to hack stuff like " fnord setup -l compiler" should work.
16:47:02 <Deewiant> You're not a good enough dancer; it won't do it for you
16:47:03 <alise> fizzie: hey you broke ified it
16:47:08 <HackEgo> No output.
16:47:11 <alise> biFro :: Integer -> (Integer,Integer)
16:47:13 <alise> biFro n = (m - (n - biTo (m,0)), n - biTo (m,0))
16:47:13 <alise> where m = (floor (sqrt (8 * fromInteger n + 1) :: Double) - 1) `div` 2
16:47:14 <alise> NO WORKY.
16:47:19 <alise> For one,
16:47:20 <alise> *Main> biFro 1
16:47:21 <alise> (2,-1)
16:47:58 <alise> floor (sqrt (8*1+1)) = 3;
16:48:00 <alise> -1 = 2;
16:48:04 <alise> `div` 2 = 1;
16:48:06 <HackEgo> No output.
16:48:12 <alise> then we get ridiculous things involving 1 -
16:48:20 <alise> fizzie: I bet floor around the sqrt doesn't really work.
16:48:39 <fizzie> alise: It does work. I assume your biTo isn't exactly my f[u, v] there.
16:48:50 <alise> biTo :: (Integer, Integer) -> Integer
16:48:51 <alise> biTo (u,v) = triang (u+v) + u
16:48:51 <alise> where triang n = n * (n+1) `div` 2
16:48:57 <alise> Or is it.
16:49:02 <alise> You have +v
16:49:03 <alise> silly wabbit
16:49:09 <alise> make it +u and ask mathematica again?
16:49:23 <Phantom_Hoover> When I am in charge spammers will be hunted and slowly tortured.
16:49:28 <fizzie> Why don't you just make it +v there? I'm making food right now. :p
16:49:49 <fizzie> Alternatively, swap u/v; it shouldn't affect u+v, after all.
16:50:05 <fizzie> That is, ask for biTo(0, m) there.
16:50:08 <fizzie> (In biFro.)
16:50:19 <Phantom_Hoover> Anyway, I *think* I've got a coding that doesn't increase exponentially.
16:50:39 <alise> fizzie: >_>
16:50:43 <alise> fizzie: Set up a mathematica bot, dammit.
16:50:51 <Deewiant> WolframAlpha
16:51:09 <fax> hello
16:51:24 <Deewiant> alise: I can type it into Mathematica if you tell me what to type :-P
16:51:39 <alise> Wolfram Alpha fails at life
16:51:43 <alise> Um I think we need to be solving like a function
16:52:01 -!- nooga has quit (Ping timeout: 264 seconds).
16:52:51 <alise> Yay, it works now.
16:53:41 <alise> $ echo ',[.,]' | ./bifroexp encode | ./bifroexp decode
16:53:41 <alise> [[][++]+-]<
16:53:48 <alise> Interesting! Interesting but incorrect!
16:54:04 <fax> what'sup
16:54:05 <Phantom_Hoover> What encoding are you using?
16:54:05 <alise> Deewiant: Solve[f[((u+v) * (u+v+1))/2 + u] = u+v, f] or something, I guess.
16:54:07 <alise> er
16:54:10 <alise> Deewiant: Solve[f[((u+v) * (u+v+1))/2 + u] == u+v, f] or something, I guess.
16:54:13 <fax> hey alise you're doing it wrong
16:54:27 <fax> type Bijection a b = (a -> b, b -> a)
16:54:37 <alise> fax: yeah yeah shut up.
16:54:40 <alise> :P
16:54:48 <Deewiant> alise: There's an infinite number of solutions to that, you can't solve for a function :-P
16:54:49 <fax> :/
16:55:04 <alise> Deewiant: Solve[x == u+v, x] or something, I guess.
16:55:08 <alise> fax: that just makse the code more cluttered
16:55:08 <alise> *makes
16:55:10 <alise> in my case
16:55:15 <Deewiant> alise: Solution: x = u+v
16:55:19 <alise> Er yes :P
16:55:21 <Phantom_Hoover> alise: How are you encoding the program into tuples of naturals?
16:55:26 <alise> Deewiant: I am sure it can solve functions.
16:55:27 <Phantom_Hoover> The old method?
16:55:31 <fax> alise you don'tknow anything about code clutter
16:55:32 <alise> Phantom_Hoover: yes
16:55:42 <alise> fax: see, this is why i don't like you ^
16:55:53 <Deewiant> alise: Fine, I humoured you: it gives "{{}}" i.e. there are infinite solutions.
16:55:56 <fax> alise - I was trying to thelp you and you just tell me shut up
16:55:58 <Deewiant> alise: As expected.
16:56:03 <alise> Deewiant: MEH :P
16:56:08 <alise> I know there is some sort of function solver.
16:56:13 -!- augur has joined.
16:56:14 -!- augur has quit (Remote host closed the connection).
16:56:19 <alise> Well, http://reference.wolfram.com/mathematica/ref/RSolve.html...
16:56:32 <alise> f[((u+v) * (u+v+1))/2 + u] - (u+v) == 0
16:56:33 <alise> :-)
16:56:33 -!- augur has joined.
16:56:44 <fax> why is everyone such a dick
16:56:50 <alise> because
16:56:56 <alise> "<useless advice>" "that doesn't help in this case"
16:57:02 <alise> "you don't know anything about <subject>!"
16:57:13 <fax> that doesn't help in this case???
16:57:35 <augur> hey fax
16:57:38 <fax> hi
16:58:01 <alise> Deewiant: Fine then,
16:58:07 -!- lereah_ has quit (Quit: Leaving).
16:58:14 <alise> f[u_,v_] := ((u+v) * (u+v+1))/2 + u;
16:58:20 <alise> InverseFunction[f]
16:58:20 <fax> why do I even come here everyone hates me or ignores me
16:58:32 <Deewiant> alise: f^(-1)
16:58:36 <alise> fax: God dammit shut the fuck up; you were a jerk to me. Simple as.
16:58:57 <alise> grr, inversefunction only works on 1-adic functions
16:59:07 <alise> * InverseFunction is generated by Solve when the option InverseFunctions is set to Automatic or True.
16:59:10 <fax> you think you are so smart because you didn't grow up around people of the same age that were smarter than you
17:00:10 <alise> dear fax; you are batshit insane, insult people when they reject your useless advice, deny irc lines that clearly did happen, whine when people talk to you, ignore people then whine when people ignore you, and insult people's intelligence just because they did some random thing that annoys you.
17:00:15 <alise> just stop it. FFS.
17:01:12 <fax> sorry but I have written highly non-trivial haskell programs and I have been programing for years. I think if you took my advice you could learn something. Is that arrogant? To think I have actually learned something from years of experience?
17:01:45 <alise> So one day you claim "Haskell sucks it is too hard I don't know how to structure programs properly in it"
17:01:51 <alise> the next is "I AM EXPERT HASKELL PROGRAMMER".
17:01:57 <alise> Anyway, of course I have used that bijection structure before.
17:02:06 <alise> biTo :: (Integer, Integer) -> Integer
17:02:07 <alise> biTo (u,v) = triang (u+v) + u
17:02:07 <alise> where triang n = n * (n+1) `div` 2
17:02:07 <alise> biFro :: Integer -> (Integer,Integer)
17:02:07 <alise> biFro n = (m - (n - biTo (0, m)), n - biTo (0, m))
17:02:08 <alise> where m = floor (((sqrt (8 * fromInteger n + 1) - 1) / 2) :: Double)
17:02:09 <alise> How the ROYAL FUCK does it help here?
17:02:14 <alise> It would just be (to, fro)
17:02:17 <alise> because from references to, anyway
17:02:18 <fax> are you aware that it is an open research problem I was talking about when I said I didn't know how to structure that program?
17:02:19 <alise> so it needs to be bound
17:02:25 <alise> not that one
17:02:28 <alise> you said it about a general case
17:02:28 <Phantom_Hoover> fax: We're working on the *algorithm*, not the code?
17:02:53 <fax> oh suddenly I exist, isn't that convenient
17:03:07 <Phantom_Hoover> Oh, for heaven's sake.
17:03:10 <fax> lets just stop arguing about this
17:03:13 <alise> I think we're getting pretty solid evidence that fax is actually mentally ill here.
17:03:29 <Phantom_Hoover> alise: Not really helping.
17:03:36 <alise> I never help :)
17:04:11 <alise> fax: Considering my program has only one bijection in it, and one half of the bijection references the other, it would have to look like
17:04:18 <alise> bij = (to, ...)
17:04:20 <alise> where to = ...
17:04:32 <alise> Since in fact they both have extra bound definitions, the things they use would be tangled together
17:04:34 <alise> the whole thing would be uglier
17:04:35 <alise> harder to call
17:04:37 <alise> and for no reason whatsoever.
17:04:40 <alise> That is all.
17:04:55 <fax> alise: okay alise if you think you are doing the right thing by all means - don't let me get in the way. You don't have to be nasty about it thoug, I was trying to be constructive
17:05:05 <alise> I wasn't nasty!
17:05:11 <Deewiant> alise is always nasty
17:05:15 <alise> <fax> type Bijection a b = (a -> b, b -> a) <alise> fax: that just makse the code more cluttered
17:05:35 <alise> Yes, I said "yeah yeah shut up :P" before it, which was quite clearly in jest (I thought you were mentioning the fact that
17:05:40 <alise> I used that structure once before and you inquired as to its point.)
17:06:05 <alise> Deewiant: Not always.
17:06:18 <Deewiant> Close enough
17:06:29 -!- MizardX- has joined.
17:07:09 <alise> Well, fuck you too :)
17:07:18 <fax> come on
17:07:35 <Deewiant> Hey, you've admitted in the past :-P
17:07:39 <Deewiant> +it
17:08:08 -!- MizardX has quit (Ping timeout: 240 seconds).
17:08:18 <Phantom_Hoover> Oh, for heaven's sake!
17:08:27 -!- MizardX- has changed nick to MizardX.
17:08:34 <alise> Deewiant: I'm an asshole, in general; but not nasty, in almost-all specific cases.
17:08:40 <alise> I'm just nasty often.
17:08:42 <Deewiant> Meh, semantics
17:08:54 <alise> I don't really care though, fax has done his fair share of nastiness to me yesterday and today, so
17:09:12 <Phantom_Hoover> We still need a) a saner bijection and b) a coding that doesn't go mad on loops.
17:09:18 <fax> alise, in retaliation
17:09:22 <alise> We have that bijection, Phantom_Hoover.
17:09:24 <alise> fax: no.
17:09:30 <Phantom_Hoover> alise: Oh/
17:09:41 <Phantom_Hoover> I must have missed it in between the flame war.
17:10:12 <alise> Yep, just implemented it now.
17:10:15 <alise> Just change +u to +v.
17:10:27 <Phantom_Hoover> But they're equivalent!
17:10:27 <fax> I just want everyone to be nice to me
17:10:36 <fax> unconditionally
17:10:46 <alise> $ echo ',[.,]' | ./bifro encode | ./bifro decode
17:10:47 <alise> ,[.,]
17:10:52 <alise> fax: See, that is the problem.
17:11:00 <alise> You cannot be nasty to someone else then expect them to be lovely to you.
17:11:04 <alise> People are not Jesus.
17:11:10 <fax> I wasn't being nasty to anyone
17:11:14 <Phantom_Hoover> alise: How does it deal with, say, '[[[]]]'?
17:11:23 <alise> I beg to differ, so I'm not even going to bother responding any more.
17:11:27 <alise> Phantom_Hoover: 85492
17:11:29 <Phantom_Hoover> It gives 2^70 with the old bijection.
17:11:37 <Phantom_Hoover> *Much* better.
17:11:44 <fax> I've got a better bijection than you guys
17:11:46 <Phantom_Hoover> ,[.[-],]?
17:11:57 <alise> $ echo ',[,[-[++]].]-[[[++]+]+]' | ./bifro encode
17:11:57 <alise> 56046302675444742920145996600032729174513643271562716998685181
17:12:09 <alise> it still croaks on hello world iirc
17:12:12 <alise> not sure
17:12:23 <fax> program n = (filter balanced . generate $ ",.+-<>[]") !! n
17:12:24 <Phantom_Hoover> Can I have the bijection code?
17:12:28 <fax> the inverse is trivial
17:12:35 <fax> just a lookup table
17:12:37 <Phantom_Hoover> fax: *VALID*
17:12:42 <alise> yeah hello world hangs it for no reason
17:12:42 <fax> durppp
17:12:49 <fax> learn to read code
17:12:57 <alise> fax: doesn't work
17:13:00 <fax> yes it does
17:13:04 <fax> my word against yours
17:13:07 <alise> no, because you might end up with
17:13:10 <alise> [-]
17:13:13 <fax> that's valid
17:13:15 <alise> [...every program...]
17:13:19 <alise> [[-]...]
17:13:22 <alise> [[...etc...]...]
17:13:22 <alise> and never get to
17:13:27 <alise> +[...]-[.[etc]]
17:13:30 <fax> wrong it generates every program in finite time
17:13:37 <fax> generate is just n-ary counting
17:13:40 <Phantom_Hoover> fax is right, I think.
17:13:41 <alise> that's nice; anyway btw you're being a jerk now
17:13:46 <fax> 16:13 < alise> that's nice; anyway btw you're being a jerk now
17:13:55 <fax> ^ just admitted that he god pwnd
17:14:03 <Phantom_Hoover> Count up in base 8, then discard the invalid ones.
17:14:05 <alise> no, I just don't think it is nearly a good a bijection
17:14:09 <Phantom_Hoover> Yes.
17:14:11 <Phantom_Hoover> I agree.
17:14:15 <alise> *as good
17:14:23 <fax> alise: YOU ARE THE ONE BEING A JERK
17:14:26 <alise> anyway, fax is talking right now solely for the purpose of trying to annoy me right now, so
17:14:28 <Phantom_Hoover> It works, but it's as elegant as a pig with wheels.
17:14:32 <alise> time to figure out how you ignore in xchat.
17:14:40 <alise> there we go
17:14:50 <alise> Phantom_Hoover: hello world still hangs it
17:15:06 * alise considers running dbfi through it!
17:15:11 <fax> You are the kind of low tier human that has to tell other people what they are so that you believe it yourself
17:15:14 <alise> BAD IDEA NO
17:15:23 <alise> Phantom_Hoover: So, what is your nested encoding?
17:15:24 <fax> you are calling me a jerk over and over because you don't want to admit that you are the one being horrible
17:15:37 <Phantom_Hoover> alise: It doesn't work.
17:15:44 <alise> thought so :P
17:15:53 <Phantom_Hoover> Some programs are representable by two sequences.
17:16:10 * alise logreads to find out what fax's response to his ignoring her was; decides not to logread for such purposes any more
17:16:24 <alise> Now on to things that aren't about crazy people.
17:16:29 <alise> Phantom_Hoover: yeah
17:16:31 <alise> that's the basic issue
17:16:32 <fax> You guys are stupid, I can't beleive you've spent 2 days on this and I wrote it in one line of code
17:16:43 <Phantom_Hoover> fax: Inelegantly.
17:17:00 <fax> and the only way you can justify your termoil and excessive fail is by pretending it's not elegant
17:17:00 * Phantom_Hoover shouldn't feed the troll...
17:17:03 <Deewiant> Your one line includes two undefined identifiers
17:17:12 <fax> Phantom_Hoover: Fuck you. You're a fucking wanke
17:17:18 <fax> Phantom_Hoover: what the fuck would you know
17:17:22 <Deewiant> And presumably runs a fair bit slower than the one the others've got
17:17:40 <fax> Phantom_Hoover: I hope you have a heart attack, fuck you
17:18:22 <fax> fucking pathetic simple minded idiots
17:18:33 <Phantom_Hoover> alise: So, better encoding now?
17:18:35 <fax> alise calls me a jerk and ignores me, therefore I must be a troll
17:18:43 <Phantom_Hoover> Ahahaha.
17:18:57 <fax> seriously this is like reddit
17:19:01 <fax> this channel
17:20:30 * Phantom_Hoover pokes head above battlements
17:21:08 <Ilari> Hmm. LostKng has 20963 loops...
17:21:30 <Phantom_Hoover> Forget it.
17:21:41 <Phantom_Hoover> It's probably somewhere in the region of xkcd.
17:22:55 <pikhq> Ilari: How far does it nest?
17:24:17 <alise> pikhq: Too far
17:24:21 <alise> Especially considering it was compiled
17:25:03 <Phantom_Hoover> From what?
17:25:19 <Phantom_Hoover> Just some hacked-together decision tree compiler?
17:26:37 <alise> BFBASIC
17:27:19 <Phantom_Hoover> Have you tried just leaving HW to encode for a few hours?
17:27:22 <alise> hmm... now /I/ feel an urge to write a BASIC->BF compiler
17:27:43 <alise> Phantom_Hoover: No; considering that the translation just ends up being simple recursion plus a lot of lot of arithmetic, it is almost certainly memory allocation it hangs on.
17:27:49 <alise> By which token, it's either very, VERY big, or too big.
17:28:09 <alise> It's loops that do it.
17:28:27 <fax> I don't know why everyone is so nasty
17:28:40 <alise> I wonder what the state-of-the-art is in constant string -> BF to generate it.
17:28:44 <Phantom_Hoover> Did you post the triangular bijection functions?
17:28:55 <alise> Want the code?
17:29:00 <Phantom_Hoover> Yes.
17:29:01 <fax> I know you are struggling alise but I know you are strong enough not to have to take it out on me
17:29:17 <Phantom_Hoover> And I think HW could be optimised for this by eliminating loops.
17:30:05 <alise> Of course.
17:30:07 <alise> http://pastie.org/943767.txt?key=qjqgkkxho8wjgybmhdww
17:30:32 <alise> I like how we rely on real arithmetic being at least SLIGHTLY accurate.
17:30:39 <alise> It's such an... amusingly inaccurate assumption.
17:30:46 <pikhq> Phantom_Hoover: A hacked-together decision tree compiler? Why, that's *my* effort at doing a text adventure game in Brainfuck!
17:31:12 <pikhq> Oh, and I should note: Yes, I wrote it. No, I do not have a game for it. Just the engine. :P
17:31:24 <Ilari> I estimate that with the enumeration I'm trying to figure out, enumeration of LostKng would be around 2^153 000 000 (assuming enumeration of structure encoding is low)...
17:32:28 <alise> "I do know that the halting problem is unsolvable in general, but I was not sure whether there did not exist special case exceptions. Like, maybe Matlab might function as a Super Turing machine able to determine the halting of the bf program."
17:32:36 <alise> "SECOND EDIT: I have written what I purport to be infinite loop detector. It probably misses some edge cases (or less probably, somehow escapes Mr. Turing's clutches), but seems to work for me as of now. In pseudocode form, here it goes:"
17:32:51 <Phantom_Hoover> From where?
17:33:27 <alise> http://stackoverflow.com/questions/367571/detecting-infinite-loop-in-brainfuck-program
17:33:37 <alise> "I have created a truly marvelous program to do this, which this textbox is too narrow to contain." --comment
17:34:06 <fax> LAME
17:34:15 <fax> that joke is so old it makes me physically sick hearing it
17:35:15 <Phantom_Hoover> alise: But it's clearly possible sometimes.
17:35:29 <Deewiant> Hmmh, ++++++++++[>+++++++>++++] encodes to a 3.2 million digit number.
17:35:44 <Ilari> I estimate between 46 020 000 and 46 030 000 base-10 digits...
17:35:53 <Phantom_Hoover> A word of advice: Avoid loops.
17:36:04 <pikhq> http://sprunge.us/SYFg
17:36:10 <pikhq> That was some fun code 3 years ago.
17:37:03 <pikhq> Pity I never made it into an actual game.
17:37:15 <Phantom_Hoover> I wonder what move is...
17:37:28 <pikhq> (oh, yes, if you want the source I can tarball it up)
17:38:03 <Phantom_Hoover> >>[-]<<[->>+<<] > 4*10^1185
17:38:27 <alise> pikhq: hey, you could implement basic with pebble
17:38:33 <alise> write the basic primitives as pebble macros
17:38:40 <alise> use tcl to read code from stdin, translate to pebble primitives
17:38:40 <pikhq> alise: It would be quite feasible.
17:39:00 <pikhq> PEBBLE is sufficiently high-level to make targetting it not a pain.
17:39:14 <Phantom_Hoover> Pebble?
17:39:30 <pikhq> Practical Esoteric Brainfuck-Based Language, Eh?
17:39:46 <pikhq> It's a macro language for Brainfuck I wrote a few years back.
17:40:29 <alise> Hey, gosub/return is easy with computed gotos, which is easy with the standard method of BF labels.
17:41:00 <pikhq> Yup.
17:41:10 <alise> GOSUB x := Put (CURRENT LINE), which we know at compile-time, somewhere global; GOTO x
17:41:16 <alise> RETURN := GOTO (GLOBAL PLACE)
17:42:46 <alise> ("Line numbers" would just be labels, really, since you'd want to normalise them anyway.)
17:43:35 <Deewiant> Gah, I might run out of memory on ++++++++++[>+++++++>++++++++++>]
17:45:46 <Phantom_Hoover> Can we generalise this?
17:45:59 <alise> Generalise what?
17:46:08 <Phantom_Hoover> This bijection.
17:46:10 <alise> the bijection?
17:46:11 <alise> yes
17:46:16 <alise> consider that for any nested data type
17:46:27 <alise> we can assign a constant C_n to all n non-nesters
17:46:40 <Phantom_Hoover> For all languages in which the syntax is equivalent to a nested list of nats?
17:46:40 <alise> then, say the thing has one nester
17:46:43 <alise> with only one argument, the nester
17:46:52 <alise> represent this as {nested}
17:47:01 <alise> this produces an arbitrarily nested list of nats
17:47:04 <alise> apply the bijection; Q.E.D.
17:47:19 <alise> more than one nester: set the constants such that they are all, say, even
17:47:25 <alise> then make one nester have all its subterms odd, and the other even
17:47:28 <alise> or something
17:47:44 <Phantom_Hoover> Lazy K seems like it would lend itself to bijection.
17:47:55 <alise> gee, what about jot! wait.
17:48:34 <alise> 09:38:03 <Phantom_Hoover> >>[-]<<[->>+<<] > 4*10^1185
17:48:35 <alise> wow :)
17:49:32 <Phantom_Hoover> But you get something much smaller if you don't double the moves.
17:49:53 <Phantom_Hoover> >10^71, admittedly, but still.
17:50:31 <Phantom_Hoover> Are all strings of 0 and 1 valid in Jot?
17:50:51 <Deewiant> Yay, ++++++++++[>+++++++>++++++++++>] finished
17:50:59 <Deewiant> A 733741052-digit number
17:51:10 <Phantom_Hoover> Save it, quickly!
17:51:22 <Deewiant> Nah, I just piped it into wc :-P
17:52:14 <Phantom_Hoover> Bifro should ideally have the capacity to write the number in base 256 with a string of bytes.
17:52:22 <Phantom_Hoover> Much more compact.
17:52:36 <Deewiant> Your decoder is broken, btw; probably the double-cast
17:52:49 <fax> what's the point of putting brainfuck programs in bijection with natural numbers?
17:52:52 <pikhq> Phantom_Hoover: Yes.
17:53:09 <Deewiant> "What's the point" is rarely a sensible question on this channel
17:53:09 <pikhq> Every string of 0 and 1 is valid, including the empty string.
17:53:21 <pikhq> fax: Putting Brainfuck programs in a bijection with natural numbers.
17:53:27 <Phantom_Hoover> pikhq: Then it's trivial.
17:53:35 <pikhq> Phantom_Hoover: Yes.
17:53:56 <Phantom_Hoover> Just stick a 1 on the start and make it binary.
17:53:57 <pikhq> Jot is intended as a Goedel numbering. :)
17:54:12 <pikhq> Uh, what?
17:54:19 <Phantom_Hoover> Wait, forget that.
17:54:26 <Phantom_Hoover> No 1 is needed.
17:54:38 <pikhq> *Just use the freaking number*.
17:54:51 <alise> <Deewiant> Your decoder is broken, btw; probably the double-cast
17:54:52 <alise> what double cast
17:55:06 <Deewiant> alise: fromInteger
17:55:10 <alise> pikhq: no
17:55:12 <alise> consider 0001
17:55:19 <Phantom_Hoover> Ooh, it is broken.
17:55:20 <alise> Deewiant: what would you propose then
17:55:30 <alise> :/
17:55:33 <Deewiant> alise: A custom sqrt that works on Integer.
17:55:34 <Phantom_Hoover> echo ">[-]<[->+<]" | ./bifro encode | ./bifro decode
17:55:41 <Deewiant> [[[[[[[[[[[[[[[[[[[[
17:55:42 <alise> Deewiant: Bah, okay.
17:55:48 <alise> http://www.haskell.org/haskellwiki/Generic_number_type#squareRoot
17:55:51 <Phantom_Hoover> Just blasts you with [[[[
17:55:53 * alise writes it
17:56:25 <alise> (^!) :: Num a => a -> Int -> a
17:56:26 <alise> (^!) x n = x^n
17:56:28 * alise wonders why
17:56:31 <alise> oh, for type specification
17:56:33 <alise> (why)
17:56:40 <Deewiant> Probably an optimization
17:56:43 <alise> right
17:57:27 <Phantom_Hoover> Is biFro working? The function, not the program.
17:57:41 <alise> no
17:57:47 <alise> Deewiant: Can I use isqrt? There's a /2.
17:57:52 <alise> And I am not sure the result is always divisible by two.
17:58:01 <Deewiant> ++++++++++[>+++++++] at least comes out correctly now.
17:58:18 <Deewiant> alise: Wasn't it being floored? `div` 2
17:58:24 <alise> Ah, true.
17:58:25 <pikhq> alise: Mmm, yes.
17:58:25 <fax> alise: i can't beleive you are talking this long to solve a quadratic equation. lol
17:58:29 <alise> Deewiant: Now.
17:58:33 <alise> Deewiant: gimme a number that didn't work
17:58:49 <Deewiant> alise: It works now, I already copied squareRoot into it myself.
17:58:51 <Ilari> Well, that was too optimistic estimate. But I estimate that Lost Kindom encodes to less than 10^(10^8)...
17:58:59 <Deewiant> alise: But, e.g. '+++++++'.
17:59:10 <Ilari> *Kingdom
17:59:13 <Deewiant> 5695183504492614029263277.
17:59:28 <alise> Deewiant: Do you think that I should change how loops are encoded?
17:59:29 <Deewiant> 'K8'@*+'E28'@**+'%2'@f2+**+"I$@"*+"/KHQa"738*+345'@**+*****+****
17:59:30 <alise> I'm just not sure how.
17:59:44 <Phantom_Hoover> All other efforts have failed
17:59:45 <alise> Ilari: Reassuring to know
17:59:53 <Deewiant> I think you should if you find a way to ;-)
17:59:54 <alise> It's less than a googolple, at least
18:00:15 <alise> This program has rekindled my love affair with Haskell.
18:00:21 <alise> (Is it a love affair if you don't have any other partners?)
18:00:36 <alise> ((This applies in both the programming and otherwise meanings.))
18:00:54 <Phantom_Hoover> Bah, Lazy K is trivial. How about Unlambda?
18:00:54 <alise> Come back up, pastie!
18:00:56 -!- adam_d has joined.
18:00:57 <alise> I need to deliver version 4!
18:00:57 <alise> yay
18:00:58 <alise> No 3.
18:01:04 <alise> Off by one there :D
18:01:16 <alise> Version three, guyz: http://pastie.org/943801.txt?key=uwdomh4k9krj16tc9ezw
18:01:19 <alise> Update your copies.
18:02:52 <alise> ++[+[+[+[+[++++]+]+]+]+]++ generates a 6264 digit number
18:03:19 * alise has an idea
18:03:21 <Deewiant> How very short
18:03:25 <alise> Instead of
18:03:26 <alise> loop xs = crush xs + 6
18:03:27 <alise> how about
18:03:32 <alise> loop xs = crush (map (+ 6) xs)
18:03:32 <alise> ?
18:03:35 <Deewiant> And it's 6263, not 6264
18:03:37 <alise> would this work, I wonder?
18:03:38 <Deewiant> The newline isn't part of it
18:03:43 <alise> eh, [] would = [[]] :/
18:03:50 <alise> Deewiant: Oh, I forgot echo -n
18:03:51 <Phantom_Hoover> alise: That's even worse!
18:04:00 <alise> Phantom_Hoover: is it?
18:04:05 <alise> wait [] would not = [[]]
18:04:14 <alise> crush [] = 0; [0] = 1+biTo(0,0)
18:04:18 <Deewiant> alise: That won't help unless you meant echo 'brainfuck' | echo -n $(foo encode) | wc -c
18:04:22 <alise> = 1
18:04:26 <Phantom_Hoover> Surely increasing pre-crush means that the crushed list is much larger?
18:04:26 <alise> oh, darn
18:04:27 <alise> that doesn't work
18:04:31 <alise> Deewiant: that's what i meant
18:04:35 <alise> err...
18:04:36 <alise> what?
18:04:37 <alise> I did
18:04:42 <alise> $ echo butt | ./bifro encode
18:04:42 <Deewiant> Which actually doesn't work, that's interesting
18:04:46 <alise> (actually via terminal but)
18:04:47 <alise> copy it
18:04:53 <alise> echo, paste, | wc -c
18:05:06 <Deewiant> Oh, right, need to wrap the whole thing *duh*
18:05:14 <alise> Phantom_Hoover: Hmm... maybe, yeah.
18:05:36 <Deewiant> alise: You know you can pipe the output of a program without having to copy-echo-paste :-P
18:05:47 <alise> Deewiant: I know, I just forgot the first time.
18:05:49 <alise> Wanted to see what it'd look like.
18:05:58 <alise> Huh, these numbers often repeat.
18:06:04 <alise> Lots and lots of 77s and 777s in that progam's number
18:06:07 <alise> Then again, lots of 88s too
18:06:08 <alise> And 444s
18:06:13 <alise> Maybe they just repeat naturally, or maybe it's just a coincidence.
18:09:31 <Phantom_Hoover> Is there any limit to the languages this can represent?
18:11:17 -!- Phantom_Hoover_ has joined.
18:11:20 <alise> It cannot represent the language of love.
18:11:33 <Phantom_Hoover_> Is the language of love well-defined?
18:11:37 <alise> Apart from that, uh, the reals? But we can't construct the reals so it'd be pointless to apply such an algorithm to them.
18:11:50 <alise> But anything countable, which is... all programming languages?, yes, has a bijection to the naturals. By definition.
18:12:03 <Phantom_Hoover_> Ah, yes.
18:12:12 <Phantom_Hoover_> But using this system?
18:12:31 <alise> Well... I don't know. It would have to be changed in all cases; sometimes minorly, sometimes it might be completely unrecognisable.
18:12:35 <alise> So it's hard to answer.
18:12:47 <Phantom_Hoover_> The syntax needs to be representable using nested lists, I think.
18:12:54 <Phantom_Hoover_> Of naturals
18:13:02 <Phantom_Hoover_> With an upper bound.
18:14:07 <alise> Yes, the only problem is the multiple nesting case.
18:14:12 <alise> But I am sure you can do that as something.
18:14:17 <Phantom_Hoover_> Multiple nesting?
18:14:19 -!- Phantom_Hoover has quit (Ping timeout: 265 seconds).
18:14:29 <alise> like instead of just [] {} too
18:14:29 -!- Phantom_Hoover_ has quit (Client Quit).
18:14:42 -!- Phantom_Hoover_ has joined.
18:14:57 <Phantom_Hoover_> Ooh.
18:15:29 <Phantom_Hoover_> If they're properly nested, it shouldn't matter.
18:15:45 <Phantom_Hoover_> So long as {(}) isn't legal.
18:15:55 <alise> Yes, but it's just a question of "how do you represent it" because lists only have one type of nesting.
18:15:59 <alise> One way would be
18:16:03 <alise> say all instructions are even
18:16:09 <alise> then one type of loop would increase so that it's even
18:16:12 <alise> another would increase so it's odd
18:16:17 <alise> then you can identify which, I think
18:16:24 <alise> or something
18:16:30 <Phantom_Hoover_> Or you could just encode the information into the list.
18:16:33 <alise> i.e.,
18:16:47 <alise> odd_naturals[crush(looptype1)] + N
18:16:51 <alise> even_naturals[crush(looptype2)] + N
18:16:58 <alise> (with some munging so that all naturals are covered by this)
18:17:17 <alise> repeat with similar spacings for all M types of loop
18:17:19 <alise> or, well, nesting in general
18:17:49 <Phantom_Hoover_> Incidentally, have we proven that, taking g(n) to be the triangular cdr, the recurrence relation u_n+1=g(u_n) ends up at 0 for all u_0?
18:18:47 * alise 's brain flags up "LOOKS LIKE COLLATZ BE SCARED"
18:18:50 * alise shuts up stupid heuristics
18:18:53 <alise> Triangular cdr?
18:19:02 <alise> As in "snd (biFro (n-1))"?
18:19:05 <Phantom_Hoover_> Yes.
18:19:07 <alise> Or "snd (biFro n)"?
18:19:22 <alise> Assuming the latter,
18:19:27 <Phantom_Hoover_> g(n) = snd(biFro n)
18:20:03 <alise> this simplifies to (n - biTo ((isqrt (8*n+1) - 1) `div` 2))
18:20:04 <Phantom_Hoover_> Whatever, it just needs to be shown that we get a finite list from all n.
18:20:24 <alise> ehh, I'll just code it an test it empiraclly
18:20:26 <alise> *empirically
18:20:29 <alise> that's the best way to prove anything
18:20:37 <alise> is this to check that all numbers give a finite program?
18:20:39 <alise> yeah
18:21:05 <Phantom_Hoover_> alise: You can't test *all* nats!
18:21:20 <Phantom_Hoover_> I want your computer.
18:21:28 <alise> Of course, but I can be reasonably sure of something!
18:21:32 <alise> It's the lazy-fucktard's way of proving something.
18:22:02 <alise> Well, u_0 = 0 falsifies it.
18:22:14 <alise> But we special-case 0 in the recursion, so nyah.
18:22:15 <alise> But ignoring /that/,
18:22:22 <alise> -- uh, I really should make it stop on 0s
18:22:26 <alise> silly me
18:22:39 <alise> [1]
18:22:40 <alise> [2,1]
18:22:41 <alise> [3]
18:22:42 <alise> [4,1]
18:22:44 <alise> [5,2,1]
18:22:56 <alise> *Main> ulist 10000
18:22:57 <alise> [10000,130,10]
18:22:57 <alise> *Main> ulist 100000
18:22:57 <alise> [100000,319,19,4,1]
18:23:08 <alise> Ooh, I should use quickcheck!
18:23:19 <Deewiant> And smallcheck! And lazy smallcheck!
18:23:33 <alise> Why!
18:23:36 <alise> Why instead of QuickCheck!
18:23:52 <Phantom_Hoover_> But it's not a *proof*!
18:23:55 <Deewiant> I said "and" not "instead of"!
18:24:00 <alise> Yes but why!
18:24:04 <Deewiant> Because!
18:24:14 <alise> Deewiant: You do it!
18:24:17 <Deewiant> No!
18:24:28 <Phantom_Hoover_> alise: THERE'S NO SUCH THING!
18:24:55 <alise> Phantom_Hoover_: Uh, there is actually.
18:24:59 <alise> Verifya:P
18:25:01 <alise> *:P
18:25:10 <Phantom_Hoover_> Really?
18:25:13 <alise> You can get more confidence in a proposition forall n, P(n) by testing P(n) for many n.
18:25:28 <fax> lol confidence
18:25:34 <Phantom_Hoover_> *More* confidence, not certainty.
18:25:34 <alise> You can't outright *prove* it, but this is why people have computers searching for counterexamples to the Collatz conjecture.
18:25:39 <fax> sure is engineering in here
18:25:44 <alise> Mathematics isn't /all/ about proofs.
18:26:22 <Phantom_Hoover_> oerjan's proof seemed to use the fact that 1+f(u, v) > u and v.
18:26:50 <Phantom_Hoover_> It's somewhere in today's logs, and it should be adjustable for the triangular function.
18:27:12 <alise> Well, this is almost true.
18:27:23 <alise> No, wait, it is true.
18:27:25 <alise> Q.E.D.
18:27:47 <alise> So since 1+f(u,v) > u and v,
18:28:01 <alise> f^-1(n-1) < u and v
18:28:11 <alise> So, the result always gets smaller.
18:28:22 <alise> Since this is the naturals, the only value it can approach if it always gets smaller is 0.
18:28:29 <alise> 0 always terminates, for it results in [].
18:28:35 <alise> Therefore, the function always terminates. Q.E.D.
18:28:42 <Phantom_Hoover_> Good.
18:29:01 <Phantom_Hoover_> Now we just need to write the wiki page.
18:29:06 <alise> Er, rather, I mean:
18:29:18 <alise> If (u,v) = f^-1(n-1), u and v < n
18:29:23 <alise> I think. Anyway, it's true.
18:29:36 <alise> Phantom_Hoover_: I'd like to think about making loops better first. And there isn't much to write.
18:29:49 <alise> Silly language: BF, but in Bifro syntax.
18:30:05 <alise> You can't run non-trivial programs, because they don't fit into the universe.
18:30:18 <alise> So it's very theoretically Turing complete only. :P
18:30:29 <Phantom_Hoover_> That still confuses me, BtW.
18:30:29 <alise> Unless you produced an interpreter with no, or not many at all, nested brackets...
18:30:33 <alise> Why?
18:30:44 <alise> How something can be TC but not possible in the universe like that?
18:30:59 <fax> alise unignore me
18:31:06 <alise> Because mathematics is larger than the universe; that's why we can say "for all" and it means "every natural", not "everything up to 10^80 or so"
18:31:18 <Phantom_Hoover_> No, I get that.
18:31:21 <fax> alise
18:35:06 <alise> fizzie: ping
18:35:40 <alise> Ping pong
18:35:49 <alise> Let's play ... NETWORK TABLE TENNIS!
18:35:59 <alise> Ping. Pong. Ping. Pong. Pingpongpingpongpingpong connection dropped.
18:42:57 <alise> pikhq: ping
18:43:36 <Phantom_Hoover_> Hmm... More random ideas for noop.
18:43:49 <alise> orly
18:44:00 <Phantom_Hoover_> I'm not sure if they'll work, though.
18:44:34 <Phantom_Hoover_> Incidentally, does hugeness come mainly from loops?
18:45:02 <alise> Yes.
18:45:34 <Phantom_Hoover_> It seems to have frozen on "+++++++++++++++++++++++++++++++"
18:46:10 <pikhq> alise: Pong
18:46:16 <Phantom_Hoover_> It *should* only be quadratic...
18:47:22 <alise> pikhq: I realised that my typesetting system can easily be used for literate programming too.
18:47:29 <alise> Phantom_Hoover_: Why not evaluate it manually?
18:49:06 <alise> pikhq: Some hypothetical usage: http://pastie.org/943852.txt?key=321l5gwchzzohrrzdehmzg
18:49:15 <alise> Using the evilly-named commands \, \\, and \\=.
18:56:03 <alise> http://www.literateprogramming.com/adventure.pdf ADVENTURE, the literate program.
18:57:00 <alise> Penned by Knuth himself.
18:57:10 <Phantom_Hoover_> Tried "++++++++++++++++++". It comes out as a 50085-digit number.
18:57:50 <pikhq> Hmm.
18:57:57 <Phantom_Hoover_> My problem is that I can't see what's in the lower numbers. There must be some *enormous* trivial ones.
18:59:19 <alise> Phantom_Hoover_: well it's not quadratic because biTo is nested tons, right?
18:59:27 <alise> so there's a ton of /nested/ multiplications
18:59:40 <Phantom_Hoover_> Oh, yeah
19:01:09 <alise> I advise everyone to read http://www.literateprogramming.com/adventure.pdf, by the way.
19:01:49 <alise> "If I were writing this program, I would allow the word woods, but Don apparently didnt want to."
19:01:54 <alise> Damn INTERCALator.
19:02:03 <alise> INTERCALator, n. one who uses INTERCAL.
19:03:05 <alise> I dislike how it has visible spaces in strings, but eh
19:04:24 <alise> mess wd ("fuck");
19:04:25 <alise> new mess ("Watch it!");
19:05:57 <alise> 27. The instructions here keep you in the forest with probability 50%, otherwise they take you to the
19:05:57 <alise> woods . This gives the illusion that we maintain more state information about you than we really do.
19:07:32 <Phantom_Hoover_> You know, fax's method may have been mathematically inelegant, but at least it would have given sane numbers.
19:08:25 <alise> Would it have? I beg to differ.
19:08:36 <alise> I think it would enumerate all programs with loops of length N before getting onto a single one with N+1.
19:08:46 <Phantom_Hoover_> No, that's the thing.
19:09:53 <Phantom_Hoover_> If you count up in base 8, using the instructions as the digits, until you reach the program, then discard the invalid programs, the length of what's left is a bijection
19:10:13 <fax> Phantom_Hoover_: fuck off troll
19:10:15 <Phantom_Hoover_> It would take ages to compute, though.
19:10:16 <alise> "The twisty little passages of this maze are said to be all alike,"
19:10:20 <alise> Phantom_Hoover_: I know.
19:10:24 <alise> I think it would enumerate all programs with loops of length N before getting onto a single one with N+1.
19:10:30 <alise> Which would mean the numbers would not be reasonable.
19:10:41 -!- impomatic has joined.
19:10:44 <impomatic> Hi :-)
19:10:45 -!- oerjan has joined.
19:10:57 <fax> alise: yeah the numbers relating to the size of the program.. that must be unreasonable
19:11:01 <Phantom_Hoover_> alise: No, it wouldn't.
19:11:38 <oerjan> hi, have you rewritten bi{Fro,To} to use triangular numbers yet?
19:11:42 <alise> oerjan: yes
19:11:43 <alise> and it works
19:11:48 <alise> oerjan: but we need a better loop nester
19:12:02 <oerjan> btw i realized after i logged out that there is a way to do the floor exactly
19:12:06 <alise> http://pastie.org/943801.txt?key=uwdomh4k9krj16tc9ezw
19:12:10 <alise> where m = (isqrt (8*n+1) - 1) `div` 2
19:12:17 <alise> oerjan: we did not use your algorithm
19:12:21 <alise> fizzie got a computer to invert it, hooray
19:12:23 <alise> biFro n = (m - (n - biTo (m,0)), n - biTo (m,0))
19:12:24 <oerjan> ok you found that formula too
19:12:24 <alise> where m = (isqrt (8*n+1) - 1) `div` 2
19:12:28 <alise> this is for
19:12:28 <alise> biTo (u,v) = triang (u+v) + v
19:12:29 <alise> where triang n = n * (n+1) `div` 2
19:12:29 <alise> instead of +u
19:12:32 <alise> oerjan: lol
19:12:48 <alise> you're sad now :))
19:12:57 <oerjan> well u,v, is the same thing
19:13:03 <Phantom_Hoover_> I think that the number for a program of length n with fax's method must be less than 8^n, but there may be an off-by-one in that.
19:13:31 <oerjan> alise: why sad? just because you found what i would have suggested?
19:13:43 <oerjan> what algorithm didn't you use?
19:13:55 <alise> the one you suggested with the floor of sqrt 2n
19:13:59 <oerjan> right
19:14:09 <alise> I dunno, I get sad when my discoveries aren't a prodigal genius one :-)
19:14:11 <alise> *ones
19:14:38 <oerjan> yeah i realized that the (x+y)(x-y) rule could be used to make it exact instead, with that 8*n+1 etc. thing
19:14:40 <fax> who are you to judge what is mathematically elegant?
19:15:16 <oerjan> anyway i'm not sad. today i forgot a ballpoint pen in my laundry, first time for me afair
19:15:42 <oerjan> so i expected complete disaster, but both the sweater and the pen appear to have survived :)
19:16:03 <oerjan> (it even wrote when i tested)
19:16:46 -!- adam_d has quit (Ping timeout: 245 seconds).
19:19:34 <alise> oerjan: this is the kind of thing all mathematicians get happy about, isn't it...
19:19:37 <alise> I can just tell from the way you say it :D
19:20:13 <oerjan> i don't know how much other mathematicians forget pens in their laundry, might be an occupational danger...
19:20:37 <alise> *hazard, is more idiomatic.
19:20:39 <oerjan> it's just i'm usually careful about it
19:20:41 <oerjan> ah.
19:21:07 <oerjan> what's wrong with the loop nesting?
19:21:25 <Phantom_Hoover_> Nothing, mathematically,
19:21:29 <alise> we do "crush xs" which makes a ruddy big number, then later on we crush that /again/ to flatten the whole program
19:21:31 <fax> I use pencils
19:21:33 <alise> now consider nested loops
19:21:35 <Phantom_Hoover_> It just generates bloody huge numbers.
19:21:37 <alise> feel the pain, FEEEEEL the pain
19:22:14 <Phantom_Hoover_> No-one's computed the number for a non-trivial program much longer than cat.
19:22:16 <oerjan> i _did_ think about it a bit when away, on long lists it would tend to blow the final parts up more than the beginning, wouldn't it?
19:22:46 <oerjan> but i didn't think the nesting of loops would be the problem...
19:22:51 <alise> also that, yes!
19:22:54 <alise> it blows up a lot more with that
19:22:56 <alise> maybe it IS that...
19:23:04 <oerjan> i thought of a way around it
19:23:08 <Phantom_Hoover_> Ooh, what?
19:23:17 <alise> oerjan: do tell
19:23:30 <oerjan> basically store a list as a tree instead, so tuples spread out more balancedly
19:23:57 <oerjan> this requires some care to make sure we don't miss numbers, i think
19:23:58 <alise> *Main Data.List> elemIndex ",[.,]" . filter balanced . kleene . map (:[]) $ "-+<>,.[]"
19:23:59 <alise> Just 9316
19:24:05 <Phantom_Hoover_> So... What would the structure for ",[.,]"?
19:24:09 <alise> I think my loop conjecture about fax's may be wrong :(
19:24:13 <alise> oerjan: hey hey
19:24:16 <alise> that was Ilari's idea
19:24:28 <oerjan> alise: oh well i guess :D
19:24:36 <alise> STEALING FILTH :p
19:24:37 <alise> *:P
19:24:38 <fax> I also mentioned this alise did not understand it
19:24:47 <oerjan> except i thought that it is necessary to give each list a _unique_ tree
19:24:59 <alise> *Main Data.List> elemIndex ",[.[-],]" . filter balanced . kleene . map (:[]) $ "-+<>,.[]"
19:25:00 <alise> [nothing]
19:25:03 <alise> This thing is biased against EOF on 0
19:25:14 <alise> Conclusion: Not a viable computational algorithm.
19:25:21 <Phantom_Hoover_> Yes.
19:25:33 <Phantom_Hoover_> It's even worse if you try to reverse it.
19:25:37 <oerjan> um what's kleene
19:25:42 <alise> v a 0 = [[]]
19:25:42 <alise> v a i = [s++t | s <- v a (i-1), t <- a]
19:25:42 <alise> kleene a = kleene' a 0
19:25:42 <alise> where kleene' a n = v a n ++ kleene' a (n+1)
19:25:44 <alise> kleene star
19:25:51 <alise> so kleene on that generates all valid and invalid bf progams
19:25:53 <alise> *programs
19:25:58 <alise> then we filter to get only balanced ones, and look up the prog
19:26:05 <alise> fax was yelling at us to use this instead because it's soooo trivial
19:26:12 <alise> but it seems it does not like being computed. maybe it'd be better with fusion
19:26:40 <Phantom_Hoover_> It's trivial in terms of the algorithm, but it's even worse than ours in terms of practicality.
19:27:00 <fax> that's because you don't know how to implement it efficently
19:27:23 <fax> look up stirling numbers if you are serious about this
19:28:18 <Phantom_Hoover_> fax: Your method requires that we enumerate *every* valid program up to x, a huge computation.
19:30:50 <fax> take a class on counting
19:31:01 <fax> you can do this efficently
19:31:19 <Phantom_Hoover_> OK, briefly describe the algorithm.
19:31:32 <fax> Phantom_Hoover_: take back what you said earlier
19:31:43 <oerjan> <alise> hey oerjan log-reading <-- hello
19:31:43 <Phantom_Hoover_> What? That it's inelegant?
19:31:50 <fax> Phantom_Hoover_: you called me a troll
19:32:00 <Phantom_Hoover_> You *were* trolling.
19:32:09 <fax> k bye
19:32:26 <Phantom_Hoover_> Fine.
19:32:52 <alise> oerjan: i said something to you :P
19:33:02 <Phantom_Hoover_> Anyone any idea what his magic algorithm is?
19:33:25 <oerjan> <alise> "plus or minus any off-by-one errors"; says oerjan
19:33:26 <fax> I pity those who have too much pride to admit they are wrong
19:33:44 <alise> Phantom_Hoover_: i'd tell you, but you're NASTY
19:33:47 <oerjan> there weren't any in that formula, amazingly
19:33:54 <alise> sometimes you've had a reply-latency of a FEW MINUTES!
19:33:59 <oerjan> alise: i noticed. the logs are just huge today.
19:34:02 <alise> oerjan: off-by-one errors are, like, the scourge of everything
19:34:06 -!- Gracenotes has joined.
19:34:13 <Phantom_Hoover_> oerjan: Bank holiday in the UK.
19:34:20 <Phantom_Hoover_> I assume.
19:34:21 <fax> off by one errors are something you learn to avoid when you are beginner
19:34:35 <fax> if you are still stuggling with them it's time to go over he basics again
19:34:56 <Phantom_Hoover_> Now you're insulting the channel op?
19:34:58 <alise> statement to nothing?
19:35:04 <alise> oh fax
19:35:08 <fax> im not insulting anyone
19:35:35 <Phantom_Hoover_> Well, I suppose you'll just accuse us of fabricating what you said two minutes ago.
19:36:24 <Phantom_Hoover_> oerjan: How do you encode the BF program into a tree?
19:36:39 <Phantom_Hoover_> And is it easily flattenable into a natural?
19:37:10 <fax> <BF> ::= \epsilon | <INST> <BF> | '[ <BF> ']'
19:37:21 <fax> <INST> ::= '+' | '-' | ...
19:37:36 -!- adam_d has joined.
19:37:56 <fax> BNF is a pretty basic technique from computing, dates back to ALGOL
19:38:07 <Phantom_Hoover_> Oh yeah.
19:38:25 <oerjan> fax: i said it might contain off-by-one errors because i didn't bother to check before writing it, i knew that was the essence apart from it. although it was also accidentally completely correct.
19:39:01 <oerjan> fax: i've been mentioning algebraic data types before, for this problem that's about equivalent
19:39:19 <fax> afk
19:40:06 <oerjan> anyway i though that if the length of the list is 2^n+1 <= l < 2^n, we use a tree of depth n
19:40:33 <oerjan> with all empty nodes at either the left end or the right one
19:40:38 <Phantom_Hoover_> Basically, how would you treeify "+++"?
19:41:02 <oerjan> however _some_ of the nodes are just tuples, others are variants (haskell Either)
19:41:15 <alise> Either tuple variants!
19:41:20 <alise> Either tuple Either
19:41:37 <oerjan> as ((Empty,+),(+,+)) but with some care there
19:42:04 <oerjan> lessee...
19:42:27 <Phantom_Hoover_> OK, I must leave for now. I'll look at the logs later.
19:42:35 -!- Phantom_Hoover_ has quit (Quit: Phantom_Hoover_).
19:43:11 <oerjan> data Tree a = Leaf a | Branch (Tree a) (CompleteTree a)
19:43:23 <AnMaster> http://thedailywtf.com/Articles/A-Real-TriState.aspx <-- this is to tristate as filenotfound is to boolean
19:43:24 <oerjan> i'm not bothering to incorporate the depth
19:43:28 <AnMaster> very wtf
19:44:20 <alise> 3, 5, ...
19:44:23 <oerjan> or wait, maybe i'll do that with a "dependent n", not legal haskell but more descriptive
19:44:30 <alise> clearly, size_of_presumably(n) = odds[n]
19:45:40 -!- adam_d has quit (Ping timeout: 265 seconds).
19:45:56 <oerjan> the thing about the CompleteTree part is that we know the depth from the left part of the branch, so we can just use tuples without variants down to the bottom
19:46:28 <oerjan> actually we need an Empty | in that i think
19:47:16 -!- adam_d has joined.
19:47:41 <oerjan> it is possible that it needs another data type PossiblyEmptyTree a :D
19:48:36 <oerjan> oh wait of course we have the empty list too hm
19:48:46 <alise> EmptyTreeWithProbabilityOnePointSeventyFive
19:49:11 <alise> data EmptyTreeWithProbabilityOnePointSeventyFive = Empty1 | Empty2 | Empty3 | NotEmpty Tree
19:49:21 <alise> (the constructors are hidden and a function uses unsafePerformIO to return one of these randomly)
19:52:05 <oerjan> lessee to get this started
19:52:17 <oerjan> an empty list = 0
19:52:35 <alise> *tree, surely.
19:52:35 <oerjan> a single element list [x] = 1+2*x
19:53:39 <oerjan> well tree or list, it's about the number of elements
19:54:22 <oerjan> a larger list/tree than that is 2+2*f(left part, right part)
19:54:44 <alise> <oerjan> a single element list [x] = 1+2*x
19:54:50 <alise> what about [[x]]?
19:55:03 <alise> or do we not have that?
19:55:22 <oerjan> um the inner [x] is using the ordinary 6+crush [x] stuff
19:55:28 <oerjan> since it's a single element
19:55:43 <alise> right.
19:55:51 <alise> so this is to solve the problem that crush is horrible?
19:55:55 <oerjan> yeah
19:56:00 <alise> what is the algorithm for distributing the tree?
19:56:01 <oerjan> or try, at least
19:56:23 <oerjan> well i think the best is simply all elements as far to the left in the tree as possible
19:56:40 <oerjan> (since the opposite is harder to collect in haskell, i think)
19:57:23 <alise> isn't this actually bigger than the list encoding
19:57:27 <alise> ... we timesify the f
19:57:32 <alise> and if we go the left part, then...
19:57:47 <oerjan> um no because we have less depth of nesting of f's
19:57:54 <oerjan> or so i think
19:58:30 <alise> really? why?
19:58:45 <alise> you said distribute everything to the left.
19:58:56 <oerjan> oh that's not what i meant
19:59:03 <oerjan> the tree is perfectly balanced
19:59:26 <oerjan> it's just that the left over empty parts from 2^n-x should be put at the right end
20:00:16 <oerjan> the thing about is: see the 2+2*f(left part, right part) thing?
20:00:40 <oerjan> if we distribute like this, we know that "left part" is a _complete_ tree with 2^(n-1) leafs
20:01:02 <oerjan> which means we need no variants when encoding it
20:01:14 <alise> sure
20:01:22 <alise> i vote you write the code and i relax
20:01:25 <oerjan> let me try to show what +++ is, if my brain grasps it
20:04:18 <oerjan> 2+2*f(f(+,+),1+2*f(2*(+),0))
20:04:24 <oerjan> no i'm _not_ sure of that :D
20:04:32 <alise> okayyy
20:04:33 <alise> :Dd
20:04:35 <alise> *:D
20:05:05 <oerjan> the thing is to use variants (Either) splits only where we know there _can_ be a split
20:05:40 <oerjan> and this leads to a number of cases for how a subtree is encoded.
20:07:00 <oerjan> if it's a left branch of something with a nonempty right branch, then we know it is a full tree, like in that f(+,+) part, and we need not bother with possibility of leafs or empty nodes - we already know the depth from the right branch
20:07:31 <fax> oerjah, http://i.imgur.com/F0q6m.jpg
20:08:03 <oerjan> you don't say.
20:09:12 <oerjan> now for the right branch of the top, we know that it cannot be an empty tree (since then we'd just need one level less) and so it's 1+ rather than 2+
20:09:37 <oerjan> it could still be a leaf though, thus the 1+2* to show it's not
20:10:10 <oerjan> (although that subtree contains just 1 leaf, we still make it depth 2 so all branches are the same depth)
20:10:28 <oerjan> now the right branch of the right branch is empty, thus 0
20:11:22 <oerjan> the left branch of the right branch is a leaf, so 2*leaf value (there is no possibility of this being empty, for the same reason as before, so no 1+)
20:11:58 <fax> oerjan*
20:12:02 <oerjan> and having looked at the right branch of the whole tree like this, we now know that the tree depth is 2, and can use f(+,+) for the tree's left branch
20:12:46 <oerjan> (as already mentioned)
20:13:03 <oerjan> note that we look at the right branch to find the information about the depth of the left branch
20:14:17 <alise> now that /is/ overcomplicated :D
20:14:49 <oerjan> yeah all that complication is to ensure no numbers encode a tree that cannot be gotten from a list
20:15:55 <alise> sheesh, ADVENT has really simple code
20:16:04 <alise> it doesn't even have proper conditionals, or even code, in the adventure part
20:16:09 <oerjan> btw i also thought of another possible list encoding, but that might be harder to invert
20:16:13 <alise> just a huge table of boolean things, and rules for directions/commands at each place
20:16:15 <alise> without even code!
20:16:34 <oerjan> basically l -> (length l, encoding of tuple l using _multiple_ binomial coefficients)
20:17:31 <oerjan> iirc (x1,x2,...,xn) -> binom (x1+x2+...+xn, n) + binom(x1+x2+...+x(n-1), n-1) + ... + x1
20:18:04 <oerjan> the generalization of the triangular method to N^n <-> N
20:18:24 <alise> oh so this is basically the bijection we have but to ^n?
20:18:29 <oerjan> yeah
20:18:35 <alise> I wonder if anyone else has written an N^n <-> N bijection
20:18:38 <alise> I didn't find one
20:18:42 <alise> sounds like something that could Come In Handy.
20:18:53 <oerjan> however it's going to be harder to invert, probably requires something with nth root
20:19:30 <oerjan> alise: i think we mentioned this one when fax discussed finite integrals at one time
20:19:42 <oerjan> so it's presumably well-known
20:19:46 <alise> yeah the C stuff
20:19:46 <alise> iirc
20:19:48 <alise> as in C()
20:19:49 <alise> and T()
20:19:51 <alise> there was a lot of that
20:19:54 <oerjan> binom aka C
20:19:58 <alise> yeah
20:20:01 <alise> of course, I know that :P
20:20:08 <alise> but i think the C involved had three arguments?
20:20:09 <alise> I guess not
20:20:31 <oerjan> i don't think so
20:22:01 <alise> "# (If you hit the bear after feeding it:) The bear is confused; he only wants to be your friend."
20:22:06 <alise> --[[Colossal Cave Adventure]]
20:23:22 <oerjan> oh and then there was the fibonacci idea i've mentioned before
20:23:39 <oerjan> for encoding a list
20:24:04 <alise> oh?
20:24:04 <oerjan> it requires converting to/from fibonacci base as well as binary though
20:24:35 <oerjan> basically in fibonacci base any number >= 1 starts with 1, then some series of 0,1 with _no_ instance of 11
20:25:38 <oerjan> which means if you concatenate numbers in fibonacci base with 1 intercalated between, you get a bitstring and this process is reversible
20:26:01 <alise> ah that
20:26:14 <alise> but we need the reversibility to apply to all nats
20:27:00 <oerjan> yes, i'm a bit fishy on what is missed this way
20:27:34 <oerjan> or well, _any_ bitstring starting with 1 can clearly be split up at points where you have 11
20:27:55 <oerjan> or wait
20:28:04 <oerjan> 11 at beginning and end may be subtle
20:29:33 <oerjan> and several 11 in a row too
20:30:01 <oerjan> possibly 0 should be the empty string in fibonacci, or does that make things worse...
20:30:58 <oerjan> well, anywhere you get 110 you have a clear split, the first 1 must be the separator
20:31:47 -!- Gracenotes has quit (Quit: Leaving).
20:32:08 <oerjan> one nice thing about this is that loops would only blow up by about log_2 phi
20:32:16 <oerjan> (in bitsize)
20:32:38 <oerjan> well any list element, really
20:32:59 <oerjan> maybe a bit more for small elements
20:34:26 <oerjan> ok you cannot have 0 as empty string, 111 could mean either ,1, or ,0,0, in that case
20:34:47 <alise> dear oerjan,
20:34:48 <alise> you are crazy
20:34:49 <alise> -alise
20:34:52 <oerjan> thank you
20:35:33 <alise> oerjan: now finish figuring out the encoding, i'll even implement it :P
20:35:36 <oerjan> now if you have 111110 say, we know that's 111++[10..,...]
20:36:10 <oerjan> a 11 at the end can only be ,1 i think
20:36:33 <oerjan> and so if we have several 11 in a row we can nest them up from the back
20:37:02 <oerjan> little-endian is probably good for this stuff
20:37:29 <oerjan> or wait, big-endian for encoding _into_ fibonacci
20:38:32 <oerjan> 11 alone, what does that mean
20:38:51 <oerjan> you cannot get that from concatenating stuff :(
20:39:37 <oerjan> there are some loose ends there :D
20:40:17 -!- adam_d has quit (Ping timeout: 265 seconds).
20:40:34 <oerjan> you cannot get a bitstring starting with 110 in this way either
20:42:04 -!- Phantom_Hoover_ has joined.
20:42:18 <Phantom_Hoover_> OK, so what have you got now?
20:42:34 <oerjan> trying to something with fibonacci base
20:42:41 <Phantom_Hoover_> Fibonacci!
20:42:49 <oerjan> alas it seems to miss some bitstrings
20:42:59 -!- nooga has joined.
20:44:13 <nooga> i'm working on chaos based music
20:44:23 <oerjan> you cannot get bitstrings starting with an even number of 1's
20:44:35 <alise> nooga: ok merzbow
20:44:41 <alise> oerjan: well fix that
20:45:54 <oerjan> well it seems that adding 1 toggles between legal and illegal, so we can encode a Bool in addition to the list ;)
20:46:12 <oerjan> *prepending
20:47:45 <alise> yes but stop cheating :D
20:49:24 <oerjan> well i can cheat _more_ by merging that Bool with the first list element (2*x-b)
20:49:44 <alise> but why
20:50:21 <oerjan> erm to get a bijection with non-empty lists of integers >= 1. at least that may be what we get
20:50:43 <alise> then set 0 = []
20:50:45 <alise> easy
20:50:58 <alise> ok now i'd like an actual algorithm :D
20:51:20 <oerjan> hm
20:51:32 <oerjan> ok so given a non-empty list of integers >= 1
20:51:51 <oerjan> divide the first one by 2 and take a bool for the remainder
20:52:25 <oerjan> hm lessee
20:52:34 <alise> oh integers >= 1
20:52:39 <oerjan> crush [] = 0
20:52:39 <alise> so basically
20:52:42 <alise> f [] = 0
20:52:48 <alise> f xs = g (map (+1) xs)
20:53:06 <alise> divide?
20:53:08 <alise> as in floor-divide?
20:55:55 <oerjan> crush (x:xs) = fromBinary $ (if b==1 then "1" else "") ++ intercalate "1" [toFibonacci (x+1) | x <- y:xs] where (b,y) = divMod x 2
20:56:07 <oerjan> _maybe_.
20:56:59 <oerjan> maybe using x for two things is a bit bad.
20:57:50 <Phantom_Hoover_> What about the old idea of alternating the bits?
20:57:57 <oerjan> er *(y, b) = divMod x 2
20:58:12 <oerjan> Phantom_Hoover_: what?
20:58:35 <alise> oerjan: decode numbers as bits
20:58:40 <alise> then ababababab
20:58:41 <Phantom_Hoover_> Then alternate.
20:58:49 <Phantom_Hoover_> Rinse, repeat.
20:59:11 <oerjan> there is no guarantee of numbers being the same length
20:59:18 <Phantom_Hoover_> Pad with 0.
20:59:40 <alise> yeah, pad with 0 would work fine
20:59:41 <Deewiant> Note that quotRem is faster than divMod
20:59:42 <Phantom_Hoover_> It's just another NxN->N bijection, though.
20:59:43 <alise> since it'd turn into 0000x
20:59:48 <Deewiant> If that's at all relevant
20:59:56 <nooga> alise: merzbow's creations aren't in my style
21:00:01 <oerjan> hm... maybe that works
21:00:06 <impomatic> Does anyone remember the name of the language similar to Brainfuck from the 1960s?
21:00:12 <Phantom_Hoover_> p''?
21:00:15 <pikhq> P''
21:00:22 <alise> nooga: they're not in /any/ style
21:00:26 <alise> oerjan: but it grows a lot, doesn't it
21:00:52 <alise> if log_2(x) = a and log_2(y) = b, then log_2(f(x,y)) = a+b
21:00:56 <alise> roughly, at least
21:00:59 <alise> hmm
21:01:07 <alise> so two 500 binary digit numbers -> 1000
21:01:07 <nooga> alise: merzbow is distinguishable
21:01:08 <alise> digit
21:01:10 <alise> that's not bad actually
21:01:23 <Phantom_Hoover_> As fast as the triangular or factorising ones?
21:01:24 <oerjan> alise: um that's the minimum information theory allows, or so :D
21:01:46 <alise> yeah
21:01:51 <alise> oerjan: so it's actually very good, isn't it
21:02:07 <oerjan> what about combining this with my idea of (length l, tuple encoding)
21:02:17 <Phantom_Hoover_> Can it be done efficiently with bignums?
21:02:28 <alise> Phantom_Hoover_: It's just divmod
21:02:31 <alise> to extract bits
21:02:37 -!- Oranjer has joined.
21:02:40 <oerjan> then you can alternate the bits of _all_ the numbers
21:02:42 <alise> oerjan: Sure, although I've no idea what that encoding is
21:02:45 <Phantom_Hoover_> Is that efficient?
21:02:55 <alise> yes.
21:03:06 <oerjan> alise: um i meant to use this alternating for that tuple encoding
21:03:15 <alise> yes, what tuple encoding :D
21:03:24 * oerjan swats alise -----###
21:03:30 <oerjan> _as_ that tuple encoding
21:03:30 <alise> oh the fib thing?
21:03:33 <alise> oh
21:03:38 <alise> why encode it with length
21:03:39 <alise> I don't ge it
21:03:40 <alise> *get
21:03:47 <alise> anyway so let's see
21:03:51 <alise> biTo will be recursive, eek
21:03:53 <alise> that's not good is it
21:03:56 <alise> oh well
21:03:59 <oerjan> so you know how many numbers you've mingled
21:04:13 <Phantom_Hoover_> Interleaving the bits two by two is just as space-efficient as interleaving them all at once.
21:04:25 <oerjan> oh, hm, maybe
21:04:35 <Phantom_Hoover_> It's just another NxN->N bijection, so we can use our old encoding.
21:05:02 <oerjan> yeah but our problem was to avoid blowing up some parts
21:05:05 <nooga> oerjan: what does theese mean: "man pleier å få som fortjent!" and "Disse statusoppdateringene som inneholder varmegrader kan du godt spare deg for."
21:05:08 <nooga> ?
21:05:27 <alise> biTo :: (Integer, Integer) -> Integer
21:05:28 <alise> biTo (0,0) = 0
21:05:28 <alise> biTo (u,v) =
21:05:28 <alise> let
21:05:28 <alise> (u',a) = if u == 0 then (0,0) else u `divMod` 2
21:05:28 <alise> (v',b) = if u == 0 then (0,0) else v `divMod` 2
21:05:29 <oerjan> Phantom_Hoover_: using this for NxN-> N will be _bad_ for long lists with the old method
21:05:29 <alise> in
21:05:31 <alise> (((u' * 2) + v') * 2) + biTo (u',v')
21:05:34 <alise> right?
21:05:48 <oerjan> because alternating is only efficient when the numbers are approx. same size
21:05:51 <alise> no, then (0,1) = 0
21:05:52 <alise> ugh, why
21:06:05 <Phantom_Hoover_> oerjan: Hmm.
21:06:12 <alise> oh
21:06:14 <alise> wrong way around
21:06:15 <alise> lulz
21:06:18 <alise> should be a,u'
21:06:19 <alise> right?
21:06:24 <nooga> ;\
21:06:24 <alise> no wait
21:06:27 <alise> 2 = 10
21:06:30 <alise> so 0,1 it should be read
21:06:34 <alise> er wait
21:06:35 <alise> 1 = 1
21:06:37 <alise> so yeah, wrong way around
21:06:37 <Phantom_Hoover_> Yeah, we'll need to use a more balanced method for this.
21:06:47 <alise> oh no wait
21:06:48 <alise> lol
21:06:51 <alise> I'm thick
21:07:03 <oerjan> which is why i suggested alternating all the bits simultaneously
21:07:10 <Phantom_Hoover_> And lists?
21:07:13 <alise> oerjan: ah
21:07:13 <alise> so
21:07:19 <alise> [1,1,1] = 111
21:07:22 <oerjan> yeah
21:07:23 <alise> yeah?
21:07:27 <alise> so it's stored as (3,111)
21:07:29 <nooga> oerjan: please ;3
21:07:34 <alise> oerjan: then we crush recursively?
21:07:44 <alise> [1,[1,1,1],1] = (3,1(3,111)1)
21:07:46 <alise> how do we do that
21:08:00 <alise> or does 3 go into the number somehow?
21:08:01 <oerjan> we might
21:08:03 <Phantom_Hoover_> Wait, interleaving at once is no better.
21:08:14 <alise> Phantom_Hoover_: it's information-theoretically optimal...
21:08:22 <oerjan> alise: crushing (3,111) gives something (2, x) and the 2 is redundant
21:08:50 <Phantom_Hoover_> Ooh, wait, you're right.
21:08:50 <oerjan> although that's not very efficient since 3 might be much smaller than the snd
21:08:58 <alise> oerjan: eh?
21:09:19 <oerjan> alise: if we crush (3,x) where x is large we get a _lot_ of zero padding on the 3
21:09:33 <alise> oh wait,
21:09:34 <alise> (((a * 2) + b) * 2) + biTo (u',v')
21:09:36 <alise> is totally broken
21:09:37 <alise> grr
21:09:43 <alise> this recursion is hairy i think it is iterative :(
21:09:54 <alise> oerjan: so, question
21:10:01 <alise> is the interleaving good
21:10:05 <alise> or is your fib thing good
21:10:31 <nooga> oerjan
21:11:30 <oerjan> nooga: "one usually gets as one deserves!" "these status updates containing above zero (celsius) degrees you can just stop doing."
21:11:49 <nooga> oh right, thank you
21:12:15 <alise> what
21:12:33 <Phantom_Hoover_> nooga had some Foreign to be translated.
21:12:34 <alise> :P
21:12:51 <oerjan> alise: the interleaving is much simpler but has that problem with size differences giving much padding
21:13:49 <alise> oerjan: what is wrong with cons-cell interleaving?
21:14:10 <Phantom_Hoover_> It exacerbates the padding problem hugely.
21:14:37 <alise> ah right
21:14:40 <Phantom_Hoover_> The accumulator gets much larger than the car, so it's padded.
21:14:42 <alise> no, does it?
21:14:48 <oerjan> alise: well if you do (a,(b,(c,(d,(e,0))))) then the bits of e will end up 32 bits apart, while the bits of a just end up 2 apart
21:14:49 <alise> Phantom_Hoover_: so do it the other way around!
21:14:51 <alise> oh wait
21:14:55 <alise> doesn't work like that lol
21:15:03 <oerjan> or thereabouts
21:15:07 <alise> oerjan: then we need some kind of synchronization
21:15:08 <alise> hmm
21:15:12 <alise> oerjan: does your fibonacci thing suffer this problem?
21:15:31 <Phantom_Hoover_> We could always re-use the unary one, too.
21:15:43 <oerjan> alise: and actually if you only do pairs then the triangle method is perfectly adequate, i should think
21:15:50 <Phantom_Hoover_> So that the sequence {1, 2, 3} would be 1010010001?
21:16:13 <alise> Phantom_Hoover_: eh
21:16:17 <alise> what about 00110
21:16:28 <alise> oh, i see
21:16:29 <alise> 0 = 1
21:16:30 <Phantom_Hoover_> Ooh, fair point.
21:16:35 <alise> like
21:16:36 <alise> sa in
21:16:37 <alise> as in
21:16:43 <alise> ..00110..
21:16:43 <alise> =
21:16:52 <alise> [...,3,0,2,...]
21:16:54 <Phantom_Hoover_> No, wait, code {1, 2, 3} as 101001000
21:16:55 <alise> erm
21:16:57 <alise> [...,2,0,1,...]
21:17:06 <alise> so 11 = 0 element
21:17:08 <Phantom_Hoover_> Then if it ends with one the final thing is 0.
21:17:13 <oerjan> i think the fibonacci method is quite lean, it only uses about log_2 phi * bitsize bits + 1 for each element regardless of size differences
21:17:14 <alise> 11 at the start would be 0, too, because 1 is the starter
21:17:23 <alise> oerjan: no bitsize
21:17:48 <oerjan> alise: bits are intrinsic to the fibonacci method
21:18:05 <oerjan> and is a perfectly valid measure of number size
21:18:13 <alise> ah well true
21:18:16 <fax> a stream of bits controls a machine
21:18:18 <alise> is it actually log_2(n)
21:18:23 <fax> the machine is a type writer
21:18:32 <oerjan> no, log_2(phi) * element size
21:18:39 <alise> o_O
21:18:41 <alise> ok, i'm confused now
21:19:04 <oerjan> phi is the golden ratio, the limit of ratios of consecutive fibonacci numbers
21:19:07 <Phantom_Hoover_> That makes sense.
21:19:13 <fax> if | is the cursor: | +| +>| +>[|] +>[+|] this is the sort of typing you can do
21:19:20 <oerjan> so converting binary -> fibonacci base expands by about that much
21:19:23 <Phantom_Hoover_> log_2() gives the no. of bytes.
21:19:43 <Phantom_Hoover_> Of phi^n.
21:19:47 <fax> when you are inside a bracket, there is an extra key allowed which steps out - but this has some redundancy
21:19:47 <oerjan> Phantom_Hoover_: bits
21:19:59 <oerjan> log_256 otoh :D
21:20:14 <fax> because there is a difference between +>[+|] and +>[+]| for example.. but they are equal programs
21:20:20 <fax> how to reconsile this?
21:20:54 <oerjan> alise: oh i mean element size in bits, of course
21:21:03 <fax> maybe you always have to put down a symbol when you step out a bracket -- but that interferes with stepping out of multiple nested brackets
21:21:04 <oerjan> not the bitsize of machine words :D
21:21:13 <alise> yeah
21:21:18 <alise> i know what phi is
21:21:19 <alise> thx :P
21:21:45 <alise> log_2 is no. of bits, yeah
21:22:10 <Phantom_Hoover_> fax: An interesting idea, but it would seem that it would be difficult to get uniqueness.
21:22:37 <fax> is it possible to fix this idea?
21:23:23 <Phantom_Hoover_> I don't really know. Also, would it be easy to compute both ways?
21:23:48 <oerjan> sheesh i still haven't gotten to the logs...
21:23:58 <oerjan> i think i'm just going to search for my name
21:27:16 <oerjan> alise: i conclude that although you mentioned my nick several times, all the problems were solved before i arrived
21:27:41 <alise> oerjan: wut :P
21:27:48 <Phantom_Hoover_> So exactly how does the base-phi encoding work? Write the no.s in base phi, then use 11 to separate
21:27:52 <Phantom_Hoover_> ?
21:28:11 <oerjan> alise: well the parts of the problems you were mentioning my nick about, anyway
21:28:22 <oerjan> use 1 to separate
21:28:32 <oerjan> the second 1 is just the beginning of the next number
21:28:49 <Phantom_Hoover_> So how would {1, 2, 3} work?
21:28:59 <oerjan> also, there is some trickiness at the beginning, see my haskell code far above ;)
21:29:27 <oerjan> first to fix the trickiness, divide 1 by 2 giving 0, remainder 1
21:29:29 <alise> how is the 1 the beginning of the next?
21:29:45 <oerjan> alise: all numbers >= 1 begin with 1 in fibonacci base
21:29:47 <Phantom_Hoover_> Oh, god. Please tell me it's an easy-to-find URL.
21:30:22 <oerjan> alise: boundaries are marked with 11, where the first 1 is inserted and the second is just the begining of the next number
21:30:27 <oerjan> Phantom_Hoover_: nope
21:30:43 <oerjan> 21:55 oerjan> crush (x:xs) = fromBinary $ (if b==1 then "1" else "") ++ intercalate "1" [toFibonacci (x+1) | x <- y:xs] where (b,y) = divMod x 2
21:30:59 <oerjan> also crush [] = 0
21:31:14 <oerjan> there may be off-by-one errors as usual ;)
21:31:24 <Phantom_Hoover_> What does intercalate do?
21:31:28 -!- alise_ has joined.
21:31:42 <oerjan> concatenates all the strings with "1" between
21:31:43 <oerjan> iirc
21:32:52 <alise_> oerjan: so does that cover every string?
21:32:54 <oerjan> the divMod stuff is necessary because the intercalation always gives a string beginning with an _odd_ number of 1's
21:32:55 <alise_> & does it compact well?
21:33:20 <oerjan> as i repeatedly said, it should expand by about log_2(phi)
21:33:56 <oerjan> !haskell logBase 2 ((sqrt 5 + 1)/2)
21:34:08 -!- alise has quit (Ping timeout: 252 seconds).
21:34:09 <EgoBot> 0.6942419136306174
21:34:12 <Phantom_Hoover_> Do all base phi nats end with 1?
21:34:20 -!- impomatic has quit (Quit: ChatZilla 0.9.86 [Firefox 3.5.9/20100315083431]).
21:34:25 <oerjan> no
21:34:31 <oerjan> e.g. 10 is 2
21:34:44 <oerjan> 100 is 3, 1000 is 5
21:34:53 <alise_> what, expand by the concatenation of all the bitstrings with no separator?
21:34:56 <alise_> it'll only be log_2(phi) bigger?
21:35:08 <Phantom_Hoover_> Wait, is base fib base phi?
21:35:09 <oerjan> in _bitsize_
21:35:16 <oerjan> Phantom_Hoover_: approximately
21:35:36 <Phantom_Hoover_> So 111 is 3+2+1?
21:35:40 <oerjan> you write your number as a sum of fibonacci numbers, never using consecutive ones
21:35:49 <Phantom_Hoover_> Oh.
21:35:54 <oerjan> nopt, 11 is illegal in a fibonacci representation
21:35:57 <oerjan> *nope
21:36:06 <oerjan> but 101 is 3+1
21:36:17 <Phantom_Hoover_> 1001 is 5+1=6?
21:36:46 <oerjan> alise_: oh hm if phi is < 1 then it should be 1/phi, naturally
21:36:55 <oerjan> Phantom_Hoover_: yeah
21:37:03 <alise_> oerjan: so
21:37:23 <Phantom_Hoover_> So to extract we:
21:37:31 <alise_> bigness (yourEncoding [a,b,c]) ~= bigness (concatMap bitStrings [a,b,c]) + 1/phi
21:37:32 <alise_> ??
21:37:34 <alise_> are you serious?!
21:37:50 <alise_> ~+ 0.618
21:37:52 <oerjan> um no
21:37:52 <alise_> surely not
21:38:44 <oerjan> if x has n bits, then fibonacci x is approximately n/log_2(phi) long
21:38:59 <oerjan> i just realized it needs division, not multiplication
21:39:08 <oerjan> because log_2(phi) < 1
21:40:21 <alise_> ah
21:40:22 <oerjan> fib(n) ~= phi^n, so log_2(fib(n)) ~= n*logBase 2 phi
21:40:32 <alise_> logBase 2?
21:40:36 <alise_> you changed mid-thing :P
21:40:43 <alise_> oerjan: what about the list encoding
21:40:44 <oerjan> i just changed to haskell
21:40:46 <alise_> how much overhead?
21:40:57 <alise_> but you changed language across the sing!
21:40:58 <alise_> *sign!
21:41:37 <oerjan> the fibonacci representation, plus the 1 bit in between...
21:41:40 <oerjan> *1 bits
21:41:42 <alise_> ah
21:41:49 <alise_> does it cover every nat then??
21:41:56 <Phantom_Hoover_> Yes, I think.
21:41:57 <oerjan> i think so
21:42:02 <Phantom_Hoover_> Wait, what's 111?
21:42:07 <Phantom_Hoover_> (in binary)?
21:42:08 <oerjan> with the divMod fix
21:42:15 <oerjan> Phantom_Hoover_: 7 :D
21:42:27 <alise_> hey oerjan
21:42:29 <alise_> "Everyone who applies for Norwegian citizenship after 1 September 2008 must be able to document that they have completed 300 hours of Norwegian language tuition or be able to document adequate knowledge of Norwegian or Sami.
21:42:31 <Phantom_Hoover_> How does it decode?
21:42:35 <alise_> if this didn't apply to in-EU migration too,
21:42:37 <alise_> I'd say fuck you
21:42:40 <alise_> er
21:42:41 <alise_> if this did
21:42:48 <oerjan> heh
21:43:00 <alise_> i hope it doesn't
21:43:00 <oerjan> alise_: citizenship is not the same as moving
21:43:03 <alise_> ah
21:43:08 <alise_> cool
21:43:09 <oerjan> citizenship takes years of residence to get
21:43:19 <alise_> what if you try and move in from outside the EU?
21:43:29 <oerjan> then you may have a hard time
21:43:30 <alise_> is that just the regular visa thing?
21:43:31 <alise_> just curious
21:43:35 <alise_> i mean
21:43:37 <alise_> move in as residence
21:44:04 <oerjan> you need to be an especially needed person to get a working permit if you're not from the EU/EEA
21:44:06 <alise_> speaking of which, pikhq: ping
21:44:11 <alise_> (he's my personal immigration law expert)
21:44:28 <pikhq> Pong!
21:44:30 <Phantom_Hoover_> Oerjan: what tuple does 111 decode to in your system?
21:44:33 <alise_> oerjan: I only ask because I've been discussing, with a friend, utterly crazy ways to move
21:44:51 <Phantom_Hoover_> alise_: Positive-imaginary?
21:44:56 <alise_> First one was "him and me should get married so that I can move to the US"; issues: I'm 14; his state is heavily Republican so no gay marriage
21:45:02 <alise_> Phantom_Hoover_: wut
21:45:03 <oerjan> Phantom_Hoover_: [1,0] i think
21:45:10 -!- Phantom_Hoover_ has left (?).
21:45:23 <pikhq> oerjan: Alise is an EU citizen, and as such, is entitled to reside in Norway permanently.
21:45:34 <alise_> I was talking about said friend
21:45:40 <oerjan> pikhq: she was specifically asking about non-EU
21:45:43 <alise_> who, of course, is entirely joking
21:45:45 <pikhq> Mmm.
21:45:55 <alise_> oerjan: I'm surprised you're actually keeping up the pronoun thing
21:46:08 <oerjan> alise_: when i remember
21:46:11 <alise_> anyway pikhq
21:46:17 <alise_> see /msg in a sec
21:46:45 -!- Sgeo_ has quit (Ping timeout: 245 seconds).
21:48:08 <oerjan> whee, i'm forgetting to eat
21:48:16 <alise_> I do that too
21:48:19 <alise_> other things are just so much more interesting
21:59:42 -!- hiato has joined.
22:02:02 -!- Mathnerd314 has joined.
22:26:16 -!- tombom has quit (Quit: Leaving).
22:32:02 <alise_> i have an idea
22:32:10 <oerjan> yay
22:32:13 <alise_> let's create [[Remarkable language list]]
22:32:22 <alise_> which lists all the actually good languages on the wiki
22:32:23 <alise_> but
22:32:25 <alise_> we'll put at the start
22:32:30 <alise_> languages known in the community for a while
22:32:36 <alise_> that have shown good esoteric theoretical/practical qualities
22:32:37 <alise_> etc
22:32:44 <alise_> and telling people not to put new languages on the list
22:32:48 <alise_> tada, a language list that is actually usable!
22:32:53 <alise_> and nobody is offended
22:32:56 <alise_> perhaps [[Languages of note]]
22:33:33 <oerjan> !haskell data Remarkable = Remarkable String String deriving Show; language = "Haskell"; list = "compendium"; main = print [[Remarkable language list]]
22:33:36 <EgoBot> [[Remarkable "Haskell" "compendium"]]
22:34:44 <alise_> lol
22:42:19 -!- gm|lap has joined.
22:45:27 <nooga> alise_: what are your esolangs?
22:45:36 <alise_> hmm
22:45:40 <alise_> let's see
22:46:35 <alise_> nooga: just finding them :P
22:47:58 <alise_> nooga: here are all the ones I can find right now, mostly old:
22:48:00 <alise_> http://esolangs.org/wiki/Qq
22:48:01 <alise_> http://esolangs.org/wiki/Jumping_to_-1_is_exciting
22:48:03 <alise_> http://esolangs.org/wiki/Yael
22:48:10 <alise_> http://esolangs.org/wiki/UniCode (never specified)
22:48:12 <alise_> http://esolangs.org/wiki/JumpFuck
22:48:19 <alise_> http://esolangs.org/wiki/BF_machine (not really a language; part of a project)
22:49:11 <alise_> JumpFuck was a project too, for a something->BF compiler iirc
22:49:19 <alise_> a rather ugly extension too
22:49:27 -!- BeholdMyGlory has quit (Remote host closed the connection).
22:50:33 <alise_> Qq was quite nice, took a while to be disproved TC
22:50:45 <alise_> Jumping to -1 is exciting is confusing.
22:50:48 <nooga> hm
22:51:27 <alise_> the things after the instructions are the tape/stack/whatever
22:51:37 <alise_> and # is incompletely specified
22:51:38 <alise_> just examples
22:51:53 <alise_> it's "cherry-pick from the stack" basically, iirc
22:51:57 <nooga> ;]
22:52:01 <alise_> and move it elsewhere
22:52:05 <nooga> Qq looks nice
22:52:31 <alise_> yeah; it's sub-TC due to the instructions not allowing arbitrary function calls or something
22:52:36 <alise_> I forget
22:52:47 <alise_> Yael is a nice little computotron, with very limited memory.
22:53:46 <nooga> i could even implement yael in FPGA
22:54:48 <alise_> 0001 AAA BBB
22:54:49 <alise_> Moves the data in register B to register A.
22:54:49 <alise_> 1000 AAA BBB
22:54:49 <alise_> Store - in the memory whose address is in register B - the data in register A.
22:54:51 <alise_> How inconsistent! Oh well.
22:55:20 <alise_> nooga: You can implement it in practically anything. It only has 264 bytes of memory.
22:56:02 <nooga> relays!
22:56:14 <pikhq> That actually wouldn't be too hard.
22:56:24 <pikhq> You could even do the memory in relays.
22:56:27 <nooga> that's why i am saying that
22:56:48 <pikhq> It would also make some absolutely *wonderful* noises.
22:57:02 <pikhq> Relay computers are awesome.
22:57:15 <nooga> http://www.youtube.com/watch?v=MM4IUxXiArY
22:57:20 <nooga> this is awesome
22:58:24 <pikhq> Yeah.
22:58:39 <alise_> Dammit, I loaded /prog/ again. Now I won't be able to stop myself calling Python FIOC.
23:01:43 -!- FireFly has quit (Quit: null).
23:06:52 <fax> I want to tell alise something
23:09:14 <fax> !haskell alise unignore me I have news to tell you
23:09:26 <fax> !haskell "alise unignore me I have news to tell you"
23:09:28 <EgoBot> "alise unignore me I have news to tell you"
23:11:28 * oerjan chuckles
23:13:49 * pikhq wishes for a way to request someone's ignore list
23:14:15 <fax> pikhq only assholes and stalkers do this but you can /ping people to see if they have you on /ignore
23:14:17 * oerjan cannot hear you LALALALA
23:14:39 <fax> why the hell would you ping me
23:14:53 <fax> I clearly don't have you on ignore
23:14:56 <pikhq> Lawlz
23:15:13 <fax> ...
23:19:15 <alise_> fax: I don't know how to unignore you o_O
23:19:24 <alise_> fax: done; what is it?
23:19:33 <fax> alise you are listening now?
23:19:46 -!- coppro has joined.
23:19:52 <fax> ..
23:19:58 <fax> you are pretending to have unignored me
23:20:09 <alise_> no
23:20:11 <alise_> I'm not :P
23:20:15 -!- gm|lap has quit (Quit: ilua).
23:20:19 <alise_> i'm not /that/ stupid
23:20:38 <pikhq> /unignore
23:21:07 <alise_> yeah but you need the full mask
23:21:27 <fax> does [] ever come up in real brainfuck programs?
23:21:45 <fax> I mean it always finite loops.. or it's a noop - so we can ignore it yes?
23:21:53 <alise_> well no.
23:21:57 <coppro> you mean infinite loops?
23:21:58 <alise_> because we're trying to translate every bf program :)
23:22:01 <alise_> trivial to translate some subset
23:22:10 <alise_> the edge-cases are what makes it hard -- but go on anyway
23:22:34 <alise_> the hard part isn't "a bijection from BF prog <-> nat", anyway, it's "a feasibly computable bijection from BF prog <-> nat" :-P
23:22:58 <fax> if you need []'s in the programs then my idea is worth nothing
23:24:13 <alise_> I am interested anyway
23:24:17 <alise_> ideas are always worth something... sometimes it's negative though
23:24:29 <alise_> but that's okay because you can find out some positive-worth idea to balance it out
23:24:38 <alise_> so somehow -a + a > 0???
23:24:40 <fax> lets say that +- -+ <> >< [] never occur in any program
23:24:47 <alise_> fax: what about <<>>
23:25:02 <fax> that contains <>
23:25:07 <alise_> ah true
23:25:14 <fax> I just realized this idea doesn't work anyway
23:25:55 <fax> it will only work for programs of even length
23:26:40 <alise_> lol
23:26:42 <alise_> go ahead anyway
23:26:44 <fax> what I noticed was that there's 6*6 two-symbol codes, 5 of them aren't used, 6*6-5 is 31
23:26:45 <alise_> it sounds so bad it's interesting
23:26:48 <fax> then you add loops 32
23:27:32 <fax> the condition is a bit harsher than just even length programs actually, anyway this idea is broken so never mind
23:27:54 <fax> I thought I had solved it
23:30:03 <alise_> Argh, I am sick of hot chocolate. I cannot be arsed to deal with the stupid skin that forms.
23:30:10 <alise_> I should just drink tea or something.
23:30:27 <fax> the key thing is that 32 is a power of two
23:31:15 <alise_> you don't say :P
23:33:08 -!- hiato has quit (Quit: underflow).
23:34:15 <MizardX> ][ too, since when exiting a loop, the current memory cell will be zero, and the next loop won't start.
23:34:27 <alise_> but it still must be encoded.
23:34:57 <alise_> filtercomments | bf encode | bf decode = filtercomments
23:35:09 <alise_> er
23:35:11 <alise_> bf encode | bf decode = filtercomments
23:35:17 <pikhq> If you don't encode it, then you are encoding a subset of the valid Brainfuck programs.
23:36:02 <MizardX> a-z + 0-9 = 36 symbols
23:38:42 <oerjan> a loop after ] is a comment :)
23:38:50 <oerjan> walk ->
23:39:53 <alise_> oerjan: at this time?
23:39:59 <alise_> in NORWAY?
23:40:03 <alise_> you're hard as fuck.
23:43:07 <coppro> ...
23:43:15 <alise_> what
23:43:48 <alise_> it's past midnight in norway. in trondheim, it is 0 degrees right now
23:43:53 <alise_> and oerjan is going for a walk.
23:44:11 <alise_> :P
23:44:33 <coppro> oerjan's in trondheim?
23:46:20 <alise_> he lives in trondheim.
23:46:27 <alise_> bit more than "in" :P
23:46:57 <oerjan> heh
23:47:19 <alise_> oerjan: why heh? :P
23:47:37 <oerjan> i actually turned around when i discovered the stairs were so slippery with sleet it was dangerous to walk on them :/
23:47:43 <alise_> :D
23:47:51 <alise_> hardcore motherfucker
23:48:02 <pikhq> I think I love Norway's weather now. :P
23:48:11 <alise_> pikhq: it's fucking amazing!
23:48:18 <alise_> it isn't even freezing ALL the time
23:48:29 <pikhq> alise_: Also, 0 is not *that* cold.
23:48:31 <oerjan> i figured if i took a walk, came back and forgot about the sleet i'd probably fall and break my neck
23:48:34 <alise_> Yes, but still.
23:48:45 <alise_> 0 degrees, can't see very well, ...
23:48:48 <oerjan> or something
23:48:51 <alise_> now of course oerjan you realise that you are going to have to lodge me.
23:49:01 <alise_> <oerjan> eek!
23:49:17 <oerjan> eek.
23:49:50 <alise_> also, how come half of Trondheim's streets are water, I'm going to ignore the real explanation and substitute "you are all Jesus", or "you all have high-tech ice-making shoes"
23:50:10 <oerjan> wait since when
23:50:27 <oerjan> we _do_ have a river through the city center, but...
23:50:39 <pikhq> alise_: You... Might be confusing Trondheim with Venice.
23:50:43 <pikhq> :P
23:50:47 <oerjan> that could be.
23:50:56 <pikhq> Quite some confusion.
23:51:09 <alise_> I was actually going to link to one of these pictures saying "the Venice of Norway":
23:51:13 <alise_> http://www.trondheim.com/multimedia.ap?id=1114985653&width=138
23:51:14 <alise_> http://www.trondheim.com/multimedia.ap?id=9652293
23:51:17 <oerjan> also it _shouldn't_ be this cold in the beginning of may.
23:51:22 <alise_> and
23:51:36 <alise_> http://upload.wikimedia.org/wikipedia/commons/d/d3/TrondheimNidelva-improved.jpg
23:51:38 <alise_> and
23:51:39 <pikhq> oerjan: I have seen snowstorms in June.
23:51:42 <alise_> http://upload.wikimedia.org/wikipedia/commons/1/13/Nidelva-Trondheim-foliage.JPG
23:51:48 <alise_> I REST MY CASE
23:52:38 <pikhq> Colorado has fucking schizophrenic weather.
23:52:57 <oerjan> how sad that you don't have rivers in england.
23:53:04 <alise_> oerjan: i know right :P
23:53:17 <alise_> There was just a disproportionately large portion of pictures of buildings with water right behind them, so...
23:53:27 <alise_> pikhq: Here. You. Let's move to Norway on the basis that broke+broke = not broke.
23:53:42 <alise_> (It doesn't matter whether you're broke beforehand; move to Norway, become enbroken.)
23:53:53 <pikhq> alise_: Hahahah.
23:54:03 <oerjan> i have taken walks at -5 as well, this winter. -10 starts to get a bit grating.
23:54:05 <pikhq> Do they speak... Japanese there?
23:54:07 <pikhq> :P
23:54:14 <alise_> pikhq: They don't speak Japanese in Colorado.
23:54:24 <pikhq> oerjan: I've walked to school in that.
23:54:27 <alise_> ...and Japan itself has quite a few issues. Namely, being fucked up.
23:54:30 <alise_> Thus, Norway.
23:54:39 <alise_> I'd say Finland, but military at 18 makes alise sad.
23:54:52 <oerjan> pikhq: i mean taking walks just to stretch my legs.
23:55:02 <pikhq> でも日本語を話せるぜ〜
23:55:11 <oerjan> i've certainly walked to school in -15..-20 when i was younger
23:55:31 <pikhq> alise_: How's about we just move to the moon?
23:55:38 <oerjan> it's not _that_ common here though. temperature has a tendency to cling around 0.
23:56:01 <oerjan> pikhq: we did have the japanese emperor visiting a few years ago.
23:56:16 <oerjan> apparently he wrote a poem about us afterwards.
23:56:20 <alise_> pikhq: it has huge ping to earth iirc
23:56:23 <alise_> or was that mars
23:56:28 <alise_> that was a really depressing conversation
23:56:41 <alise_> when i found out that colonising even near planets in the solar system meant really slow internet, only e-mail and the like
23:56:58 <alise_> oerjan:
23:57:02 <alise_> cold cold cold cold,
23:57:04 <alise_> cold cold fucking cold ow,
23:57:06 <alise_> why did i visit
23:57:12 <alise_> He does not like you.
23:57:19 <oerjan> nah :D
23:57:25 <pikhq> alise_: Mars has absurd ping to Earth.
23:57:39 <pikhq> alise_: The Moon is not much worse than my current link.
23:57:43 <alise_> lol
23:57:51 <alise_> mars is more likely to sustain life though :P
23:58:00 <pikhq> oerjan: Well, he's got to do something with his time.
23:58:12 <pikhq> It's not like he has *any power or responsibility*.
23:58:36 <pikhq> He's not even a nominal head of state.
23:59:16 <pikhq> He's only got his position because the Diet wouldn't think to remove it.
23:59:35 <oerjan> http://www.kunaicho.go.jp/e-culture/utakai-h18.html
23:59:48 * oerjan didn't expect to actually find it :)
←2010-05-02 2010-05-03 2010-05-04→ ↑2010 ↑all