00:02:37 -!- calamari has joined.
00:03:13 -!- puzzlet has joined.
00:03:17 -!- puzzlet__ has quit (Connection timed out).
00:08:55 -!- puzzlet__ has joined.
00:15:47 -!- puzzlet_ has quit (Read error: 110 (Connection timed out)).
00:20:22 -!- puzzlet has quit (Connection timed out).
00:22:11 -!- calamari has quit ("Leaving").
00:27:31 -!- puzzlet has joined.
00:27:31 -!- puzzlet__ has quit (Remote closed the connection).
00:42:29 -!- puzzlet has quit (Remote closed the connection).
00:42:29 -!- puzzlet_ has joined.
00:51:36 -!- puzzlet_ has quit (Remote closed the connection).
00:53:13 -!- puzzlet has joined.
00:55:42 -!- bsmntbombdood has joined.
01:11:05 -!- puzzlet has quit (Remote closed the connection).
01:11:05 -!- puzzlet has joined.
01:19:54 -!- puzzlet_ has joined.
01:34:15 -!- puzzlet has quit (Read error: 110 (Connection timed out)).
01:45:22 <ehird`> oklopol: have you got a rough oklotalk spec yet?
01:45:27 <ehird`> i want to implement it sometime
01:49:18 -!- puzzlet_ has quit (Remote closed the connection).
01:49:25 -!- puzzlet has joined.
01:57:39 -!- puzzlet has quit (Remote closed the connection).
01:57:39 -!- puzzlet_ has joined.
02:05:16 -!- ehird` has quit (Remote closed the connection).
02:05:49 -!- puzzlet has joined.
02:07:31 -!- puzzlet_ has quit (Read error: 104 (Connection reset by peer)).
02:13:14 -!- RodgerTheGreat has joined.
02:44:35 -!- oerjan has quit ("Good night").
02:56:07 <faxathisia> s = ((s ((s (k s)) ((s (k k)) ((s (k s)) ((s ((s (k s)) ((s (k k)) i))) (k i)))))) (k ((s ((s (k s)) ((s (k k)) i))) (k i))))
02:57:13 <faxathisia> cause I was always typing it out longhand before I realised....
02:57:15 <faxathisia> :p
02:57:52 <pikhq> Or: s = s
02:59:06 <faxathisia> \x y z w -> ((x y) (z w)) = ((s ((s (k s)) ((s (k (s (k s)))) ((s (k (s (k k)))) ((s (k (s (k s)))) ((s (k (s (k k)))) ((s ((s (k s)) ((s (k k)) i))) (k i)))))))) (k (k ((s ((s (k s)) ((s (k k)) i))) (k i)))))
02:59:22 <faxathisia>  I wonder why thi thing prints out such long expressions though..
03:00:28 <pikhq> It's automated.
03:00:40 <pikhq> Simplify what you can. ;)
03:01:18 <pikhq> Hmm. SKKI? s k k i -> k i (k k) -> i
03:01:53 <faxathisia> hmm
03:02:35 <faxathisia> if I have a list of combinators, and an expression made from those combinators.. I should be able to automatically generate some optimization rules I think
03:03:55 <faxathisia> that would be hard :S
03:04:10 <pikhq> It's called 'eval'.
03:04:18 <faxathisia> haha
03:04:21 <faxathisia> damn.. you're right
03:04:33 <faxathisia> I was thinking of combining the types together and seraching for reduced version
03:32:33 -!- Sgeo has joined.
03:32:39 <ihope_> \x y z w -> ``xy`zw. Apply a simple rule and that's reduced to \x y z -> ``s`xyz. Apply another one and it's reduced to \x y -> `s`xy. Another and it becomes \x -> ``s`ksx. One more and it becomes `s`ks.
03:32:56 <ihope_> It's quite obvious that you have room for improvement.
03:33:58 <ihope_> \x y z -> ``xz`yz can become \x y -> ``sxy can become \x -> `sx can become s. \x y -> x can become `ky can become k.
03:34:13 <ihope_> Moral of the story: \x -> `fx is the same as f. :-)
03:34:33 <ihope_> (Assuming f doesn't contain x, obviously.)
04:01:31 -!- RodgerTheGreat has quit.
04:28:59 -!- ihope_ has quit (Connection timed out).
05:38:48 -!- RodgerTheGreat has joined.
05:40:58 <RodgerTheGreat> Hm. Well, Pidgin is interesting.
05:41:18 <RodgerTheGreat> not exactly my ideal vision of an IRC client, but hey
05:41:31 <RodgerTheGreat> I need to install XChat on this thing
05:43:36 <pikhq> I'd prefer irssi, but yeah, Pidgin is not the greatest at IRC.
05:44:07 <RodgerTheGreat> I'm mainly just giving it a spin because it was already here
05:45:17 <RodgerTheGreat> well, cya- I think I'm going to turn in.
05:45:37 -!- RodgerTheGreat has quit ("Leaving.").
06:00:36 -!- Sgeo has quit (Connection reset by peer).
07:13:54 -!- weilawei has quit (Nick collision from services.).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
10:22:28 -!- asiekierka has joined.
10:22:34 <asiekierka> hi
10:33:52 -!- andreou has joined.
10:46:21 -!- jix has joined.
11:07:34 -!- oklopol has quit (Remote closed the connection).
11:11:52 -!- ololobot__ has quit (Read error: 104 (Connection reset by peer)).
11:11:53 -!- ololobot_ has quit (Read error: 104 (Connection reset by peer)).
11:12:21 -!- oklopol has joined.
11:21:37 -!- puzzlet has quit (Remote closed the connection).
11:21:44 -!- puzzlet has joined.
13:10:53 <Slereah-> Is there a way to reduce a combinator expression without using a dummy variable to test the expression?
13:13:32 <oklopol> isn't that an undecidable problem in general?
13:13:54 <Slereah-> Well, I'm not even talking in general.
13:14:05 <oklopol> i'm just asking in general
13:14:21 <Slereah-> I think it is, yes.
13:14:35 <Slereah-> I gives a contradiction with the omega combinator IIRC
13:14:38 <Slereah-> it*
13:16:19 <Slereah-> I tried to reduce them abstractions of ^ab.a, and ended up on (S(KK))I.
13:16:59 <Slereah-> Which gives Kx when applied to some combinator x, but well
13:20:55 <oklopol> then it's K
13:20:57 <oklopol> ...right?
13:21:17 <Slereah-> Well, for ^ab.a, I hope so.
13:21:35 <Slereah-> Just wondered if there was a way to do it without applyin it.
13:22:12 <oklopol> eta reduction
13:22:22 <oklopol> a function is how it behaves
13:22:41 <oklopol> applying is just a way to see how it behaves
13:23:15 <Slereah-> 'kay.
13:23:32 <oklopol> errr don't think i actually know anything
13:23:52 <oklopol> that's just how i see it
13:24:15 <Slereah-> Let's just see if someone comes up with another answer!
13:24:28 <Slereah-> In the next... three or four hours, considering the rythm of this chan.
13:25:14 <Slereah-> Dealing with free variables is alrerady bothersome, but if I also have to apply the result...
14:06:17 -!- RedDak has joined.
14:15:20 <asiekierka> hi
14:21:04 -!- RedDak has quit (Remote closed the connection).
14:23:30 <oklopol> lo
14:26:08 <faxathisia> Slereah-: My thought was, you have a tree of combinators... typecheck branches of it -- if they're a combinator you know already you can replace it
14:27:12 <faxathisia> e.g. when you see a branch with ((s ((s (k s)) ((s (k k)) ((s (k s)) ((s ((s (k s)) ((s (k k)) i))) (k i)))))) (k ((s ((s (k s)) ((s (k k)) i))) (k i)))) in it -- which has type (a -> b -> c) -> (a  -> b) -> a -> c, just replace it with s
14:27:32 <faxathisia> then I think I just coded the algorithm the wrong way around :S
14:32:03 -!- Sgeo has joined.
14:33:03 -!- andreou has quit (Read error: 110 (Connection timed out)).
15:02:59 <Slereah-> I'm not sure what you mean by "typecheck".
15:04:13 <faxathisia> you know what type s is and k, so you can tell what type is (s k) (k s) (s (s k)) .. etc
15:04:26 <faxathisia> I didn't try to code though
15:04:46 <Slereah-> Type?
15:04:50 <faxathisia> but I thought inspecting the types should give a way to reduce the expressions
15:05:04 <faxathisia> i :: a -> a
15:05:19 <faxathisia> s :: (a -> b -> c) -> (a -> b) -> a -> c
15:05:26 <Slereah-> Oh.
15:05:30 <faxathisia> k :: a -> b -> a
15:06:31 <Slereah-> Would the type checking involve testing the combinators on some x-y-z combinators?
15:06:54 <faxathisia> (s (s (s (s k)))) :: ((((a -> b) -> a) -> a -> b) -> (a -> b) -> a) -> (((a -> b) -> a) -> a -> b) -> a
15:08:55 <faxathisia> well if you have (k s), you let a = (a' -> b' -> c') -> (a' -> b') -> a' -> c' in a -> b -> a and remove the first thing since one application was done.. to get b -> (a' -> b' -> c') -> (a' -> b') -> a' -> c'
15:09:39 <faxathisia> I was thinking it would be possible to reduce by, taking the type of every branch of the tree of combinators.. and seraching for types you already know
15:10:11 <faxathisia> but it would be better probably to just generated reduces expressions in the first place (I don't know why the algorithm on wikipedia doesn't)
15:11:12 <faxathisia> :t let k x y = x ; s x y z = (x z) (y z) ; i x = x in (s k) -- I was checking the combinators output with this
15:11:32 <Slereah-> I tried to search for some moar, but apparently abstractino reduction isn't popular on the interweb.
15:12:01 <faxathisia> pikhq suggested eval
15:12:10 <faxathisia> but I didn't realize expressions can diverge :p
15:12:27 * Slereah- seems to lack some jargon
15:12:34 <faxathisia> so it might work for simplifying somethings, just evaling things which make it shorter
15:13:32 -!- jix has quit (Nick collision from services.).
15:13:42 -!- jix has joined.
15:14:11 <faxathisia> (((s i) i) ((s i) i)) -- diverges
15:14:26 <faxathisia> it is an infinite loop
15:14:51 <Slereah-> Why yes, yes they are.
15:14:57 <Slereah-> It's the omega combinator.
15:36:24 -!- sebbu2 has joined.
15:44:16 -!- sebbu has quit (Read error: 113 (No route to host)).
15:44:17 -!- sebbu2 has changed nick to sebbu.
15:47:21 -!- oerjan has joined.
16:12:12 -!- andreou has joined.
16:35:44 * pikhq cheers
16:36:05 <pikhq> oerjan: It appears that I have won the game, and may well earn the title 'Scamster'.
16:36:29 <oerjan> ooh
16:37:01 <pikhq> Points are a currency. Currencies can be created by their recordkeepor, unless the backing document for the currency says otherwise.
16:37:08 <pikhq> I am the recordkeepor of points.
16:37:54 <pikhq> So, I just say "I create 100 points in my posession. I win the game."
16:37:55 <pikhq> Voila.
16:38:37 <pikhq> Also, I have earned the patent title 'Agoran Spy'. Tell me, is there anything here to spy on?
16:38:50 <pikhq> ;p
16:38:57 <oerjan> I could tell you, but then I would have to kill you.
16:39:27 <pikhq> LMAO
16:39:45 <pikhq> I see that you've been playing Paranomic.
16:39:53 <oerjan> i did?
16:40:00 <oerjan> i don't quite remember
16:40:12 <pikhq> Paranomic XP is a recently formed Nomic. . .
16:40:20 <pikhq> Proposals have a security clearance.
16:40:25 <oerjan> so i haven't.
16:40:35 <pikhq> You need to have that security clearance to be aware of it existing, much less to vote on it.
16:40:44 <oerjan> i did however play Blind Nomic.  That was fun.
16:40:50 <pikhq> So, the phrase "I could tell you, but then I would have to kill you." is entirely true.
16:41:35 <oerjan> unfortunately it disappeared...
16:52:57 <pikhq> Ah, Christmas break. . . A wonderful time of year.
18:05:14 -!- asiekierka has quit.
18:52:14 <SimonRC> faxathisia: If you reduce the outermost combinator first you are guaranted to reach an answer if tyhere is one
18:52:30 <SimonRC> It is equivalent to "lazy evaluation" in proagramming languages
18:53:27 <SimonRC> Actually, combbinators are a bit like pure OO
18:53:47 <SimonRC> instead of "All you can do is send a message", you have "All you can do is calll it"
18:54:12 <Slereah-> OO?
18:54:20 <SimonRC> Object orientation
18:54:38 <SimonRC> you can't test for equality, you have to pass in things that tel it what to do in various cases
18:56:11 <oerjan> http://people.csail.mit.edu/gregs/ll1-discuss-archive-html/msg03277.html
19:34:38 <SimonRC> yup
19:50:09 -!- calamari has joined.
20:23:48 -!- calamari has quit ("Leaving").
20:59:05 <Slereah-> Hm. What's the shortest way to make a nor out of nands?
20:59:31 <Slereah-> I got ((P|P)|(Q|Q))|((P|P)|(Q|Q)) so far.
21:19:47 -!- oerjan has quit ("Good night").
21:31:13 -!- RedDak has joined.
22:42:07 -!- Slereah has joined.
22:53:04 -!- calamari has joined.
23:07:34 -!- Slereah- has quit (Read error: 110 (Connection timed out)).