00:00:07 Uggh. You reminded me of an awful SAT article. 00:00:16 one could say that it's rejection of traditional artistic concepts is indeed annoying 00:00:35 the SAT was easy. I enjoyed it the most the second time I took it. 00:00:56 I was really quite disappointed with some of the revisions, however. 00:01:37 Hmm. What did you get? 00:02:09 1320. it served my purposes 00:05:10 that's with the latest revision. The national average is approximately 1028 00:05:20 a perfect score would be 1600 00:07:34 (this is for the multiple-choice versions of the test) 00:07:54 s /versions/sections 00:16:43 Ah. 00:46:53 -!- Anders has changed nick to anders. 00:53:18 -!- ihope has joined. 00:55:26 * bsmntbombdood wastes more time not coding esoteric languages 00:55:53 Hasp! 00:56:09 (As opposed to "gasp", a very different word.) 00:56:15 Hasp? 00:56:30 hasp: a new esoteric language horrendously mixing haskell and lisp 00:56:35 hmmm 00:56:42 brainfuck + stack == bliss 00:57:01 http://en.wiktionary.org/wiki/hasp 00:57:19 * bsmntbombdood has an bf extension 00:58:20 _ puts the current cell on the stack 00:58:31 ^ pops the stack into the current cell 00:59:45 but if two stacks can emulate a tape, isn't this then essensially a three-stack language? 01:00:17 *essentially 01:01:28 now if we used four stacks and let <>^V all act analogously... 01:01:41 wait 01:01:49 2 stacks can emulate a tape? 01:02:03 certainly. 01:02:12 explain 01:02:21 oh wait 01:02:22 I get it 01:03:25 to go over one you just do b.push(a.pop()) 01:03:46 exactly. 01:04:42 but a tape can't emulate 2 stacks 01:05:04 unless you have two pointers 01:05:05 not without some heavy copying, i assume 01:05:53 actually, if you have one reserved symbol you could do it with merely a lot of movement 01:06:28 by putting the tops of the stacks at either _end_ of the tape 01:06:45 and letting the bottoms meet in the middle 01:07:05 assuming the tape is infinite in both directions. 01:07:14 tapes are endless 01:07:51 otherwise you could still do it by keeping one stack on the odd addresses and the other on the even ones. 01:08:08 sometimes they are endless just in one direction. 01:08:37 you would still need an extra pointer 01:08:46 but of course all of these _can_ emulate the others, being enough for turing-completeness 01:09:28 not trivially 01:09:29 no, you just put the reserved symbol on the top positions, and search for them. i am not saying there would be constant-time access. 01:09:57 that would work 01:10:16 Then a tape can emulate any number of stacks 01:10:28 if you have a reserved character 01:11:09 if you don't then you can code one character set as strings in another. 01:11:40 ? 01:12:57 you can for example code the stack abcdef as 0a0b0c0d0e0f1 01:13:17 yeah 01:15:05 two stacks can emulate any number of tapes 01:15:40 i think 01:15:45 I don't see why you couldn't do 2 stacks in a single tape. . . 01:16:07 |s1|s2|s1|s2|. . . 01:16:17 i thought that was what i just said! 01:16:36 yeah 01:16:41 about odd and even addresses 01:16:41 Or just: 01:16:52 |s1|c|s2|c|. . . 01:17:25 (c would be used for stopping a loop for finding stack locations (in Brainfuck).) 01:17:46 that would be combining the two techniques we just discussed. 01:18:00 * pikhq looks back. 01:18:03 . . . Oh. 01:18:24 Didn't pay attention. ;) 01:19:51 it's ok. we hadn't made it explicit how to combine them. 01:20:01 I didn't even read the whole discussion. 01:26:40 ooooh 01:26:47 imagine if we had a tape of stacks 01:28:32 imagine if the contents of stacks were stacks 01:31:10 imagine if the contents of the contents were contents! 01:31:47 imagine if the imagination of the images were imagined! 01:32:43 a recursive stack wouldn't work 01:32:55 sure it could. 01:32:55 you wouldn't be able to put any data in it 01:33:15 unless it held two different data types 01:33:20 you could distinguish empty stacks 01:34:51 this is probably rather equivalent to lists in Lisp that only contain lists. 01:35:31 how would you put data in it? 01:36:00 also, it resembles somewhat the coding of set theory, where every element of a set is a set and you can still emulate any mathematical object 01:36:27 well, let 0 = [], 1 = [[]]. 01:36:51 now you have enough for a stack of bits... 01:37:13 i'm not quite sure you can emulate any mathematical object with just sets 01:39:00 bah, i suppose you can. 01:39:19 just about any. there are some issues with proper classes that create paradoxes if you make them sets. 01:40:08 i wonder if it's provable? 01:40:16 oh, true, there's classes 01:40:26 so it's disprovable 01:41:01 however you can sort of get around that by assuming your classes live as sets in an even larger universe 01:41:39 nah, that's silly 01:43:44 it's not so silly. there are researchers in logic/set theory that investigate large cardinalities that if they exist, imply there are smaller universes inside your set theory 01:44:15 brainfuck plus stack, eh? 01:44:21 that actually sounds useable. 01:45:07 and if you want to investigate category theory with set theory, you need to make such assumptions to allow you to build the categories you want (categories are major sources of proper classes) 01:45:42 oerjan: it's not silly in itself, it's silly as a way of reducing all mathematical objects to sets because it doesn't work 01:45:43 -!- puzzlet has quit (Client Quit). 01:46:09 oerjan: unless you accept paradoxes and treat ZFC as a paradox-free part of the whole universe 01:46:11 -!- puzzlet has joined. 01:46:25 but, er, i don't think that's generally done 01:47:52 but large cardinalities are essentially about accepting ZFC as a part of something larger. but their existence cannot be proven because of Gõdel's theorem. 01:48:37 you mean something larger but paradox-free? 01:48:49 hopefully paradox-free, yes. 01:49:07 right 01:49:22 but i think as long as you try to have "everything is a set", you can't possibly escape russel's paradox 01:49:39 so no matter what paradox-free stuff you have, you will also have non-paradox-free stuff 01:49:46 it actually combines both Gõdel's completeness theorem and his incompleteness theorem. 01:50:57 the completeness theorem says that if you have a model of set theory that is a set, then set theory is consistent, while the incompleteness theorem shows that set theory cannot prove itself consistent. 01:51:49 that doesn't prove much, does it. 01:52:07 so you can never prove that there are smaller universes, unless you are already inconsistent. 01:53:41 not sure how that's relevant. 01:55:56 well, it means that while you might be alright assuming all of your mathematics fits into a smaller set, you can never prove it for sure. 01:56:16 "smaller"? 01:56:47 small enough to be a set rather than a class. 01:57:04 how can you possibly fit "the set of everything" that way? 01:58:10 let me try a different tack, which actually is more relevant to making everything a set. 01:58:51 Gõdel's completeness theorem says that any mathematical theory which is consistent can be modeled as a set. 02:00:28 to me that just seems to imply that "the set of everything" is not an object in that model. 02:00:39 sorry, in that theory. 02:01:24 there is a problem though: if the theory itself talks about sets then the model might represent them as something different than the set of their elements 02:02:00 right. I guess you could just have a special flag for "whether this set is a set of everything" 02:03:40 well, any "normal" set theory which allows subset comprehension cannot have a set of everything without running into Russell's paradox. 02:05:04 anyway 02:05:08 that flag would probably be something like the distinction between proper class and set 02:05:10 like most of set theory 02:05:20 this discussion is utterly pointless :) 02:05:43 so we should turn to point set topology then? :) 02:05:48 nobody seriosly tries representing everything as sets 02:05:55 heh 02:06:08 the ZFC foundation of mathematics does so. 02:06:13 exactly 02:06:17 a bunch of wankers :) 02:06:26 well, the ZFC doesn't, they freely admit classes 02:06:49 actually they don't it is NBG which does that 02:07:15 slightly different formulation with equivalent results for sets 02:07:26 well, either they freely admit classes or they simply don't consider a whole class of mathematical objects. 02:07:48 (von Neumann - Bernays - Gõdel, I think) 02:08:42 "class of everything" is clearly a mathematical object, doesn't create any paradoxes, behaves nicely in every respect, and is even rather boring. 02:08:47 nono, there is no class of classes :) 02:09:25 there is however a class of every set 02:10:08 if you want a class of classes you need to add some type theory or large cardinality embedding 02:10:36 haha 02:10:55 all i want is numbers :) 02:10:57 1 + 1 = 2 02:11:11 why then we are all set with the von Neumann cardinals. 02:11:24 no, no 02:11:26 ordinals rather 02:11:28 i don't want sets 02:11:32 i just want numbers 02:11:40 :) 02:11:43 1 + 1 = 2 02:11:49 fine, use Peano arithmetic. 02:12:45 hmmm... 02:12:53 i wouldn't even use that 02:13:03 i would just use integers :D 02:13:27 um, Peano arithmetic uses only natural numbers 02:13:36 even less 02:14:06 i mean, i don't need to bother constructing stuff 02:14:14 i will just use integers :) 02:14:16 So... 02:14:35 after all i've been learning for like 18 years how to use them 02:15:06 newoperator $ newoperator $ print param1 + param2 02:15:20 1 newoperator 23 02:15:23 24 02:15:29 well, if you are willing to use induction, then all you know about integers probably includes Peano arithmetic already 02:15:58 sure 02:16:21 what language is that? slightly resembles haskell but not quite 02:16:55 slightly resembles a horrible haskell slash forth derivative? 02:17:15 Not haskell.. just some concept I made up. 02:17:24 nah, newoperator looks infix to me 02:17:36 for a programming language that allows you to define new operators with customized grammatical structure. 02:17:45 oerjan: what CakeProphet just said. 02:18:14 oerjan: that's Forth, and syntax seems to be forthish 02:18:24 forth doesn't even have to be postfix, of course 02:19:37 (operator name) $ (grammatical syntax) $ (definition) 02:19:51 CakeProphet: how do you know where the definition ends? 02:20:15 *shrugs* Dunno... I'll think of that later. 02:20:22 eh 02:20:28 i suggest you think about it reasonably soon :) 02:21:08 Could probably just denote it with a blank line. 02:21:17 yeah 02:21:24 or a more visible token 02:21:26 Unless people absolutely cherish the ability to make blank lines for logical divisions. 02:22:04 you could use indentation 02:22:13 and then the other principle I had was "mutual association" 02:22:14 or something like . 02:22:20 . works :D 02:22:36 phew, punctuation :( 02:22:36 Let's say % is the operator for mutual association 02:22:43 x % 2 02:22:47 okay, not . 02:22:48 x returns 2 02:22:51 2 returns x 02:22:53 oerjan doesn't like 2 02:22:55 er 02:22:59 oerjan doesn't like . 02:23:05 use :( instead, he clearly likes that :) 02:23:06 fuck oerjan 02:23:17 Hmmm... actually 02:23:21 :P 02:23:28 We'll use :P for the end-of-definition 02:23:32 heh 02:23:46 so, x returns 2, 2 returns x 02:23:48 now what? 02:23:57 That was pretty much it... 02:24:01 in that case you should use :( and :) for the first and second $, respectively. 02:24:17 are you sure you want 2 to return stuff? it's a number after all 02:24:21 If we wanted to make it more esoteric... we could have numbers return their ASCII character correspondent... and have characters return their ASCII ordinals. 02:24:27 oerjan: speaking of 2 returning stuff, functions are so much cooler than sets. 02:24:44 Don't see why not... having rules is for silly people 02:24:55 Make anything associationable. 02:25:17 oerjan: especially if you allow functions to never terminate to avoid all the boring turing issues 02:25:35 resembles FORTE a bit in that way 02:26:19 that doesn't avoid anything... 02:26:21 (allow functions to never terminate but still return a value, that is) 02:26:30 :P 02:27:10 and then <>'s denote an argument for the operators local scope. 02:27:23 with everything else just being themselves (or something they return if they have an association) 02:28:06 that still doesn't avoid anything. 02:28:40 sorry, what i meant is 02:28:41 remember, the halting problem is essentially the computation version of Russell's paradox. 02:29:23 have all functions return a value, which might require infinite computation 02:30:08 Hmmm.. I need a langauge that has indexed functions... simply because that would be strange 02:30:25 indexed? 02:30:26 CakeProphet: you mean functions that behave like arrays? 02:31:06 that would just be a different syntax for function calling 02:31:28 oerjan: there's no halting problem when everything halts :) 02:31:59 Hmmm... 02:32:22 so then.... []'s could denote optional gramatically particles in the operators syntax... 02:32:30 no, but you could construct a paradox of sorts. 02:32:44 so... the grammar definition would basically look like all those syntax explainations you see. 02:33:37 right, some form of BNF. 02:33:44 oerjan: yeah, i'm sure you could. 02:34:26 (but not sure how) 02:34:46 blah $ [with [in ] ] # (code code code code) :P 02:34:55 :P being the end-of-definition token. 02:35:11 suppose you have a function x=-x, what would that return... 02:35:11 actually there might not be a paradox, it would just have strange semantics. 02:35:19 very strange semantics indeed 02:35:42 (i guess that function ought to return 0 :D) 02:37:04 x=x+1 returns infinity... 02:37:55 x=x returns...uh... 02:38:15 the problem appears if there is no reasonable fix point for the x = f(x). 02:38:19 and \ would be the standard "ignore special stuff associated with the next character" thing. 02:39:03 So you could put brackets and tags in your gramar definition without the parser reading it as part of the definitions structure. 02:39:16 oerjan: yes, but isn't there one always? 02:39:24 the problem with such a scheme is that the syntax will easily become ambiguous if it is too flexible. 02:39:41 Yes but... I don't care... so it works. 02:39:52 :P 02:39:53 CakeProphet: do look at forth, which works similarly 02:40:14 you can define new stuff on the fly 02:40:22 what about x=not x ? 02:41:02 oerjan: hm... type error? :) 02:41:05 Well.... with some more polishing... this concept-language would make an excellent language-construction language. 02:41:48 how is there a type error? 02:42:05 oerjan: i guess if x=x+1 returns infinity (which is not a number) then x=not x returns some kind of Maybe (which is not a boolean) 02:42:34 In Python.... x = not x returns the opposite boolean value.... so infinity would have to have some sort of boolean value. 02:42:44 so the type of the function cannot be deduced simply from what functions it uses internally 02:43:11 'not' takes booleans, but we extend it to include the fixed point. 02:43:37 explicitly define a value as "that which is the fixed point of x=not x" and return that :) 02:43:48 but then infinity becomes essentially a bottom value, in that any function applied to infinity is infinity. in the haskell semantics, this is equivalent to nontermination. 02:44:33 x = not infinity could just return None (or nil, or void... depending on your naitive language) 02:45:07 but then infinity would not be a fixpoint of x = not x, and so couldn't be returned by it. 02:45:08 say As something that is not in everything is nothing. :D 02:45:09 -!- GregorR-L has joined. 02:45:34 i don't want x = not x to return infinity 02:45:49 by 'infinity' i meant 'the fixed point of x=x+1' :) 02:46:20 yes, i was referring to cakeprophet's suggestion 02:46:35 "every type can be extended to include the fixed point of a function returning a value of that type" seems reasonable 02:47:13 in haskell i suppose the extension is always Bottom but does it have to be? 02:47:52 x=-x returning 0 is already different semantics from Haskell though. 02:48:12 x=x would return..... uhh... a randomly chosen fixed point? the class of Everything? dunno.. :) 02:48:43 if you do randomization, then why not just let x=not x return randomly True or False... 02:48:59 because those are not the fixed points of that function. 02:49:28 you could return sets (:C 02:49:42 x = x or false would return randomly true or false :) 02:49:46 x=not x returning {True,False} 02:49:57 no 02:50:10 it should return the fixed point 02:50:34 otherwise it's kinda pointless... 02:50:36 ..and adrift... 02:50:40 but {True,False} would be a fixed point of not, if it acted pointwise. 02:50:47 oh 02:50:54 right 02:51:37 then x=x+1 would return Z 02:52:45 x=x^2 would return the set of all squares :) 02:53:13 actually no. because not all squares are squares of squares. 02:53:27 er, right 02:53:38 in fact you would probably return {0, infinity} 02:53:42 1 02:53:47 that too 02:53:47 0,1,inf 02:54:22 well, inf is not a number so just 0,1 02:54:27 assuming the default type is integers 02:54:42 but then what about x = x^2+1? :) 02:54:47 Hmm.. yeah FORTH looks similar to my idea... but it seems to use different structures and stuff... 02:55:19 oerjan: that would return "a newly added integer equal to its own square plus 1" 02:55:35 ...i can see potential for abuse :) 02:56:15 you might do something with nonstandard analysis 02:56:20 i guess that "newly created integer" IS bottom after all 02:56:29 well, almost 02:56:37 since most of the operations are undefined for it 02:57:45 call this "new integer" q, then q-1 just returns "a newly created integer r", and sqrt(r) returns q 02:58:17 ...now i'm pretty sure there's gotta a paradox somewhere. 02:58:49 well, it should satisfy q % 3 == 2 02:59:35 it satisfies a bunch of things 02:59:43 some of which will probably lead to contradictions 03:00:18 now, what about x = if x == 0 then 1 else 0 03:00:42 well, obviously that can't return 0 or 1 03:01:11 although if we use sets like you suggested, then it's just {0,1} 03:01:31 hm 03:01:57 hm... this reminds me of Icon iterators. 03:02:02 hm. 03:02:29 i guess it would return a "newly created integer that is both equal and not equal to zero and one"? :))) 03:02:34 because obviously {0,1} == 0 would have to give {True, False} 03:02:54 and then the if would need to take both branches 03:02:56 yes, so both 'then' and 'else' are followed 03:03:05 so it returns {1,0} as expected 03:04:30 oerjan: i guess the language cannot have an "object identity equality" operator 03:04:38 this reminds me a lot of non-standard analysis, where you add infinite numbers in a consistent way 03:04:47 oerjan: that always returns true when the operands are the same, and false otherwise 03:04:49 apparently not 03:05:01 but if we disallow that, there're no problems once again. 03:05:14 your function returns something like 0.5 and == has integer semantics. 03:06:14 actually that description fails on x = if x == 0 then 2 else 0 03:06:48 Hooks are extremly powerful weapons of mass destruction. 03:07:04 what kind of hooks are these? 03:07:25 oerjan: by "0.5" i mean "a newly created integer that's equal to both 0 and 1" 03:07:31 The kinds that are performed before or after something else automagically. 03:08:09 ah, this thing i've heard mentioned called aspect oriented programming? 03:08:30 oerjan: hmmmmmmmmmmmmmm 03:08:32 Probably. 03:08:46 oerjan: if it does return such an integer 03:08:56 oerjan: then it's effectively the same as returning {0,1} 03:09:22 call that integer s, then s+s is "new integer that's equal to 0,1 and 2" etc 03:09:27 yes. it seems to me that if x = f(x) goes through a bounded set then it will return that set. 03:09:34 so we can't avoid returning sets 03:09:36 * bsmntbombdood thinks of a language that has 3 instructions 03:09:49 ah, there is a problem. 03:10:05 it should really just be equal to 0 and 2 03:10:10 * pikhq notes that it's probably already been done 03:10:21 because s+s == 2*s 03:10:34 oerjan: no 03:10:53 oerjan: we don't consider the integers to be a ring anymore 03:11:13 we're not in Kansas anymore... 03:11:14 oerjan: just treat them as a type with operations + and * defined on the "original" integers so that they form a ring 03:11:28 but they could and will act differently on sets 03:11:50 i think the semantics is turning out even weirder than i expected. 03:11:58 haha 03:12:21 but no paradox so far! :) 03:12:23 Forth not FORTH! 03:12:31 @ Everyone. 03:12:47 well, you can easily avoid paradox if you are willing to remove all your theorems :) 03:12:51 @ takes two arguments, not one. 03:12:54 oerjan: :) 03:13:07 Actually, @ only requires one item already on the stack. 03:13:07 oerjan: it's a programming language, who needs theorems? 03:13:27 oerjan: everything will still work provided your program takes care to halt in the "usual" way 03:13:47 oerjan: and if it doesn't, everything will work "differently" but still in a predictable fashion 03:14:03 Warning: this language solves the halting problem by doing even more unspeakable things... 03:14:39 Warning: this language is in violation of the Laws Of turing. 03:15:04 s/turing/Turing/ 03:15:10 Turning 03:15:11 ! 03:15:15 Huh? 03:15:24 Not you EgoBot. Go back to sleep. 03:15:57 OK. 03:16:09 !help 03:16:13 help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon 03:16:15 1l 2l adjust axo bch bf{8,[16],32,64} funge93 fyb fybs glass glypho kipple lambda lazyk linguine malbolge pbrain qbf rail rhotor sadol sceql trigger udage01 unlambda whirl 03:16:23 What's Rail? 03:16:27 Don't tell me it's Ruby on Rails. 03:16:36 !help rail 03:16:39 To use an interpreter: Note: can be the actual program, an http:// URL, or a file:// URL which refers to my pseudofilesystem. 03:16:44 Yes. Very helpful. 03:17:01 !bf_txtgen hi bob 03:17:02 !rail 1 03:17:05 Internal Error: Crash: No 'main' function found 03:17:08 !rail main 03:17:10 !rail main 03:17:12 Internal Error: Crash: No 'main' function found 03:17:13 69 ++++++++[>+++++++++++++>++++++++++++>++++><<<<-]>.+.>>.<++.<++++++.>. [97] 03:17:13 Guh. 03:17:15 Internal Error: Crash: No 'main' function found 03:17:23 !bf ++++++++[>+++++++++++++>++++++++++++>++++><<<<-]>.+.>>.<++.<++++++.>. 03:17:23 !rail main { 4 } 03:17:25 hi bob 03:17:27 Internal Error: Crash: No 'main' function found 03:17:37 !bf_txtgen hi bsmntbombdood 03:17:39 What is this ``rail'' hmm.... 03:17:42 Rail was invented by User:Duerig in 2005. It is a two-dimensional language along the lines of Befunge and PATH. 03:17:51 Aha 03:17:51 . 03:17:53 111 +++++++++++++++[>+++++++>++++++++>+++++++>++<<<<-]>-.>>.>++.<<<------.>-----.>++++.+.<+.<.>-----.>-.<<.++.>..<. [640] 03:18:03 Thank you for switching to your browser which I will not. 03:18:30 !bf +[] 03:19:07 !ps d 03:19:11