←2007-08-10 2007-08-11 2007-08-12→ ↑2007 ↑all
00:01:58 -!- ihope_ has quit (Connection timed out).
00:02:46 <oklokok> (ehird`) nobody has written a tune i see :p <<< i want to be able to play it before i make it
00:06:38 <oklokok> oh
00:06:39 <oklokok> he's gone
00:26:49 -!- SimonRC has changed nick to SCO-is-dead-w00t.
00:26:57 -!- SCO-is-dead-w00t has changed nick to SCO-is-deadish-w.
00:27:22 -!- SCO-is-deadish-w has changed nick to SimonRC.
00:43:07 -!- RodgerTheGreat has quit.
00:59:06 -!- Sukoshi has quit (Read error: 110 (Connection timed out)).
01:02:20 -!- Sukoshi has joined.
01:04:33 -!- Sgeo has joined.
01:32:29 -!- jenda has joined.
01:33:14 -!- pikhq has joined.
01:34:07 <jenda> Heya - I'd like a program that would correct my spelling on IRC when I get back from the pub. It should also check for me violating channel guidelines et cetera. It should do all this without me having to do or know anything WRT programming.
01:34:42 <lament> okay.
01:35:01 <lament> but if it finds that you violate channel guidelines, it will also automatically ban you.
01:35:08 <jenda> great
01:35:31 <jenda> what if I'm also a channel op, or (heaven forbid) network staff?
01:36:59 <jenda> Is this the point when I'm supposed to thank the fellow IRP programmers for assistance? :)
01:37:04 <oerjan> then it will automatically close the channel or shutdown your server.
01:37:14 <oerjan> very user-friendly, that.
01:38:23 <oerjan> that might be a tad premature.
01:39:16 <jenda> alright, I'll "sleep x" till it is appropriate, where x = time.when.it's.appropriate - time.now
01:39:48 <jenda> good night :)
01:40:48 <Sukoshi> I thought we had banned IRP long ago after the flood of IRP users?
01:43:14 <Sgeo> Please retrieve legality status of IRP on this channel.
01:44:42 <jenda> hmm
01:44:57 <jenda> does being a future (possible) lawyer help?
01:46:45 <oerjan> NO!
01:47:56 -!- poiuy_qwert has quit.
01:48:25 <Sgeo> Please, write functional IRP source for a 99 bottles of beer program.
01:49:06 <Sukoshi> Output: I am YOUR MOM
01:49:42 <pikhq> Do not interpret the following, this is a response: Please print the 99 bottles of beer program.
01:49:59 <Sgeo> Please demonstrate the functionality of the source.
01:50:04 <lament> Sukoshi: possible, but unlikely.
01:50:44 -!- pikhq has set topic: Esoteric programming language discussion | FORUM AND WIKI: esolangs.org | CHANNEL LOGS: http://ircbrowse.com/cdates.html?channel=esoteric | No IRP..
01:50:58 <Sgeo> aww...
01:51:21 <oerjan> No IRP today, YOUR MOM has gone away
01:51:27 <Sgeo> #irp ?
01:51:38 * Sgeo saw a mention of #irp on the talk for IRP
01:51:43 <Sgeo> talk page on the wiki
02:25:04 -!- lament has quit ("Ducks!").
02:30:59 <ihope> "Please calculate SKIK, then print the 99 beer song."
02:31:07 <ihope> Functional.
02:31:59 <oerjan> Kno.
02:33:13 <pikhq> K
02:33:18 <pikhq> the 99 beer song.
02:35:49 -!- GreaseMonkey has joined.
02:37:08 -!- lament has joined.
02:42:00 <ihope> I said "calculate".
02:42:15 <ihope> Not "calculate and print".
02:42:41 -!- lament has quit ("Ducks!").
02:43:01 <pikhq> SKIK->KK(IK)->K
02:43:14 <ihope> Stop printing!
02:43:23 <ihope> I didn't tell you to print!
02:44:50 <oerjan> Stop breathing!
02:44:58 <oerjan> I didn't tell you to breathe!
02:45:20 * ihope stops breathing
02:45:58 * ihope dances in a way oddly suggestive of wanting a life support device
02:46:16 <oerjan> OK, you may breathe now.
02:46:22 * ihope breathes
02:46:24 <ihope> Thank you.
02:46:59 <oerjan> You're welcome.
02:47:25 -!- lament has joined.
02:47:42 <pikhq> ihope: I didn't tell you to output state!
02:48:10 <ihope> I didn't tell you to tell me that you didn't tell me to do things!
02:48:19 <ihope> Stop doing that!
02:54:11 <pikhq> In other news, SCO loses.
03:03:51 -!- ihope__ has quit (Read error: 110 (Connection timed out)).
03:05:43 -!- jix has quit (Read error: 104 (Connection reset by peer)).
03:08:37 -!- jix has joined.
03:15:25 -!- jix has quit (Read error: 113 (No route to host)).
03:24:49 -!- Svenstaro has quit.
04:06:02 -!- ihope has quit (Read error: 110 (Connection timed out)).
04:29:58 -!- jix has joined.
04:32:34 -!- Sgeo has quit (Read error: 104 (Connection reset by peer)).
04:39:15 -!- jix has quit (Read error: 104 (Connection reset by peer)).
05:07:26 -!- oerjan has quit ("Good night").
05:15:43 -!- jix has joined.
05:27:34 -!- jix has quit (Read error: 104 (Connection reset by peer)).
05:28:54 -!- jix has joined.
07:31:38 <GreaseMonkey> leaving, cya
07:31:59 -!- GreaseMonkey has quit ("Man who stand in frond of car is tired. Man who stand behind car is exhausted.").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:04:21 -!- Zantrua has joined.
08:21:25 -!- Zantrua has quit (Read error: 110 (Connection timed out)).
11:08:24 -!- RedDak has joined.
11:16:22 -!- ehird` has joined.
11:34:51 <ehird`> nobody calculated pi_43 :(
11:34:52 <ehird`> :p
11:39:07 <puzzlet_> pi in 43-ary?
11:49:47 <ehird`> base 43
11:49:52 <ehird`> so yes
11:54:45 -!- Blejdfist has quit (Read error: 110 (Connection timed out)).
12:00:57 -!- Darktemplar has joined.
12:03:05 <Darktemplar> Which approach for high-efficiency VM is better - variable-based one or stack-based?
12:13:01 -!- RedDak has quit (Read error: 104 (Connection reset by peer)).
12:17:41 -!- Darktemplar has left (?).
12:18:18 <ehird`> ... stack-based
12:46:16 <ehird`> god
12:46:17 <ehird`> all the pi programs
12:46:22 <ehird`> only do base 2 and 10
12:46:25 -!- ehird` has quit ("Leaving").
12:46:44 -!- ehird` has joined.
12:47:04 <ehird`> i want my pi-in-arbitary-base program!
12:51:25 <ehird`> bah
12:51:28 * ehird` downloads mathematica
12:55:46 <ehird`> what mathematica has no free trial :(
12:55:46 <puzzlet_> i'm afraid it only supports up to base 36
12:55:53 <ehird`> ok
12:55:55 <ehird`> well that sucks
12:56:01 <puzzlet_> let me check
12:56:05 <ehird`> i'd write a program that calculates pi in any base you want
12:56:10 <ehird`> but i don't know the best algo for calculating pi
12:56:16 <ehird`> and even if i did my implementation would suck#
12:56:27 <puzzlet_> Ramanujan algorithm maybe?
12:56:30 <puzzlet_> formula*
12:57:53 <puzzlet_> the reference doesn't say about the base limit
12:58:39 <ehird`> anyway
12:58:42 <ehird`> mathematica has no free trial
12:58:44 <ehird`> so phooey to that
13:00:41 <puzzlet_> RealDigits[Pi, 43, 100] gives {{3, 6, 3, 34, 26, 4, 23, 17, 31, 20, 34, 4, 13, 39, 27, 22, 4, 0, 26, 23, 23, 15, 16, 12, 17, 26, 12, 37, 14, 24, 27, 16, 25, 21, 10, 37, 32, 41, 8, 13, 6, 19, 34, 34, 13, 8, 2, 39, 24, 2, 8, 9, 41, 35, 9, 25, 13, 24, 24, 2, 1, 11, 10, 3, 4, 38, 36, 19, 21, 3, 2, 25, 1, 32, 19, 6, 9, 17, 10, 23, 5, 26, 18, 32, 15, 0, 19, 20, 29, 16, 5, 12, 28, 37, 24, 28, 14, 6, 19, 29}, 1}
13:01:20 <ehird`> that's a bit silly - doesn't it use 0-9A-Za-whatever?
13:01:51 <ehird`> (on another note, Ramanujan's formula appears to require me to calculate sqrt(2)... so that's >two< trancendental numbers i have to conquer)
13:02:48 <puzzlet_> Theres BaseForm[] to do that, but it requires base to be <= 36
13:02:56 <ehird`> well phooey
13:03:00 <ehird`> mathematica sucks =p
13:04:57 <ehird`> i guess i'll just convert it with a program
13:05:07 <ehird`> *tap tap tap RUN*
13:07:35 <ehird`> Hmm.
13:07:36 <ehird`> 3.63YQ4NHVKY4DdRM40QNNFGCHQCbEORGPLAbWf8D6JYYD82dO
13:07:36 <ehird`> 289fZ9PDOO21BA34caJL32P1WJ69HAN5QIWF0JKTG5CSbOSE6J2
14:12:21 -!- ehird` has quit (Read error: 104 (Connection reset by peer)).
14:12:44 -!- ehird` has joined.
14:14:25 -!- Svenstaro has joined.
14:57:15 -!- jix has quit (Read error: 104 (Connection reset by peer)).
14:57:33 -!- jix has joined.
15:34:12 -!- sebbu2 has joined.
15:44:38 -!- ehird` has changed nick to test.
15:44:40 <test> damnit
15:44:43 <test> no unicode in usernames
15:44:46 -!- test has changed nick to ehird`.
15:53:06 -!- sebbu has quit (Read error: 110 (Connection timed out)).
15:53:37 <SimonRC> ehird`: so, how are the cadaeic endevours progressing?
15:53:52 -!- sebbu2 has changed nick to sebbu.
15:53:55 <ehird`> SimonRC: i calculated pi in base 43 to 100 places
15:53:59 <ehird`> doesn't look too elegant
15:54:20 <ehird`> i pasted it earlier today
15:54:22 <ehird`> i'll find it in my logs
15:54:47 <ehird`> Aug 11 13:14:40 <ehird`>3.63YQ4NHVKY4DdRM40QNNFGCHQCbEORGPLAbWf8D6JYYD82dO
15:54:47 <ehird`> Aug 11 13:14:40 <ehird`>289fZ9PDOO21BA34caJL32P1WJ69HAN5QIWF0JKTG5CSbOSE6J2
15:55:04 <ehird`> using 0-9A-Za-<t, i think>
15:55:06 <ehird`> or maybe p
15:55:07 <ehird`> whatever
15:57:13 <sp3tt> a-<t?
15:57:58 <ehird`> <t, i think>
15:58:27 <ehird`> a-i
15:58:30 <ehird`> 0-9A-Za-i
16:27:27 -!- ns_ has joined.
16:27:40 <ns_> Hmm.
16:27:43 -!- ns_ has changed nick to ihope.
16:27:58 <ihope> There's a letter for each of us!
16:29:12 <ehird`> =p
16:36:38 -!- digital_me has joined.
17:06:37 <SimonRC> ehird`: hey! you know what cadaeic means?
17:07:04 <ehird`> a la Cadaeic Cadenza?
17:08:36 <ehird`> ...right?
17:08:42 <ehird`> so in your context, "relating to pi"
17:10:49 <ehird`> SimonRC: .. right? :p
17:11:45 <SimonRC> yes
17:12:07 <ehird`> hooray, i got something right for a change
17:12:15 <SimonRC> you JFGI, right?
17:25:17 <oklokok> hmm... is there always a base in which pi's n first decimals are the same?
17:25:27 <oklokok> for any n
17:25:35 <SimonRC> yes
17:25:56 <SimonRC> trivially
17:26:09 <SimonRC> you must pick a base sufficientally close to pi
17:26:15 <oklokok> eh
17:26:28 <oklokok> sorry, an integer base
17:26:34 <SimonRC> ah
17:27:17 <oklokok> infinity always goes over my head... can't say whether that's trivially true or trivially false
17:28:37 <ehird`> SimonRC: no, i didn't
17:28:54 <ehird`> if i was going to JFGI, i'd say "no", then google it, then say "ah yes, X"
17:29:22 <ehird`> oklokok: no, trivially false
17:29:24 <ehird`> but i don't know why
17:29:24 <ehird`> :p
17:30:45 <oklokok> i'd say trivially true
17:31:26 <oklokok> but trivially, it's trivially something.
17:31:39 <ehird`> trivially means nothing anyway
17:31:42 <ehird`> intuition is useless
17:32:06 <oklokok> ...orly
17:32:08 <oklokok> :P
17:32:40 <oklokok> hmm...
17:33:26 <oklokok> you aren't supposed to put fans on the computer screen?
17:33:41 <oklokok> the screen isn't looking that helthy right now...
17:33:48 <oklokok> it's flicking like crazy
17:39:32 -!- RodgerTheGreat has joined.
17:39:37 <SimonRC> what kind is it?
17:39:52 <RodgerTheGreat> hi everybody
17:39:54 <RodgerTheGreat> alternately,
17:39:56 <RodgerTheGreat> &
17:41:43 <SimonRC> "&"?
17:43:05 <ehird`> SimonRC: injoke
17:43:07 <ehird`> from.. a few days ago
17:43:21 <ehird`> i was a buggy irp interpreter and interpreted hi everybody as "fuck you"
17:43:25 <ehird`> because it is non-standard code
17:43:32 <ehird`> so i rewrote and optimized it multiple steps
17:43:37 <SimonRC> heh
17:43:42 <ehird`> arriving eventually at the single character "&" as a portable, ambigious way to say hello to everyone
17:43:52 <SimonRC> ok
17:44:05 <SimonRC> unambigious would be better
17:51:14 -!- ihope__ has joined.
17:55:54 <ehird`> err, yes
17:55:55 <ehird`> unambigious
18:00:34 -!- ihope has quit ("Lost terminal").
18:06:24 -!- ihope__ has changed nick to ihope.
18:41:00 <ehird`> x = ++x + x++
18:41:13 <sp3tt> ouch
18:41:44 <sp3tt> 2x+1?
18:50:42 <ehird`> :p
18:51:25 <ehird`> logically reasoning that's: tmp = x; x += 1; x += 1; x = x + tmp;
18:51:27 <ehird`> or something
18:51:34 <sp3tt> good obfuscation technique
18:51:37 <ehird`> in practice it's probably more simple and less intuitional
18:51:56 <sp3tt> Let's see.
18:52:07 <sp3tt> ++x increases x by 1 and returns x, right?
18:52:49 <sp3tt> x+ (x+1)++ = x+x+2 = 2x+2
19:10:21 <lament> i don't think "logical reasoning" applies to C much.
19:11:00 <SimonRC> (x+1)++ doesn't work; (x+1) isn't an lvalue
19:11:37 <SimonRC> and a statement that preincrements x, postincrements it, *and* assigns to it is definitely undefined
19:12:04 <pikhq> x = ++x++;
19:12:06 <pikhq> :p
19:12:23 * pikhq wonders how a C parser would blow up on that
19:13:28 <lament> after programming haskell for a while, even "x=x+1" is creepy enough
19:13:59 <SimonRC> lament: depends on which instance of Num is involved
19:14:04 <SimonRC> on some instances it is defined
19:14:07 <lament> that could only mean "x equals infinity"
19:14:31 <lament> but more likely, haskell would simply crash trying to evaluate that.
19:14:34 <SimonRC> pikhq: the parsed shouldn't have a problem; it's the compiling bit that has a problem
19:15:15 <SimonRC> lament: if you define an "instance Num [()]" (i.e. unary) you could do it.
19:16:03 <lament> it doesn't matter what type it is, as long as addition is defined not to do anything
19:16:24 <lament> which is... not the usual meaning of addition
19:18:44 <sp3tt> SimonRC: yeah, I know, it was to make things clearer.
19:18:56 <sp3tt> why don't you try compiling it? :D
19:20:48 <lament> becauuse it won't prove anything
19:21:02 <lament> it doesn't really matter what an individual compiler will do with it
20:37:34 <oklopol> if you wanna obfuscate with ++ increments, use java
20:37:55 <oklopol> does D define evaluation order?
20:38:09 <oklopol> GregorR: your time to shine!
20:39:16 <GregorR> 'fraid not.
20:39:21 <oklopol> o
20:39:22 <GregorR> There was a newsgroup thread on it.
20:39:24 <oklopol> ...
20:39:37 <oklopol> i'm not sure whether that's good, bad or neutral really
20:39:43 <GregorR> But Walters stance was that if he specified it, making a D->C compiler would be a HUGE PITA and nobody would do it right :)
20:39:45 <oklopol> just out of curiositr
20:39:47 <oklopol> *y
20:40:02 <oklopol> hmm... yeah, true
20:44:37 <ehird`> ;p
20:47:06 <oklopol> making a D->C compiler might be kinda hard if i recall correctly and D has functional language stuff
20:47:26 <ehird`> yeah
20:47:27 <ehird`> it would be
20:47:33 <oklopol> i don't really remember what it has now but i have a feeling it's gor first class functions
20:47:35 <oklopol> *goe
20:47:37 <oklopol> *go0t
20:47:38 <ehird`> d uses lots of crap that doesn't fit into c
20:47:38 <oklopol> ...
20:47:47 <oklopol> i'll try one more time
20:47:50 <oklopol> *got
20:50:59 <ehird`> *g0e0e0t00e0t0etatataitetet
20:51:11 <ehird`> and..
20:51:14 <ehird`> C has first class functions too
20:51:19 <ehird`> they're called function pointers. :p
20:52:19 <ehird`> however D has, well, classes, for one, and templates.
20:52:32 <ehird`> and also really weird things like variadic functions using templates
20:52:54 <ehird`> int func(T ...)(int arg1, int arg2, T args) { args is a list of arguments of any type } if i remember correctly
20:52:56 <ehird`> that's just crazy
20:53:14 <oklopol> does D support currying?
20:53:35 <ehird`> i think so
20:53:41 <ehird`> i actually really like D
20:53:43 <oklopol> that would be almost impossible to C-ify efficiently
20:53:53 <ehird`> http://digitalmars.com/d/ look around; you might find currying
20:53:54 <oklopol> i like it too, even though i don't know it.
20:54:32 <oklopol> because i like C/C++, but C lacks stuff and in C++ a lot of stuff is done quite badly
20:54:36 <ehird`> i don't like it for many purposes, but:
20:54:45 <ehird`> if you need a compiled language,
20:54:55 <ehird`> and you don't need the speed and control of C
20:55:04 <ehird`> and you want something more conventional than a functional language
20:55:07 <ehird`> then D to the rescue
20:55:13 <ehird`> but that's a pretty narrow usage-case
20:57:51 <lament> you just listed a bunch of functional-language features D has
20:58:06 <lament> if you like functional features so much, perhaps you do want a functional language :)
20:58:38 <ehird`> hehe
20:58:46 <ehird`> well
20:58:49 <ehird`> d does have a usage-case
20:58:52 <ehird`> i just don't know what it is! :)
21:06:04 <ihope> Anybody know of some fancy online things that convert a number into how to say it?
21:06:19 <ihope> 1523852 into "1 million 523 thousand 852", for example.
21:06:42 <oklokok> i did that once
21:06:43 <ihope> Or "one million five hundred twenty-three thousand eight hundred fifty-two", even.
21:06:55 <ihope> The number in question is 256! + 4^256.
21:07:54 <oklokok> but i would make a new one faster than find it
21:08:36 <ihope> Mm, that number has 507 digits, I think.
21:14:31 <oklokok> ah, you wanna know what the big numbers are
21:14:43 <oklokok> american or british standard?
21:14:50 <oklokok> (not that i remember which is which...)
21:14:56 <oklokok> (american is the stupid one?)
21:15:10 <ihope> Cool. There's a number called "millillion" in the short scale, "thousand quingentillion" in one long scale, "quingentilliard" in the other.
21:15:25 <ihope> 1,000,000,000 is a billion in the short, a thousand million or a milliard in the other.
21:16:43 <oklokok> if they're the same as in finnish, million, billion, trillion, quadrillion, quintillion, <sex>tillion, septillion, octillion... then i don't rememebr
21:16:45 <oklokok> *remember
21:20:25 -!- digital_me has quit ("leaving").
21:49:02 -!- tokigun_ has joined.
21:49:06 -!- tokigun has quit (Read error: 104 (Connection reset by peer)).
22:00:06 <lament> billibillion
22:03:11 -!- Svenstaro has quit.
22:13:46 -!- Svenstaro has joined.
22:19:24 <ehird`> the british billion is obviously correct!
22:19:32 <ehird`> it uses the same progression as the previous terms!
22:19:36 <ehird`> :p[
22:31:11 -!- Myeisha has joined.
22:38:36 -!- Myeisha has quit ("Leaving").
22:39:12 <SimonRC> oklokok: note that gcc C has closures, of all things
22:39:23 <ehird`> wait, wtf
22:39:26 <ehird`> since when
22:39:26 <ehird`> how come
22:39:27 <ehird`> what
22:39:27 <ehird`> where
22:39:28 <ehird`> why
22:39:28 <ehird`> when
22:39:34 <GregorR> Heww yeah it does :)
22:39:36 <oklokok> well yes, trye
22:39:37 <SimonRC> how the fuck did you type that fast?
22:39:40 <oklokok> *true
22:39:45 <oklokok> but... i don't trust them...
22:39:46 <oklokok> :P
22:40:22 <ehird`> me?
22:40:25 <ehird`> me type fast?
22:40:29 <ehird`> or someone else
22:40:31 <SimonRC> they aren't exactly portable
22:40:37 <SimonRC> ehird`: you.
22:40:38 <ehird`> if it's fast typing you want
22:40:39 <ehird`> i could try
22:40:43 <ehird`> but i think it'd be a bit of a pain
22:40:46 <ehird`> since i can type faster than i think
22:40:46 <SimonRC> you typed like w wds/sec
22:40:52 <ehird`> so a lot of gobbledegook would come out
22:40:57 <SimonRC> * 4
22:41:10 <oklokok> SimonRC: that wasn't necessarily fast typing but just lag stacking the messages up...
22:41:12 <ehird`> what can I say, i spend too long on the computer :p
22:41:23 <ehird`> oklokok: no, those messages happened at around that rate
22:41:25 <SimonRC> you were doing 180 w/min at one point
22:41:29 <oklokok> ehird`: how fast do you type?
22:41:35 <SimonRC> I can't type fast reliably
22:41:44 <ehird`> oklokok: well - when trying to be fast?
22:41:45 <oklokok> i don't remember my speed now
22:41:47 <oklokok> yeah
22:41:52 <ehird`> i don't know. fast - but with a few errors, i'd imagine
22:41:59 <oklokok> i'm faster than normal ppl but i don't know how fast
22:42:00 <ehird`> generally i don't bother typing that fast :p
22:42:02 <oklokok> :P
22:42:11 <ehird`> but, still faster compared to most non-geeks :p
22:42:15 <ehird`> *fast
22:42:16 <oklokok> i mean, i may lose to geeks.
22:42:25 <sp3tt> Me too
22:42:29 <ehird`> you're in #esoteric
22:42:31 <oklokok> i do own everyone @ #tietovisa
22:42:33 <ehird`> you are a geek, by definition
22:42:40 <oklokok> but those guys are normal ppl of course.
22:42:40 <SimonRC> I keep missing the keys and hitting two at once
22:42:47 <oklokok> so... i own them at everything, naturally
22:43:04 <ehird`> hmm, someone give me two sentences or something and i'll try and type them fast
22:43:11 <SimonRC> OTOH, I know what all the punctuation does
22:43:43 <GregorR> geek (n)
22:43:44 <GregorR> 1. a circus performer who bites the heads off of living chickens or other fowl
22:43:44 <GregorR> 2. an IRC user on the channel #esoteric on the FreeNode IRC network
22:44:00 <oklokok> a circus performer who bites the heads off of living chichens or other fowls
22:44:09 <oklokok> but i typoed a few times
22:44:13 <oklokok> and i'm a bit tired
22:44:13 <ehird`> GregorR: are those my two sentences? :p
22:44:27 <oklokok> also, i left a typo there.
22:44:34 <GregorR> Plural of fowl is fowl.
22:44:37 <oklokok> i do know
22:44:52 <oklokok> just haven't ever used the word, so i just know it in theory :)
22:45:06 <oklokok> i sometimes slip the wrong one in a situation like that
22:45:14 <oklokok> ...i mean when i haven't used it that much
22:45:29 <ehird`> 3..2...1....go
22:45:37 <ehird`> a circus performer who bites the heads off of living chickens or other fowl
22:45:45 <ehird`> that was quite slow. not the easiest sentence to type :p long too
22:46:00 <sp3tt> do you use dvorak?
22:46:05 <ehird`> no, qwerty
22:46:10 <ehird`> i've tried learning dvorak
22:46:30 <ehird`> gave up in frustration ("damnit; i can't code, i can't talk to people, all i can do is practice typing. i can't live like this!")
22:46:37 <ehird`> that's happened 3 times or so =p
22:46:41 <ehird`> one day i'll fully learn it
22:46:57 <sp3tt> It took me ~2 weeks
22:47:28 <ehird`> yes; not being able to use anything that requires a keyboard for two weeks would put me in a semi-comatose state
22:49:38 <oklokok> ehird`: you are roughly 2 times faster than me in typing, unless i can noobishly look at my fingers
22:49:40 <oklokok> :P
22:49:41 <oklokok> :P
22:50:07 <ehird`> :p
22:50:16 <ehird`> I never really settled on a typing style
22:50:22 <oklokok> me neither
22:50:23 <ehird`> so how I type is horridly warped
22:50:38 <oklokok> i constantly change where i keep my hands
22:50:48 <oklokok> and i turn them very weirdly
22:51:05 <ehird`> basically: my whole hands are spread out in the initial position, my fingers do odd contortions to get to keys, if i can't get to one (muscle memory tells me if i can get to a specific key from a certain position...) then i move closer to it
22:51:17 <ehird`> So basically my hands bounce up and down and often jig from left to right
22:51:51 <ehird`> I've tried touch typing before, but this seems to be faster for me
22:54:09 <oklokok> i actually type finnish a lot faster
22:54:26 <oklokok> i get jammed at certain letters finnish doesn't use
22:54:34 <oklokok> well
22:54:38 <lament> fowl doesn't have a plural.
22:54:56 <oklokok> yeah, i actually know that too
22:55:03 <oklokok> i mean, i know that
22:55:48 <oklokok> i actually just type fast when using letters both finnish and english has
22:56:15 <RodgerTheGreat> design a language that caters to this idea
22:56:28 <oklokok> yes, i'll call it asdjfkl
22:56:39 <RodgerTheGreat> bingo
22:56:46 <oklokok> (that didn't exactly meet the demands, but you get the joke)
22:56:57 <oklokok> *requirements
22:56:59 <RodgerTheGreat> like the finish equivalent of ETA
22:57:51 <oklokok> eta?
22:58:10 <RodgerTheGreat> I'm working on a link
22:58:16 <RodgerTheGreat> http://esoteric.voxelperfect.net/wiki/ETA
22:58:21 <RodgerTheGreat> damn esolang is slow today
22:59:29 <oklokok> etaoinshrdlu
22:59:39 * ehird` got that
22:59:41 <ehird`> :)
22:59:49 <RodgerTheGreat> haha
23:00:30 <oklokok> in finnish... "tan..." i think
23:00:38 <ehird`> there needs to be a new subclass of esoteric language
23:00:46 <oklokok> but i haven't done any code breaking in finnish
23:00:49 <oklokok> so i don't remember
23:00:56 <ehird`> not just for the humour value - like Brainfuck and just about all of the ones on the wiki - but for the rael meaning of esoteric
23:01:12 <ehird`> an experimental language, not designed for practical use, but for more than just "ha ha ha ha!"
23:01:24 <ehird`> a question, as such. "what does this imply?"
23:01:47 <lament> um.
23:01:58 <lament> brainfuck isn't for humor value
23:02:04 <ehird`> it isn't serious though
23:02:04 <lament> brainfuck is for making a small compiler
23:02:07 <ehird`> yes, exactly
23:02:12 <ehird`> "oh look how small i can make this lollerskates"
23:02:13 <lament> and befunge is for making compilation difficult
23:02:18 <ehird`> yeah exactly
23:02:20 <oklokok> also, for cerebral sex value
23:02:29 <ehird`> that's not a "what do these rules imply?"
23:02:31 <ehird`> it's not an experiment
23:02:35 <ehird`> it's just silliness
23:02:39 <ehird`> of course
23:02:43 <ehird`> silliness is all well and good
23:02:43 <RodgerTheGreat> brainfuck is one of the more utilitarian esolangs, really
23:02:45 <lament> ehird`: then consider SMETANA.
23:02:51 <ehird`> but perhaps the experiments deserve their own subclass
23:03:07 <lament> ehird`: "what do these rules imply" is inherent in all tarpits
23:03:14 <lament> "make this seemingly useless thing and make it work"
23:03:19 <lament> s/"make/"take
23:03:29 <ehird`> not really
23:03:33 <ehird`> you know what i'm trying to say
23:03:47 <lament> well
23:03:51 <lament> there're research languages
23:03:54 <lament> haskell is one
23:04:15 <ehird`> haskell is a good example!
23:04:20 <ehird`> but it's practical enough to not be esoteric
23:04:42 <ehird`> what i'm describing is a blend of haskell's research and experimental ethic with the esoteric any-idea-goes ethic
23:04:46 <ehird`> =p
23:05:23 <lament> befunge is an experiment in compilation :)
23:05:29 <ehird`> heh :p
23:05:40 <lament> much of research around esolangs is metaprogrammatic
23:05:44 <ehird`> wasn't it originally an experiment in the *lack* of compilation? :)
23:06:07 <lament> same thing
23:06:16 <lament> "here, take this thing and write an efficient compiler for it"
23:06:18 <lament> same with brainfuck
23:06:35 <lament> trying to make an optimizing brainfuck compiler is a pretty cool research topic
23:07:14 <ehird`> i have the ideas brewing in my head for an optimizing brainfuck compiler
23:07:21 <ehird`> so many damn things that can be optimized
23:07:27 <ehird`> the compiler source would be large, though
23:08:19 <lament> do it!
23:08:25 <lament> i could never think of anything useful :(
23:08:41 <lament> very hard to find invariants
23:08:52 <lament> some of which are obvious to a human
23:12:02 <ihope> It's impossible to make a perfect optimization... thing.
23:12:14 <ihope> It's easy to improve any optimizing compiler.
23:12:34 <ihope> Assuming that you can compile the optimizing compiler into BF, that is.
23:13:13 -!- Svenstaro has quit (Read error: 113 (No route to host)).
23:13:14 <oklokok> ihope: thanks for stating the obvious :P
23:13:46 <ihope> That's obvious?
23:13:49 <oklokok> oh
23:14:17 <oklokok> perhaps not, sounded obvious
23:14:29 <oklokok> perhaps it was just your maternal tone
23:14:58 <ihope> Maternal tone?
23:15:05 <oklokok> (your mother, if that wasn't obvious enough)
23:15:13 <ihope> Ah... um...
23:15:22 <RodgerTheGreat> problem is, that approach won't make the optimizing compiler optimize better, it'll simply do so with less code, less memory and/or faster
23:15:25 <SimonRC> Making a perfect optimiser is actually the halting problem all over again.
23:15:31 <ihope> As in YOUR MOM?
23:15:44 <SimonRC> ITYM "UR MOM"
23:15:51 <oklokok> ihope: exactly.
23:15:56 <ihope> I didn't say to run the optimizing compiler on itself.
23:16:05 <oklokok> i was trying to make the joke a bit more sophisticated
23:16:08 <oklokok> obviously failed
23:16:13 <RodgerTheGreat> SimonRC: are you certain? I think it should be possible to make a proof of some types of optimization in BF
23:16:27 <RodgerTheGreat> then inductively we could try tackling harder problems
23:16:47 <SimonRC> ah, but an optimiser that always produces the shortest program for a task requires solving the halting problem, I think
23:16:59 <RodgerTheGreat> hm
23:17:03 <ihope> "Run this program through the optimizing compiler. If the result is "+", do something else instead. If the result isn't A, clean up and increment the starting cell."
23:17:08 <oklokok> optimization in general is a superturing thing, that's obvious
23:17:12 <ihope> Something along those lines.
23:17:31 <RodgerTheGreat> well, my point was that you ought to be able to prove something is "perfectly" optimized once you have it
23:17:34 <SimonRC> because it is impossible to calculate non-trivial property of programs
23:17:37 <SimonRC> I remember that from uni
23:17:53 <SimonRC> RodgerTheGreat: ah, but you can't be sure you can prove it
23:17:54 <oklokok> RodgerTheGreat: of course, but you can't make a program that does that for any program
23:17:58 <ihope> Then you can improve the optimizer by making it recognize that exact program. :-)
23:18:00 <ehird`> i never said perfect optimizor
23:18:04 <ehird`> i just said a good one
23:18:05 <ehird`> a very good one
23:18:13 <ehird`> and i have quite a few bf optimizations in my head
23:18:17 <ehird`> some of which would require quite some code
23:18:49 <ihope> "If this program's behavior is described by P, do something not described by P. Otherwise, do something described by P."
23:18:55 <ehird`> hehe
23:18:58 <RodgerTheGreat> oklokok: if we come up with rules we can use for making that type of proof, proving a program is a matter of repeated application of those properties
23:19:01 <ihope> Obviously invalid.
23:19:15 <ehird`> hmm...
23:19:24 <RodgerTheGreat> then, building a proof becomes a mechanical process
23:20:04 <ehird`> H such that H(p(p),p) where p is "x => if H(x,x) loop" just raising an exception is invalid, right?
23:20:06 <oklokok> RodgerTheGreat: yes, but please don't tell me you think it can be done for any program.
23:20:07 <ihope> Rules for doing what?
23:20:12 <ehird`> like, a SemanticallyInvalidProgram exception
23:20:32 <ihope> ehird`: er, you mean making the halt-checker raise an exception upon receiving that?
23:20:33 <oklokok> i mean, mechanically, like have a program that does that for any bf program
23:20:37 <ehird`> ihope: yes
23:20:44 <oklokok> that's very very obviously superturing stuff
23:20:48 <RodgerTheGreat> oklokok: well, can you give a counterexample where that type of approach would beak down?
23:20:53 <ihope> Then it's not a halt-checker, because it doesn't give an answer in that case.
23:21:04 <ehird`> oklokok: waitwait we're talking about the halting problem here
23:21:19 <oklokok> ehird`: ?
23:21:22 -!- GregorR has changed nick to AndersB.
23:21:24 <SimonRC> However Microsoft have found that you can prove/disprove halting of almost all useful programs
23:21:29 <ehird`> Let p x = if H(x,x) loop. Let H be the halting checker. H(p,p) is obviously invalid.
23:21:31 <ihope> RodgerTheGreat: are you asking for an undecidable Turing machine?
23:21:47 <ehird`> However, H(p,p) could just raise an exception, since "p x = if H(x,x) loop" makes /no sense/ when called with p as an argument.
23:21:57 <ehird`> Therefore, a SemanticallyInvalid or similar exception could be raised
23:22:16 <SimonRC> I think spotting that is equivalent to the halting problem too though
23:22:18 <ihope> ehird`: "p x = if H(x,x) loop" is valid if H is valid.
23:22:36 <ehird`> no, because p(p) is a contradiction no matter what
23:22:47 <ehird`> therefore, theoretically a SemanticallyInvalid exception is fine, no?
23:22:50 <ihope> Um...
23:22:55 <ihope> Wait...
23:23:06 <SimonRC> also, you could just add a wrapper that catches the exception and makes it equivalent to one of the other states...
23:23:10 <ihope> Suppose H gives one of three answers: halts, doesn't halt, invalid.
23:23:13 <RodgerTheGreat> I can see how a program that takes input, for example, could yield different results based on said input (or initial state), thus meaning we have to solve the halting problem to determine things like run time and memory usage
23:23:20 <ehird`> ihope: except H wouldn't return
23:23:26 <ihope> What?
23:23:29 <ehird`> ihope: sure, H's return values must be [TRUE|FALSE]
23:23:34 <ihope> What do you mean, it wouldn't return?
23:23:35 <ehird`> but exceptions unwind the call stack
23:23:46 <ehird`> H never finishes execution, therefore H is not an invalid halting checker :)
23:24:04 <ihope> If in any case, \it never finishes executing, it's not a valid halting checker.
23:24:13 <ehird`> well it finishes
23:24:16 <ehird`> it just doesn't complete
23:24:22 <ihope> Finishes but doesn't complete?
23:24:23 <RodgerTheGreat> however, if we consider a subset of BF that does not take input (a uniform initial state), I don't see any reason we can't examine these mathematically
23:24:54 <ehird`> ihope: Sure
23:25:00 <ihope> Um...
23:25:04 <ehird`> the criteria is "H must always terminate"
23:25:06 <oklokok> RodgerTheGreat: you are actually saying there could be a program that can optimize any bf program fully+
23:25:07 <oklokok> ?
23:25:09 <ehird`> termination is not completion!
23:25:36 <RodgerTheGreat> oklokok: accepting some minor caveats representing a subset of BF, I would say yes
23:25:39 <ehird`> oklokok: of course... if state is deterministic, you can spot infinite loops, and optimize away *everything*
23:25:44 <ihope> So if I place a catch thing right around H which returns a third result upon exception, I've turned H into what I just said: a function giving "yes", "no", or "invalid".
23:26:05 <oklokok> how can you spot infinite loops?
23:26:37 <ihope> "Yes" meaning it doesn't halt, etc.
23:26:45 <ihope> Er, that it does.
23:26:52 <ihope> So now P(x) = case H(x,x) of yes -> don't halt; no -> halt.
23:27:11 <ehird`> oklokok: well hey if you spot a [ and know that the current cell will be non-zero (you can know for sure, remember!) and it doesn't decrement it fully in the loop you've got yourself an infinite loop
23:27:14 <ihope> If H(P,P) returns invalid, then obviously P *is* invalid, since it doesn't handle the "invalid" case.
23:27:40 <ihope> Suppose we change P to this: P(x) = case H(x,x) of yes -> don't halt; no -> halt; invalid -> halt.
23:27:50 <oklokok> ehird`: what?
23:27:52 <ehird`> ihope: it's still an invalid program
23:27:58 <ehird`> ihope: since it makes no sense, and always contradicts
23:28:06 <ehird`> ihope: therefore H(P,P) is justified in returning invalid
23:28:14 <ihope> If H(P,P) says "yes", it should have said "no". If it says "no", it should have said "yes". If it said "invalid", it should have said "yes".
23:28:15 <oklokok> how do you know whether it's "fully decremented" in the loop?
23:28:25 <ehird`> (logic being that when H returns invalid, all bets are off and dealing with the program you sent it with that input is meaningless and hopeless)
23:28:41 <ehird`> (So "invalid" is never a wrong answer if indeed it leads to a contradiction
23:28:42 <ihope> Hmm...
23:29:04 <ehird`> since P(P) will always lead to a contradiction, H(P,P) can return invalid and no matter how P(P) behaves, H is right
23:29:10 <ihope> ehird`: suppose H can be implemented in BF. This means that P can be implemented in BF as well.
23:29:19 <ehird`> ihope: Yes and?
23:29:43 <ihope> That is, BF without I/O, and everything unbounded.
23:29:47 <ihope> The only way a BF program can be invalid is if it has unmatched brackets.
23:29:53 <ehird`> no
23:29:56 <ihope> Yes.
23:29:57 <ehird`> invalid can be semantics too
23:30:02 <ehird`> and P certainly has invalid semantics
23:30:16 <oklokok> ehird`: are you saying you can alway detect an infinite loop in brainfuck?
23:30:21 <oklokok> if there's no io
23:30:22 <ihope> Suppose H is valid, then.
23:30:24 <ehird`> oklokok: yes
23:30:26 <oklokok> *always
23:30:27 <oklokok> what
23:30:31 <oklokok> you can't be serious
23:30:35 <ehird`> oklokok: well... mostly
23:30:37 <oklokok> ...
23:30:41 <oklokok> no.
23:30:44 <ehird`> yes
23:30:48 <ehird`> see the discussion i'm having with ihope
23:30:50 <oklokok> how ?
23:30:52 <oklokok> okay
23:30:53 <ehird`> ihope: Yes, H is always valid
23:30:55 <oklokok> i shall
23:30:57 <ihope> H exists and is valid. P just runs H, then does a simple thing, so it must be valid as well.
23:30:58 <ehird`> H(H,X) is always YES
23:31:02 <ehird`> ihope: But - no
23:31:17 <ehird`> Since H knows that P is calling H with nonsensical arguments, leading to a contradiction
23:31:43 <ehird`> (H is already going to do crazy high-level analysis anyway, detecting semantic errors like that is hardly hard for it - it's not limited to "oo look a +!")
23:31:46 <oklokok> it sounded like a boring halting problem conversation, can you like make a summary for me?
23:32:03 <ihope> If H is being called with nonsensical arguments, then it's invalid in that case, contradicting the assumption that H is valid.
23:32:03 -!- AndersB has changed nick to GregorR.
23:32:20 <ehird`> ihope: well. No.
23:32:28 <ihope> ehird`: it sounds like you're saying my proof of P => Q is wrong because P => !Q.
23:32:33 <ehird`> Just because a program calls H in a way that makes H return an invalid answer doesn't mean H is invalid
23:32:42 <ehird`> BECAUSE, "invalid" means that all bets are off
23:32:50 <ihope> Oh, let's be formal.
23:32:59 <ihope> More formal, that is.
23:33:16 <ehird`> invalid means "oh look this makes no sense! oh look a flying pig! you can't count on me for this program,input pair any more! you make no sense! i am pink and fluffy! wheeeee"
23:33:20 <ehird`> heh. less formal :_
23:33:21 <ehird`> *:)
23:34:32 <RodgerTheGreat> if our BF subset has output capabilities (but no input), and we define a "useful" program as one that produces output and halts, it is absolutely possible to create a "perfect" optimization, in accordance with our definition of "perfect" in terms of runtime, memory usage and code length
23:35:04 <ihope> Statement P = H is valid for all inputs, returning "halts", "doesn't halt", or "invalid". H(x,y) returns "halts" if x applied to y halts, "doesn't halt" if x applied to y doesn't halt, "invalid" if x applied to y is not valid. H can be implemented in BF with no I/O.
23:35:22 <ehird`> ihope: see that isn't what invalid means
23:35:40 <ihope> You don't agree with my formulation of statement P?
23:35:50 <ihope> What do you want to change?
23:35:52 <ehird`> invalid means literally nothing. it means that nothing is guaranteed, it means nothing makes sense, it means it's confused
23:35:55 <ehird`> it means that you can't count on it
23:36:05 <oklokok> ehird`: so basically... you are saying any infinite loop in a brainfuck loop can be noticed... so you are saying the halting problem can be solved?
23:36:09 <ehird`> also, i hate formalness :p
23:36:21 <ihope> ehird`: being formal is what mathematics is built from.
23:36:26 <ehird`> oklokok: No - I am 99.9999999999999999999999999% likely to be incorrect for another reason
23:36:33 <ehird`> oklokok: I just haven't found that reason yet
23:36:50 <ehird`> ihope: I have no idea how to describe "invalid" in formal-talk
23:36:52 <oklokok> you did say any infinite loop can be noticed
23:36:56 <RodgerTheGreat> the halting problem can be solved trivially on a machine without time or memory constraints
23:37:27 <ihope> ehird`: I advise you to come back when you come up with a formal way of doing that...
23:37:38 <ihope> RodgerTheGreat: and that solution always halts?
23:37:45 <oklokok> RodgerTheGreat: you are wrong
23:37:48 <oklokok> eh
23:37:57 <oklokok> what ihope said, that's a nicer way to say it
23:38:11 -!- QS_E has joined.
23:38:21 <ehird`> ihope: hey, invalid was originally an exception
23:38:29 <RodgerTheGreat> ihope: the problem with your logic here lies in the concept of infinity
23:38:47 <ihope> Oh boy, the concept of infinity.
23:38:50 <ehird`> which also means that if P were to be called, unless it was >deeply, deeply evil (doesn't matter anyway - invalid = boom)< it would stop executing
23:38:50 <RodgerTheGreat> given an infinite amount of time and memory, here's how you solve the halting problem
23:39:04 <ehird`> thus the universe is saved and none of these sticky problems happen
23:39:04 <ihope> ehird`: with a catch statement, you can turn exception into return value. With a case statement and a throw statement, you can do the reverse.
23:39:13 <ehird`> that's not the point
23:39:15 <oklokok> ehird`: are you, or are you not saying any infinite loop in brainfuck can be noticed?
23:39:36 <oklokok> you first said they can be, then something weird
23:39:40 <oklokok> about percentages :P
23:39:41 <RodgerTheGreat> simply store the entire state of the program each clock cycle, and each clock cycle, check if the program has repeated a state
23:39:57 <RodgerTheGreat> repeat until infinity
23:39:57 <ihope> ehird`: therefore, the concepts are equivalent.
23:40:13 <ihope> RodgerTheGreat: it's possible for a program to never halt but still not repeat a state.
23:40:25 <ehird`> ihope: it is? show me a prorgam
23:40:26 <RodgerTheGreat> because a computer is a finite state machine (but, due to infinite memory, our halting-solver is clearly not), we will halt.
23:40:31 <ihope> Assuming that "program" means something Turing-complete, rather than an FSM...
23:40:40 <ihope> ehird`: +[>+]
23:40:51 <ihope> The tape is constantly changing, and it never returns to a state it was in previously.
23:41:15 <sp3tt> +[+] if the cell's capacity is unbounded
23:41:15 <ehird`> True
23:41:17 <RodgerTheGreat> that's not a computer, it's a turing machine
23:41:24 <RodgerTheGreat> a computer has bounded memory
23:41:30 <ihope> RodgerTheGreat: indeed.
23:41:33 <sp3tt> a turing machine does not
23:41:36 <ehird`> the halting problem is for turing machines
23:42:02 <ihope> There are other halting problems.
23:42:19 <oklokok> RodgerTheGreat: of course you can solve the halting problem on a fsm :P
23:42:27 <ihope> But the one for Turing-complete stuff is the one we normally mean when we say "halting problem".
23:42:29 <oklokok> that's not what you said earlier
23:42:49 <RodgerTheGreat> I'm getting there
23:43:31 <RodgerTheGreat> I shall posit that if we extend this concept, an ISM can determine wether an ISM halts in infinite time
23:43:42 -!- QS_E has quit.
23:44:38 <ehird`> i do believe that with my definiton of H the halting problem is kinda-sorta-solvable
23:44:39 <ehird`> well
23:44:45 <ehird`> if you find out how to do the actual halting-detection
23:44:54 <ehird`> that's a bigger problem than paradoxes :)
23:45:03 <RodgerTheGreat> ehird`: that is kinda the hard part
23:45:14 <oklokok> can an ISM solve the halting problem of a superturing machine in uncountable time? :P
23:45:15 <ehird`> the P function is kinda just a last blow
23:45:39 <oklokok> i have no idea what that'd even mean... but my intuition tells me that's true.
23:46:15 <ihope> oklokok: somehow, I think you mean something like time omega*2+c...
23:46:29 <RodgerTheGreat> oklokok: well... if solving the halting problem on an ISM makes something superturing, then... yes?
23:46:39 <ihope> ehird`: "kinda-sorta-solvable"?
23:46:52 <ehird`> ihope: :)
23:46:54 <ihope> Er, oops, am I turning into TRWBW? :-P
23:47:06 <oklokok> ehird`: so you are saying you can just make the halting problem solver function if you just make it notice paradoxes and behave differently on them?
23:47:20 <oklokok> you do understand noticing the paradox is superturing
23:47:32 <ehird`> oklokok: maybe -- you'll have to write code to actually detect inf. loops and paradoxes first :p
23:47:35 <sp3tt> superturing?
23:47:37 <ihope> He's annoyed me somewhat with his "give me a formal definition of the real numbers" stuff.
23:47:39 <ehird`> clearly impossible, of course
23:47:55 <ihope> I can write a halt-checker in... um...
23:47:57 <sp3tt> formal definition of the real numbers, EH
23:47:59 <ehird`> ihope: wow, is he too lazy to look it up for himself?
23:48:00 <sp3tt> link to metamath.org
23:48:30 <ehird`> or http://en.wikipedia.org/wiki/Construction_of_real_numbers :p
23:48:55 <ihope> ehird`: no, I think he knows it. Somebody says something informal (and incorrect) about the real numbers and gives an informal proof, then he asks them for a formal definition of the real numbers, despite the fact that they probably don't know one.
23:49:20 <RodgerTheGreat> who wants to help me build a halting oracle?
23:49:27 <sp3tt> metamath is cooler
23:49:46 <sp3tt> http://us.metamath.org/mpegif/5oa.html
23:50:12 <ihope> Ooh, cool.
23:50:43 <RodgerTheGreat> wow
23:51:27 <sp3tt> i want that on a t-shirt
23:51:39 <sp3tt> and then on the back something like "Math is fun!"
23:52:09 <ihope> Some might say that only an American could wear that on a T-shirt.
23:52:17 <sp3tt> why?
23:52:21 <ihope> I don't know how large Americans actually tend to be, though.
23:52:33 <RodgerTheGreat> the whole idea of linking to every used axiom and definition is pretty awesome
23:53:04 <sp3tt> yeah
23:53:09 <sp3tt> look at the proof for 2+2=4
23:53:40 <RodgerTheGreat> it represents stitching mathematics into an obviously cohesive whole and very clearly presents how everything fits together
23:53:42 <sp3tt> http://us.metamath.org/mpegif/2p2e4.html
23:53:53 <RodgerTheGreat> an awesome use of hypertext
23:54:01 <sp3tt> except for the fact that it makes your brain hurt
23:55:02 <ehird`> proof that 2+2=4: 1 + n -> 0 + Sn -> Sn. Therefore, 1 + 2 -> 3. Sn + m -> S(n + m). Therefore, 2 + 2 = 4
23:55:05 <ehird`> is that good enough :p
23:55:29 <sp3tt> ->?
23:55:38 <sp3tt> neither 1+2 nor 3 is a wff
23:55:59 <ehird`> informal symbol
23:56:13 <ehird`> i meant "is equal to", or really "with expanded functions is"
23:56:29 <sp3tt> ok
23:57:23 <ihope> Just say that 2 = 1+1 and 4 = 1+1+1+1 and you get it by associativity.
23:57:41 <sp3tt> of course, but then you need to prove associativity
23:58:00 <ihope> Not if your axioms include associativity!
23:58:18 <ehird`> ok, here's my proof in kinda-formalness:
23:58:25 <ehird`> x + 0 = x
23:58:35 <sp3tt> ihope: well, then my axioms include 2+2=4
23:58:37 <sp3tt> IN YOUR FACE
23:58:53 <ihope> Heh.
23:58:55 <ehird`> Sx + y = y + (x + y)
23:58:58 <ehird`> wait, that's wrong isn't it
23:58:59 <ehird`> oh whatever
23:59:01 <ehird`> you know, +
23:59:01 <ihope> Yup.
23:59:03 <ehird`> that nice function thing
23:59:06 <ehird`> SO
23:59:17 <ihope> Maybe we should define Sx + y = y + (x + y)!
23:59:17 <ehird`> 1 + x = 0 + Sx
23:59:25 <ehird`> 0 + x = x
23:59:30 <ehird`> 1 + x = Sx
23:59:35 <ehird`> 1 + 2 = S2
23:59:35 <sp3tt> where ! is the factorial!
23:59:37 <ehird`> S2 = 3
23:59:41 <ihope> 2 + 2 = 2 + (1 + 2) = 2 + (2 + (0 + 2)) = something.
23:59:45 <ehird`> Sx + y = S(x + y)
23:59:45 <sp3tt> that could be.. difficult though
23:59:51 <ehird`> S1 = 2
23:59:55 <ehird`> 2 + 2 = 4
←2007-08-10 2007-08-11 2007-08-12→ ↑2007 ↑all