←2019-01-05 2019-01-06 2019-01-07→ ↑2019 ↑all
00:00:11 <ais523> it's probably worth a separate answer if we can make it work
00:01:08 <ais523> how do you get the pointer back to the correct alignment after a zeroing happens?
00:02:51 <ais523> (one advantage I see is that it doesn't matter where it is, so long as the alignment is correct, which makes me more confident that it's possible)
00:03:54 <ais523> oh, you need to make it so that the "throwaway" counter is on the same alignment as a real counter, just further left; this likely makes many of the counters not function correctly but as long as sufficiently many of them do, it's still TC
00:04:50 <esowiki> [[Template:Yearcats]] https://esolangs.org/w/index.php?diff=58960&oldid=53929 * Oerjan * (+26) Updoot
00:06:54 <oerjan> ais523: Um, it's just a question of finding a Golomb ruler with *two* positions per value (mod p), then all the counters should work.
00:07:45 <ais523> oerjan: oh, the idea is that you maintain the ones at the left at 0?
00:07:54 <oerjan> Right
00:08:16 <oerjan> (They'll be briefly nonzero after they're hit, thus the cleanup mention)
00:10:02 <ais523> actually, I've been thinking a lot about a "resets to 0" variant of The Waterfall Model
00:10:39 <ais523> I believe this is TC if you permit the situation where two counters are 0, but the one that zeroed more recently increases the one that zeroed less recently, and the one that zeroed less recently decreases the one that zeroed more recently
00:10:54 <ais523> that would make this situation much cleaner
00:11:01 <ais523> that said, although I /believe/ that it's TC I haven't proved it
00:13:56 <ais523> if we're doing this in positive-reset Waterfall, then I assume your construction is that each real counter increases the corresponding fallback counter to its own reset value, and each real and fallback counter decreases the previous fallback counter by the reset value?
00:14:36 <oerjan> Yep
00:15:37 <ais523> oh, and to make the decrements work, each real and fallback counter has to decrease the /next/ counter by 1
00:16:15 <oerjan> 'xactly (you're basically restating point 2)
00:16:38 <ais523> yes, this is me trying to understand what you've written
00:18:22 <oerjan> I suppose summing it all up in one SE comment (I think I had one byte left) doesn't help.
00:25:08 <ais523> OK, so here's what the Erdős–Turán construction looks like, but it only hits half the moduli: https://tio.run/##y0rNyan8///w9Ic7lmgf2qR6aCnXwx3bDi8/tPXhzpb4w/sSDq10B7IObT20zs3OQOVY@8Odi8D8Rw1zHjXMBTK5DrcFHW5/1LTm4c7ZQMH///8bWgIA
00:25:27 <oerjan> Which is actually perfect for this use...
00:25:34 <oerjan> oh wait right
00:25:37 <oerjan> duh
00:26:40 <ais523> it'd be nice to find some way of creating small Golomb rulers that hit all of them twice
00:27:58 <oerjan> 2p
00:28:00 <oerjan> oops
00:29:11 <oerjan> 2p*f(i)+i, where f is any Golomb ruler.
00:29:34 <ais523> version with the moduli shown: https://tio.run/##y0rNyan8///w9Ic7lmgf2qR6aCnXwx3bDi8/tPPhzpZDK1UfNe4AMbYeWhd/eF/CoZXuUJ6bnYHKsfaHOxeB@Y8a5jxqmAtkch1uCzrc/qhpzcOds4GC////N7QEAA
00:30:11 <ais523> oerjan: OK, if it's 2p not just p, I think that works
00:30:19 <ais523> although of course you need each i twice
00:30:35 <oerjan> Well I mean to think of i,i+p as the pair for a counter
00:30:37 <ais523> probably isn't asymptotically optimal but it may be good enough in practice
00:31:24 <ais523> I'd expect that not to work, but maybe it does?
00:31:45 <oerjan> I mean 2p*f(i)+i, 2p*f(i+p)+i+p
00:31:54 <ais523> oh, that's better
00:32:12 <ais523> but now the "distance p between real and fallback counter" is intriguing me
00:32:44 <oerjan> It's not p, there's f(i+p) too
00:32:55 <ais523> it doesn't work, each real counter would have to decrease the previous one by the reset value
00:32:59 <ais523> which is too harsh a restriction
00:33:11 <ais523> so yes, full Golomb ruler for all the real and fallback counters
00:34:04 <oerjan> This is really just taking the p*f(i)+i construction for a Golomb ruler that hits each remainder once, and using 2p instead
00:34:35 <ais523> no, if you're hitting each remainder once, you need 2p*f(i)+i
00:35:03 <oerjan> Are we talking about the same thing
00:35:03 <ais523> because "high i minus low i" from one difference and "low i minus high i" from a different difference can subtract to more than p
00:35:07 <ais523> I think so
00:35:34 <ais523> a Golomb ruler has f(i)-f(j) all distinct, i.e. they differ by at least 1
00:35:50 <ais523> so p*f(i) and p*f(j) differ by at least p
00:35:53 <oerjan> No, because the differences have to be equal (mod p) to be equal
00:36:20 <oerjan> so if i<j, k<l, and j-i = l-k (mod p), then j-i=l-k
00:37:19 <ais523> if you use p*f(i)+i and p*f(j)+j, we're changing each of those differences by ±(p-1), so the difference can be adjusted by up to 2p-2
00:37:29 <oerjan> Let me try being less brief.
00:38:26 <ais523> OK, if f is increasing, I can believe it works
00:38:42 <ais523> (not sure, but I can see how that restriction might help)
00:39:26 <oerjan> Define g(i) = p*f(i)+i
00:40:02 <oerjan> Let i<j, k<l. Assume g(j)-g(i) = g(l)-g(k). (g is increasing too).
00:40:25 <oerjan> Then j-i = l-k (mod p), and thus j-i = l-k
00:41:01 <oerjan> And thus p*f(j)-p*f(i) = p*f(l)-p*f(k).
00:41:17 <oerjan> Thus j=l and i=k since f is Golomb.
00:41:40 <ais523> ah right, because f is increasing, the fact that two differences of g have the same sign means that the two differences of i also have to have the same sign
00:41:59 <ais523> so we can't produce a value greater than p by subtracting a negative number from a positive one
00:42:22 <esowiki> [[Bitch]] M https://esolangs.org/w/index.php?diff=58961&oldid=58957 * Helen * (-2) Fixed spelling mistakes
00:43:25 <esowiki> [[Bitch]] M https://esolangs.org/w/index.php?diff=58962&oldid=58961 * Helen * (+11) Undid mess up to popular problems section
00:43:43 <ais523> this construction is, what, O(n³)? that seems beatable but is likely already good enough
00:45:11 <oerjan> I think so, if we plug Erdős–Turan in as f
00:49:46 <ais523> I suspect even optimal Golomb rulers are O(n²), although the obvious pigeonhole argument doesn't work for that
00:53:24 <oerjan> I vaguely interpreted Wikipedia that way (although there's a possibility Erdős–Turan isn't asymptotically optimal despite what it says in the previous paragraph)
00:53:34 <ais523> http://oeis.org/A003022 does look pretty quadratic
00:55:36 <ais523> that said, I think these "each modulus twice" rulers can also be done in O(n²), just don't know how
00:56:18 <oerjan> "a(n) >= n(n-1)/2, with strict inequality for n >= 5 (Golomb)." it says further down on the page
00:57:31 <oerjan> Although the very first comment sounds a bit off - it's not the obvious definition but maybe it's equivalent somehow.
00:59:18 <oerjan> Oh wait it's almost obvious.
00:59:37 <oerjan> Just rearrange a-b=c-d into a+d=b+c.
01:02:52 <ais523> oh of course, then you need n(n-1)/2 distinct sums, so the largest sum must be at least n(n-1)/2, so the largest number must be at least n(n-1)/4
01:03:34 -!- sftp has quit (Ping timeout: 272 seconds).
01:31:46 <esowiki> [[Bitch]] M https://esolangs.org/w/index.php?diff=58963&oldid=58962 * Helen * (-2) Fixed interpreter code
01:34:23 -!- FreeFull has quit (Ping timeout: 246 seconds).
01:41:43 -!- Essadon has quit (Quit: Qutting).
01:54:45 <ais523> fwiw, you can trivially improve the Erdős–Turan construction by subtracting rather than adding k², and if you're using a 4n-3 prime that gives you the other half of the values mod p
01:54:49 <ais523> *4n+3 prime
01:57:26 <ais523> I was hoping there'd be some way to stitch the two together by, e.g., running two identical copies of the same The Waterfall Model program (thus not needing any interaction between the two, or differences between the two halves), but I don't think it works
02:37:43 -!- tromp has quit (Remote host closed the connection).
02:50:29 <esowiki> [[BuxRo]] N https://esolangs.org/w/index.php?oldid=58964 * Areallycoolusername * (+632) Created page with "An esolang created by [[User: Areallycoolusername]]. It has only one command and that's "Oof...". This command is used to print whatever the user desires. When any other word..."
02:53:27 -!- tromp has joined.
02:57:33 <oerjan> If there were some way to replace k² by a permutation of 0,...,p-1, then that would be O(p^2).
02:57:54 -!- tromp has quit (Ping timeout: 244 seconds).
02:58:48 <oerjan> It needs to have the property that if s(l)-s(k)=s(j)-s(i) and l-k=j-i, then l=j.
03:01:58 <oerjan> Oh the first equation needs to be (mod p), probably.
03:02:18 <oerjan> No wait it doesn't.
03:04:27 <oerjan> (It replaces (k² mod p), not just k²)
03:04:37 <oerjan> *s
03:06:48 <oerjan> Wait, is this the same as a Costas array
03:07:13 <oerjan> I think it is
03:07:19 <oerjan> ais523: ^
03:07:54 <oerjan> (Which I just found in the links from w:Golomb ruler)
03:07:59 <ais523> oh right, I think it might be
03:08:39 <ais523> I was thinking along the same lines myself, I was sitting in Brachylog looking for permutations
03:08:44 <oerjan> heh
03:09:21 <ais523> (and obviously, you can get the "repeated" property via producing a Golomb ruler of length 2p)
03:09:35 -!- eico has joined.
03:09:41 <oerjan> Yeah
03:10:49 <ais523> unfortunately, even numbers are not prime, but there's a construction on the Wikipedia article for arrays whose size is a prime power minus 3
03:10:52 <ais523> that's capable of being even
03:11:16 <ais523> oh, also for prime numbers minus 1
03:11:27 <ais523> which is simpler, and also capable of being even (in fact, it nearly always is)
03:18:41 <oerjan> That's Golomb ruler of *order* 2p btw, length means the maximal distance.
03:20:09 <ais523> OK, so we have c counters, and we want 2c+1 to be prime, and we calculate our counter locations (of both real and fallback counters) as 4ck+(((r**k)-1)%2c), where r is a primitive root of 2c+1
03:26:51 <oerjan> Whee!
03:28:59 -!- tromp has joined.
03:30:37 -!- eico has quit (Quit: Leaving).
03:49:55 -!- Lord_of_Life has quit (Ping timeout: 258 seconds).
03:52:47 -!- Lord_of_Life has joined.
03:55:02 <esowiki> [[Qwote]] N https://esolangs.org/w/index.php?oldid=58966 * Areallycoolusername * (+331) Created page with "Qwote is an [[esoteric programming language]] created by [[User: Areallycoolusername]]. The only valid commands are single and double quotes. The language is binary, so 0s are..."
03:56:41 <esowiki> [[Works in progress]] https://esolangs.org/w/index.php?diff=58967&oldid=56222 * Areallycoolusername * (+14)
03:57:23 <esowiki> [[Works in progress]] https://esolangs.org/w/index.php?diff=58968&oldid=58967 * Areallycoolusername * (-2)
04:00:43 <esowiki> [[Qwote]] https://esolangs.org/w/index.php?diff=58969&oldid=58966 * Areallycoolusername * (+136)
04:01:29 <ais523> oerjan: a potential problem with this construction: how do we prevent non-counter cells becoming 0 as we iterate over them?
04:01:44 <ais523> oh, because they never get decremented
04:02:16 <ais523> or, hmm
04:02:19 <esowiki> [[Joke language list]] https://esolangs.org/w/index.php?diff=58970&oldid=58921 * Areallycoolusername * (+45)
04:02:26 <oerjan> That was my point 3...
04:02:47 <ais523> oh, I see
04:02:55 <ais523> I misread that, I thought you were doubling the distances between cells
04:03:04 <ais523> so that you had a working halt mechanism
04:03:20 <oerjan> Nope, on the contrary, it's halved.
04:03:51 <ais523> if we want to maintain halt behaviour we can double the distances and put a 1 to the left of non-halt counters, a 0 to the left of the halt counter
04:04:32 <oerjan> I had a different idea, namely to replace >>> and <<< with the distance between the halting counter and its fallback
04:04:50 <ais523> the halt counter's fallback won't be 0 though
04:05:02 <oerjan> We can make an exception for it
04:05:13 <oerjan> So it's not adjusted like the rest
04:05:14 <ais523> or, wait, it will be 0
04:05:30 <ais523> by the time we get round to the halt counter again
04:05:49 <ais523> the "mark the halt counters" approach is clearer to implement, but makes the program larger
04:06:10 <ais523> (well, unless the halt counter happens to be a long way from its fallback)
04:06:55 <oerjan> I mean that it works like this: When the halting counter is hit and 0, it does *not* adjust its fallback, instead keeping it zero so that hits it and exits.
04:07:05 <oerjan> (Almost immediately)
04:07:45 <ais523> ah yes, I think that works
04:14:26 <oerjan> Although the other method allows more easily more than one halt counter
04:20:00 <esowiki> [[User:Cortex/draft]] https://esolangs.org/w/index.php?diff=58971&oldid=58947 * Cortex * (+62)
04:22:22 -!- uplime has joined.
04:23:56 <oerjan> Not sure my point 4 (keeping all irrelevant cells non-negative) works.
04:24:10 <ais523> nor am I, but I don't think it matters for this
04:24:38 <ais523> the constant factor of this construction appears to be 16 (i.e. it uses less than 16×c² cells, for c counters with 2c+1 prime)
04:24:53 <ais523> that's with your version of the halting code
04:25:14 <ais523> wait, no, 24
04:25:35 <oerjan> Well I thought it would be a nice restriction to add, since not all bignum BF support negative numbers.
04:26:06 -!- imode has quit (Ping timeout: 252 seconds).
04:26:11 <ais523> the ruler itself takes up 8c² squares, and the movement of the tape head can overshoot up to the length of the ruler in either direction (plus a small constant, less than c, to the right)
04:28:15 <oerjan> 10c² squares, isn't it?
04:31:08 -!- imode has joined.
04:31:38 <oerjan> 4c*2c + 2c
04:33:32 <oerjan> The overshoot to the left is due to the halting mechanism, no, so might be minimized by choosing a halting counter close to its fallback
04:33:39 <oerjan> *no?
04:35:37 <oerjan> Wait never mind
04:35:51 <oerjan> seeing c^2 where none is
04:40:19 <oerjan> (g^i mod (2c+1)) = (g^j mod (2c+1)) (mod c) might not be trivial to solve
04:41:00 <oerjan> minimzing j-i
04:43:41 <oerjan> hm
04:46:23 <oerjan> g^(i+1)-g^i = (g-1)*g^i, that can easily be made c (mod (2c+1)), although then it may be 50% whether that's actually 1-c instead.
04:47:15 <oerjan> Er
04:47:28 <oerjan> Yes
04:48:41 <oerjan> No wait, -1-c
04:49:39 <oerjan> If this is random, there should be a good chance of getting a small distance by trying g^(i+k)-g^i for growing k.
04:55:56 <ais523> I'm now using the formula 4ck-(((r**k)-1)%2c) (with a - not a +), which works for the same reason and gives a slightly shorter ruler
04:56:32 <ais523> as for the overshoot to the left, there are two things that can cause it: a write overshoot (the length of the ruler), and a read overshoot (the distance between halt and halt-fallback)
04:56:33 <oerjan> I think you want %(2c+1)
04:56:39 <ais523> yes
04:56:50 <ais523> I've corrected that in the program I'm writing but forgot to in my paste
04:57:37 <oerjan> Slightly shorter ruler assuming r is small
04:57:40 <ais523> <http://nethack4.org/esolangs/2bbf.pl> Smallest primitive root of 23 is 5. Formula is thus 2*22*i - (5**i)%23 + 1.
04:57:50 <ais523> it's slightly shorter regardless
04:58:26 <oerjan> Oh at the right end
04:58:34 <ais523> yep
04:58:45 <oerjan> The left won't matter because it's +-0
04:58:47 <ais523> (the link there is unfinished, but I thought I'd show my work so far)
05:18:19 <zzo38> What should I call program implementing Z-machine with Glulx?
05:20:36 <oerjan> ais523: BTW the very first counter should probably be pre-decremented at initialization (unless you want to consider execution to start with the second one)
05:22:59 <ais523> oh right, good point
05:23:48 <ais523> wait, no
05:24:03 <ais523> I'm starting execution with the last counter's fallback so that things start at the right place
05:24:28 <ais523> that means I should pre-/increment/ the last counter at initialization, because it will be decremented by the code for counter 0
05:24:36 <oerjan> I suppose it doesn't actually matter, because of the rule that a TWM program can only zero one counter at a time
05:24:53 <ais523> indeed
05:25:42 <oerjan> Wait
05:26:03 <ais523> specifically, I'm starting in a hypothetical state just after the fallback for the last counter ran
05:26:04 <oerjan> I envisioned that the code for a counter/fallback decrements the *next* counter.
05:26:38 <ais523> hmm, again I don't think it matters
05:27:04 <ais523> is it worth rewriting this code I've already written for the slight clarity gain?
05:27:06 <ais523> I guess it is
05:28:48 <ais523> OK, that didn't take long
05:40:44 -!- MDude has quit (Ping timeout: 250 seconds).
05:59:24 -!- MDude has joined.
06:07:36 -!- heroux has quit (Ping timeout: 250 seconds).
06:08:44 -!- heroux has joined.
06:13:27 <ais523> oerjan: it works!
06:15:11 <ais523> http://nethack4.org/esolangs/2bbf.pl is the compiler; https://tinyurl.com/y7nfzxhh is an example of a compiled The Waterfall Model program (included BF interpreted by @ASCII-only on PPCG)
06:15:42 <ais523> *interpreter
06:18:53 -!- eico has joined.
06:19:21 <ais523> oerjan: I'll let you write up the construction on cs.se if you wish, because it's mostly yours; if you don't want to I can do it for you, although probably not tonight
06:23:21 -!- eico has quit (Client Quit).
06:23:30 <ais523> it crosses my mind that we could probably even make this do output (although we'd have to be outputting NULs every loop iteration which wouldn't otherwise output unless we used a third pair of brackets, and the output operations would be "increment output value", "output output value", "decrement output value" rather than "increment output value", "output output value and zero it")
06:26:18 <esowiki> [[Brainfuck]] https://esolangs.org/w/index.php?diff=58972&oldid=58929 * Ais523 * (+501) /* Computational class */ 3-loop brainfuck improved to 2-loop brainfuck
06:27:05 <ais523> I guess this gives an alternative proof that BF only needs nesting level 2 to be TC ;-)
06:27:57 <oerjan> Actually the proof that's there requires unbounded tape length but bounded cells, unlike this one.
06:28:09 <oerjan> So it's a different case.
06:28:30 <oerjan> (Which I'd been hoping to solve as well)
06:29:40 <esowiki> [[Brainfuck]] https://esolangs.org/w/index.php?diff=58973&oldid=58972 * Ais523 * (+3) /* Computational class */ fix my misremembering of the complexity of the two-bracket-pair construction
06:30:00 <esowiki> [[Brainfuck]] M https://esolangs.org/w/index.php?diff=58974&oldid=58973 * Ais523 * (-1) /* Computational class */ typo fix
06:30:20 <ais523> oerjan: I know, and it works in BF-- too
06:30:22 <ais523> which is a lot harder
06:30:26 <ais523> that's what the wink was for
06:30:41 -!- MDude has quit (Quit: Going offline, see ya! (www.adiirc.com)).
06:30:50 -!- MDead has changed nick to MDude.
06:37:01 -!- ais523 has quit (Quit: quit).
06:46:14 -!- oerjan has quit (Quit: Nite).
07:04:20 <esowiki> [[]] https://esolangs.org/w/index.php?diff=58975&oldid=58640 * Salpynx * (-31) /* Non-Latin Hello Worlds */ fix capitalisation and spacing in output
07:52:13 -!- tromp has quit (Remote host closed the connection).
07:52:25 -!- tromp has joined.
08:12:59 <imode> what could be more primitive than finite state machines.
08:15:27 <pikhq> Stateless machines?
08:16:04 <imode> would you even consider them "machines" at that point? :P
08:16:24 <shachaf> Are functions stateless machines?
08:16:46 <imode> not really, no.
08:19:34 <imode> when carrying out the computation of a function given an input, there's always some state, be it in your head or on paper.
08:19:45 <imode> it may be in the form of rewriting an expression.
08:25:14 -!- AnotherTest has joined.
08:30:31 <shachaf> I mean, if you describe a machine with state, you probably have a lookup table corresponding to which state you're in, which input you see, which action you take, which new state, etc.
08:30:46 <shachaf> If you remove the states from that, you just get a fixed lookup table for a function.
08:32:24 <imode> well when you put it like that, "lookup tables" are more primitive, but FSMs are defined in terms of, well, their transition function.
08:33:57 <imode> heh. you can't go much lower than that, unless you define constant functions..
08:40:42 <imode> then again, if you consider the "state" of a system and the current input as inputs to the transition function, an FSM _is_ a lookup table.
08:40:49 <imode> just a really weird one.
08:41:29 <imode> or rather, a nonobvious one. one with some extra logic on top of it. you hand in a state, it hands you back one, you hand that state back to it with a new input, it hands you back a new state.. etc. etc.
08:45:03 -!- AnotherTest has quit (Ping timeout: 252 seconds).
09:02:48 <imode> I wonder what the _smallest_ change you'd have to make to an FSM that'd make it turing complete would be.
09:02:59 <imode> part of me says communication.
09:12:27 -!- S_Gautam has quit (Quit: Connection closed for inactivity).
09:13:46 <imode> communicating state machines are interesting. if you allow an unbounded set of communication channels between finite state machines, this can be seen as a queue automaton.
09:15:29 <imode> a single machine can store its state by sending messages on a channel that's unique to it, thus encoding its internal state, and cycling through its messages and requeueing them.
09:15:40 <imode> hm.
09:20:40 <esowiki> [[Laser]] M https://esolangs.org/w/index.php?diff=58976&oldid=58946 * FizzyApple12 * (+29)
09:21:50 -!- sftp has joined.
09:28:37 -!- j-bot has quit (Remote host closed the connection).
09:37:32 <esowiki> [[Laser]] https://esolangs.org/w/index.php?diff=58977&oldid=58976 * FizzyApple12 * (-131)
10:03:44 <rdococ> How would a programming language where you map the old state to the new state with dataflow fare against a typical imperative language in terms of parallel programming?
10:07:30 -!- imode has quit (Ping timeout: 258 seconds).
10:16:52 <esowiki> [[Laser]] https://esolangs.org/w/index.php?diff=58978&oldid=58977 * FizzyApple12 * (-140) Put link to github repo
10:18:13 <esowiki> [[Laser]] M https://esolangs.org/w/index.php?diff=58979&oldid=58978 * FizzyApple12 * (+2) grammer
10:21:06 <esowiki> [[Laser]] M https://esolangs.org/w/index.php?diff=58980&oldid=58979 * FizzyApple12 * (+0) fix syntax in reference
10:21:57 -!- uplime has quit (Quit: WeeChat 2.2).
10:28:55 -!- AnotherTest has joined.
10:35:09 -!- AnotherTest has quit (Ping timeout: 252 seconds).
11:35:30 -!- AnotherTest has joined.
11:45:08 -!- AnotherTest has quit (Ping timeout: 272 seconds).
11:52:20 -!- AnotherTest has joined.
11:54:57 <esowiki> [[Bitch]] M https://esolangs.org/w/index.php?diff=58981&oldid=58963 * Helen * (+0) Fixed truth-machine code
12:04:01 -!- AnotherTest has quit (Ping timeout: 244 seconds).
12:15:30 -!- zzo38 has quit (Ping timeout: 250 seconds).
12:29:18 -!- arseniiv has joined.
13:44:18 -!- AnotherTest has joined.
14:15:36 -!- AnotherTest has quit (Ping timeout: 252 seconds).
14:20:49 -!- b_jonas has joined.
14:21:02 <b_jonas> oh! so ais523 has a separate account for golf SE from the rest of SE.
14:22:01 <b_jonas> https://cs.stackexchange.com/questions/102363/how-many-pairs-of-brackets-in-bf-be-sufficient-enough-to-make-it-turing-complete/102369#102369
14:29:02 -!- Essadon has quit (Max SendQ exceeded).
14:45:44 <rain1> https://i.imgur.com/cnCBR0d.png my IRC client liked that link
15:34:15 <b_jonas> ? oerjen
15:34:17 <HackEso> oerjen? ¯\(°​_o)/¯
15:39:14 <b_jonas> ? tla
15:39:15 <HackEso> tla? ¯\(°​_o)/¯
15:39:17 <b_jonas> ? acronym
15:39:18 <HackEso> acronym? ¯\(°​_o)/¯
15:39:27 <b_jonas> ? xtla
15:39:29 <HackEso> xtla? ¯\(°​_o)/¯
15:39:29 <b_jonas> ? etla
15:39:30 <HackEso> etla? ¯\(°​_o)/¯
15:41:38 <b_jonas> In Super Mario, spiny eggs have spines right when they are laid by the lakitu. Doesn't that have somewhat disturbing implications for the mother spiny?
15:42:07 <b_jonas> And those spikes can't be soft either, because they hurt Mario.
15:48:07 -!- Lord_of_Life_ has joined.
15:51:33 -!- Lord_of_Life has quit (Ping timeout: 246 seconds).
15:51:33 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
15:55:21 <b_jonas> ? tas
15:55:22 <HackEso> TAS is a tool-assisted speedrun: a race in which participants must use quality tools such as the PHP hammer, Autoconf, and the Arkenpliers to assist them in running.
15:55:48 <b_jonas> or "totally authentic speedrun"
16:07:08 <Taneb> b_jonas: maybe they harden after a short contact with air
16:09:44 <b_jonas> http://math.ucr.edu/home/baez/diary/december_2018.html#december_28 Wow, this is a strange way to get inspiration for computability results. "I'd never heard before that the Church-Turing thesis was born right after Kleene got dosed with laughing gas!" on John Baez's blog
16:10:24 <b_jonas> sadly it might be false
16:12:33 <b_jonas> apparently he was anesthesized but we don't specifically know if it's laughing gas, and the number of wisdom teeth pulled is in question
16:14:31 <Taneb> Hmm, how was it first proven that Turing machines are as computationally powerful as the lambda calculus?
16:14:42 <b_jonas> Maybe that's the ultimate question of Life, Universe, and Everything. How many wisdom teeth do you need to get pulled to be in such an altered mental state that you prove P!=NP? 42.
16:20:14 <int-e> that's a lot of teeth
16:27:39 -!- ais523 has joined.
16:31:08 <arseniiv> b_jonas: Baez gives a wrong formula for nitrous oxide (correct N2O) :( I strongly hope it’s a typo or a memory error
16:31:23 <arseniiv> as NO2 is fairly toxic
16:31:39 -!- ais523 has quit (Remote host closed the connection).
16:32:52 -!- ais523 has joined.
16:39:18 -!- Sgeo_ has joined.
16:41:07 -!- Sgeo has joined.
16:41:48 -!- kritixilithos has joined.
16:42:33 -!- Sgeo__ has quit (Ping timeout: 252 seconds).
16:43:44 -!- Sgeo_ has quit (Ping timeout: 250 seconds).
16:44:28 -!- Sgeo_ has joined.
16:46:14 <ais523> @tell oerjan simpler construction (untested but feels like it should work): instead of one fallback counter per waterclock, have two global fallback counters that zero each other and decrement every waterclock, then use [<] as the inner loop rather than doing something mod-number-of-counters
16:46:14 <lambdabot> Consider it noted.
16:47:12 -!- Sgeo has quit (Ping timeout: 250 seconds).
17:05:28 <b_jonas> arseniiv: no, Baez quotes an article that gives the wrong fortuna, and then Baez points out the error in his own text
17:05:34 <b_jonas> hmm wait
17:05:42 <b_jonas> he gives the wrong correction?
17:05:49 <b_jonas> let me see
17:06:18 <b_jonas> hmm, you're right. Baez writes "NO_2".
17:06:30 <b_jonas> that really seems wrong.
17:07:00 <b_jonas> let me drop him a mail
17:16:26 -!- AnotherTest has joined.
17:17:19 <arseniiv> b_jonas: oh, it would be nice!
17:23:27 -!- AnotherTest has quit (Ping timeout: 264 seconds).
17:28:38 <b_jonas> also, TWO PAIRS OF BRACKETS in bignum brainfuck, wow.
17:29:22 <b_jonas> by the way, oerjan, does that construction work with only zero and positive values in tape cells? I think it does, but I don't know for sure
17:34:04 <ais523> b_jonas: not obviously; it's hard to adjust all the possible decremented cells to keep them positive
17:34:18 <ais523> the "simpler construction" above may be easier to keep cells positive
17:34:44 <ais523> it is the case that if a cell goes negative at any point, we never read it as 0 at any point
17:40:41 <b_jonas> hmm
17:41:00 <b_jonas> ok
17:44:51 <b_jonas> but aren't all the adjustments using the bulk of the matrix positive, and you only decrement real counters one by one?
17:45:02 <b_jonas> jumping from counter to counter
17:46:02 <ais523> b_jonas: the two-bracket construction decrements all sorts of random tape cells
17:46:38 <ais523> because the only way it has to do an if statement is to change a cell at a fixed offset from the pointer, in such a way that if the condition is false, the changed cell isn't used for anything
17:47:01 <ais523> the construction has conditional decrements, so that's a lot of random unused cells being decremented
17:54:14 <esowiki> [[APLWSI]] https://esolangs.org/w/index.php?diff=58982&oldid=58102 * Weirdlang * (+3) /* Interpreter */
17:54:52 <esowiki> [[User:Weirdlang]] N https://esolangs.org/w/index.php?oldid=58983 * Weirdlang * (+7) Created page with "My page"
17:56:32 <esowiki> [[User:Weirdlang]] https://esolangs.org/w/index.php?diff=58984&oldid=58983 * Weirdlang * (+28)
18:00:16 <b_jonas> ais523: ok, so this is a difference between the two bracket and the three bracket
18:01:10 <esowiki> [[APLWSI]] https://esolangs.org/w/index.php?diff=58985&oldid=58982 * Weirdlang * (+10)
18:01:53 <arseniiv> it seems there are almost no(?) languages supporting arbitrary-element regexes. It calls for a prefix encoding of arbitrary natural numbers by regex-easy strings, which means it better be free of escapes, as some people may want to debug those regexes. So I come to an encoding like this:
18:01:53 <arseniiv> write a number in base 32, then code the leading digit as A…Z0…4@ and all other digits as a…z5…9&. But maybe there is something both more performant (decoding included) and space efficient?
18:03:04 <arseniiv> (A…Z0…4@ means 'A' ~ 0, 'B' ~ 1, … '4' ~ 30, '@' ~ 31)
18:04:08 <ais523> some fixed prefix character followed by base 64 digits?
18:05:54 <arseniiv> darn, I have looked at that but gone it all wrong (n backticks then n base-64 digits, so obviously it was worse)
18:06:15 <arseniiv> thank you, it should be better for big element sets
18:07:07 <arseniiv> s/gone/done
18:08:19 -!- kritixilithos has quit (Quit: :q).
18:09:13 -!- spiegelau has joined.
18:12:28 <esowiki> [[APLWSI]] https://esolangs.org/w/index.php?diff=58986&oldid=58985 * Weirdlang * (+21)
18:16:14 -!- Sgeo__ has joined.
18:16:53 -!- imode has joined.
18:19:30 -!- Sgeo_ has quit (Ping timeout: 250 seconds).
18:26:58 <esowiki> [[Laser]] https://esolangs.org/w/index.php?diff=58987&oldid=58980 * FizzyApple12 * (+15)
18:27:55 -!- FreeFull has joined.
18:32:26 <b_jonas> ? thrice
18:32:28 <HackEso> thrice? ¯\(°​_o)/¯
18:32:34 <b_jonas> ? third
18:32:35 <HackEso> third? ¯\(°​_o)/¯
18:34:18 -!- hexfive has joined.
18:34:24 <esowiki> [[Laser]] https://esolangs.org/w/index.php?diff=58988&oldid=58987 * FizzyApple12 * (+44) Add cat program to example codde
18:35:41 -!- uplime has joined.
18:36:23 <esowiki> [[Laser]] M https://esolangs.org/w/index.php?diff=58989&oldid=58988 * FizzyApple12 * (+11) fix truth machine example
18:47:16 -!- tromp has quit (Remote host closed the connection).
19:15:31 -!- tromp has joined.
19:50:20 <arseniiv> ais523: hmm, it shows not to be so efficient for e. g. int32s; random int32 encodes as ≈6.742 chars for base-32 code and ≈6.746 chars for base-64 code, and for int64s the results are ≈12.9 vs ≈11.9, here we begin to reap the economy sown; for entities counting in hundreds or thousands the base-32 code seems still more affordable (≈2.0 vs ≈2.9 for random numbers in 0..999)
19:50:52 <ais523> arseniiv: as with all these things, it depends on how large you expect the values to get
19:51:09 -!- AnotherTest has joined.
19:51:34 <arseniiv> yeah, I remember some Knuth article on some encoding like these
19:51:34 <ais523> binary may be best for performance, for example, as it simplifies the regexes that have to do calculations on it
19:55:30 -!- AnotherTest has quit (Ping timeout: 252 seconds).
19:56:46 <int-e> arseniiv: hmm, fancy. so you can get down to 5.742 if you use an alphabet of size 64, but use the lowest bit to indicate whether it's the last character in the encoding of a number or not.
19:57:26 <int-e> > 6 - (sum [32^i | i <- [0..6]] / 2^32)
19:57:28 <lambdabot> 5.741935483878478
19:57:35 <int-e> > 6 - (sum [64^i | i <- [0..5]] / 2^32)
19:57:37 <lambdabot> 5.746031746035442
19:58:01 <arseniiv> hm I was calculating it the other way…
19:59:01 <arseniiv> the longer one, alas
20:00:02 <int-e> hmm, something is wrong there
20:00:08 <int-e> > 7 - (sum [32^i | i <- [0..6]] / 2^32)
20:00:10 <lambdabot> 6.741935483878478
20:00:17 <arseniiv> it seems these are off by 1, yes
20:00:26 <int-e> > 1+6 - (sum [64^i | i <- [0..5]] / 2^32)
20:00:29 <lambdabot> 6.746031746035442
20:02:47 <int-e> > 7 - (sum [32^i | i <- [1..6]] / 2^32) -- oops, the empty encoding for 0 doesn't work here
20:02:49 <lambdabot> 6.741935484111309
20:02:56 <int-e> (not that it makes any big difference)
20:10:36 -!- spiegelau has quit (Quit: leaving).
20:15:31 -!- hexfive has quit (Read error: Connection reset by peer).
20:16:08 <int-e> arseniiv: hmm, given the way regular expression matching usually works... wouldn't it be helpful if we had an encoding that is both a prefix- and suffix-code?
20:16:36 <arseniiv> didn’t think about that
20:20:38 <arseniiv> I picked one of them so there wouldn’t be potential matchings of not exactly well-formed subsequences of the input, not because of efficiency
20:22:21 <int-e> arseniiv: uhm, that *is* my question though. We don't have that property.
20:23:14 <int-e> in the base64 thing, the encoding of 1 is a prefix of the encoding of 64; in the base32 version it's similar for 1 and 32.
20:24:16 <arseniiv> ow
20:25:31 <arseniiv> yeah, the last two days I’m too inattentive to almost all I’m doing :(
20:27:59 <arseniiv> in ais523’s modification, we could somewhat leverage this, though, adding the separator character at the end of string and modifying regexes
20:28:24 <arseniiv> I think it can be complex, however
20:32:02 <arseniiv> either should we use a fixed-length slice of these encodings or think up something a la UTF-8
20:32:22 <arseniiv> maybe I even thought of the first case originally
20:34:35 <b_jonas> base 2? base 32? base 64? why would you ever want a representation of integers other than nega-Zeckendorf?
20:35:49 <b_jonas> unless it's for compatibility with displaying the score when your human players don't natively read nega-Zeckendorf and you don't want to do a radix conversion every time the player hits an enemy or gets a coin
20:36:26 <b_jonas> but come on, who cares about selling games to people who can only read hexadecimal
20:37:35 <arseniiv> b_jonas: did you accidently mean octal?
20:37:36 <int-e> b_jonas: nega-Zeckendorf arithmetic is hard. And besides it doesn't satisfy the prefix- and suffix-code desideratum
20:38:06 <arseniiv> accidentally*
20:38:09 <ais523> clearly you should be using Radixal!!!! numbers
20:38:28 <b_jonas> int-e: yes, I know it's hard. I couldn't even figure out its rules properly, but zzo38 did figure them out
20:39:28 -!- Phantom_Hoover has joined.
20:39:47 <b_jonas> ais523: which one is that? it's not the one with binomial coefficients all the way down, right? maybe it's one of those crazy ones that logicians study about statements independent of Peano-arithmetic?
20:40:24 <ais523> b_jonas: it's a notation invented to be difficult in an esolang
20:40:26 <b_jonas> and... I'm afraid to ask this. how many of the four exclamation points are part of the name?
20:40:31 <ais523> and all four
20:40:35 <int-e> b_jonas: I did increment manually at some point: https://github.com/int-e/zeckendorf/blob/master/NegaZeckendorf.hs#L32-L42
20:45:22 <int-e> b_jonas: and I have horrible generated code for the simplification part of the addition: https://github.com/int-e/zeckendorf/blob/master/simps.hs#L145-L187 (the simplification part takes the sequence of sums of digits from the two input numbers (so now we have digits with values 0, 1, and 2) and turns it back into a nega-Zeckendorf number.)
20:46:40 <imode> do you use bitvectors to represent which "digits" are present or am I thinking of another thing.
20:48:00 <b_jonas> ais523: wow. Radixal!!!! looks like a language that's designed to be hard for humans to understand, even though it probably isn't as horrible as it seems
20:48:09 <int-e> imode: there are no bitvectors in that code, I think.
20:48:15 <b_jonas> int-e: sorry, did I confuse you with zzo then?
20:48:31 <ais523> b_jonas: pretty much
20:49:52 <int-e> b_jonas: I don't know. I don't keep track of zzo's doings.
20:49:55 <b_jonas> I implemented zeckendorf, binary, and even decimal arithmetic, but nega-Zeckendorf is just too scary. the obvious way to do addition leads to carries that go both left and right in a way that it's not clear why they can't take up a long time to resolve.
20:52:47 <b_jonas> Then there's some nice mixed bases, like the mayan or babylonian or whatever it is base 20,18,20,20,20,20,..., and http://www.madore.org/~david/weblog/d.2015-11-09.2335.html#d.2015-11-09.2335 for base 6,5,6,5,6,5,6,5,...
20:53:52 <int-e> . o O ( 365.2425,24,60,60 )
20:55:45 <arseniiv> my favorite base is 1,2,3,4,5,…
20:57:21 <int-e> b_jonas: it turns out that, somewhat miraculously, you never need more than one carry per place. In addition, as you keep processing digits from the least significant, you can always prune some of those possibilities away and only a bounded number remains.
20:58:17 -!- zzo38 has joined.
20:58:33 <int-e> But I forgot a lot of the details.
20:59:23 <b_jonas> int-e: yeah, you can turn it to a nice proper state machine that can do serial addition, ancient shift register ALU style
21:00:11 <arseniiv> oh, these things reminded me about my unsuccesful Clifford algebra crush. Did someone here implemented them in any way?
21:01:55 -!- Sgeo has joined.
21:02:08 <arseniiv> a naive implementation would suffer from O(2^n) space for each element in an algebra on an n-dimension vector space, but general elements are rare in practically interesting calculations
21:02:16 -!- AnotherTest has joined.
21:03:37 <arseniiv> though elements of a spin group have 2^(n−1) elements in general, and they are useful
21:03:54 <arseniiv> so not so many economy
21:03:58 <arseniiv> much*
21:04:07 -!- Sgeo__ has quit (Ping timeout: 240 seconds).
21:05:36 -!- uplime has quit (Quit: WeeChat 2.2).
21:13:36 -!- AnotherTest has quit (Ping timeout: 252 seconds).
21:35:15 <b_jonas> [ 15%3.3
21:35:21 <b_jonas> ( 15%3.3
21:35:25 <b_jonas> ) 15%3.3
21:35:32 <b_jonas> no j-bot? hmm
21:35:45 <b_jonas> perl -ewarn 15/3.3
21:35:46 <HackEso> 4.54545454545455 at -e line 1.
21:45:21 <ais523> b_jonas: why not -Esay?
21:53:56 <arseniiv> ? algol
21:53:57 <HackEso> ALGOL stands for A Programming Language
21:54:17 <arseniiv> ? algorithm
21:54:18 <HackEso> Algorithms (derived from the medieval "algorisms") are popular sayings by former president Al Gore, except for God's Algorithm which was invented by a Google computer cluster.
21:54:34 <arseniiv> ? modula
21:54:35 <HackEso> modula? ¯\(°​_o)/¯
21:54:38 <arseniiv> ? module
21:54:40 <HackEso> A module is like a vector space, except with a ring instead of a field.
21:54:45 <arseniiv> ? modular
21:54:47 <HackEso> modular? ¯\(°​_o)/¯
21:54:55 -!- uplime has joined.
21:55:30 -!- j-bot has joined.
21:55:35 <Luciole> [ 'j-bot restored'
21:55:36 <j-bot> Luciole: j-bot restored
21:56:35 <arseniiv> think we should call a language nonmodular when it thinks that x mod 0 ≠ x?
22:05:22 <ais523> arseniiv: x mod 0 = x would imply x / 0 was valid and evaluated to something
22:05:32 <ais523> I agree that x mod 0 cannot definedly be anything other than x though
22:05:54 <ais523> err, that's integer division x/0
22:06:18 <ais523> I can sort-of see a perverse argument that x/0 is 0 with integer division but Inf with real-number division…
22:06:32 <ais523> except for 0/0, which is of course always _ from Prolog
22:06:40 <int-e> > 2 mod 0
22:06:42 <lambdabot> *Exception: divide by zero
22:07:06 <arseniiv> we also could define mod n as a canonical homomorphism Z → Z/nZ, and Z/0Z is Z sooo…
22:07:09 <ais523> > -1 mod 5
22:07:11 <lambdabot> -1
22:07:14 <ais523> oh come on
22:07:33 <ais523> perl -E say -1 % 5
22:07:34 <HackEso> 4
22:07:37 <ais523> that's better
22:08:06 <ais523> that said, Perl doesn't actually have an integer division operation
22:08:07 <arseniiv> > -1 rem 5
22:08:09 <lambdabot> -1
22:08:15 <arseniiv> whaat
22:08:15 <ais523> perl -E {use integer; say -1 / 5}
22:08:16 <HackEso> 0
22:08:30 <fizzie> perl -E {use integer; say -1 % 5}
22:08:30 <HackEso> ​-1
22:08:31 <ais523> "use integer" just gives access to the underlying operations on the processor
22:08:36 <arseniiv> > (-1) mod 5
22:08:38 <lambdabot> 4
22:09:00 <ais523> arseniiv: I expected that to be a type error
22:09:13 <ais523> > (+1) mod 5
22:09:15 <lambdabot> error:
22:09:15 <lambdabot> • No instance for (Integral (Integer -> Integer))
22:09:15 <lambdabot> arising from a use of ‘e_115’
22:09:22 <fizzie> I'm sort of happy it follows the (a/b)*b + a%b == a rule under 'use integer'.
22:09:23 <int-e> unary minus is a special case in the Haskell syntax
22:09:39 <ais523> fizzie: 'use integer' is basically just metacircular
22:09:49 <arseniiv> I always forget what (-1) and (- 1) are and what they aren’t in Haskell
22:09:50 <ais523> so there are few guarantees about what it actually does
22:10:07 <int-e> arseniiv: they're the same
22:10:24 <int-e> arseniiv: unless you enable the NegativeLiterals extension
22:10:33 <arseniiv> for some time I’ll surely remember
22:10:43 <arseniiv> :D
22:10:53 <int-e> With that extension, -1 mod 5 == 4
22:11:04 <int-e> but - 1 mod 5 = -1
22:11:14 <ais523> how does -1 mod 5 even parse?
22:11:31 <int-e> ais523: unary minus, at a lower precedence than mod
22:11:41 <arseniiv> yes, it was strange and unobvious
22:11:41 <ais523> oh, and 1 mod 5 is 1
22:11:45 <int-e> > negate (mod 1 5)
22:11:48 <lambdabot> -1
22:12:41 <ais523> I can sympathise with C's rules that unary operators are always tighter than anything else, it's at least easy to remember
22:13:09 <int-e> > -2^2
22:13:11 <lambdabot> -4
22:13:34 <arseniiv> what is a precedence of unary minus exactly btw?
22:14:12 <int-e> this is why it has a precedence lower than ^ on level 8, and * is on level 7, as are all the other multiplicative operators, including mod.
22:14:15 <arseniiv> (or maybe it’s mod that has an unusual one?)
22:14:48 <imode> anybody know any literature on proving the turing completeness of communicating state machines?
22:14:51 <ais523> I'm surprised that identifier operators even have precedences of their own, rather than all being the same
22:14:59 <arseniiv> so -2 * 3 will parse as -(2 * 3)?
22:15:03 <ais523> imode: where does the infinite memory come from?
22:15:32 <arseniiv> ais523: yeah, you can assign even a fixity to -operation!
22:15:38 <imode> ais523: the channels used for communication are unbounded queues.
22:16:07 <imode> but from what I can see, don't contain more than one kind of symbol.
22:16:25 <b_jonas> [ 15%3.3
22:16:25 <j-bot> b_jonas: 4.54545
22:16:26 <ais523> imode: well it's obvious you can implement, e.g., cyclic tag with that
22:16:39 <int-e> arseniiv: "Prefix negation has the same precedence as the infix operator - defined in the Prelude (see Table 4.1). " https://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-280003.4
22:17:52 <imode> ais523: right, I'm wondering if anybody's done it already. like I'd like to see a specific construction to wrap my head around it.
22:18:25 <arseniiv> int-e: thank you! Interesting, this choice seems not so odd now
22:19:02 <int-e> > 1 + -1
22:19:04 <lambdabot> error:
22:19:04 <lambdabot> Precedence parsing error
22:19:04 <lambdabot> cannot mix ‘+’ [infixl 6] and prefix -' [infixl 6] in the same infi...
22:19:27 <int-e> arseniiv: it's annoying :)
22:19:30 <ais523> but that isn't even an ambiguous parse :-P
22:19:49 <ais523> unless you parse 1 as a function and + as unary
22:20:00 <int-e> there is no unary +
22:20:17 <arseniiv> still annoying, agree
22:20:19 <int-e> you can only make that case for 1 - -1
22:20:27 <ais523> how is the ambiguity in "f - g" fixed?
22:21:03 <int-e> Subtraction wins.
22:21:07 <b_jonas> ais523: and then there's prolog syntax, which allows the program to define almost any token as an infix operator
22:21:31 <ais523> Prolog doesn't have operators (other than arguably is)
22:22:19 <ais523> 3+4*5 is a data structure '+'(3,'*'(4,5))
22:22:26 <ais523> so it has infix constructors, not infix operators
22:22:38 <b_jonas> yeah, that
22:22:41 <b_jonas> infix constructors
22:22:58 <b_jonas> but only in the sense that scheme with eval only has constructors
22:23:02 <ais523> the is operator/statement happens to interpret this as an arithmetic expression, but it's is that puts the arithmetic interpretation on the structure, '+' and '*' by themselves are just identifiers
22:23:18 <b_jonas> you write constructors, but then they're going to be used as proper functions later if the expression is evaluated
22:23:26 <ais523> no, that's not right at all
22:23:33 <b_jonas> sometimes they're in a context when they're never evaluated of course
22:23:41 <ais523> Prolog programs /frequently/ use these punctuation constructors for arbitrary uses
22:23:49 <ais523> and they don't have any inherent meaning
22:23:52 <b_jonas> sure
22:24:05 <b_jonas> I've seen them use infix minus for ordered pairs
22:24:07 <b_jonas> it's crazy
22:24:15 <int-e> The Haskell report is not very nice in this area... the grammar it provides is very ambiguous.
22:24:27 <arseniiv> why shouldn’t be constructors a sub-notion of functions?
22:24:35 <ais523> b_jonas: when golfing I normally use infix minus and infix slash as my main constructors for everything
22:24:41 <ais523> e.g. a list isn't [1,2,3], it's 1/2/3/e
22:24:44 <arseniiv> they take arguments and return something
22:24:58 <ais523> err, or possibly the other way round, I forget the associativity
22:25:12 <arseniiv> and then infix ones would be infix operators :)
22:25:32 <b_jonas> ais523: does that help? the list constructor . has some built-in syntax, and more importantly, library primitives for a few list operations
22:25:45 <b_jonas> the prolog libraries are quite lacking in useful functions
22:25:48 <ais523> b_jonas: [A|B] is way more verbose than A/B
22:25:58 <ais523> and the builtins are normally too verbose to use
22:26:10 <b_jonas> it's like prolog people enjoy inventing everything on their own
22:27:19 <arseniiv> or really prolog is an experimental language :P
22:27:46 <arseniiv> so it doesn’t need extensive libraries
22:27:47 <int-e> so you have to actually dive into https://www.haskell.org/onlinereport/haskell2010/haskellch10.html#x17-18100010.6 to see that for unary negation it checks the precedence of the preceding infix operator (if any)
22:29:38 <int-e> maybe the reason is that you don't want to disambiguate 1 - -1 - 1 (is it 1 - (- (1 - 1)) or (1 - (- 1)) - 1?)
22:29:55 <int-e> but actually
22:29:59 <int-e> > -1 - 2
22:30:02 <lambdabot> -3
22:30:21 <int-e> Meh I just don't know. It is what it is.
22:31:11 <b_jonas> ? penguin
22:31:13 <HackEso> penguin? ¯\(°​_o)/¯
22:33:30 <ais523> b_jonas: prolog doesn't /need/ many builtins because it's so powerful
22:33:56 <ais523> I've been planning a declarative golflang, it can do a lot with only a fraction of the builtins of other golfing languages
22:33:58 <int-e> let us backtrack a bit here...
22:34:03 <imode> how in the world are CFSMs TC... it honestly looks like they're counter machines unless their channels can contain other "types" of messages, i.e other symbols.
22:34:12 <b_jonas> ais523: it needs _library functions_. that's not the same as "builtins".
22:34:22 * imode thonks.
22:35:05 <b_jonas> ais523: it's like Consumer Society. it only needs two builtins, because those already allow you to do anything. but I still want to add an optional library that can do commonly useful stuff like arithmetic,
22:35:26 <ais523> a language I'm working on only needs four builtins, but I'm planning to add a macro system
22:35:30 <int-e> ? cfsm
22:35:31 <HackEso> cfsm? ¯\(°​_o)/¯
22:35:37 <b_jonas> I just show that it doesn't really add power to the language by writing a reference implementation in pure Consumer Society, but an interpreter may still offer a more optimized version of it.
22:35:48 <ais523> to let you do things in a user-friendly way while obviously not needing other builtins
22:35:52 <int-e> . o O ( Church of the Flying Spaghetti Monster )
22:35:56 <b_jonas> I mean a version that isn't implemented in pure Consumer Society, but in implementation-defined ways.
22:36:02 <int-e> . o O ( Sometimes Google is less than helpful. )
22:36:27 <imode> communicating finite state machines. ;)
22:36:55 <b_jonas> I'm not planning to add "macros". Consumer Society doesn't need them. The library has a perfectly normal interface for something you'd write in Consumer Society.
22:37:20 <b_jonas> It uses such calling conventions that you can use it from pure Consumer Society and implement it in pure Consumer Society.
22:37:25 -!- Sgeo_ has joined.
22:37:33 <b_jonas> That restricts what interface it can have, but not too much to make it unusable.
22:37:50 <ais523> well, I'm aiming for a weird computational class (NL-complete)
22:38:04 <ais523> not only is it weird class-wise, it's also weird to program in
22:38:17 <ais523> e.g. it can add two numbers, but can't store the result of the addition, it has to basically output each digit as it's calculated
22:38:46 <b_jonas> two numbers as in bigints?
22:38:51 <ais523> yes
22:40:01 <b_jonas> that does sound weird, yes
22:41:16 -!- Sgeo has quit (Ping timeout: 272 seconds).
22:43:04 <ais523> btw, what do we do on the wiki about languages whose computational class is known, but doesn't have a category?
22:45:22 <b_jonas> ais523: well, (0) is such a language I think
22:45:37 <ais523> what class is it in?
22:45:49 <ais523> I think primitive-recursive is probably the best known class with no category
22:47:34 <imode> https://www.cmi.ac.in/~madhavan/courses/concurrency2016/literature/brand-zafiropulo-jacm83.pdf what the fuck. this paper references itself regarding the actual construction of memory devices.. yet I can't seem to find where they do it..?
22:47:40 <imode> maybe I'm just blind.
22:48:05 <imode> they say refer to reference 9... reference 9 is the paper I'm reading.
22:48:35 <ais523> is this a conference paper referencing a journal paper that's an expanded version of itself?
22:48:45 <int-e> Nope, it's referring to a technical report.
22:48:54 <int-e> Still, it's not the paper you're reading.
22:48:59 <b_jonas> uh... basically, if you give a (0) program integer inputs, then it's merely Turing-complete, but if you give it arguments that are not integers, then it can do as many operation as the, uh, Church-Kleene closure of the largest argument, if such a thing exists
22:49:05 <b_jonas> or so I think
22:49:23 <b_jonas> it's more than Turing-complete
22:50:04 <imode> oh I am so dumb, thanks int-e.
22:50:15 <b_jonas> I don't know if there's a name for that computational class
22:50:36 <imode> now to find that.
22:50:40 <ais523> that doesn't seem like a very commonly investigated computational class!
22:51:13 <b_jonas> Amycus is also higher than Turing-complete, but it only takes integer arguments, so it has a fixed computational complexity
22:52:15 <ais523> all >Turing languages are just "Uncomputable" on the wiki, though
22:52:24 <b_jonas> in particular, it has the same complexity as (0) with omega as an input and nothing higher, it can effectively do omega_1^{\mathrm{CK}} steps
22:52:25 <ais523> so we do have a category for them
22:52:58 <b_jonas> isn't that the category for !<Turing languages?
22:53:07 <b_jonas> or, um, !<=Turing languages
22:53:10 <ais523> !≤
22:53:23 <ais523> sorry, for a moment I forgot complexities weren't ordered
22:53:49 <ais523> although a language which isn't Turing-implementable and also isn't Turing-hard would be pretty unusual
22:53:54 <int-e> imode: https://domino.research.ibm.com/library/cyberdig.nsf/1e4115aea78b6e7c85256b360066f0d4/b09aab28334bb3ff8525777b0047357b!OpenDocument
22:54:24 <int-e> That was surprisingly easy.
22:54:25 <imode> lmao we hit the same place. thanks!
22:54:52 <b_jonas> pretty unusual even by good esolangs standards? or only by the standard where random newbies post brainfuck substitutions and simple stack-based interpreters and call them "esolangs"?
22:55:04 <ais523> even by good esolangs standards
22:55:21 <ais523> unless, possibly, you count things like the ". ." not-a-token in HOMESPRING
22:55:30 <ais523> (which is defined to cause a temporal paradox)
22:55:35 <ais523> (with no further information)
22:56:11 <ais523> that's sort of the uncomputable version of X from HQ9+
22:57:28 <b_jonas> then there's the [[:Category:Unusable for programming]] or whatever it's called, for all the languages that let you print a constant message but not do anything else. common among bad esolangs.
22:58:35 <b_jonas> and then there's brainfuck with single level loops... what complexity class does that one have?
22:59:27 <ais523> FSM I think
22:59:42 <ais523> but not FSM-complete, it's lower
23:00:28 <b_jonas> but I think that still counts as [[:Category:Unusable for programming]], right?
23:00:52 <b_jonas> or would if we cared enough about the pages for all those bad esolangs to cat'ze them
23:02:47 <ais523> it's best to leave terrible esolangs uncategorized if the author forgets, IMO
23:02:52 <b_jonas> sure
23:03:02 -!- uplime has quit (Quit: WeeChat 2.2).
23:04:16 <ais523> if you see a /good/ uncategorized esolang, feel free to categorize it
23:04:29 <int-e> A single level of loops is enough for a string reversal program in Brainfuck.
23:04:38 -!- arseniiv has quit (Ping timeout: 245 seconds).
23:05:33 <ais523> int-e: oh right, so more than FSM
23:05:43 <ais523> each individual loop is an FSM but they can store data for the later loops
23:06:27 <int-e> yeah that sounds right.
23:08:33 <b_jonas> ? milkman
23:08:35 <HackEso> milkman? ¯\(°​_o)/¯
23:09:05 <int-e> `? psychonauts
23:09:07 <HackEso> psychonauts? ¯\(°​_o)/¯
23:09:24 <b_jonas> why was gingerbread and milk even delivered by two different professionals? wouldn't the people who bought gingerbread also buy milk to drink with it?
23:09:34 <b_jonas> any sane person would centralize those to one job
23:10:10 <int-e> hmm "sane".
23:10:10 <ais523> I don't think the gingerbread man is a real profession/job
23:10:37 <ais523> <Wikipedia> A gingerbread man is a biscuit or cookie made of gingerbread, usually in the shape of a stylized human, although other shapes, especially seasonal themes (Christmas, Halloween, Easter, etc.) and characters, are common.
23:10:59 <int-e> But no, they are entirely different... milk has to be delivered much more frequently and regularly than baking goods, because it expires so quickly.
23:11:52 <b_jonas> int-e: only if it's not properly pasteurized, or if the iceman doesn't deliver enough ice for your fridge. if you follow proper procedures, then you can keep milk for six weeks.
23:11:59 <ais523> also, fictional gingerbread men tend to be anthropomorphised versions of the biscuit/cookie, not someone who delivers gingerbread
23:13:12 <int-e> b_jonas: Hmm I'm not sure when pasteurization became common.
23:15:45 <b_jonas> int-e: dunno, it was already common in my childhood. all stores sold both normal pasteurized milk and ultra-high-temperature tasteless milk already. the difference was that (1) they sold 0.5 liter packs as well as 1 liter ones, and (2) they only sold them in nylon wrapping, none of the handful of modern variety packaging, such as waxed cardboard cartons, PET coke bottles with flat bottom and wide screw
23:15:51 <b_jonas> tops, etc.
23:16:29 -!- Sgeo__ has joined.
23:16:49 <b_jonas> those nylong things were among the earliest plastic packaging used, as far as my memory goes, equalled only by dark raisins in similar nylon packaging
23:17:15 <b_jonas> the raisins sucked, but we didn't know better, because we didn't have all the cheap tasty sweets like today
23:17:59 <b_jonas> I sound like a grumpy old grandpa now, don't I? (shakes his walking stick at the young whippersnappers) Get off my lawn, kids!
23:19:32 -!- Sgeo_ has quit (Ping timeout: 246 seconds).
23:20:02 -!- uplime has joined.
23:22:39 <int-e> b_jonas: parrotting wikipedia, it became common in the middle of the last century, because that's when states began mandating pasteurization to prevent diseases like tuberculosis being spread that way.
23:24:28 <int-e> b_jonas: but what's unclear to me is how old the milkman profession is. I had assumed that it had been around long before Pasteur (1864 is when he came up with a heating procedure for preserving wine, which was later also applied to milk)
23:32:57 <int-e> fungot
23:32:57 <fungot> int-e: the only way out. go on. run along now. i mean, from four storeys up it looked quite expensive, but that was only one kind of genetics.' susan peered around the edge of the mountains, and anyone who upsets important people is automatically not a good idea,' said
23:37:35 -!- tromp has quit (Remote host closed the connection).
23:41:49 <esowiki> [[Talk:APLWSI]] https://esolangs.org/w/index.php?diff=58990&oldid=54604 * Salpynx * (+469) compare Nil, and definitions
23:52:14 <esowiki> [[APLWSI]] https://esolangs.org/w/index.php?diff=58991&oldid=58986 * Salpynx * (+33) /* Example programs */ Self-Interpreter
23:55:11 <int-e> @metar lowi
23:55:12 <lambdabot> LOWI 062350Z AUTO VRB01KT 6000 -RASN FEW004 SCT020 BKN032 01/00 Q1030
←2019-01-05 2019-01-06 2019-01-07→ ↑2019 ↑all