←2008-01-03 2008-01-04 2008-01-05→ ↑2008 ↑all
00:05:04 -!- tesseracter__ has changed nick to tesseracter.
00:45:16 <Slereah> Heh. Explaining lambda calculus is a hard task.
00:48:13 <pikhq> It's remarkably easier when one can assume an understanding of functions.
00:49:26 <pikhq> "Alright, you have functions, right?" "Right." "You just pass those around. That's your entire semantic setup." "Whoa. . ."
01:03:09 <tesseracter> .
01:06:37 <tesseracter> Slereah: i was most confused by the FoG syntax. F(G(x)) is sooooo much simpler
01:07:15 <tesseracter> math dudes have so many symbols.
01:07:49 <lament> errr yeagh.
01:07:54 <tesseracter> i learned 4 notations for boolean logic, thats just insane.
01:08:12 <lament> FoG, of course, doesn't mean the same as F(G(x)).
01:08:36 * oerjan had a secret idea of trying to sneak in a couple :-) :-( smileys as dual operators in a math paper
01:08:36 <tesseracter> lament, GoF or FoG....its been a while.
01:08:42 <lament> it means the same as lambda x -> F(G(x)), which is rather painful to write out.
01:08:53 <lament> and it introduces an unnecessary symbol.
01:09:44 <tesseracter> oerjan: i think i did those in C at one point...
01:10:45 <oerjan> hm, :-> and :-< would work in haskell
01:11:15 <tesseracter> or maybe it was :- as a post operation and a function, so :-(x, y:-)
01:13:20 <oerjan> (-: "only" )-: "joking"
01:13:42 <oerjan> i've got to try that in lambdabot
01:13:51 <tesseracter> heh.
01:14:25 <oerjan> if i can find a way to make it well-typed
01:16:31 <oerjan> hm needs polymorphism at least
01:20:57 <pikhq> oerjan, if you get that in a math paper, I will worship you.
01:20:59 <pikhq> (more)
01:21:01 <pikhq> :p
01:30:52 <Slereah> Well, lambda calculus doesn't have FoG as far as I know:
01:31:12 <Slereah> It's just fg or `fg, unlambda style.
01:34:45 <Slereah> But the hard part is explaining the lambda itself, it seems.
01:38:25 * Slereah tried to do some Unlambda loop
01:38:32 <Slereah> ```sii``s`k`.xi``sii
01:38:37 <Slereah> I get stack overflow.
01:42:17 <Slereah> What be the problem?
01:42:23 <oerjan> hm
01:43:31 <Slereah> Well, after printing one x, the C stack overflow, that is.
01:43:46 <oerjan> -> ``i``s`k`.xi``sii`i``s`k`.xi``sii
01:44:46 <Slereah> Why can't the doubling be just a SII?
01:46:17 <oerjan> -> ```s`k`.xi``sii`i``s`k`.xi``sii -> ```k`.xi`i``s`k`.xi``sii```sii`i``s`k`.xi``sii
01:46:26 <oerjan> argh
01:46:43 <Slereah> I do it on paper with parenthesis. Less strain on the brain.
01:46:55 <Slereah> The thing was :
01:47:08 <Slereah> (SII)(S(K(.xi))(SII))
01:47:17 <Slereah> (S(K(.xi))(SII))(S(K(.xi))(SII))
01:47:44 <Slereah> [(K(.xi))(S(K(.xi))(SII))][(SII)(S(K(.xi))(SII))]
01:47:56 <Slereah> (.xi)[(SII)(S(K(.xi))(SII))]
01:48:06 <Slereah> And then back to (SII)(S(K(.xi))(SII))
01:48:24 <Slereah> But with a bonus x on the screen.
01:48:59 <Slereah> But it seems to overflow my stack or something.
01:49:20 <oerjan> um how fast are you removing the I's?
01:49:52 <Slereah> Wut?
01:50:08 <oerjan> you ignored the I's
01:50:26 <oerjan> I((S(K(.xi))(SII))I(S(K(.xi))(SII))
01:50:27 <Slereah> Let me redo that.
01:50:43 <oerjan> er no
01:50:56 <Slereah> Oh, that.
01:51:09 <Slereah> Well, I apply SII as ^x.xx
01:51:12 <Slereah> Faster to do.
01:51:33 <oerjan> how does a turing machine stack overflow anyway?
01:51:40 <oerjan> or is this something else?
01:51:43 <Slereah> That's on your interpreter.
01:52:08 <Slereah> The Turing (or Love) machine (9000) is right now resting.
01:52:16 <oerjan> mine? which one?
01:52:21 <Slereah> Haskell one.
01:52:25 <oerjan> oh
01:52:27 <Slereah> On them winhugs.
01:52:41 <oerjan> oh dear
01:53:46 <Slereah> The Love Machine cannot stack overflow. Maybe tape-overflow, but well.
01:56:17 <oerjan> argh! why oh why can't winhugs paste into a running program :(
01:57:49 <Slereah> Well, it's only 20 chars.
01:58:16 <oerjan> ` is horrible to type on a norwegian keyboard :(
01:59:00 <Slereah> It is particularly annoying to type on Winhugs, because you have to type ` + space, or it crashes.
01:59:48 <oerjan> hm where is it on an english keyboard?
01:59:58 <Slereah> I don't have an english keyboard.
01:59:59 <pikhq> oerjan, seeing the Norwegian keyboard layout, that is not my idea of a keyboard that's good for coding. . .
02:00:16 <pikhq> On the US QWERTY keyboard, ` is to the right of 1.
02:00:19 <pikhq> s/right/left/
02:00:34 <oerjan> ah
02:00:40 * Slereah has : http://upload.wikimedia.org/wikipedia/commons/thumb/c/ca/Azerty_fr.svg/800px-Azerty_fr.svg.png
02:00:50 <Slereah> ` is alt + 7
02:01:50 <pikhq> Single keystroke here. w00ts.
02:02:13 <oerjan> shift-\ space here
02:02:16 <pikhq> Granted, the US keyboard layout is kinda handy for most coding, since the most you'll have to do is hit shift.
02:02:26 <Slereah> I wonder why keyboards still have keys that have no longer any purpose.
02:02:33 <Slereah> At least not that often.
02:02:39 <pikhq> (unless you decide to use US international, which has deadkeys)
02:02:54 <Slereah> Like pause, inser or num lock
02:03:16 <pikhq> Num lock changes the behavior of the number bad.
02:03:16 <oerjan> oh now wait
02:03:29 <Slereah> Yes it does. But does anyone use it?
02:03:31 <oerjan> we were doing lazy evaluation
02:03:35 <pikhq> Some people do.
02:03:51 <pikhq> I don't even touch the number pad, so. . . ;)
02:03:58 <Slereah> Last time I used it, I think it was for Civilisation 2.
02:04:09 <Slereah> Because the diagonal arrows were somehow useful.
02:04:57 <oklopol> the numpad makes no sense, who in their right mind would want to write numbers with right hand only
02:05:06 <oklopol> unless left-handed of course
02:05:21 <oklopol> i should get a leftie keyboard
02:05:57 <oerjan> ah, the C interpreter doesn't print more than one either :)
02:06:05 <Slereah> oerjan : Does the interpreter change (SII)(S(K(.xi))(SII)) in (SII)(S(KI)(SII)) directly.
02:06:19 <oerjan> unlambda is a strict language
02:06:21 <Slereah> Or something similar, that is.
02:06:28 <oerjan> it evaluates arguments first
02:06:51 <oerjan> the `.xi is only evaluated once
02:07:11 <oerjan> although i am still disappointed haskell stack overflows, a bit :(
02:07:21 <Slereah> That's why I copied it via some fixpoint combinator.
02:07:33 <Slereah> But apparently, not good enough!
02:09:03 -!- Jontte has quit ("Konversation terminated!").
02:10:05 <oerjan> try adding `d before `k
02:11:20 <oerjan> hmph, it eventually stack overflows then too
02:11:33 <oerjan> but at least it prints x'es galore
02:13:38 <Slereah> Ah yes!
02:14:01 <Slereah> Was it because the interpreter evaluated the (.xi) inside the expression first?
02:14:06 <oerjan> right
02:14:43 <Slereah> Is the non-lazy evaluation done for optimisation purpose?
02:15:09 <oerjan> only madore knows :)
02:15:39 <Slereah> Damn him!
02:15:42 <oerjan> but strict is usually more efficient than lazy
02:16:11 <oerjan> when naively implemented at least
02:16:20 <oerjan> oh one more thing
02:16:47 <oerjan> continuations depend on strictness
02:19:13 <Slereah> I wonder if I could make some sort of lazy unlambda.
02:19:41 <Slereah> Well, on something else than the Love Machine 9000.
02:19:51 <oerjan> you know about Lazy K, right?
02:19:54 <Slereah> It puts a strain on my good mood, with all those chars.
02:20:02 <Slereah> Yes, but Lazy K has horrible I/O
02:20:16 <oerjan> so does unlambda, I at least
02:21:09 <Slereah> What would be a good input for a purely functional language?
02:21:39 <oerjan> heh
02:22:04 <oerjan> lazy K's basic idea (stream -> stream function) is pretty neat
02:22:53 <Slereah> The only output I ever got from Lazy K was more combinators. I don't know if it's because that's supposed to be or because I don't know how to use it.
02:22:59 <oerjan> (neat enough that haskell as an interact function which uses it)
02:23:19 <oerjan> you wrote your own interpreter?
02:23:44 <Slereah> No.
02:24:01 <oerjan> weird maybe it has different modes of running
02:24:12 <Slereah> Or I just don't know how to use it.
02:24:31 <oerjan> i mean, you actually got it to print combinators?
02:25:11 <Slereah> If it surprises you, I doubt it.
02:26:41 <Slereah> I think what I got was the Scheme - Lazy K translator and the program never was interpreted.
02:27:05 <oerjan> aha
02:29:40 <Slereah> Is the interpreter only available as the C++ one and the .exe one?
02:30:09 <oerjan> i don't recall
02:30:56 <Slereah> If so, that would explain it. I never got them working.
02:56:35 -!- puzzlet_ has quit (Read error: 104 (Connection reset by peer)).
02:56:40 -!- puzzlet has joined.
03:07:15 -!- wooby has quit (Read error: 104 (Connection reset by peer)).
03:14:02 * Slereah made some sort of minimalist lazy Unlambda on Python.
03:14:48 <Slereah> I get my gallore of x's, but apparently the expression keeps increasing in size.
03:14:58 <Slereah> `i's all over the place.
03:16:29 <Slereah> Something like this : http://membres.lycos.fr/bewulf/Russell/Loop.txt
03:17:55 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
03:18:00 -!- puzzlet has joined.
03:37:19 <Slereah> When it is said that SKK is equivalent to I, isn't it actually SK[any combinator]?
03:37:29 <bsmntbombdood_> yeah
03:37:45 <Slereah> Good. Makes abstraction elimination easier.
03:38:34 -!- bsmntbombdood_ has changed nick to bsmntbombdood.
03:38:51 <oklopol> no tail for bsmnt
03:39:31 <Slereah> Or does it?
03:39:33 <Slereah> Damn.
03:39:52 <oerjan> in actual unlambda there is a bit restriction, SKxy = Ky(xy) so x must be something which has no effect when evaluated or applied
03:40:19 <Slereah> Well, since I'm doing it lazy style, no problem
03:40:37 <Slereah> Although I'm not sure it works perfectly.
03:40:52 <Slereah> When I try actual Unlambda programs, I get errors.
03:41:24 <oerjan> actual unlambda programs usually depend on strictness
03:41:44 <Slereah> Well, I would expect screwed up text display.
03:41:48 <Slereah> But not errors.
03:42:07 <oerjan> hm errors?
03:42:33 * pikhq wonders why Unlambda assumes strictness
03:42:53 <Slereah> Index out of range, mostly.
03:43:19 <Slereah> http://membres.lycos.fr/bewulf/Russell/Lazylambda.py
03:43:28 <Slereah> I think it's linked to the argument checker.
03:45:33 <oerjan> you might write a test that the program remains well-formed at eah step...
03:45:41 <oerjan> *each
03:46:53 <Slereah> Well, right now I'm mostly trying some simple programs with the lambda expressions displayd at each step.
03:47:18 -!- puzzlet has quit (Remote closed the connection).
03:47:27 -!- puzzlet has joined.
03:47:29 <oerjan> i can see that you would get index out of range if the first primitve is applied to too few parameters
03:48:17 <Slereah> Probably. I tried to avoid that, but I guess I'll just have to check manually.
03:49:08 <oerjan> ah yes you have a check for single remaining primitve
03:49:21 <oerjan> *primitive
03:49:29 <Slereah> Well, that's only to stop the program.
03:49:48 <Slereah> I was referring to the if k == len(lambexp) : and such
03:50:23 <Slereah> Well, so far s and k with few arguments work
03:50:32 <oerjan> um, i am referring to index out of bounds < 0
03:51:12 <Slereah> Wut?
03:51:51 <oerjan> `ki e.g. will crash at lambexp[i-2]=="`":
03:52:32 <Slereah> `ki doesn't crash.
03:52:45 <Slereah> Heh. ```sii``sii has the expected effect!
03:53:13 <Slereah> I should make a combinator for SII that doesn't leave `i's everywhere.
03:53:13 <oerjan> oh wait you continue at `
03:53:50 <Slereah> Lazy evaluation make that sort of loop hard on the memory
03:55:01 <oerjan> hm wait
03:55:11 <oerjan> how is it possible that `ki does not crash?
03:55:27 * oerjan doesn't have python
03:56:10 <Slereah> `ki doesn't have the required ``, so it doesn't transform into anything.
03:56:20 <Slereah> It just remains `ki forever.
03:56:26 <oerjan> er i mean the test for `` crashes it
03:56:49 <oerjan> that's my point
03:57:00 <oklopol> sleeps ->
03:57:08 <Slereah> What's the problem in that?
03:57:41 <oerjan> when i=1 and it reaches the k, it gets to the line:
03:57:51 <oerjan> if lambexp[i]=="k" and lambexp[i-1]=="`" and lambexp[i-2]=="`":
03:58:24 <oerjan> the lambexp[i-2] then gives an index out of bounds error afaics
03:58:39 <Slereah> I would expect it to, but for some reason, it doesn't.
03:58:58 <Slereah> The problem boys are usually if lambexp[l]=="`":
04:01:09 <oerjan> oh wait
04:01:28 <oerjan> negative indices in python restart from the end of the string don't they.
04:01:41 <oerjan> that explains it.
04:01:43 <Slereah> Yes.
04:01:51 <Slereah> This might cause problems now that you mention it.
04:02:12 <oerjan> although no expression should ever end in `
04:02:23 <Slereah> I should make if lambexp[i-2]=="`": inside the other conditional
04:02:31 <Slereah> Yes, but well, you never know!
04:02:54 <oerjan> if you test for well-formed-ness at the start...
04:04:04 <oerjan> oh wait
04:04:11 <oerjan> in theory it could end in .`
04:04:19 <Slereah> That too.
04:05:38 * Slereah added if i>1
04:05:55 <Slereah> It's not a lazy program for nothing!
04:14:35 <Slereah> What's a compact way to do Chuch numerals in SKI?
04:14:49 <Slereah> ``s`k``s``s`k``s`ksks`kk``s`k`sik isn't very compact.
04:15:42 <oerjan> i cannot quite decipher that this late...
04:16:00 <Slereah> Don't bother, I'm not even sure they're proper Church numerals.
04:16:19 <oerjan> but i've usually started with 2 and 3 and used arithmetic
04:17:23 <oerjan> powers are just application, multiplication is composition
04:18:01 <oerjan> addition is composition after application
04:35:00 <Slereah> ``s``s`ks``s`kki``s``s`ks``s`kki`ki
04:35:13 <Slereah> Well, I was hoping for something somehow shorter.
04:35:27 <Slereah> But applied to .x and i, it gives the expected result.
04:35:55 <oerjan> hm...
04:36:03 -!- puzzlet has quit (Remote closed the connection).
04:36:08 -!- puzzlet has joined.
04:36:34 <oerjan> ``s`kki = k
04:37:06 <oerjan> eta-reduction
04:37:55 <Slereah> That man is a combinator machine!
04:38:55 <Slereah> I should make a small file of combinators.
04:39:15 <oerjan> 18 and 256 are in my unlambda self-interpreter, btw
04:39:28 <Slereah> Why 18?
04:39:44 <oerjan> length of a table
04:40:09 <Slereah> Well, I have 0 and 2. Let's try 1:
04:40:57 <oerjan> ``s``s`kski = 2 can be extracted from those
04:41:44 <oerjan> and yours above after that reduction
04:42:39 <Slereah> So ``s`kki``s``s`ksk`ki = `ki?
04:42:48 <oerjan> 1 = i
04:42:59 <Slereah> Or maybe not.
04:43:05 <Slereah> Aaaargh
04:43:11 <Slereah> ` notation is hard to read
04:45:05 -!- puzzlet has quit (Remote closed the connection).
04:45:10 -!- puzzlet has joined.
04:47:32 <Slereah> How can 1 be i?
04:47:39 <Slereah> Or...
04:47:42 * Slereah thinks
04:48:02 <Slereah> Eta reduction?
04:48:08 <Slereah> Dang.
04:48:21 <oerjan> 1 f x = f x
04:48:58 <oerjan> 0 f x = x = i x = k i f x, so 0 = k i
04:49:14 <Slereah> It was the (^fx.fx)C = ^x.Cx that worried me
04:49:20 <Slereah> But then I thought of Eta reduction.
04:50:15 <oerjan> haskell puts foralls on automatically, but outermost
04:50:58 * oerjan throws a holy hand grenade after Mr. Wong. after counting to 3.
05:15:07 <Slereah> ````s`k``s``s`kski``s``s`kski.1i
05:15:07 <Slereah> Yay
05:19:53 <Slereah> Argh. It's not even a valid expression apparently
05:31:19 <Slereah> Or not.
05:31:31 <Slereah> Why can't http://www.angelfire.com/tx4/cus/combinator/birds.html give me correct answer?
05:53:24 -!- oerjan has quit ("Good night").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:23:27 <Slereah> Turing fixpoint combinator >> Curry fixpoint combinator
10:18:37 -!- faxathisia has joined.
13:17:12 -!- RedDak has joined.
14:20:05 -!- tejeez_ has joined.
14:25:52 -!- tejeez has quit (Read error: 145 (Connection timed out)).
14:35:14 -!- AnMaster has joined.
14:36:47 -!- oerjan has joined.
15:01:59 -!- Jontte has joined.
15:02:37 -!- Jontte has quit (Remote closed the connection).
15:03:43 -!- Jontte has joined.
15:12:25 -!- Jontte has quit (Remote closed the connection).
15:12:53 -!- Jontte has joined.
15:13:09 -!- Jontte has quit (Remote closed the connection).
15:17:10 -!- Jontte has joined.
15:17:53 -!- Jontte has quit (Remote closed the connection).
15:18:21 -!- Jontte has joined.
15:29:16 -!- jix has quit (Nick collision from services.).
15:29:26 -!- jix has joined.
15:51:36 -!- AnMaster_ has joined.
15:58:48 -!- AnMaster has quit (Connection timed out).
16:10:32 -!- AnMaster_ has quit (Connection timed out).
16:12:58 -!- AnMaster_ has joined.
16:20:04 -!- RedDak has quit (Remote closed the connection).
16:20:56 -!- AnMaster_ has changed nick to AnMaster.
16:26:27 -!- oklopol has quit (Read error: 110 (Connection timed out)).
16:58:09 -!- AnMaster_ has joined.
16:58:20 -!- AnMaster has quit (Connection timed out).
16:59:15 -!- AnMaster_ has changed nick to AnMaster.
17:59:08 -!- Jontte has quit (Remote closed the connection).
17:59:34 -!- Jontte has joined.
17:59:54 -!- Jontte has quit (Remote closed the connection).
18:07:45 -!- Jontte has joined.
18:22:06 * Slereah added the m combinator on the interpreter for SII
18:22:15 <oerjan> m?
18:22:39 <Slereah> http://www.angelfire.com/tx4/cus/combinator/birds.html
18:23:06 <Slereah> SII leaves a lot of `i in the interpreter when using lazy evaluation.
18:23:13 <oerjan> ah yes
18:23:33 <oerjan> i had a similar thought that Lazy K needed it
18:24:04 <oerjan> ideally you would memoize its results somehow. then you would get genuinely cached cyclic structures
18:24:53 <Slereah> Ah, index string out of range.
18:25:08 <Slereah> What to do what to do.
18:25:12 <oerjan> still haven't solved that problem?
18:25:25 <Slereah> Still haven't found the problem.
18:25:40 <Slereah> It's the first time some code I made have the problem.
18:25:44 <Slereah> `m``s`k`.xim
18:25:56 <oerjan> does this show up on the first iteration?
18:26:31 <oerjan> otherwise i repeat my suggestion to make a test that the expression remains well-formed at each stage
18:26:32 <Slereah> Yes. and unsurprisingly, it's in the m combinator section.
18:29:01 <Slereah> Ah yes, I just forgot to add the case where there's another m combinator.
18:30:15 -!- oerjan has quit ("Going, going, gone").
18:30:30 -!- calamari has joined.
18:34:10 <pikhq> Allow me to give you hell's weather report. . .
18:34:23 -!- Sgeo has joined.
18:34:28 <pikhq> "Cold, with a blizzard expected for the next week. Visibility, 0."
18:35:20 * Sgeo didn't work on PSOX or go on IRC yesterday..
18:36:07 <pikhq> There are, as of today, no major labels not offering or soon going to be offering DRM-free music for download.
18:49:22 <tesseracter> pikhq: well, motley fools just told investors not to invest in record labels.
18:49:42 <tesseracter> let us pray to the almighty buck.
18:50:20 <pikhq> I still wouldn't invest in them.
18:50:28 <pikhq> I don't see them lasting out the decade at this rate.
18:50:42 <tesseracter> and indies topping billboard charts? bye bye big record companies.
18:51:50 <pikhq> And fairly major artists leaving the record companies? That's *got* to hurt.
18:54:11 <tesseracter> everything points to it. only thing left is the pa-ra-dig-em shift.
18:54:24 <pikhq> Which is in progress.
19:09:17 -!- ais523 has joined.
19:17:20 <Slereah> Hello sir.
19:17:51 <ais523> hello
19:18:17 * ais523 is busy handling the fallout from the recent release of C-INTERCAL 0.27
19:20:23 <ais523> I actually had a crazy idea for functional INTERCAL
19:20:37 <ais523> where you could create virtual threads with frozen values for variables
19:20:45 <ais523> that could still steal control of the program from the main thread
19:20:53 <ais523> as a complicated way of implementing lambda
19:40:58 <Slereah> Maybe I should write an abstraction eliminator with lambda calculus written unlambda style.
19:40:58 <pikhq> You are insane.
19:41:06 <Slereah> Parenthesis are bothersome to deal with.
19:46:32 * ais523 has one of those, in elisp
19:46:41 <ais523> not on this computer, though, so I can't post it right now
19:46:45 <ais523> and it was buggy anyway
19:47:19 <ais523> besides, if it was fully parenthesised before, all you need to do is get rid of all the closing parens
19:47:24 <Slereah> I have one, but it's in my pen.
19:49:18 <ais523> I used it to write a P'' interpreter in Unlambda
19:49:47 <ais523> it was pretty poor-quality Unlambda code, though. Just abstraction-eliminated s, k, and i, apart from a single c
19:50:01 <ais523> the c was to handle Unlambda's silly I/O model
19:50:57 <Slereah> I'm doing this for some sort of lazy unlambda.
19:51:23 <Slereah> 'cause I don't do very well with strict evaluation.
19:57:16 -!- oklopol has joined.
20:02:20 <ais523> you could always use `d before everything
20:02:57 <ais523> BTW, I like the way that d can be dynamically moved around the program in Unlambda, so you can decide whether evaluation is lazy or not at runtime
20:05:23 <Slereah> Well, that would increase drastically the size of programs
20:05:42 <Slereah> Which aren't that small to begin with.
20:10:28 <ais523> clearly the way to go is full Unlambda virtualisation
20:10:44 <oklopol> did something happen while i was gone?
20:12:37 <Slereah> We solved the halting problem.
20:13:45 <pikhq> We also made an infinite tape.
20:14:44 <Slereah> And we made a Malbolge interpreter in Malbolge.
20:15:00 <ais523> correction: Malbolge-T, there isn't enough memory otherwise
20:15:00 <oklopol> but nothing interesting?
20:15:13 <Slereah> Same old, same old.
20:16:25 <oklopol> ais523: halting problem + infinite tape, but a malbolge self-interpreter is impossible? :)
20:16:47 <Slereah> Well, we're not that good!
20:16:58 <Slereah> Solving the halting problem is easy next to Malbolge!
20:18:16 <pikhq> I'm not too impressed.
20:18:28 <ais523> infinite tape should be possible; you synthesize it out of materials in the environment
20:18:47 <pikhq> Frankly, a Brainfuck interpreter in Malbolge would be much more significant than an infinite tape or a function H.
20:18:57 <Slereah> Well, even if there's infinite materials, it will take an infinite time.
20:19:15 <ais523> you can solve the halting problem if you have infinite time
20:19:23 <Slereah> I'm not even going into the energy problem.
20:19:24 <ais523> I suppose you've seen how it's possible in TwoDucks?
20:19:28 <Slereah> Yes.
20:19:37 <Slereah> I've also read the papers on hypercomputation.
20:19:50 <pikhq> A hypothetical Infinity Machine would actually make the halting problem trivial.
20:19:54 <pikhq> http://www.chiark.greenend.org.uk/~sgtatham/infinity.html
20:19:56 <Slereah> Although it can only solve the halting problems of Turing machine.
20:20:01 <Slereah> Not its own.
20:20:28 <Slereah> http://www.hypercomputation.net/
20:22:45 -!- tejeez_ has changed nick to tejeez.
21:35:54 -!- oerjan has joined.
21:39:04 -!- ais523 has quit (""""").
21:40:18 -!- RedDak has joined.
21:54:17 <Slereah> Does this look okay as an abstraction eliminator? http://membres.lycos.fr/bewulf/Russell/AE4.py
21:54:31 <Slereah> For instance, `^a`^ba
21:54:37 <Slereah> gives ``s`kki
21:55:24 <oerjan> the string index handling makes me shiver these days :(
21:55:55 -!- faxathisia has left (?).
21:56:00 -!- faxathisia has joined.
21:56:28 <oerjan> wait a minute, why ` ?
21:56:31 <Slereah> And `^a`^b`^c``ac`bc gives ``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kki``s`kk`ki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk`ki``s`kk`ki
21:56:52 <oerjan> you really need some optimizations
21:56:56 <Slereah> I use unlambda notation, because string handling gets that much worse with parenthesis.
21:57:34 <faxathisia> :S
21:57:36 <faxathisia> really?
21:57:45 <Slereah> Well, for me at least.
21:57:45 <oerjan> um, the notation from the unlambdaifier is ^a^b$a
21:58:06 <Slereah> Well, not the exact lambda notation of unlambda.
21:58:18 <oerjan> you need eta reduction. ``s`kfi = f
21:58:27 <Slereah> I use `^xC for lambda x.C
21:58:39 <oerjan> the ` is deceptive
21:59:13 <oerjan> you're not really applying anything
21:59:21 <Slereah> I guess so.
21:59:37 <Slereah> I though I would run in some ``^x situation, but you're right.
22:00:01 <oerjan> also, the $x notation prevents trouble if you have a variable called s k or i ...
22:01:34 <oerjan> anyway the pain of doing this with indices into strings rather than an actual data structure... >_<
22:02:06 <Slereah> I don't know the difference, so there's that.
22:02:27 <oerjan> of course avoiding pain may not be a big goal here :D
22:02:50 <oerjan> well, an AST
22:02:59 <Slereah> Wait.
22:03:07 <Slereah> I think `^x is still useful.
22:03:32 <Slereah> For the C1 function, which looks for the end of the combinator applied.
22:04:46 <Slereah> So that ^x(^y.y) is counted as one combinator.
22:05:18 <Slereah> `^x`^yy - 2 apply operator, 3 "variables"
22:05:55 <oerjan> nah, all you need to do is treat ^ as you treat `
22:06:09 <Slereah> Oh.
22:06:28 <Slereah> Well, let's try that.
22:14:34 <Slereah> String index isn't hard to make
22:14:38 <Slereah> It's hard to modify.
22:24:42 <Slereah> Well, seems to work so far
22:24:49 <Slereah> Let's try eta reduction now.
22:33:03 <Slereah> Works for k.
22:33:39 <Slereah> s doesn't seem to eta reduce that easily though
22:37:24 <Slereah> Maybe replace ``skf by i.
22:38:31 <oerjan> with lazy evaluation that is fine
22:38:56 <oerjan> although, i don't think ``skf is produced by abstraction elimination
22:39:14 <oerjan> hm or could it?
22:39:54 <oerjan> ^x`kx`fx
22:40:12 <oerjan> after eta reduction, that would become ``skf
22:40:16 <Slereah> I can't see it in the AE of s at least.
22:40:40 <oerjan> er, missing a `
22:42:38 <oerjan> oh you mean reducing ^x^y^z``xz`yz to s somehow?
22:42:57 <Slereah> Yes.
22:43:12 <Slereah> So far, with eta reduction, it's ``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kkk``s`kk`ki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk`ki``s`kk`ki
22:43:23 <Slereah> Which works fine on the lazy interpreter, but well.
22:43:38 <oerjan> -> ^x^y``sxy
22:44:08 <oerjan> the trick is to do abstraction elimination and eta reduction fully on the innermost lambda first
22:44:30 <Slereah> Ah. Right now, the eta reduction is only on the end of the process.
23:16:22 -!- RedDak has quit (Read error: 104 (Connection reset by peer)).
23:34:37 <Slereah> The abstraction elimination seems to work okay.
23:35:55 <Slereah> Or maybe not.
23:36:08 <Slereah> Index out of range for half the Turing combinator.
23:37:01 <Slereah> Oh. I just wrote it wrong.
23:48:10 -!- timotiis has joined.
23:48:49 <pikhq> Slereah: Out of immense curiosity, why are you so intent on inventing new combinators/making a lazy Unlambda? :p
23:50:53 <Slereah> I'm not inventing them.
23:51:00 <Slereah> All those combinators already exist!
23:51:21 <Slereah> The lazy is because I'm just not that eager to use strict evaluation.
23:51:33 * oerjan groans
23:51:52 * oerjan wonders if Slereah knows he just made a pun
23:52:17 <Slereah> What, lazy?
23:52:32 <oerjan> strict and eager are synonyms :D
23:52:39 <Slereah> Oh. Then no.
23:52:48 <faxathisia> woah
23:53:16 <faxathisia> That was such an incredibly bad pun
23:53:34 <faxathisia> amazing coincidence
23:55:22 <oerjan> everyone can make a pun others don't understand. but to make one you don't understand yourself... :D
23:56:51 <Slereah> Boy, now that I know, I'm thinking of an even worst pun!
23:57:30 * pikhq groans
23:59:14 -!- timotiis has quit ("leaving").
←2008-01-03 2008-01-04 2008-01-05→ ↑2008 ↑all