00:03:54 -!- sprocklem has quit (Ping timeout: 250 seconds).
00:07:27 -!- sprocklem has joined.
00:20:58 -!- S_Gautam has quit (Quit: Connection closed for inactivity).
00:29:46 -!- user24 has joined.
00:33:50 -!- imode has joined.
00:35:41 <zzo38> I thought of once a rule variation for mahjong that if you have menzentsumo it does not count 1 han but it does reduce your requirement by 1 han (reducing it normally to zero, although sometimes it will still be 1)
00:35:50 <zzo38> What do you think of this?
00:37:23 <rain1> I don't know mahjong so i can't comment
00:53:52 -!- Hello has joined.
00:54:29 -!- Hello has quit (Client Quit).
01:01:52 -!- Phantom_Hoover has quit (Read error: Connection reset by peer).
01:29:31 -!- AnotherTest has joined.
01:33:45 -!- user24 has quit (Remote host closed the connection).
01:35:19 -!- MDead has joined.
01:35:59 -!- user24 has joined.
01:36:50 -!- MDude has quit (Ping timeout: 246 seconds).
01:40:32 -!- MDead has quit (Ping timeout: 250 seconds).
01:44:59 -!- MDude has joined.
01:48:23 -!- sprocklem has quit (Remote host closed the connection).
01:50:10 -!- sprocklem has joined.
02:03:16 <esowiki> [[Brain-Flak]] https://esolangs.org/w/index.php?diff=58535&oldid=54319 * Ais523 * (+355) /* External resources */ add BrainFlak::Symbolic
02:03:56 <esowiki> [[Brain-Flak]] M https://esolangs.org/w/index.php?diff=58536&oldid=58535 * Ais523 * (+14) /* External resources */ apparently it needs the http://; also mention the implementation language
02:10:05 -!- doesthiswork has joined.
02:11:26 -!- doesthiswork has quit (Client Quit).
03:07:30 -!- doesthiswork has joined.
03:13:58 -!- b_jonas has quit (Quit: leaving).
03:14:10 -!- tromp has quit (Remote host closed the connection).
03:14:45 -!- tromp has joined.
04:11:30 -!- Sgeo_ has joined.
04:14:22 -!- Sgeo has quit (Ping timeout: 250 seconds).
04:24:35 -!- Sgeo_ has quit (Read error: Connection reset by peer).
04:31:36 <zzo38> One thing I thought of for SQLite that I don't know whether or ont it would improve anything is sqlite3_str_context() function, which returns a string building object and makes the result of the function to effectively be whatever is then appended to the string, if your program does not call sqlite3_str_reset() or sqlite3_str_finish() on it.
04:44:18 <zzo38> Also, I wrote a shell script to download and compile SQLite
04:46:34 -!- Sgeo has joined.
04:58:47 -!- user24 has quit (Quit: Leaving).
05:15:36 -!- arseniiv has joined.
05:40:09 -!- Essadon has quit (Quit: Qutting).
05:43:56 -!- hexfive has quit (Quit: WeeChat 2.2).
06:00:38 -!- nfd9001 has joined.
06:23:45 <zzo38> SQLite does not have a upsert that causes it to become an error if the WHERE clause does not match.
06:24:27 -!- Cale has quit (Remote host closed the connection).
06:32:55 -!- xkapastel has quit (Quit: Connection closed for inactivity).
06:43:26 -!- AnotherTest has quit (Ping timeout: 250 seconds).
06:46:21 <zzo38> (One idea is that after the WHERE clause of a upsert you can optionally add "ELSE ABORT", "ELSE ROLLBACK", "ELSE FAIL", or "ELSE IGNORE" (the default if none is specified, which corresponds to the current behaviour).)
06:53:42 -!- imode has quit (Ping timeout: 244 seconds).
07:02:31 -!- hexfive has joined.
07:15:08 <zzo38> Other suggestions of rule variations of mahjong I have seen include menzenron instead of menzentsumo, and another is "reverse yakitori" where you start without yakitori but if you deal into someone's hand then you do have yakitori.
07:16:01 <zzo38> (You could also do both ways yakitori together: if you win or if you deal into someone else's hand, it can be changed; whichever one applied last is in use)
07:18:15 <zzo38> One thing I thought of also is a variant where red dora is not affected by dora indicators, even if the indicator is four of that suit
07:43:38 -!- Sgeo has quit (Ping timeout: 246 seconds).
07:45:54 -!- Sgeo has joined.
08:00:03 -!- tromp has quit (Remote host closed the connection).
08:00:18 -!- tromp has joined.
08:12:46 -!- doesthiswork has quit (Quit: Leaving.).
08:14:50 -!- doesthiswork has joined.
08:30:42 -!- gurmble has joined.
08:32:08 -!- tromp has quit (Remote host closed the connection).
08:32:40 -!- tromp has joined.
08:33:39 -!- tromp has quit (Remote host closed the connection).
08:33:41 -!- doesthiswork has quit (Quit: Leaving.).
08:33:52 -!- tromp has joined.
08:37:52 -!- oerjan has joined.
08:39:11 -!- grumble has quit (Ping timeout: 633 seconds).
09:20:35 -!- Lord_of_Life has quit (Ping timeout: 246 seconds).
09:23:14 -!- Lord_of_Life has joined.
09:23:14 -!- Lord_of_Life has quit (Changing host).
09:23:14 -!- Lord_of_Life has joined.
09:44:04 -!- b_jonas has joined.
09:48:39 <b_jonas> `makelist bobadventureslist b_jonas
09:48:41 <HackEso> makelistlist bobadventureslist: shachaf
09:48:58 <b_jonas> `bobadventureslist http://bobadventures.comicgenesis.com/d/20181201.html
09:48:59 <HackEso> bobadventureslist http://bobadventures.comicgenesis.com/d/20181201.html: b_jonas
09:49:44 <HackEso> makelistlist ehlist: shachaf
09:50:51 <shachaf> who put me on makelistlist
09:51:58 <b_jonas> shachaf: ask the mercury repo if you want to know
09:53:00 <b_jonas> zzo38: in sqlite, do these new window functions allow you to write a parenthisized subquery that returns the group_concat of a query but with values concatenated in a deterministic sort order given by an ORDER BY clause?
10:13:33 -!- AnotherTest has joined.
10:35:29 -!- AnotherTest has quit (Ping timeout: 246 seconds).
10:41:29 -!- oerjan has quit (Quit: Later).
11:01:01 -!- Hooloovo0 has quit (Ping timeout: 260 seconds).
11:07:44 -!- AnotherTest has joined.
11:15:06 -!- Hoolootwo has joined.
11:39:24 -!- AnotherTest has quit (Ping timeout: 250 seconds).
12:02:21 -!- user24 has joined.
12:09:53 -!- Phantom_Hoover has joined.
12:27:19 -!- Essadon has joined.
12:35:46 -!- user24 has quit (Quit: Leaving).
12:47:03 -!- hexfive has quit (Quit: WeeChat 2.2).
13:10:47 -!- xkapastel has joined.
13:19:48 -!- Phantom_Hoover has quit (Ping timeout: 252 seconds).
13:59:51 -!- Phantom_Hoover has joined.
14:00:24 -!- doesthiswork has joined.
15:27:44 -!- limbo_ has joined.
15:28:35 <limbo_> Is there an explaination for the limes in the wiki logo on esolangs.org?
16:00:19 <fizzie> Not a real one. It's called "trilime", though.
16:03:37 <fizzie> https://esolangs.org/logs/2011-05-24.html#l5x 2011-05-25 21:31:34 <ais523> I think the official answer is "it's just an image Graue chose as a placeholder, and people decided they liked it"
16:34:40 <limbo_> ha! I've done that exact thing before, but with a public-domain image of a cactus.
16:50:02 <zzo38> b_jonas: Yes, window functions do allow you to use a deterministic sort order (unlike normal aggregate functions)
17:09:53 <zzo38> That is OK, although I think that a proper logo should be made specific for Free Hero Mesh.
17:10:53 -!- ais523 has joined.
17:11:17 <ais523> regular expressions can be implemented efficiently by compiling them into NFAs
17:11:27 <ais523> is there a similar efficient compilation technique for regular expressions + backreferencess?
17:17:25 <ais523> oh, it's been shown that there almost certainly isn't: https://perl.plover.com/NPC/NPC-3SAT.html
17:17:34 <ais523> 3SAT in regex+backreference :-)
17:28:53 -!- oerjan has joined.
17:35:29 <zzo38> Another thing I thought of for mahjong is to avoid rounding errors by making all hands worth 25 fu. There may be other ways to do this too though, such as not rounding at all. Since, this rounding sometimes results a hand being worth more for tsumo win than with ron win, even though it is supposed to be same.
17:36:07 <zzo38> (Different hands are still worth different amount of han, but fixed at 25 fu.)
17:36:23 <zzo38> Do you like mahjong?
17:38:57 <int-e> ais523: hmm, why 3SAT when the same code works for SAT?
17:39:16 <int-e> (CNF-SAT if you will)
17:39:28 <ais523> int-e: probably just a case of doing the minimum necessary amount of work
17:39:39 <ais523> you know that implementing 3SAT is sufficient, so you don't notice it works even without the 3
17:40:16 <oerjan> as long as they're SATisfied.
17:40:58 <ais523> that's not even really a pun? SAT is an abbreviation for "satisfaction" already
17:41:19 <int-e> but it has unSATisfactory instances... or something like that.
17:41:53 <ais523> if you wanted a pun you'd have to use SATurate or SATchel or some similarly unrelated word
17:42:02 <int-e> (fwiw, "satisfiability" is the usual term)
17:44:25 <fizzie> As famously used in the Rolling Stones song, I can't get no satisfiability.
17:45:06 <fizzie> (It's about the NP-completeness of the problem.)
17:46:20 <b_jonas> zzo38: deterministic sort order goes most of the way, good. can you use any ordinary aggregate function for that, or do you have to write a custom window function aggregate function? is the sqlite built-in function string_concat (or whatever it's called) suitable?
17:48:37 <b_jonas> ais523: re backreferences, also https://laurikari.net/tre/ is a thesis project proving that implements regular expressions with capture groups efficiently, there's obviously a lot of work done with it, it implements backreferences but for that it falls back to a slower alternate implementation,
17:49:28 <b_jonas> which also shows that at least there's no easy way to extend the implementation to backreferences, because clearly Ville Laukari has worked a lot on the theory there.
17:52:34 <b_jonas> ais523: also, there's a one-line proof that factoring reduces to regexes with backreferences: https://www.perlmonks.com/?node_id=510925 https://www.perlmonks.com/?node_id=52469
17:52:59 <b_jonas> that doesn't make it NP-complete, because factoring likely isn't, but still, it shows that we don't know a polynomial time implementation
17:53:21 <b_jonas> we can factor unary numbers in polynomial time
17:54:39 <ais523> thinking about this a bit more, I suspect regex+backreferences is implemented by a nondeterministic LBA, rather than a nondeterminstic finite state machine
17:55:14 <ais523> there's no particular reason to expect those to be fast in general, but there may be a method of implementing them efficiently in the cases that typically arise in practice
17:57:48 <b_jonas> "you know that implementing 3SAT is sufficient, so you don't notice it works even without the 3" - hehe. I have a published NP-completeness proof where I reduce to SAT, not 3-SAT specifically, because the proof automatically works for any expression reduced to conjuctive normal form.
17:58:10 <b_jonas> It's not a very useful proof, mind you, because the problem we reduce to is not something you are generally interested in.
17:59:50 <b_jonas> ais523: you can probably read Ville Laukari's book and source code for how he implements them
18:00:03 <b_jonas> and there are a few other independent implementations
18:00:11 <b_jonas> a gnu one in libc in particular
18:00:13 <ais523> many mathematicians are suspicious of P-inequivalence proof claims based on 3SAT because they often would work for 2SAT as well
18:00:30 <ais523> that might be one of the simplest ways to prove that such a proof might contain an error
18:00:59 <b_jonas> ais523: yeah, but this isn't a P-equivalence proof. this is a proof for hardness of a decision problem. 2-SAT reduces to it too, but that's not a problem.
18:01:31 <ais523> right, with proofs in that direction you don't care if they work for 2-SAT too
18:02:16 <b_jonas> I made the proof because I wanted to see why we don't know an algorithm for a certain other decision problem, only I couldn't prove hardness of that particular problem rigorously.
18:02:29 <b_jonas> So I proved hardness of a less interesting problem.
18:03:34 <b_jonas> The actual problem we're interested in might be in P for all we know, but on the other hand it need not be in R.
18:03:51 <b_jonas> It's somewhere low in the arithmetic hierarchy.
18:04:18 <b_jonas> Probably at some greek letter plus _1
18:05:04 <b_jonas> I have some reason to suspect that it might not be in R, but I can't really conjecture it.
18:05:11 <ais523> there are so many complexity classes that I keep forgetting their names
18:05:37 <b_jonas> ais523: recursive decision problems, the ones for which there's a det' algorithm that always terminates and gives correct result
18:05:48 <ais523> right, just looked it up
18:06:02 <b_jonas> at least I think some people call it R, but the naming conventions in that field are terrible
18:06:09 <ais523> decision problems that can be solved both ways, i.e. you can write a Turing machine that halts on true, and also a Turing machine that halts on false
18:06:16 <b_jonas> hopefully Knuth cleans them up at least a little in volumes 4 and 5
18:06:20 <ais523> and yes, Complexity Zoo calls it R, that's my normal source for these things
18:06:38 <ais523> (if you can write a Turing machine that halts on true, but maybe can't write one that halts on false, that's RE)
18:07:57 <b_jonas> Iirc in this case we do have a proof that it's at some particular level of the arithmetical hierarchy, but it's not obvious at first glance.
18:08:10 <b_jonas> Or maybe it is, depending on how you interpret "obvious".
18:09:13 <b_jonas> Stupid problem defined with multivariate calculus that you have to reduce to a discrete problem by a calculus theorem like the uniform continuity or some other compactness stuff.
18:11:29 <oerjan> <ais523> that's not even really a pun? <-- i considered not capitalizing SAT, would that have helped?
18:12:41 <b_jonas> Calculus if full of these things by the way. The staple example is finding arbitrarily close rational bounds for the real roots of a polynomial with integer coeffs. That one does go down with an elementary calculus argument, but you wouldn't guess the algorithm unless someone tells you.
18:13:01 <b_jonas> And I don't even know the proof for complex roots.
18:13:49 <b_jonas> I think the complex version uses Gerschgorin circles, but it could need more.
18:15:01 <b_jonas> s/Gerschgorin circles/Geršgorin circles/
18:32:15 -!- imode has joined.
18:42:50 <ais523> come to think of it, I suspect you can run regexes in O(n**(2r+1)), where r is the number of backreferences used in the regex
18:43:24 <ais523> that wouldn't violate the boolean-satisfaction result above, because the more variables you have, the larger r gets
18:45:53 <ais523> the algorithm for doing so is trivial: for each backreference, iterate over the O(n**2) substrings of the input; for each of the sets of potential backreferences values produced, run the regular expression with the backreferences hardcoded, then verify that the capture groups match the hardcoded backreferences
18:46:46 <ais523> of course, a cubic implementation for one backreference isn't particularly "efficient", but polynomial time beats the exponential time that most implementations use
19:11:12 -!- ais523 has quit (Quit: quit).
19:16:30 <zzo38> b_jonas: All of the built-in aggregate functions can be used as window functions. If you are defining your own functions, you must define a few additional methods in order to work as a window function; such functions can also be used as ordinary aggregate functions.
19:25:43 -!- j-bot has quit (Ping timeout: 250 seconds).
19:52:41 <esowiki> [[Ases]] https://esolangs.org/w/index.php?diff=58537&oldid=54842 * Gamer * (-15)
19:57:21 <esowiki> [[Symbols]] https://esolangs.org/w/index.php?diff=58538&oldid=39458 * Gamer * (+51)
19:58:32 <esowiki> [[SeMo-PATH]] https://esolangs.org/w/index.php?diff=58539&oldid=57516 * Gamer * (+0) /* Computational Class */
19:58:55 <esowiki> [[Symbols]] https://esolangs.org/w/index.php?diff=58540&oldid=58538 * Gamer * (+0) /* Examples */
20:09:14 <esowiki> [[A:;]] M https://esolangs.org/w/index.php?diff=58541&oldid=46643 * Gamer * (+4) /* Commands */
20:14:56 <esowiki> [[A:;]] https://esolangs.org/w/index.php?diff=58542&oldid=58541 * Gamer * (+32) /* Example programs */
20:16:57 <esowiki> [[A:;]] https://esolangs.org/w/index.php?diff=58543&oldid=58542 * Gamer * (+6) /* Example programs */
20:17:32 <esowiki> [[A:;]] https://esolangs.org/w/index.php?diff=58544&oldid=58543 * Gamer * (+2) /* Example programs */
20:18:28 <esowiki> [[A:;]] https://esolangs.org/w/index.php?diff=58545&oldid=58544 * Gamer * (+3) /* Example programs */
20:52:39 -!- oerjan has quit (Quit: Nite).
21:07:25 -!- AnotherTest has joined.
21:20:23 <b_jonas> zzo38: I know they can all be used in window function expressions. I'm asking if they are still guaranteed to be called with rows in a deterministic order.
21:20:26 -!- Lord_of_Life_ has joined.
21:21:31 <b_jonas> ais523: lol. that definitely isn't a practical algorithm. I think you can do better, and libtre almost certainly doesn't do that.
21:22:33 -!- Lord_of_Life has quit (Ping timeout: 245 seconds).
21:22:33 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
21:22:34 -!- Lord_of_Life has quit (Changing host).
21:22:34 -!- Lord_of_Life has joined.
21:22:49 <b_jonas> Hmm... maybe you're right. For some devious backreference expressions, like /(.*)\1/, that might actually be efficient.
21:23:15 <b_jonas> No no. I think there's a linear time algorithm for finding /(.*)\1/ longest match.
21:55:12 -!- moei has quit (Quit: Leaving...).
21:58:38 -!- AnotherTest has quit (Ping timeout: 250 seconds).
22:16:59 -!- Lord_of_Life_ has joined.
22:17:30 -!- Lord_of_Life has quit (Ping timeout: 244 seconds).
22:17:36 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
22:17:58 -!- Lord_of_Life has quit (Changing host).
22:17:58 -!- Lord_of_Life has joined.
22:25:25 -!- arseniiv has quit (Ping timeout: 246 seconds).
22:27:49 -!- Lord_of_Life has quit (Quit: Laa shay'a waqi'un moutlaq bale kouloun moumkine).
22:28:20 <int-e> b_jonas: now try the factoring thing: (..*)\1\1*
22:28:46 <int-e> oops, that should have one more .
22:29:42 <int-e> (hmm. I guess I'm counting capturing groups)
22:30:59 -!- Lord_of_Life has joined.
22:30:59 -!- Lord_of_Life has quit (Changing host).
22:30:59 -!- Lord_of_Life has joined.
22:50:49 <b_jonas> int-e: see above. that's for unary numbers, and we can factor unary numbers in sublinear times, even sublinear for a fixed regex, which is pretty rare for a regex that is anchored to match the whole string (it's commonplace for a regex like /^a/
22:52:21 <b_jonas> we have series of regexen (strings as regexes without anchors actually) such that we can match any in linear time, but the constant factor goes to zero as a limit
22:54:31 -!- tromp has quit (Remote host closed the connection).
22:54:46 <b_jonas> Even I know how to implement factoring unary in O(n**(1/4)) time because I've implemented the corresponding algorithm for integers with arithmetic available.
22:55:03 <b_jonas> well, O(n**(1/4 + epsilon)) but still
22:55:03 -!- tromp has joined.
23:03:36 -!- tromp has quit (Remote host closed the connection).
23:03:52 -!- tromp has joined.
23:29:12 -!- imode has quit (Ping timeout: 250 seconds).
23:43:35 -!- Phantom_Hoover has quit (Read error: Connection reset by peer).
23:47:50 <esowiki> [[HARSH]] M https://esolangs.org/w/index.php?diff=58546&oldid=58529 * ShareMan * (-149) /* Language Overview */ Deleted interpreter info from language section, and fixed some grammar
23:50:32 <esowiki> [[HARSH]] M https://esolangs.org/w/index.php?diff=58547&oldid=58546 * ShareMan * (+296) /* Interpreter Help */ Added info about interpreter operation
23:52:10 -!- Lord_of_Life has quit (Ping timeout: 250 seconds).
23:53:04 -!- imode has joined.
23:54:28 -!- Lord_of_Life has joined.
23:54:28 -!- Lord_of_Life has quit (Changing host).
23:54:28 -!- Lord_of_Life has joined.
23:54:38 <esowiki> [[HARSH]] M https://esolangs.org/w/index.php?diff=58548&oldid=58547 * ShareMan * (+234) /* Examples */ Added new example programs
23:55:24 <esowiki> [[HARSH]] M https://esolangs.org/w/index.php?diff=58549&oldid=58548 * ShareMan * (+2) /* Interpreter Help */ Fixed formatting
23:57:40 -!- tromp has quit (Remote host closed the connection).
23:58:21 -!- tromp has joined.