00:21:28 <salpynx> The wiki needs a page for BQN, it seems to be a popular current APL-like, and is referenced a few times from some articles already. https://mlochbaum.github.io/BQN/
00:59:41 -!- Koen_ has quit (Quit: Leaving...).
01:29:21 <esolangs> [[Talk:ImTooLazyToMakeAnActuallyGoodEsolang]] N https://esolangs.org/w/index.php?oldid=131935 * EvyLah * (+194) Created page with "it would be really funny if I changed <code>,</code> to <code>/</code> so you could create "morse code". ~~~~"
01:31:21 <esolangs> [[BQN]] N https://esolangs.org/w/index.php?oldid=131936 * Salpynx * (+221) I know nothing about this, just found a series of 'inspired by BQN' references and was surprised there was no article yet
01:34:52 <esolangs> [[Empty]] https://esolangs.org/w/index.php?diff=131937&oldid=131670 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+268) /* Programs */
01:35:41 <esolangs> [[Empty]] https://esolangs.org/w/index.php?diff=131938&oldid=131937 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+8) /* Calculator */
01:35:50 <esolangs> [[Zirconium]] M https://esolangs.org/w/index.php?diff=131939&oldid=106986 * Salpynx * (+4) /* External links */ link to BQN
01:36:12 <esolangs> [[Empty]] https://esolangs.org/w/index.php?diff=131940&oldid=131938 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+7) /* 99 bottles of beer */
01:38:16 <esolangs> [[Quiner]] M https://esolangs.org/w/index.php?diff=131941&oldid=124422 * Salpynx * (+4) /* Interpreters */ link to BQN
02:04:52 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] N https://esolangs.org/w/index.php?oldid=131942 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+1601) Created page with "''' 'Python' is not recognized as an internal or external command, operable program or batch file.''' is made by ~~~~ ===
02:05:19 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131943&oldid=131942 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+17)
02:06:05 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131944&oldid=131943 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+29)
02:06:15 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131945&oldid=131944 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+1) /* truthmachine */
02:07:19 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131946&oldid=131945 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+0) /* truth-machine */
02:12:08 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131947&oldid=131946 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+59)
02:12:33 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131948&oldid=131947 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (-157)
02:12:50 <esolangs> [[User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff]] https://esolangs.org/w/index.php?diff=131949&oldid=131543 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+100)
02:13:27 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131950&oldid=131948 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+29)
02:14:38 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131951&oldid=131950 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (-2) /* quine= = */
02:14:54 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131952&oldid=131951 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+8) /* program */
02:15:51 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131953&oldid=131952 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+114) /* program */
02:16:36 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131954&oldid=131953 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+62) /* commands */
02:17:20 <Sgeo> Is there a reference for what "Audio Test" is supposed to sound like? My attempt to make a reference doesn't quite sound like what I've heard
02:19:20 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131955&oldid=131954 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+113) /* program */
02:21:47 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131956&oldid=131955 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+62)
02:22:08 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131957&oldid=131956 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+9) /* /// program */
02:23:26 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131958&oldid=131957 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (-36) /* Slashes program */
02:23:45 <esolangs> [['Python' is not recognized as an internal or external command, operable program or batch file.]] https://esolangs.org/w/index.php?diff=131959&oldid=131958 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+7) /* \ */
02:25:10 <esolangs> [[Maybe]] https://esolangs.org/w/index.php?diff=131960&oldid=126816 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (-2)
02:44:31 <Sgeo> I have no intuition for how ByteByteJump can do calculations
02:58:11 <zzo38> I think you would have to use lookup tables to make calculation
03:01:41 <Sgeo> Hmm, do the addresses have to be larger than a byte? That... makes it make more sense, you could.. modify a part of a destination address?
03:14:40 -!- X-Scale has joined.
03:53:02 <Sgeo> "Well, since we have no ALU, arithmetic/logic operations have to be performed by way of table lookups, which requires X to be ≥ 2 for the machine to function at all."
04:38:35 <esolangs> [[Talk:BytePusher]] https://esolangs.org/w/index.php?diff=131961&oldid=88581 * Sgeo * (+338) /* Audio from "Audio Test" */ new section
04:59:14 <esolangs> [[Talk:BytePusher]] https://esolangs.org/w/index.php?diff=131962&oldid=131961 * Sgeo * (+2) Fix typo in repo name
05:30:16 -!- Sgeo has quit (Read error: Connection reset by peer).
05:58:46 <esolangs> [[Conedy]] https://esolangs.org/w/index.php?diff=131963&oldid=57016 * Salpynx * (+160) It's a little hard to confirm this interpreter is totally correct, it might need tuning. Bug reports more than welcome!
06:28:48 -!- X-Scale has quit (Ping timeout: 250 seconds).
06:36:21 -!- tromp has joined.
07:50:44 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
08:14:16 -!- tromp has joined.
08:30:55 <b_jonas> Sgeo: so BytePusher uses 3-byte long addresses and copies one byte at a time. The easy way to do calculations would be to have full 64k sized lookup tables for an arithmetic operation, which you may be able to afford if you have lots of RAM or ROM, or cheat by simulating ROM with hardware or software that computes the result from the lookup table on the fly. But it turns out you don't actually need full
08:31:01 <b_jonas> 64k lookup tables, you can get away with just some 4k sized ones. Eg. have a 4k sized lookup table with hex address FE0uxy with value uy to get the low nybble of a byte xy, then one at hex address FE1uxy with value ux to isolate the high nybble, then a 4k sized table at FE2yzw with value zw+0y to add the a nybble, and a 4k sized table at FE3xzw with value zw+x0 to add a high nybble, and then to do the
08:31:07 <b_jonas> addition zw+xy you first use the first table at FE02xy to get 2y and then you use that 2y to look up FE2yzw to get the intermediate result zw+0y, let's call that st, then look up FE13xy to get 3x, then use that to look up FE3xst to get the final result st+x0 of the addition. You can do subtraction and bitwise ops in a similar way, and even multiplication with an extra addition step using a table to
08:31:13 <b_jonas> multiply with low nybble and another table to multiply with high nybble. Then you can use a few more helper tables to get comparisons and the carry of addition so that you can build multi-byte integer arithmetic too.
08:31:17 <b_jonas> I admit I don't like this model of computation, but it is workable.
09:04:13 <b_jonas> and of course since basic arithmetic is such a common need, you'd put a bunch of tables and common subroutines like this into your ROM or KERNAL or operating system or standard library to share them among most programs ran on the computer
09:13:18 <salpynx> `mediatype:texts AND language:(ukr OR Ukrainian) AND scanningcenter:*` is what I used with the ia client tool. Yes, I was hoping for more too :(
09:13:20 <HackEso> mediatype:texts? No such file or directory
09:56:50 <esolangs> [[Welcome to Esolang, the esoteric programming languages wiki!]] https://esolangs.org/w/index.php?diff=131964&oldid=114186 * Ractangle * (+33) /* Example */
09:57:04 <esolangs> [[Welcome to Esolang, the esoteric programming languages wiki!]] https://esolangs.org/w/index.php?diff=131965&oldid=131964 * Ractangle * (+17) /* Quine */
09:58:20 <esolangs> [[Welcome to Esolang, the esoteric programming languages wiki!]] https://esolangs.org/w/index.php?diff=131966&oldid=131965 * Ractangle * (-10) /* Quine */
10:01:12 -!- salpynx has quit (Quit: Leaving).
10:01:40 -!- wib_jonas has joined.
10:33:37 -!- __monty__ has joined.
10:45:20 <esolangs> [[Special:Log/move]] move * Ractangle * moved [[User:Ractangle/Inded]] to [[User:Ractangle/None,]]
10:53:33 <esolangs> [[User:Ractangle/None,]] https://esolangs.org/w/index.php?diff=131969&oldid=131967 * Ractangle * (+300)
10:53:45 <esolangs> [[Special:Log/move]] move * Ractangle * moved [[User:Ractangle/None,]] to [[Ractangle/None,]]
10:54:02 <esolangs> [[Special:Log/move]] move_redir * Ractangle * moved [[Ractangle/None,]] to [[User:Ractangle/None,]] over redirect
10:54:02 <esolangs> [[Special:Log/delete]] delete_redir * Ractangle * Ractangle deleted redirect [[User:Ractangle/None,]] by overwriting: Deleted to make way for move from "[[Ractangle/None,]]"
10:54:41 -!- X-Scale has joined.
10:57:36 <esolangs> [[User:Ractangle/None,]] https://esolangs.org/w/index.php?diff=131974&oldid=131972 * Ractangle * (+135)
11:01:02 <esolangs> [[User:Ractangle/None,]] https://esolangs.org/w/index.php?diff=131975&oldid=131974 * Ractangle * (+13) /* Commands */
11:01:33 <esolangs> [[User:Ractangle/None,]] https://esolangs.org/w/index.php?diff=131976&oldid=131975 * Ractangle * (+148) /* Hello, world! */
11:03:37 <esolangs> [[User:Ractangle/None,]] https://esolangs.org/w/index.php?diff=131977&oldid=131976 * Ractangle * (+45) /* Commands */
11:04:36 <esolangs> [[User:Ractangle/None,]] https://esolangs.org/w/index.php?diff=131978&oldid=131977 * Ractangle * (+37) /* Commands */
11:06:08 <esolangs> [[User:Ractangle/None,]] https://esolangs.org/w/index.php?diff=131979&oldid=131978 * Ractangle * (+67) /* Commands */
11:09:46 <esolangs> [[User:Ractangle/None,]] https://esolangs.org/w/index.php?diff=131980&oldid=131979 * Ractangle * (+245) /* Examples */
11:09:55 <esolangs> [[User:Ractangle/None,]] https://esolangs.org/w/index.php?diff=131981&oldid=131980 * Ractangle * (-11) /* Deadfish implementation */
11:10:04 <esolangs> [[User:Ractangle/None,]] https://esolangs.org/w/index.php?diff=131982&oldid=131981 * Ractangle * (+0) /* Deadfish implementation */
11:10:21 <esolangs> [[Special:Log/move]] move * Ractangle * moved [[User:Ractangle/None,]] to [[None,]]
11:10:53 <esolangs> [[Ractangle]] https://esolangs.org/w/index.php?diff=131985&oldid=131787 * Ractangle * (+36)
11:11:03 <esolangs> [[Ractangle]] https://esolangs.org/w/index.php?diff=131986&oldid=131985 * Ractangle * (+4)
11:12:21 <esolangs> [[Nope.]] https://esolangs.org/w/index.php?diff=131987&oldid=127051 * Ractangle * (+1) prints Nopf. for somereason
11:48:03 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
12:01:47 <esolangs> [[Gate]] https://esolangs.org/w/index.php?diff=131988&oldid=131916 * Yayimhere * (-5)
12:03:08 <esolangs> [[Gate]] https://esolangs.org/w/index.php?diff=131989&oldid=131988 * Yayimhere * (-67) /* A AND B */
12:14:14 -!- X-Scale71 has joined.
12:15:01 -!- X-Scale has quit (Ping timeout: 250 seconds).
12:27:53 <esolangs> [[Brainfuck]] https://esolangs.org/w/index.php?diff=131990&oldid=131922 * Ractangle * (+304) /* Truth-machine (kinda) */
12:32:22 <esolangs> [[Brainfuck]] https://esolangs.org/w/index.php?diff=131991&oldid=131990 * Ractangle * (+89) /* Truth-machine (kinda) */
12:36:59 <esolangs> [[Brainfuck]] https://esolangs.org/w/index.php?diff=131992&oldid=131991 * Ractangle * (+44) /* Truth-machine (kinda) */
12:42:38 -!- Raoof has joined.
12:45:47 <wib_jonas> ``` thank fizzie # I see HackEso is working again.
12:45:48 <HackEso> bash: thank: command not found
12:53:28 <Raoof> Hello all, I have a very simple idea about a language inspired by Z3 and Blindfolded Arithmetic, that I conjecture to be total and turing complete, anybody interested ? should I create a page myself ? would you create one for me ? I conjecture that composition of these four function (the syntax is in javascript)
12:53:29 <Raoof> sub = (a,b) => { if(a.v) return a; if(b.v) return b; return a-b-0n; }
12:53:29 <Raoof> mul = (a,b) => { if(a.v) return a; if(b.v) return b; return a*b*1n; }
12:53:30 <Raoof> div = (a,b) => { try{ if(a.v) return a; if(b.v) return b; return a/b*1n; }catch(e){ if(e.name==="RangeError") return {v:a,toString(){return this.v.toString();},[util.inspect.custom](){return this.v;}}; else throw e; } }
12:53:30 <Raoof> inc = (a) => { if(a.v) return a; return a+1n; }
12:53:31 <Raoof> are turing complete
12:53:53 <wib_jonas> https://esolangs.org/wiki/Tarski => isn't this just underload without S and with the primitives renamed?
12:54:35 <Raoof> I don't know, let me read it
12:56:42 <wib_jonas> Raoof: I don't understand, how would you get any loop from that? it looks like all those functions just finish quickly. also there's no nullary function so I'm not sure how you start building anything, or how this language is supposed to work.
12:56:43 <fizzie> Yeah, it was just a network configuration problem as far as the bot was concerned. Although I may still need to figure out why an interactive shell with a terminal in the container isn't working, since sometimes having one of those might be convenient.
12:58:38 <Raoof> wib_jonas that is my conjecture, it does not have any loops, it is a non-recursive language
12:59:42 <wib_jonas> Raoof: if there are no loops then how can it be Turing-complete?
13:02:06 <Raoof> wib_jonas my conjecture is that there is a non-recursive universal function for all functions in this language
13:02:30 <wib_jonas> I don't understand your statement then
13:03:44 <Raoof> here are a few example how to program with it, you can see that all function from integer to integer are computable in the limit (meaning unbounded program length)
13:03:45 <Raoof> zero = (a) => sub(a,a)
13:03:45 <Raoof> one = (a) => inc(zero(a))
13:03:46 <Raoof> two = (a) => inc(one(a))
13:03:46 <Raoof> three = (a) => inc(two(a))
13:03:47 <Raoof> negate = (a) => sub(zero(a),a)
13:03:47 <Raoof> add = (a,b) => sub(a,negate(b))
13:03:48 <Raoof> rem = (a,b) => sub(a,mul(b,div(a,b)))
13:03:48 <Raoof> square = (a) => mul(a,a)
13:03:49 <Raoof> isNonZero = (a) => div(square(sub(square(a),one(a))),square(add(square(a),one(a))))
13:03:49 <Raoof> isZero = (a) => isNonZero(isNonZero(a))
13:03:50 <Raoof> not = (a) => isNonZero(a)
13:03:50 <Raoof> and = (a,b) => isZero(add(isZero(a),isZero(b)))
13:03:51 <Raoof> or = (a,b) => isZero(mul(a,b))
13:03:51 <Raoof> eq = (a,b) => isZero(sub(a,b))
13:03:52 <Raoof> notEq = (a,b) => not(eq(a,b))
13:03:52 <Raoof> divz = (a,b) => div(a,add(b,isNonZero(b)))
13:03:53 <Raoof> If = (a,b,c) => add(mul(isNonZero(a),b),mul(isZero(a),c))
13:05:16 <Raoof> now if you can find a non-recursive universal function then it shows that the language is turing complete
13:05:32 -!- tromp has joined.
13:06:23 <wib_jonas> but these building block functions and their compositions are computable. if you can't make an infinite loop from them then they can't be turing-complete, right?
13:09:10 <Raoof> no it is logically possible that there is a non-recursive universal function but to find it I need a breakthrough in my understanding
13:09:10 <wib_jonas> or more concretely, it looks as if whatever you compose from these building blocks will be a function that can't grow faster than a polynomial in its outputs
13:09:44 <wib_jonas> but something like that probably is
13:10:50 <Raoof> when you program a turing machine you have to encode the input similarly if you want to compute 2^n for example you have to encode the input as a unary number for example 2^11 = 4
13:16:03 -!- sbak has joined.
13:17:33 <sbak> Raoof: I saw what you were saying in the logs. I don't think it works that way. Your functions are always-terminating, and turing completeness requires non-terminating programs
13:20:29 <Raoof> sbak I'm not convinced, can you explain why we need non-terminating programs ?
13:22:46 <wib_jonas> Raoof: I still don't understand what you start with, like what domain of values at least; and if if's just integers, then how do you get a function that grows faster than a polynomial
13:23:03 -!- X-Scale71 has quit (Ping timeout: 250 seconds).
13:24:58 <sbak> Raoof: simple argument is that any Turing complete language needs to be able to simulate arbitrary Turing machines. An always-terminating Turing complete language would therefore solve the Halting Problem
13:25:14 <sbak> which is proven to be impossible
13:27:14 <sbak> that said, Turing completeness is not the be all end all of what makes a language useful or powerful. In practice, most programs don't really need it
13:28:15 -!- Raoof has quit (Ping timeout: 250 seconds).
13:28:38 -!- Raoof has joined.
13:30:26 <Raoof> I've got disconnect for a few minutes, did I missed any messages ?
13:30:54 <sbak> possibly. Let me copy them for you
13:31:08 <sbak> <sbak> Raoof: simple argument is that any Turing complete language needs to be able to simulate arbitrary Turing machines. An always-terminating Turing complete language would therefore solve the Halting Problem
13:31:13 <sbak> <sbak> which is proven to be impossible
13:31:17 <sbak> <sbak> that said, Turing completeness is not the be all end all of what makes a language useful or powerful. In practice, most programs don't really need it
13:34:06 <Raoof> sbak thanks. halting function is non-computable (because Turing-Machine is a non-computable language) even if this language turn out to be turing complete
13:34:55 <Raoof> sbak in my understanding non-recursive is different than non-computable
13:35:32 <sbak> by the definition of Turing-completeness, a Turing-complete language needs to be able to simulate _any_ Turing machine. Including non-terminating ones.
13:35:44 <sbak> therefore a Turing-complete language has non-terminating programs
13:37:31 <Raoof> I thought that Turing-completeness means to be able to compute all total computable function, I change my conjecture this language can compute all total computable functions
13:37:58 <wib_jonas> Raoof: how do you get a power function, like a function f such that for any nonnegative integer x, f(x) is equal to 2 to the power of x ?
13:41:01 <Raoof> wib_jonas if you want to compute an exponential function you have to encode the input as a unary number for example 4 in unary is 1111 or we can use 9 as the unary symbol and use 9999 so f(9999) = 16
13:43:01 <wib_jonas> Raoof: er no, now you're inputting in unary but outputting in binary, that's cheating. or if you insist then compute a double exponential with that encoding.
13:49:17 <Raoof> wib_jonas I don't understand why that is cheating, can you explain ? I don't think double exponential makes a difference but I have to think about that
13:51:32 <wib_jonas> Raoof: you're using a different encoding for the input than for the output, and since the input is encoded in a way that's exponentially larger then sure, then you can get one exponential. but if you want to implement all total functions from integers to integers then you need to implement arbitrarily fast growing functions, just one or two or
13:51:32 <wib_jonas> three exponential doesn't cut it, you need to be able to implement ackermann too. but these building blocks look like they can't grow any faster than just a polynomial, which is why I asked for an exponential.
14:04:05 <Raoof> wib_jonas if you have a universal function then you can define ack(m,n) = u(g(m,n),m,n) , where g(m,n) is a substitution function for ack
14:06:22 <Raoof> wib_jonas do you think that doesn't work ?
14:06:43 <wib_jonas> Raoof: I don't understand what you're saying or how this is related to what you were saying earlier about those sub and mul and div and inc functions
14:08:19 <Raoof> if you defined g and u then you can define ack
14:09:22 <wib_jonas> what is g and u and how do you get them from composing those earlier functions?
14:12:47 <Raoof> wib_jonas that is the breakthrough that I need in my understanding, it is not obvious to me that they don't exist
14:14:34 -!- amby has joined.
14:22:21 <wib_jonas> ok, then either you'll need to prove that any multi-variate function that you compose from those building blocks is bound in magnitude by a polynomial of the magnitudes of its inputs; or, if you get past that by modifying the building blocks to avoid that problem, then I'd need to figure out how the diagonal argument works to prove why this kind of
14:22:22 <wib_jonas> thing with just total functions as building blocks, and I'm not ready for that right now
14:36:51 <wib_jonas> basically, consider a reasonable numbering of all the compositions of your building blocks. consider S, a function such that S(p) is one plus the result of the composition numbered p called on the integer p. Since your building blocks are total and computable, S is also computable and total. you claim that you can get any computable total function
14:36:51 <wib_jonas> as a composition of your building blocks. so let s be the numbering of the composition that computes S. then you get S(s) = 1 + S(s) a contradiction. normally you avoid this problem because you use at least one non-total building block, and S(s) will just be an infinite loop or other error.
14:38:40 <Raoof> wib_jonas you can't use diagonal argument, diagonal argument is blocked by div operation
14:39:09 <wib_jonas> Raoof: what do you mean by blocked? didn't you define div as a total function too?
14:39:52 <Raoof> wib_jonas yes n/0 = gapped n
14:40:44 <wib_jonas> then what do you mean by "blocked"?
14:42:52 <Raoof> because n/0 returns a gapped value you can't define a diagonal function
15:08:06 <Raoof> wib_jonas if you send a message in the pass 25 minutes I didn't get it
15:19:56 <wib_jonas> Raoof: if it's the "one plus" in the definition of S above that is your problem, because it's not defined for the kind of value that div(1, 0) returns, then let's just say S(p) gives 500 instead if calling the composition numbered p on the integer p returns a non-integer value.
15:24:44 <Raoof> wib_jonas not you can define S but you can NOT diagonalize it, because S(s) returns s+1 but there is no contradiction because s+1 is a gapped value
15:26:10 <Raoof> the definition of S is such that when you give it the input s it divide by zero and returns s+1
15:28:55 <Raoof> I mean it could returns any gapped value
15:32:39 <Raoof> I must have said "gap value" instead of "gapped value" I don't know why I wrote "gapped"
15:34:14 <wib_jonas> I still don't understand what you're saying about why the diagonal argument wouldn't work.
15:43:27 <Raoof> wib_jonas you defined S as S(p) = 1+u(p,p) and you get a contradiction by calling S on s but that does not work because u(p,p) returns a gap value
15:45:11 <Raoof> 1+a gap value = a gap value so no contradiction
15:49:18 <Raoof> you defined S(p) = 1 + u(p,p) to get a contradiction but S(s) = u(s,s) because u(s,s) is a gap value
15:50:27 -!- sbak has quit (Ping timeout: 268 seconds).
15:52:45 <wib_jonas> Not about the above, https://scottaaronson.blog/?p=8088 about the 2 symbol 5 state Turing machine busy beaver
16:03:01 -!- lambdabot has quit (Remote host closed the connection).
16:03:01 -!- sbak has joined.
16:03:39 -!- lambdabot has joined.
16:03:46 -!- Koen has joined.
16:04:45 -!- wib_jonas has quit (Quit: Client closed).
16:06:09 <lambdabot> [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,...
16:39:48 <esolangs> [[List of ideas]] https://esolangs.org/w/index.php?diff=131993&oldid=131884 * Gggfr * (+50) /* Looks Like */
16:44:06 <esolangs> [[List of ideas]] https://esolangs.org/w/index.php?diff=131994&oldid=131993 * Gggfr * (+122) /* General Ideas */
16:45:11 <esolangs> [[List of ideas]] https://esolangs.org/w/index.php?diff=131995&oldid=131994 * Gggfr * (+0) /* General Ideas */
16:58:04 <esolangs> [[Billiards]] https://esolangs.org/w/index.php?diff=131996&oldid=74319 * Gggfr * (-9)
17:13:21 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
17:31:25 -!- tromp has joined.
17:32:06 -!- Koen has quit (Remote host closed the connection).
17:42:14 -!- Koen has joined.
17:48:34 -!- Raoof has quit (Quit: Client closed).
17:48:53 -!- Raoof has joined.
17:50:28 -!- impomatic has joined.
17:51:00 -!- ais523 has joined.
17:53:52 <ais523> Raoof: there is a computational class called ELEMENTARY, which has inspired various esolangs that don't seem to be documented on the wiki
17:53:52 <ais523> https://en.wikipedia.org/wiki/ELEMENTARY#Basis_for_ELEMENTARY
17:53:52 -!- ais523 has quit (Client Quit).
17:54:06 -!- ais523 has joined.
17:54:17 <ais523> Raoof: I suspect your language is ELEMENTARY: https://en.wikipedia.org/wiki/ELEMENTARY
17:54:58 <ais523> although, hmm, ELEMENTARY requires some sort of exponentiation to exist (even if it's just 2**x)
17:56:08 <ais523> I've been meaning to write up (some concrete version of) ELEMENTARY on the wiki for a while, it's a fun language
17:56:15 <ais523> sub-TC but can do things like primality checking
17:56:47 <Raoof> ais523 does it have a universal function ?
17:57:55 <ais523> not within itself – because it's computable, there are universal functions for it but you have to define them in some other language
17:58:23 <ais523> or, hmm, I am not 100% certain that it doesn't have a self-interpreter – more like 90%
17:59:45 <ais523> ELEMENTARY cannot do a tetration, that might be enough to be able to prove it unable to self-interpret given reasonable program encodings
18:01:12 <ais523> right, given a reasonable program encoding, you can start with x and y and use ELEMENTARY to generate an encoding of x**(x**(x**(x**…))) with y xs – that's just producing a repeating string which is pretty easy with this level of power
18:01:42 <ais523> so a self-interpreter can't exist because it wouldn't be able to evaluate that string – if it could, it would let you do a tetration in ELEMENTARY which is known to be impossible
18:02:45 <ais523> that said, I am not sure your language is even as powerful as ELEMENTARY – it can't obviously do an exponentiation
18:03:11 <b_jonas> ais523: so this is a smaaler class than primitive recursive functions?
18:04:29 <ais523> I think of the power of primitive recursive as "this actually can't do all total programs – but if you think of a total program off the top of your head rather than trying to construct it as a counterexample, it can probably implement it"
18:04:55 <ais523> and ELEMENTARY is like that too, people thinking of an arbitrary total function probably aren't going to think of the Ackermann function or a tetration
18:06:47 <ais523> ELEMENTARY contains EXPTIME, so it can solve any problem that doesn't need more than exponential time to solve (thus it also contains PSPACE and NP)
18:08:22 <b_jonas> and it can also solve any problem that needs double exponential time, right? because that does come up often
18:09:50 <Raoof> ais523 in this language (let's call it Ar) all function from Z to Z including non-computable functions are computable in the limit, that's makes it special I think, I also not convince that it can't compute the ackermann function because Ar blocks digonalization argument I don't know how to convince myself that it does not have a universal function
18:10:10 <ais523> b_jonas: I would expect it to, but don't have a reference/proof to hand
18:11:00 <ais523> Raoof: assuming a finitely long program (i.e. not in the limit), it can't compute the Ackermann function because it can be implemented using a primitive recursive interpreter
18:11:54 <ais523> the "in the limit" argument is interesting, if you are taking an infinitely long sequence of finite programs and then taking the limit of the results they evaluate to, you are effectively adding loops to the language
18:13:21 <ais523> and I would definitely expect it to be TC then, assuming a reasonable definition of the way in which programs are allowed to grow from one sequeence element to the next
18:13:31 <ais523> but, it's probably unnecessarily complicated for that purpose
18:14:49 <ais523> ah right, multiplication + division + modulo + an infinite loop is enough to implement https://esolangs.org/wiki/Tip (and modulo is trivial to implement in terms of the operations you already have)
18:15:57 <Raoof> ais523 why do you think it's complicated ? you can easily define "if then else" "not" == < > <= >=
18:16:46 <ais523> Raoof: that's why the language is unnecessarily complicated – it's too easy to define things in it
18:16:53 <ais523> it could probably be simpler whilst still being TC
18:17:26 -!- Lord_of_Life has quit (Ping timeout: 252 seconds).
18:17:33 -!- Lord_of_Life_ has joined.
18:17:33 <ais523> for example, you have special handling for division by zero that needs special-casing in all your primitives – but it's TC even if division by zero is considered undefined behaviour
18:18:01 <ais523> there's a tradeoff between "language is complicated but allows simple programs" and "language is simple, so the programs have to be complicated"
18:18:52 <ais523> so if the programs are too simple, it leaves me concerned that the language might be too complicated
18:19:43 <Raoof> ais523 I still don't understand why do you think it's complicated, my idea with Ar is that it is just arithmetic
18:20:28 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
18:22:31 <Raoof> ais523 I have special-casing in my primitive in order to block the diagonalization argument so to leave it an open question whether the language has a universal function or not
18:26:11 <Raoof> ais523 you can remove all special-casing and return the empty string when division by zero occur that does not change the fact that it is in the limit super-TC
18:34:15 <Raoof> ais523 in your idea of primitive recursive interpreter, is the input in unary base or is it an integer ?
18:34:46 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
18:35:26 <esolangs> [[ADxc]] https://esolangs.org/w/index.php?diff=131997&oldid=72962 * Kaveh Yousefi * (+156) Introduced an examples section which embraces as its incipial member a partial geometric series generator.
18:35:36 -!- Lord_of_Life has joined.
18:36:12 <esolangs> [[ADxc]] https://esolangs.org/w/index.php?diff=131998&oldid=131997 * Kaveh Yousefi * (+185) Added a hyperlink to my implementation of the ADxc programming language on GitHub and supplemented the Implemented category tag.
18:37:24 <ais523> Raoof: I think the normal definition of primitive recursive can only take integers as input, but it doesn't really matter – primitive recursive is enough power to change between bases, including unary
18:40:21 <b_jonas> "multiplication + division + modulo + an infinite loop is enough to implement https://esolangs.org/wiki/Tip" => you also need some kind of conditional to dispatch on the IP, but you can make that from multiply and divide if you also have an add constant operation, right? then you can simulate Tip or Fractran.
18:40:52 <esolangs> [[ADxc]] https://esolangs.org/w/index.php?diff=131999&oldid=131998 * Kaveh Yousefi * (+254) Improved the code fragments' formatting and reformatted the example steps in a tabular form.
18:41:09 <ais523> b_jonas: you don't need a conditional, what you do is use a modulo chain to reduce the number to 0 or 1 and then multiply by it
18:41:24 <ais523> oh, but that needs addition
18:41:32 <ais523> maybe I am missing an operation
18:42:13 <esolangs> [[ADxc]] M https://esolangs.org/w/index.php?diff=132000&oldid=131999 * Kaveh Yousefi * (-13) Removed the duplicate Examples header erroneously introduced by myself.
18:42:39 <Raoof> ais523 assuming the input and ouput are integer and you write a function assuming that the input is in unary form, does that make the interpreter more powerful ?
18:42:45 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
18:59:02 <sbak> huh, the idea of the limit of a sequence of finite programs is a very neat idea for an esolang actually
18:59:07 <sbak> sounds like a pain to implement though
18:59:36 -!- ais523 has quit (Remote host closed the connection).
19:00:52 <b_jonas> sbak: maybe look at the https://esolangs.org/wiki/(0) family of languages then
19:00:52 -!- ais523 has joined.
19:02:32 <ais523> Raoof: it can depend on the language, but usually no for languages that aren't very restricted in terms of space or time
19:08:19 <Raoof> ais523 I have a hunch that it makes a difference because a universal function is a meta program ( it takes source code as input )
19:09:30 -!- tromp has joined.
19:19:15 <Raoof> ais523 if you have a magical universal function u(f) := f(0) and a magical substitution function g(f,n) := "substitute n in f" then you can define f(n) := u(g(f,n))
19:28:31 <ais523> Raoof: I don't think g is well defined
19:28:47 <ais523> and even if it were, it wouldn't work – there might be a different 0 somewhere that gets substituted by mistake
19:30:46 <Raoof> ais523 g is well defined I just don't know how to make it non-recursive
19:34:28 <int-e> b_jonas: Did you know that the throughput of tunnels in Shapez (if "super-charged") depends on their length? https://int-e.eu/~bf3/tmp/shapez-tunnel-throughput-x8.png
19:35:45 <Raoof> ais523 did you noticed that Ar is just your language Blindfold-Arithmetic just unrolled ?
19:37:38 <sbak> int-e: that's cursed
19:38:21 <int-e> shikhin: note that the nominal speed here is 16/s, and the readings are divided by 2, so it's above that.
19:38:44 <b_jonas> int-e: what the heck? is that a true long-term throughput, or just some starting artifact possibly combined with imprecision of those meters?:w
19:38:46 <int-e> no idea why irssi decided to complete to that.
19:38:56 <int-e> b_jonas: it's long term at 8x speedup
19:39:53 <b_jonas> I thought they'd all limit the throughput to 16
19:40:15 <int-e> Also this is with 60 ticks per second, which undoubtedly is also relevant.
19:40:34 <b_jonas> can this be used to send high throughput to the core?
19:40:50 <int-e> I thought the same; in fact I thought that the tunnels are belts under the hood, and belts are the one thing in this game that tries to be accurate when it comes to throughput.
19:41:04 <sbak> it's wacky that miner -> splitter gives 10/s in each output of the splitter, while simply a belt is 16/s
19:41:04 <b_jonas> I agree with sbak that this is cursed
19:41:18 <int-e> yes, the hub accepts items at any rate
19:41:56 <sbak> I've been thinking about making a factory game for fun, I will definitely endeavor to make it more consistent than this
19:42:37 <b_jonas> int-e: sure, but I'm not sure you can feed the tunnels fast enough. here you're feeding them from extractors, but that's very specialized, you won't have the right shapes extractable close to the hub.
19:42:40 <int-e> sbak: Right, but it's fairly well-known that balancers (what you called a splitter) are faster than there nominal speed.
19:43:22 <int-e> b_jonas: right but you can feed them with a balancer that takes one belt and a bit extra.
19:43:38 <Raoof> sbak have you played opus magnum ? are you interested in creating something like that using something like Ar as the base mechanic ?
19:43:58 <sbak> not interested in collaborations
19:44:08 <int-e> b_jonas: I have not done the pertinent experiment... namely what happens if you chain several short tunnels
19:44:09 <sbak> but yes opus magnum is good
19:45:05 <Raoof> sbak no collaborations just I give you feedback you give me the game :D
19:45:16 <sbak> nope that just sounds like doing work for free
19:46:34 <Raoof> sbak you can monetize it as your own game, I think Ar is a theory of everything so it would be cool if somebody make a game around it
19:46:50 <sbak> it's a hard no
19:47:03 <int-e> b_jonas: but (as I would expect) that works fine: https://int-e.eu/~bf3/tmp/shapez-tunnel-throughput-chained.png
19:47:31 <int-e> (I took the screenshot a bit too soon so the numbers are a bit lower than they should be)
19:48:32 <b_jonas> so how much throughput into the core can you get from this? do you get more than the 20 belts throughput that the balancer setup has (though I haven't been able to reproduce that supposed throughput myself)
19:49:16 <int-e> b_jonas: you get the usual up to 25%
19:49:40 <int-e> "usual" - the same number people get from using balancers for that purpose
19:50:23 <int-e> Well, I think. I have not actually understood how belts work internally.
19:50:29 <esolangs> [[User:B jonas]] https://esolangs.org/w/index.php?diff=132001&oldid=131914 * B jonas * (+15)
19:54:33 <int-e> At the root of all this is that some parts of the game effectively have a discrete throughput (an integer number of ticks per item). At 8x speedup, that number is 6 ticks per item. It stays at that value all the way to 11.93 (IIRC) speedup.
19:55:29 <sbak> Raoof: sorry for being rude there. what I meant is, I'm not a game developer and I'm not super interested in Ar. I want to make a game for myself to learn some new skills, but I don't think I'd be able to make what you're envisioning in a reasonable amount of time and I am not invested.
19:55:29 <int-e> Which incidentally means that between 10 and ~11.93, you can only feed belts 20 items per second.
19:55:57 <int-e> Even though the nominal throughput ranges from 20 to ~23.86.
19:56:47 <b_jonas> shapez.io continues to be such an odd game
19:57:11 <sbak> b_jonas: it's written in an esolang though so I appreciate that about it
19:57:12 <Raoof> @sbak that's okay, no hard feelings.
19:57:41 <int-e> I still like the game though... but yeah it has quite a few implementation quirks. Not sure whether this is because the developer(s?) didn't try to be more precise or because they consciously traded precision for performance.
19:58:04 <sbak> Shapez 2 is shaping up to be pretty nice
19:58:11 <sbak> pun not intended actually
19:58:32 <int-e> Anyway, let me try to get a handle on the real odditity I was trying to look into. https://old.reddit.com/r/shapezio/comments/1dto2zq/why_does_this_cause_gaps/ can be minimized to https://int-e.eu/~bf3/r/shapez-quarterbelt-speed.png
19:59:23 <int-e> (where the top part "leaks" items at speedups between 8 and 9, and 9 and 10 (excluding the bounds)).
20:02:33 <int-e> So it looks like there's some artifact in handling that one extremely short belt.
20:03:50 <sbak> corner belts and throughput issues makes me think of the corner belt throughput issue factorio used to have
20:04:02 <sbak> where the items had hitboxes and collision was wacky in corners
20:33:45 <esolangs> [[Brainfuck]] https://esolangs.org/w/index.php?diff=132002&oldid=131992 * Ractangle * (+108) /* Python interpreters */
20:36:04 <esolangs> [[Special:Log/move]] move * Ractangle * moved [[Opening square bracket]] to [[User:Ractangle/Opening square bracket]]
20:39:01 <esolangs> [[Shape-Machine]] https://esolangs.org/w/index.php?diff=132005&oldid=131928 * Ractangle * (+18)
20:40:34 <esolangs> [[Shape-Machine]] https://esolangs.org/w/index.php?diff=132006&oldid=132005 * Ractangle * (+45) /* > */
20:40:49 <esolangs> [[Shape-Machine]] https://esolangs.org/w/index.php?diff=132007&oldid=132006 * Ractangle * (-100) /* > */
20:43:29 <esolangs> [[Shape-Machine]] https://esolangs.org/w/index.php?diff=132008&oldid=132007 * Ractangle * (+31)
20:44:41 <esolangs> [[Shape-Machine]] https://esolangs.org/w/index.php?diff=132009&oldid=132008 * Ractangle * (+27)
20:45:55 -!- Raoof has quit (Ping timeout: 250 seconds).
21:06:58 -!- salpynx has joined.
21:22:07 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
21:30:31 -!- tromp has joined.
21:39:34 <esolangs> [[User:Salpynx]] https://esolangs.org/w/index.php?diff=132010&oldid=131149 * Salpynx * (+398) /* TODO: Esolang projects I'd like to finish or start (not necessarily complete, or in order) */
21:40:32 <ais523> salpynx: fwiw I think Countercall was proven sub-TC at some point, but I forget the details, and it wasn't me who proved it
21:42:48 <salpynx> oh ok, I saw Keymaker had looked into it and developed Vein, but there seemed to be no final conclusion about Countercall.
21:43:58 <salpynx> I feel like a similar thing happened with Footsteps -- I know I was looking to it, then got other ideas and parked it.
21:44:14 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
21:47:09 <ais523> I might be misremembering though
21:47:14 <salpynx> I have what seems to be a working Conedy interpreter, it can output and accepts input (clumsily atm). I now need to figure out how to do basic things with it.
21:48:08 <salpynx> A truth machine would be a good first step, and I notice Trajedy has a lot of helpful guidance. I don't know how much will apply to Conedy though.
21:49:25 <salpynx> In comparison, Countercall looks more straightforward and was tempting for that reason :)
21:50:07 <ais523> Countercall starts out looking easy and then gets amazingly confusing to think about
21:50:33 <ais523> because when you try to store things on the call stack you end up stuck in a lot of nested loops with various iteration counts that you can't control very well
21:51:08 <salpynx> I had a feeling there would be a trick... my first first thought was it did look very easy... but suspiciously so
21:57:03 <sbak> interesting, is it actually more powerful than a pushdown automaton?
21:58:01 <salpynx> A bracket matching algorithm in Conedy would be satisfying. It wouldn't prove anything (other than confirm PDA), but it'd be a nice illustration of something practical. I can't yet think how to begin, but it should be an 'easy' example.
21:59:45 <salpynx> I thought I coudl squeeze bracket matching out of the Doors language recently, but that is only FSA-equivalent, despite having an infinte counter.
22:00:09 <ais523> "language that has an infinite counter but you can't use it" is possibly an esolang genre
22:00:46 <ais523> e.g. you can count up infinitely in BuzzFizz, but can only read the value of the counters modulo constants so there are only finitely many distinguishable states
22:01:09 <ais523> and this same general principle is the reason why Three Star Programmer needs three stars rather than two
22:02:41 <salpynx> I did get quite interested in that aspect, I wasn't sure if that fits the computational class + a bit extra. I concluded that it was 'extensionally equal' to a FSA, so it's not really extra power.
22:03:06 <salpynx> and, yes, it seems FSA + infinte counter is common
22:05:11 <sbak> actually thinking about it, are there systems that are more powerful than PDAs but less powerful than Turing machines? (without using silly contrivances like "it's a PDA but it has one specific program that accepts the language of squares")
22:07:00 <ais523> sbak: LBAs are semi-common
22:07:28 <sbak> oh yes I see, I forgot about those
22:08:19 <salpynx> sbak: That's the current claim about Conedy on the article
22:09:40 <ais523> it's a PDA, plus a few things that PDAs clearly can't do but aren't obviously useful for climbing up into higher computational classes
22:15:07 <salpynx> This discussion has me thinking there is value in clearly demonstrating basic FSA, then PDA equivalence for tarpit languages that are hard to reason about, before tackling TCness.
22:15:09 <sbak> so in Conedy, if there are two adjacent nets "pointing" toward each other, does the IP just get stuck in an infinite loop? like in the case aBcbCA
22:16:08 <salpynx> even if the FSA proof is trivial, just having a concrete touch point will help ground further work
22:16:26 <ais523> sbak: aBc bCa is an infinite loop, yes
22:16:56 <salpynx> also "Hitting the boundary of two nets simultaneously is undefined behaviour."
22:16:59 <ais523> without the space, it's UB because there's a point at which the IP is in two nets simultaneously
22:18:38 <sbak> oh yes I see. that didn't register to me because I was envisioning "hitting the boundary of two nets simultaneously" as _entering_ two nets simultaneously
22:18:42 <sbak> not exiting one and entering the other
22:19:11 <salpynx> I didn't code anything specific for that to shortcut calculations, or validate that nets are separated. If practical problems arise from running examples, I'll perhaps add something
22:19:27 <sbak> it is undefined behavior after all
22:25:36 <salpynx> I do wonder how many 'implemented' esolangs on the wiki have fundamentally broken interpreters which will never be noticed. Confirming I haven't just written one is going to be quite hard :)
22:26:07 <sbak> it's quite easy to make such a mistake
22:26:10 <sbak> so probably a lot
22:27:08 <ais523> I think Underload gets a special reward for this – there is part of the spec that nobody implements, not even the original interpreter
22:27:16 -!- fungot has quit (Remote host closed the connection).
22:27:16 <ais523> and so it's arguably whether it's actually part of the spec or not at this point
22:27:40 <fizzie> (Rebooting the fungot box after finally going to Debian 12.)
22:28:05 <sbak> ais523: what part of the spec is that?
22:28:27 <ais523> sbak: " as an escape character to escape itself and <>[], which can't be used unescaped
22:28:51 <ais523> it's kind-of pointless because a) none of those characters are special-cased otherwise and b) it can't escape () which are the characters you'd really care about
22:29:21 <sbak> it's not a particularly hard thing to implement, I was expecting something more silly :p
22:29:26 <ais523> I also discovered that some people have written Underload interpreters to ignore (rather than crash on) unrecognised characters
22:29:45 <ais523> sbak: if you want something silly, HOMESPRING defines the character strings " . " and ". ." to cause temporal paradoxes
22:30:07 -!- fungot has joined.
22:30:21 <fungot> ais523: food is for mortals... oh wait... i think that's great, too. pity that's the following week. i'm not really sure whether i will yet.
22:31:46 <ais523> huh, in my client, everyone who's spoken recently has a nick in the cyan-purple range, except lambdabot who is gray and still fits within the range, and fungot, whose green nick came as a bit of a surprise because it disturbed the color-coordination
22:31:46 <fungot> ais523: taking a stack-based approach. let me find the list of his children
22:31:48 <sbak> fungot has realized its own mortality it seems
22:31:49 <fungot> sbak: " always prefer the probable impossible to the the bytecoded implementations?'
22:32:46 -!- SGautam has joined.
22:33:37 <fizzie> https://zem.fi/tmp/colors.png <- also all pretty similar, hue-wise.
22:33:49 <sbak> I've been working on a funge-98 interpreter actually. planning to implement TRDS next, that's gonna be fun
22:34:19 <ais523> how does it do on Mycology?
22:34:42 <sbak> passes everything except BADs on the >128 ASCII character because I haven't fiddled with character encodings yet
22:35:10 <sbak> it's supposed to be 0xDE but ends up as 0xFFDE
22:35:23 -!- Sgeo has joined.
22:37:17 <sbak> I've done all the fingerprints defined in the official spec too, except for TURT and PERL which I don't know if I'm even gonna do
22:37:25 <fizzie> Looks like there've been a handful of cfunge commits since the version 'got is running on, too.
22:37:27 <sbak> some of the fingerprints seem, dare I say, "too serious"
22:39:16 <sbak> though I noticed FPSP and FPDP don't have any greater-than comparison, making comparison absolutely silly for floating point numbers. wonder if that's on purpose to make them more silly
22:40:12 <ais523> it was possibly an oversight
22:40:27 <ais523> esoteric libraries are commonly designed and implemented without actually being used much
22:40:41 <ais523> so obvious oversights can exist without people noticing for a while
22:41:26 <sbak> I've been thinking about defining an FPCP fingerprint (floating point comparison) just to fix that lol
22:42:07 <ais523> you could have options for how to handle NaN and negative zero in the comparisons
22:42:27 <ais523> and whether infinities are equal to themselves
22:42:44 <sbak> hmm it would be kind of funny if it had an absurd amount of instructions just so it's inconvenient to use in conjunction with FP(S/D)P
22:43:45 <sbak> actually, not an absurd amount, just enough to cover the same letters as FP(S/D)P's basic arithmetic
22:43:47 <ais523> "this fingerprint might be badly designed, but it's badly designed for a reason!"
22:44:04 <sbak> and that reason is being funny
22:44:17 <fizzie> fungot uses the STRN, FILE, FING, SOCK, REXP, TOYS and SUBR fingerprints (with the last two only used for ^reload and ^code, respectively).
22:44:18 <fungot> fizzie: you may pick one of two function pointers. :)
22:44:30 <fizzie> fungot: Okay, I'll pick the second one.
22:44:31 <fungot> fizzie: however, it tends not to be the same for scheme48 as for anything else than stand up.
22:46:07 <fungot> ^<lang> <code>; ^def <command> <lang> <code>; ^show [command]; lang=bf/ul, code=text/str:N; ^str 0-9 get/set/add [text]; ^style [style]; ^bool
22:46:18 <fizzie> It's an admin-only command that runs the line using SUBR as Funge-98 code.
22:46:31 <fizzie> The idea being that I could use it to fix issues without having to restart.
22:46:40 <fizzie> I don't think I've ever managed to fix anything without breaking it more.
22:48:21 <sbak> but yeah my implementation is decently fast I think but probably takes more memory than necessary and isn't really optimized for performance either
22:48:58 <sbak> but hey at least I gave some thought to the time complexity of my funge-space :p
22:49:05 <sbak> it's not an n-D array!
22:51:31 <salpynx> which bot here can evaluate funge-98 code in IRC msgs? I'm sure there is one, but I can't remember the command
22:52:19 <salpynx> bf != BeFunge obviously, but I don't know how to abbreviate funge-98
22:52:41 <fizzie> HackEso/HackEgo has inherited the functionality of EgoBot, which included a bunch of interpreters, but they're quite hard to use.
22:53:20 <Sgeo> bytepusher.wat:3:6: error: only one memory block allowed
22:53:20 <Sgeo> (memory $video 4) ;; Video data in ImageData format
22:53:38 <Sgeo> Need to update the tools I guess? argh
22:53:45 <fizzie> `! befunge98 "dlrow ,olleh">:#,_@
22:54:00 <fizzie> It used some sort of pretty obscure interpreter, as I recall.
22:54:12 <fizzie> Also the repository browser is apparently borked.
22:54:27 <HackEso> The ! or interp command calls various language interpreters transfered from old EgoBot. Try `url /hackenv/ibin/ for a list.
22:54:39 <fizzie> The recommended `url command gives a 502.
22:54:56 <HackEso> 1l \ 2l \ 7 \ adjust \ asm \ asmbf \ axo \ bch \ befunge \ befunge98 \ bf \ bf16 \ bf32 \ bf8 \ bf_txtgen \ boolfuck \ brachylog \ c \ cintercal \ clcintercal \ cxx \ dimensifuck \ forth \ glass \ glypho \ haskell \ help \ java \ k \ kipple \ lambda \ lazyk \ linguine \ lua \ malbolge \ pbrain \ perl \ qbf \ rail \ rhotor \ sadol \ sceql \ sh \ slashes \ trigger \ udage01 \ underload \ unlambda \ whirl
22:55:13 <fizzie> Anyway, those would be the things you can use with `! except I'm sure some of them won't work.
22:55:53 <ais523> `! cintercal DO :1 <- #123$#456 DO READ OUT :1 PLEASE GIVE UP
22:55:56 <HackEso> /usr/bin/ld: /hackenv/interps/c-intercal/inst/bin/../lib/libick.a(cesspool.o): relocation R_X86_64_PC32 against symbol `strcmp@@GLIBC_2.2.5' can not be used when making a PIE object; recompile with -fPIC \ /usr/bin/ld: /hackenv/interps/c-intercal/inst/bin/../lib/libick.a(ick_lose.o): relocation R_X86_64_PC32 against symbol `fflush@@GLIBC_2.2.5' can not be used when making a PIE object; recompile with -fPIC \ /usr/bin/ld: /hackenv/interps/c-intercal/inst
22:56:40 <ais523> forced PIE has caused problems for me in the past in other contexts
22:57:39 <ais523> I'm not particularly annoyed with OSes forcing it on, but I am annoyed with there not being enough care to prevent bad side effects
22:58:11 <ais523> in this case, the problem is just that libick.a was built non-PIC and can't be linked into a PIE
22:58:20 <ais523> or, well, I think that's what it is
22:59:42 <fizzie> I have absolutely no recollection how the repo browser is configured, it's using hgweb and there's uWSGI involved but that's about it.
23:00:01 -!- __monty__ has quit (Quit: leaving).
23:00:33 <fizzie> Looks like it's trying to load /usr/lib/uwsgi/plugins/python_plugin.so and there's only a python3_plugin.so in there, so I guess it's that.
23:01:41 <sbak> hey btw I've come across mentions of some elusive Funge-108 or Funge-109
23:01:45 <sbak> it seems to not quite really exist
23:02:52 <fizzie> I feel like that was an effort from the cfunge author that sort of died off.
23:03:27 <ais523> there was definitely work on it but I'm not sure if that work ever finished
23:03:36 <fizzie> Around 2008/2009, as you might guess from the name.
23:03:50 <sbak> I see, makes sense
23:10:18 <fizzie> Huh, there's a pretty heavy traffic to /repo paths from all kinds of crawlers, wouldn't have expected that.
23:10:22 <salpynx> that's Seed, I added that ages ago, but the output is funge-98. There is a way to pipe it back into HackEso, but it's kinda horrible
23:11:07 <fizzie> Anthropic's ClaudeBot/1.0 was interested in /repo/rev/02ea44c6f666?revcount=7 and Amazonbot/0.1 wanted to see /repo/file/1281dde9cef7/paste/paste.29626, for example.
23:11:13 <sbak> fizzie: the linalg boxes want their training data
23:14:57 <HackEso> /hackenv/ibin/lazyk: 28: /hackenv/ibin/lazyk: /hackenv/interps/lazyk/lazy.bin: not found
23:15:14 <ais523> fungot is possibly not good training data for anything other than Befunge programs (and I don't think generative AI would do very well with Befunge)
23:15:15 <fungot> ais523: http://schemers.org/ documents/ standards/ r5rs/ html/ r5rs-z-h-9.html%_idx_438 or something with black bg and a dark green grid
23:15:54 <sbak> github copilot tried to help me implement Funge operations when I started writing my interpreter
23:16:03 <sbak> it wasn't very good at it though
23:16:32 <sbak> it seemed vaguely aware of what Funge is though
23:17:34 <fizzie> Ah, https://hack.esolangs.org/repo/file/tip/ibin works again.
23:17:44 <fizzie> And seems like I misremembered and `befunge98` just uses cfunge.
23:18:07 <fizzie> `` /hackenv/interps/cfunge/cfunge -v
23:18:08 <HackEso> cfunge 0.9.0 [+con -trace +exact-bounds -ncurses p:64 c:32] \ \ Platform: x86_64 \ OS: Linux \ Compiler path: /usr/bin/gcc \ Compiler: GCC 4.7.2 (or compatible) \ Build type: Release \ Compiled on: Linux 3.1-5.slh.2-aptosid-amd64 (x86_64) \ \ CFLAGS=" -O3 -DNDEBUG" \ LDFLAGS=" "
23:18:22 <fizzie> Not even an incredibly old one.
23:21:41 -!- FreeFull has quit (Ping timeout: 240 seconds).
23:23:57 -!- FreeFull has joined.
23:24:25 <salpynx> fungot, write a program in bf that outputs your name
23:24:26 <fungot> salpynx: thanks all. :) ( even if you used a 4-ary operator in prefix but a binary operator in infix. all expressions appear in between parenthesis. if you want
23:25:20 <sbak> the main thing I optimized for in writing my funge implementation is making it as easy as possible for me to write new instructions for fingerprints, which was a fun little puzzle
23:25:24 <salpynx> generative ai will be about as successful as that, but a bit more convincing at first glance
23:25:46 <sbak> it looks a bit like this https://i.postimg.cc/SKXrRTxs/image.png
23:27:09 <sbak> salpynx: "not very good, but convincing at first glance" describes generative AI perfectly honestly
23:33:57 -!- sbak has quit (Quit: Leaving).
23:37:19 <fizzie> ^bf ++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
23:38:19 <fizzie> Per ChatGPT, that was supposed to output "ChatGPT". It even explained how: https://chatgpt.com/share/d8df2bc6-2d6f-46c7-b54c-2699dd64fc04
23:38:51 <salpynx> lol, I was about to joke that's a best case scenario of how an ai would respond to that prompt!
23:39:15 <salpynx> I thought you were just testing f_ngot's bf ability!
23:40:48 <fizzie> Also asked for a Befunge program -- updated at the same link.
23:41:15 <fizzie> It wrote one with a rolled-out print loop and for some reason it outputs "ChaTGPt", which is an interesting capitalization.
23:41:24 <salpynx> I had similar interactions with chatGPT quite some time ago, if you were lucky it'd copy and paste exact working code from somewhere, unlucking it would modify it with totall incorrect symbols or layout
23:42:32 <fizzie> Asked it to use a loop instead, and now it prints "Hello, World!" again. Heh.
23:43:01 <fizzie> Except the loop's misaligned by one column so it actually just immediately exits after pushing the string to stack.
23:43:58 <fizzie> Besides, even a junior Befunge programmer should know the linear >:#,_ print loop is superior.
23:44:23 <ais523> I like using k for print loops
23:44:46 <ais523> I think it's because I've basically only used Befunge in cod golfing competitions and k is shortest
23:45:49 <ais523> anyway, I somehow suspect that there are so many BF hello worlds around that it finds it hard to write other things
23:46:00 <salpynx> I had a funny one with quantum circuits, it was surprisingly convincing, but it was getting something wrong. I simplified it down to two non-interacting qubits
23:46:20 <salpynx> turns out the ai could not imagine a 2 qubit cicuit where entanglement wasn't invloved
23:47:28 <salpynx> it could explain how the qubits did not interact, but them would go into detail about the resulting superposition. Apparently no one posts non-interacting qubit examples online
23:48:17 <ais523> hmm, an interesting BF-string-printing-related problem: suppose you can initialise the tape arbitrarily, then need to print a given string in the fewest characters possible, but don't know what the string is when you're initialising the tape
23:48:44 <ais523> so you're trying to initialise it to make arbitrary strings as tersely printable as possible
23:49:04 <ais523> there are almost certainly initialisations that are much better than all-zeroes
23:49:25 <ais523> (this isn't a precisely defined problem, just a general area of thought)
23:50:05 <salpynx> some kind of QWERTY cell layout (but for letter frequency not typewriter concerns)?
23:50:34 <ais523> BF string printing generally eventually comes down to adjusting multiple counters
23:50:56 <ais523> although there was one hello world program, that was the record holder for length at the time, which had a [>.] to print four characters
23:51:59 <salpynx> you'd want to just use ><. mainly, hmmm. I think I've done this before and sometimes for uncommon characters +- _is_ quicker than moving cells
23:52:41 <ais523> I have the impression that they use quite a lot of +-, <> are also used but to a lesser extent
23:53:05 <ais523> maybe the perfect tape initialisation would lead to programs where the <> were balanced with the +-
23:55:08 -!- Koen has quit (Quit: Leaving...).
23:55:25 <salpynx> I remember now, I was using bf to generate bf symbols, and had to optimise for this on a limited alphabet +-.,[]<>
23:56:13 <salpynx> ... that's the same problem, but with a reduced alphabet
23:56:27 <HackEso> 85 +++++++++++++[>+++++>++++++++>+++++++++><<<<-]>++.>.-------.>-.<<++++.+++++++++.++++. [268]
23:56:32 <fizzie> `! bf +++++++++++++[>+++++>++++++++>+++++++++><<<<-]>++.>.-------.>-.<<++++.+++++++++.++++.
23:56:57 <salpynx> wow, did you just add that, or was it always there?
23:57:00 <ais523> bf_txtgen has a very rigid template that it wants to fit all its programs into
23:57:04 <ais523> it's been there for a very long time
23:57:18 <ais523> I think it dates back to the HackEgo days?
23:57:38 <fizzie> Yeah, that's why it's under `! like that.
23:58:19 <fizzie> There's an option to set the number of cells used in the initialization, but it has to be set /a priori/, so to say.