←2020-03-05 2020-03-06 2020-03-07→ ↑2020 ↑all
00:22:23 -!- tromp has quit (Remote host closed the connection).
00:41:15 <esowiki> [[Language list]] M https://esolangs.org/w/index.php?diff=70183&oldid=70166 * PythonshellDebugwindow * (+12) /* D */
00:48:32 -!- FreeFull has quit.
00:51:42 -!- xkapastel has quit (Quit: Connection closed for inactivity).
01:04:28 -!- arseniiv has quit (Ping timeout: 256 seconds).
01:52:44 -!- sebbu has quit (Read error: Connection reset by peer).
01:52:59 -!- MDude has quit (Read error: Connection reset by peer).
01:53:03 -!- sebbu has joined.
01:53:25 -!- atslash has quit (Read error: Connection reset by peer).
01:53:46 -!- MDude has joined.
01:54:01 -!- atslash has joined.
02:17:00 -!- Melvar has quit (Ping timeout: 256 seconds).
02:17:26 -!- Melvar has joined.
03:01:17 <zzo38> Do you like or hate daylight saving time? I don't like daylight saving time.
03:01:39 <zzo38> Beckett wrote "The costs of DST outweigh the benefits. But if a significant majority of people really want that extra hour of daylight in the summer, just leave the whole country on DST year-round. I prefer standard time, but Ill be happy to compromise if it means not losing an hour every spring."
03:02:17 <zzo38> I agree with Beckett; I also prefer standard time, but permanent DST would still be better than changing it all of the time
03:02:36 <kmc> I agree that changing time zone twice a year is stupid
03:02:50 <kmc> I haven't formed an opinion on which of the two time zones would be better for permanent use
03:04:05 <kmc> zzo38: did you know that Spain changed to Central European Time during WW2, and never changed back, with the result that in western Spain during the summer the sun doesn't set until after 10 PM?
03:04:46 <kmc> https://en.wikipedia.org/wiki/Time_in_Spain#/media/File:Tzdiff-Europe-summer.png
03:06:00 <zzo38> I think standard time would be better, for use with sundials, so that it is based on noon/midnight (I don't know what is Beckett's reasoning for preferring standard time). However, either way will work as long as there is agreement what time it is, so that if something is scheduled for "five o'clock" then you will know when it is, and so on.
03:06:18 <zzo38> I did not know that about Spain. Now I do know.
03:25:01 <zzo38> I did not know that about Spain. Now I do know.
03:26:13 -!- shachaf has left.
03:45:14 -!- tromp has joined.
03:49:53 -!- tromp has quit (Ping timeout: 265 seconds).
05:01:28 -!- jix has quit (Ping timeout: 255 seconds).
05:01:46 -!- jix has joined.
05:31:57 -!- oerjan has joined.
05:33:35 -!- tromp has joined.
05:38:10 -!- tromp has quit (Ping timeout: 256 seconds).
06:01:06 -!- stux- has joined.
06:02:52 -!- stux has quit (Ping timeout: 260 seconds).
06:05:07 -!- ArthurStrong has quit (Quit: leaving).
06:10:16 <esowiki> [[Special:Log/merge]] merge * Oerjan * merged [[User:DINAC]] into [[DINAC]] (revisions up to 20200305175450): Fix history after cut and paste move
06:13:49 <esowiki> [[Special:Log/delete]] delete * Oerjan * deleted "[[User:DINAC]]": Remains of cut-and-paste move; history merged into [[DINAC]]
06:14:21 <oerjan> Well that was easier than I thought
06:15:10 <oerjan> only hitch is that the history says nothing about why the name is now DINAC rather than User:DINAC
06:28:27 -!- vertrex- has joined.
06:29:36 -!- vertrex has quit (Ping timeout: 260 seconds).
06:30:53 <esowiki> [[Special:Log/delete]] delete * Oerjan * deleted "[[User:PythonshellDebugwindow/(Unnamed language)]]": Author request: content before blanking was: "#REDIRECT [[User:DINAC]]"
06:35:04 <zzo38> I am working on adding some more stuff to bystand, including a scoring function. (This might be the only NNTP client which uses both a interactive line-oriented interface and SQLite, and may also be the only one to use SQL as its customization language.)
06:38:48 <zzo38> (Of course, these would not be the features everyone wants, but that is OK, because there are many alternatives.)
06:40:39 <esowiki> [[User talk:Voltage2007]] N https://esolangs.org/w/index.php?oldid=70184 * Voltage2007 * (+98) Created page with "Feel free to add any comments or complaints by editing the page. You ''can'' edit the page, right?"
07:13:34 <esowiki> [[Alchemy]] https://esolangs.org/w/index.php?diff=70185&oldid=36118 * Voltage2007 * (+203)
07:21:37 -!- tromp has joined.
07:26:45 -!- tromp has quit (Ping timeout: 272 seconds).
07:46:00 -!- Lord_of_Life_ has joined.
07:47:09 -!- xelxebar has joined.
07:47:58 -!- Lord_of_Life has quit (Ping timeout: 255 seconds).
07:47:58 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
08:11:29 -!- tromp_ has joined.
08:16:09 -!- tromp_ has quit (Ping timeout: 272 seconds).
08:20:37 -!- tromp has joined.
08:50:29 -!- b_jonas has quit (Quit: leaving).
09:04:31 -!- imode has quit (Ping timeout: 258 seconds).
09:23:59 <int-e> `"
09:24:03 <HackEso> 1/1:1034) <shachaf> kmc: you gotta tell me if you're an op \ 4) <Warrigal> GKennethR: he should be told that you should always ask someone before killing them.
09:29:21 -!- cpressey has joined.
09:38:40 -!- Sgeo_ has quit (Read error: Connection reset by peer).
09:39:08 -!- Sgeo_ has joined.
09:41:49 <cpressey> Welcome to the international center for esoteric programming lingonberry design, development, and deployment
09:44:07 <int-e> huh
09:48:36 <int-e> fungot: do you like bat buns?
09:48:37 <fungot> int-e: and that information may or may not be covered there? like oop, but after a while
10:06:02 -!- sprocklem has quit (Ping timeout: 240 seconds).
10:06:13 * oerjan read that as bat puns
10:06:22 <oerjan> `? banana
10:06:24 <HackEso> Bananananananana BATMAN!
10:07:25 <int-e> oerjan: you are halfway there
10:08:05 -!- sprocklem has joined.
10:13:23 <oerjan> living on a prayer
10:13:54 <int-e> surely by now you've found the "bad pun".
10:15:36 <oerjan> OKAY
10:16:07 <oerjan> google images gives a split between cupcakes, hairstyle and furrydom
10:16:32 <int-e> I think you're overcomplicating this.
10:18:21 <oerjan> also some rabbits dressed for halloween
10:19:01 <oerjan> definitely. what otherway is there to handle it?
10:19:08 <oerjan> *+
10:25:06 <int-e> I'm not complaining.
10:25:24 <int-e> This is free entertainment :P
10:32:22 <cpressey> I still don't know where the NTM came from in that MtG thing.
10:32:49 <cpressey> Probably the same place the bat buns came from, huh.
10:34:41 <int-e> The NTM is in the hypothetical play where the opponent tries to find a way to make the deck deal unbounded damage.
10:35:48 <int-e> And the thing is constructed such that damage is all dealt in the end, so for it to happen, the intermediate simulated TMs must all terminate.
10:36:36 <int-e> So you get the behavior that non-terminating runs are discarded.
10:37:45 <cpressey> This is uncomputable, of course, but that doesn't seem to matter for this hypothetical?
10:38:37 <int-e> Yeah.
10:38:49 <cpressey> OK.
10:38:52 <int-e> The hypothetical is just to show that there is an upper bound.
10:39:10 <int-e> Who cares that we'll never know what it is.
10:40:15 <int-e> But you still have to play the actual busy beaver game to actually deal huge amounts of damage.
10:42:10 <int-e> So basically what's happening here is that they're trying to build an M:tG deck that can deal any conceivable amount of money, for a very wide range of "conceivable".
10:42:54 <int-e> I've done it again.
10:43:20 <int-e> Apparently "amount" and "money" are tightly linked in my brain.
10:43:21 <int-e> :/
11:04:39 <int-e> Woah, xkcd... title=""
11:07:48 -!- arseniiv has joined.
11:09:51 -!- wib_jonas has joined.
11:43:33 -!- xkapastel has joined.
12:03:24 <cpressey> I might be wrong but I also thought there was a limit of something like 125 water clocks, i.e. a MtG hand corresponds to a The Waterfall Model program with 125 water clocks. In that case, I would say that the maximum damage a MtG hand can do, is literally BBtwm(125), where BBtwm is a version of the busy beaver function adapted to The Waterfall Model.
12:04:02 <cpressey> Literally that number, because that number is literally asking "what's the largest number you can compute with this number of water clocks".
12:04:23 -!- moony has quit (Quit: Bye!).
12:04:35 <int-e> 124, I think
12:04:44 -!- moony has joined.
12:05:09 <int-e> But I'm not sure that's correct.
12:05:51 <int-e> The 124 is what restricts the universal machine that they implement.
12:06:16 -!- erdic has quit (Ping timeout: 265 seconds).
12:07:14 <cpressey> If they want to simulate some other machine with that UTM there's the question of how they get the description of that other machine, into the UTM
12:08:49 <int-e> It's guessed.
12:09:48 <cpressey> By a person, and then encoded as waterclocks?
12:10:06 <int-e> Yes. Or by hypothetical play.
12:10:51 <int-e> So in actual play, you need to find a busy beaver. But for hypothetical play you actually get the busy beaver function as an upper bound in the end.
12:11:32 <cpressey> Er
12:12:32 <int-e> Actual play: The player sets up a terminating TM of bounded size by making corresponding choices. It is run; the number of steps (or something like that) that it runs for turn into damage at the end.
12:13:17 <int-e> Hypothetical play: We consider all the possible TMs. But only those that terminate produce any damage. So there's an upper bound, given by the busy beaver function.
12:13:24 <cpressey> A TM implemented with 124 water clocks can compute BBtwm(124) and no larger, even if said TM is a UTM and someone guesses a good TM for that UTM to simulate
12:13:42 <int-e> cpressey: You're forgetting that the outside is nondeterministic.
12:13:52 -!- erdic has joined.
12:14:41 <cpressey> I don't know what that means
12:15:34 <cpressey> You don't need to model "hypothetical play" as an NTM, that's what confuses and bugs me
12:17:15 <int-e> None of this really works without non-determinism.
12:17:33 <int-e> Because then you couldn't externalize the TM definition from the program.
12:18:33 <cpressey> Is there anything really MtG-specific to this problem? Part of it is that I don't want to guess what rules there are in that game, because I don't play it.
12:19:02 <int-e> As I suggested yesterday, we're doing something like this: NTM A(n): *guess* a TM B of size m. Run B to completion, counting steps. Return number of steps taken.
12:19:52 <int-e> Err, n, not m.
12:20:14 <cpressey> You don't need to "guess" a TM. Rather just say: let B be the TM of size n which terminates and takes the largest number of steps to do so of any TM of size n.
12:20:17 <cpressey> No NTM needed!
12:20:49 <int-e> And the variant that computes BB(BB(n)): NTM A'(n): *guess* a TM B of size n. Run B to completion, counting steps. Let m be the number of steps taken. *guess* a TM C of size m. Run C to completion, counting steps. Return number of steps taken.
12:22:21 <int-e> cpressey: guessing is essential to escape the fact that the busiest beavers cannot be found effectively.
12:23:04 <cpressey> Why "guess" when you can stipulate?
12:23:18 <int-e> Because then you can't implement it at all.
12:23:42 <cpressey> You want to "implement" hypothetical play?
12:24:05 <int-e> Nobody's *actually* computing busiest beavers here. The busiest beavers just materialize in a proof that the value we get is bounded.
12:24:50 <int-e> But as long as the play is hypothetical, we can actually have those busiest beavers.
12:25:00 <cpressey> "Our hand of cards represents a TM, so the largest damage we can do is a busy beaver number" pretty much follows from the definition of busy beaver function.
12:25:27 <int-e> No.
12:26:06 <int-e> If you absolutely want to avoid the NTM angel (personally I find it tremendously helpful), you have to allow input instead.
12:26:17 <int-e> angle
12:26:27 <int-e> I can't type at all anymore.
12:26:59 <int-e> speling errros evryerhawe...
12:28:13 <int-e> cpressey: And the matter of the fact is that we can have a fixed *N*TM without input of small size that computes the busy beaver function for a much higher number of states.
12:28:31 <cpressey> This is maddening
12:29:13 <int-e> You do know about Universal Turing Machines, right?
12:29:25 <int-e> I need a break.
12:31:38 <int-e> But maybe I should make the idea concrete at least: NTM BB_googol: *guess* a TM A with 10^100 states. Use an UTM to run it to completion, counting steps. Return number of steps taken.
12:32:29 <int-e> And recall that the model of computation here maximizes the output of all the possible runs that terminate.
12:34:39 -!- stux- has quit (Quit: Aloha!).
12:35:36 <int-e> The corresponding TM would instead have to take the description of the TM of size 10^100 as input. By virtue of having input, it's not bounded by the busy beaver function.
12:35:51 -!- stux has joined.
12:35:54 <cpressey> Are you trying to say that BB numbers on NTMs can be much larger than BB numbers for DTMs? If so, I don't disagree.
12:37:16 <int-e> I guess so.
12:37:28 <int-e> However, then we're *definitely* not talking about BB for TWM here anymore.
12:37:45 <int-e> But something like BB for M:tG.
12:38:11 <int-e> Anyway, whenever I wrote "busy beaver" I meant DTM ones.
12:41:10 <cpressey> I'm still lost. I think I'll just resign.
12:42:30 <int-e> cpressey: Can you see what that BB_googol thing does and that the result is BB(10^100) where BB is the standard busy beaver function for DTMs?
12:43:40 <cpressey> I thought I did, but I guess not.
12:44:10 <int-e> mm
12:44:25 <cpressey> Or rather: BB_googol is just a NTM for computing BB(10^100) but why do we need that?
12:44:32 <cpressey> We can just say BB(10^100), we know what it means
12:44:54 <cpressey> This NTM doesn't relate to anything in the model we're working with
12:45:17 <int-e> Well the point is that the NTM can be written up as a program, and perhaps translated to a deck of cards.
12:45:41 <cpressey> Not unless the cards are played nondeterministically somehow
12:45:53 <cpressey> From what I understand about MtG, they're not, but I don't play that game
12:46:40 <cpressey> You can talk about "all possibly plays of a hand of cards" without using an NTM
12:46:41 <int-e> The whole point is that BB(10^100) is an upper bound on the possible outputs of terminating runs.
12:46:50 <cpressey> *possible
12:46:53 <int-e> Other than that, BB(10^100) will never materialize.
12:47:31 <int-e> cpressey: The choices that set up the TM are made during play though.
12:47:48 <int-e> So the NTM model matches the actual play much more closely than a TM with input.
12:49:10 <int-e> And of course, in real play, the player will just use the best TM they can prove termination of, not the busy beaver. (And I should probably allow TMs of size less than 10^100 as well :P)
12:49:46 <cpressey> But but but
12:50:11 <cpressey> So frustrating.
12:50:23 <cpressey> BB(n) is a function on a *set of Turing machines*, yes?
12:50:30 <cpressey> All TMs with size n.
12:50:36 <int-e> ?!
12:50:36 <lambdabot> Maybe you meant: v @ ? .
12:50:43 <int-e> BB(n) is a natural number.
12:50:48 <int-e> given a natural number n.
12:51:29 <int-e> It's the maximum of number of steps taken by any TM of size n (or less, but that's monotonic)
12:51:32 <cpressey> To compute BB(6) you must consider all TMs of size 6.
12:51:41 <int-e> that terminate.
12:52:11 <cpressey> "all TMs of size 6 that terminate" is a set of TMs.
12:52:12 <int-e> It's more like...
12:52:24 <int-e> ...to compute BB(6) you *would have to* consider all TMs of size 6.
12:52:36 <int-e> Because nobody's actually computing it.
12:52:56 <cpressey> Fine, for my present purposes this is nitpicking.
12:53:18 <cpressey> BB(6) is a result *about* a *set* of Turing machines.
12:54:00 <cpressey> All possible plays of a hand of MtG cards also represents a *set* of Turing machines.
12:55:01 <cpressey> All possible plays of a hand of MtG cards of size n, represents a set of Turing machines of size m (where n and m are, let's assume, linearly related.)
12:55:02 <myname> well, all plays of a hand in any card game does
12:55:26 <cpressey> Therefore the maximum damage a hand of MtG cards of size n can do, is proportional to BB(m).
12:55:37 <int-e> m? n?
12:55:49 -!- TheLie has joined.
12:56:04 <cpressey> Using n MtG cards you can make a TWM program of size m.
12:56:10 <cpressey> is how I'm using those letters.
12:57:16 <myname> i doubt that line of reasoning
12:57:27 <int-e> You keep missing the fact that a program of bounded size can work on arbtirary sized data.
12:57:33 <myname> it fails if you have cards that do exponential damage
12:57:41 <myname> exactly that
12:57:45 <int-e> A singe universal machine can run everything.
12:57:49 <cpressey> int-e: No, the busy beaver function *accounts for that fact*.
12:58:16 <cpressey> BB(6) doesn't say *anything* about how much data any TM of size 6 uses or does not use.
12:58:34 <int-e> cpressey: Then stop saying "the" busy beaver function and define what you're actually using. "The" busy beaver function is for programs without input.
12:58:42 <int-e> cpressey: It starts on an empty tape.
12:58:44 <cpressey> I'm not talking about input.
12:58:45 <int-e> NO INPUT.
12:58:50 <cpressey> I agree, no input!
12:59:09 <int-e> The card games have input in the form of choices the players make.
12:59:10 <cpressey> The machines in BB(6) can use a lot of tape, even though they have no input
12:59:11 -!- TheLie has quit (Remote host closed the connection).
12:59:14 <int-e> This is CRUCIAL.
12:59:37 <cpressey> What kind of choices do the players make?
13:00:00 <int-e> Which cards to play, how much mana to spend on it, how often to repeat a cycle if they enter one...
13:00:03 <int-e> tons of them
13:00:04 <myname> the number of steps does not have to be proportional to the amount of damage
13:00:14 <myname> if one step doubles the damage, you are out of luck
13:00:17 <int-e> Which is why I have all those *guesses* up there.
13:01:53 <cpressey> OK. I don't play MtG, I'm not aware of the kinds of choices players can make.
13:01:58 <int-e> One of the real challenges they face is to make a TM interpreter that does *not* leave any choices to the players (with some constraints, like refusing to resign; the M:tG rules stipulate that a player may resign at any point during the game).
13:03:37 <cpressey> OK.
13:03:38 -!- xelxebar has quit (Remote host closed the connection).
13:05:25 <cpressey> I guess there's not much point trying to understand this, unless I want to understand the rules of MtG first, and I don't really have any interest in that
13:06:19 -!- xelxebar has joined.
13:08:00 <int-e> For me the new insight here was that NTMs can compute (and even iterate computations of) the busy beaver function for DTMs.
13:08:59 <int-e> So for this purpose, M:tG is just a peculiar NTM. And I totally ignored TWM.
13:11:08 <cpressey> If there's an NTM that can compute the BB function then there's also an NTM that can solve the halting problem.
13:11:33 <int-e> (As a two-player game with best play, M:tG might actually be a full ATM. I don't know.)
13:12:18 <int-e> Well the halting problem is r.e. even with TMs.
13:12:59 <cpressey> I'm aware of that.
13:13:27 <int-e> And the usual acceptance condition for NTMs is "there is an accepting run", generalizing what you do for r.e. (accepts the input).
13:13:46 <int-e> So yes, that solves the halting problem.
13:15:18 * oerjan measures cpressey's brain pressure then hides behind a rock
13:15:19 <int-e> One real stumbling block for me is to extend this to a functional model of computation, that actually computes a value from the input.
13:15:31 <int-e> s/is/was/
13:16:07 * int-e sets fire to the dynamite stick that somebody placed under that rock earlier.
13:17:03 * oerjan gets incinerated
13:18:03 <cpressey> I have a hard time understanding why someone would think that they could extend "there exists an accepting path" to something that actually finds that path in all cases.
13:18:46 * int-e is beginning to think that cpressey is one of those constructivists he's heard rumors about
13:19:20 <int-e> I mean, it's just a definition.
13:21:29 <cpressey> I guess my brain pressure is just too high. Occupational hazard of us constructivists, don't ya know.
13:22:27 <int-e> We can do it mathematically (inside a proof, say). We can't do it in practice.
13:23:26 <int-e> Using classical logic, obviously, like most people.
13:24:29 <cpressey> It would still seem that you're simply saying something like, the maximum damage you can deal in a hand of n MtG cards, is BBN(n), where BBN(x) is the busy beaver number for an *NTM* with x states.
13:27:00 <cpressey> OK, BBN(m) where m is some function of n.
13:27:03 <int-e> It's more bounding BBN(n) from below by (iterated) BB(m) where both iteration and m depend on the concrete n-sized program.
13:28:10 <myname> the amount of damage is obviously bounded by BBN(f(n)) for a function like f(n) = infty
13:28:30 <int-e> myname: Hey we're having a serious discussion here.
13:33:01 <int-e> cpressey: You're not wrong, there is something resembling BBN(n) for a fixed n here somewhere, namely in the task of finding an M:tG deck that allows dealing a huge amount of damage while having an upper bound on that damage.
13:34:34 <int-e> cpressey: But the point where the discussion started was that they wanted to find an M:tG deck, that is, an NTM, that actually computes BB(m) or BB(BB(m)) for another fixed m instead, so that they had something easier to work with: Busy beavers (for some deterministic model of computation that's easy to implement a universal machine for in TWM).
13:35:18 <cpressey> OK. "NTM" and "actually compute" do not go together. That's my first problem.
13:35:34 <int-e> You can define BB(n) but you can't compute it.
13:35:59 <int-e> The NTM semantics are something you can define, not compute.
13:36:08 <int-e> I should probably not have used "actually" there.
13:36:21 <int-e> s/actually computes/defines/
13:37:53 <int-e> You still need the busy beavers (not necesaarily the best ones) to actually play the game and deal some damage.
13:38:10 <cpressey> I think it is a bad idea to model a hand of cards an as NTM. I think it is better to model (hand of cards + player's strategy) as a DTM.
13:38:32 <int-e> Well, and I disagree completely.
13:40:22 <cpressey> Well...
13:41:16 <int-e> I honestly believe that NTM (and ATM for the full game) is the most natural model for this. I don't want to mess things up by restricting the players to a computable strategy. Not that it matters here... there are only finitely many choices to be made anyway.
13:41:39 <cpressey> Ha
13:42:02 <cpressey> Are there really only a finite many choices that a player can make when playing their hand?
13:42:17 <int-e> In this particular case? Yes.
13:42:18 <cpressey> If so then I object even more strongly to modelling that as an NTM
13:42:25 <cpressey> This is just combinatorics.
13:42:34 <cpressey> Occam would prefer you not complicate it unnecessarily, and so would I.
13:42:55 <int-e> Yes, don't model choices that happen on the fly as input, defying causality.
13:43:14 <int-e> Use the proper model for that, which is non-determinism.
13:44:18 <int-e> This may be our main disagreement really... I think non-determinism is *simple*.
13:45:05 <int-e> Yes, you get a tree of computations rather than a line. But that's all. Trees are simple.
13:48:05 <int-e> And "just combinatorics" -- in either case you still get to the point where the model of computation solves the halting problem for you.
13:48:42 <int-e> By simply disregarding non-terminating paths of execution (inputs for which your program doesn't terminate)
13:51:26 <cpressey> It seems to me that you would rather introduce an NTM that represents selecting all possible finite combinations from a finite set, than merely consider all possible finite combinations from a finite set, in your explanation, that's all.
13:52:35 <int-e> Yes. At least in this particular context.
13:52:55 -!- sprocklem has quit (Ping timeout: 255 seconds).
13:53:10 <cpressey> I would call that overkill, not just because it's nondeterministic, but also because it's a TM.
13:53:17 <int-e> (I could argue against the idea that I introduce the NTM... the NTM is already present in the game, to my mind. But meh.)
13:54:12 <int-e> Playing 13 No Need To Argue.ogg.
13:54:36 -!- oerjan has quit (Quit: leaving).
13:54:51 -!- tromp has quit (Read error: Connection reset by peer).
13:55:24 -!- tromp has joined.
14:51:31 <cpressey> If you have an NTM that "guesses" an arbitrary DTM description and writes it to a tape, then uses a UTM to simulate that DTM and "produce" its result as an integer, there is no upper bound to the integer the NTM can "produce"; it only needs to "guess" bigger DTMs to get bigger numbers.
14:53:32 <cpressey> On the other hand, if there is a limit to the set of DTMs it can "guess" - if they are drawn from a finite set - then you don't need to talk about "guessing" them and then simulating them at all - you just have an enumeration of DTMs.
15:08:56 <int-e> cpressey: But I /prefer/ to do it by guessing.
15:09:10 -!- int-e has left.
15:10:34 -!- sprocklem has joined.
15:12:37 <Taneb> Are you two doing the thing where you argue about a fundamentally unimportant detail while agreeing about all the important bits?
15:14:02 <cpressey> I think I disagree about some of the actual conclusions too, but it's hard enough to find out exactly what they are
15:14:44 <cpressey> Wouldn't BBN(x) be infinite for large enough x?
15:15:15 <esowiki> [[DINAC/STDLIB]] M https://esolangs.org/w/index.php?diff=70186&oldid=70181 * PythonshellDebugwindow * (+223) /* Arithmetic */
15:16:03 <Taneb> What is BBN?
15:16:15 <cpressey> Busy-beaver number for NTMs.
15:16:30 <Taneb> Where x is the number of states?
15:16:41 <cpressey> Yes
15:16:54 <Taneb> How would BBN(x) be > BB(x)?
15:17:10 <cpressey> The NTM has no limit to the number of states it can "guess" a DTM description to have, then it can simulate it with a UTM
15:17:30 <cpressey> So probably BBN(10) is infinite
15:17:51 <cpressey> If not 10, then some fairly small number, in the scheme of things
15:18:48 <Taneb> Hmm, wouldn't the definition of the busy beaver function preclude machines that might not halt, and hence preclude any that could be infinite
15:20:08 <cpressey> So probably BBN(10) is ω, is that better
15:21:05 <Taneb> I don't think I understand how you're defining BBN
15:22:20 <Taneb> I can't see how ω could even be in the codomain of BBN
15:22:59 <cpressey> OK. BB(x) is the largest number of steps any terminating DTM with x states takes before terminating. BBN(x) is the largest number of steps any terminating execution path of an NTM with x states.
15:23:30 <cpressey> *states has. Excuse my awkward phrasing.
15:23:42 <Taneb> Ah, I had taken BBN(x) to be the lagest number of steps of any terminating execution path of an NTM with x states that terminates in all execution paths
15:24:19 <Taneb> Because otherwise, BBN(2) is undefined, I think
15:25:58 <Taneb> Take a non-deterministic turing machine with states (I, H), and transitions I -> {1RI,1RH}
15:26:08 <Taneb> This has a terminating execution path for every natural number
15:29:07 <esowiki> [[DINAC]] M https://esolangs.org/w/index.php?diff=70187&oldid=70182 * PythonshellDebugwindow * (+198) /* Functions */ Clearing up GIVE $
15:29:42 <esowiki> [[DINAC/STDLIB]] M https://esolangs.org/w/index.php?diff=70188&oldid=70186 * PythonshellDebugwindow * (+21) /* Boolean */
15:30:42 -!- int-e has joined.
15:31:08 <int-e> cpressey: BBN(n) is cleverly defined to exclude not only non-terminating machines but also those that have unbounded results.
15:32:20 <cpressey> "they wanted to find an M:tG deck, that is, an NTM, that [defines] BB(m) or BB(BB(m)) for another fixed m instead, so that they had something easier to work with: Busy beavers (for some deterministic model of computation that's easy to implement a universal machine for in TWM)." My problem with this is in two parts:
15:33:21 <cpressey> 1) If they only have 125 waterclocks at their disposal to make this machine in TWM, then their damage is limited to BB(125) (or something proportional to it)
15:33:49 <int-e> You're ignoring the starting values of the clocks?
15:35:53 <cpressey> 2) If they use these 125 waterclocks to make a UTM, and then feed it some kind of TM description as part of how they play their hand, then I need an explanation why they are not allowed to give it an arbitrarily large TM description that produces BB(x) for arbitrarily large x, i.e. it would appear there is no upper bound at all.
15:36:32 <int-e> The x needs to be encoded in the deck, obviously.
15:36:43 <cpressey> Why obviously?
15:36:57 <int-e> Because otherwise, as you say, things would be unbounded.
15:37:14 <cpressey> How do we know they're not unbounded?
15:37:32 <int-e> Which is specifically forbidden by their task description... if the deck produces unbounded damage, it doesn't qualify.
15:38:06 <int-e> Which links back to "BBN(n) is cleverly defined to exclude not only non-terminating machines but also those that have unbounded results."
15:38:15 <cpressey> Why does x need to be encoded in the deck as opposed to the choices that the player takes when they play their cards?
15:38:37 <int-e> ...
15:38:46 <int-e> We're running in circles here.
15:38:59 <int-e> You just asked that question, I just answered it.
15:39:03 <int-e> Nothing has changed in the meantime.
15:39:37 <cpressey> I guess there's something I still don't understand about how MtG is played.
15:39:38 <int-e> The encoding may be indirect, of course. In particular, x may be something like BB(10).
15:41:11 <cpressey> I don't even care about this, it's just frustrating that, every time I say something, hoping to get more clarity, I just get responses that seem to make it more opaque.
15:41:37 <Taneb> cpressey: I think you might have misinterpreted the nature of the puzzle
15:42:11 <Taneb> Or I have misinterpreted the nature of your complaint
15:42:48 <int-e> What frustrates *me* is that you seem to understand everything about this and still are, obviously, confused, and I have no idea what you are confused about.
15:43:58 <cpressey> I don't see how how n cards could *possibly* generate the number BB(BB(n)).
15:44:13 <cpressey> I can see how they could generate the number BB(n), yes.
15:44:30 <cpressey> But you see, I don't see how they could generate any number *larger* than it.
15:44:58 -!- sprocklem has quit (Ping timeout: 255 seconds).
15:45:05 <cpressey> Unless it's something like: n cards generates BB(n), then BB(n) *plays* of those cards, generates BB(BB(n)). Something like that.
15:45:20 <int-e> BB_BB_googol: Guess a TM A of size 10^100. Run it to its conclusion, counting steps. Let m be the number of steps taken. Guess a TM B of size m. Run it to its conclusion, counting steps. Return the number of steps.
15:45:41 <int-e> (You can make the TMs your input. I don't care.)
15:46:07 <int-e> You discard all non-terminating runs, and take the maximum length of the terminating ones.
15:46:19 <int-e> That length is BB(BB(10^100)).
15:46:30 <int-e> s/length/value returned/
15:46:34 <int-e> (sorry)
15:46:52 <cpressey> "Guess a TM A of size 10^100" - May I ask to what object in the game of MtG does this A correspond?
15:47:20 <int-e> Some number of creatures of a particular creature type.
15:47:28 <int-e> Creature types === counters in TWM.
15:47:43 <cpressey> OK, can I ask another question/
15:47:47 <int-e> It's not a perfect analogy.
15:48:12 <int-e> I really prefer to think of this in terms of (N)TMs, because that's far more familar territory to me.
15:48:33 <cpressey> I can guess a TM of size 10^100. Can I guess a TM of size 10^10000 instead?
15:48:50 <int-e> Sure. That would be a different NTM though.
15:49:26 <cpressey> Can I guess an arbitrarily large TM?
15:49:30 <int-e> No.
15:49:34 <cpressey> Why not?
15:49:42 <int-e> That's the whole point of building that bound into the NTM.
15:50:15 <cpressey> May I ask, what object in the game of MtG the NTM corresponds to?
15:50:46 <int-e> You have given the explanation above: If you /could/ guess a TM of arbitrary size, there would be no maximum result (the results would be unbounded), and we don't want that.
15:51:00 <int-e> The NTM is the deck of cards.
15:51:07 <cpressey> Wait what?
15:51:16 <cpressey> I thought we were trying to find out what the maximum result *is*.
15:51:42 <int-e> Find a deck of card whose maximum damage is bounded, but really really big.
15:52:03 <int-e> The damage is all done in the end, and corresponds to the number computed by the NTM.
15:52:19 <cpressey> The answer seems to be that you can find decks of cards that do arbirarily large finite damage.
15:52:33 <int-e> But the deck size is bounded.
15:52:35 <cpressey> I was pretty sure the constraint was that we had to avoid *infinite* damage.
15:53:08 <cpressey> What is the deck size bounded by?
15:53:14 <int-e> 60.
15:53:39 <int-e> Plus a side-board of, what, 10 cards? Something like that.
15:53:59 <int-e> But that's all so awfully M:tG-specific.
15:54:29 <cpressey> OK, so you're modelling this 60-card deck as an NTM with 60 states (roughly speaking).
15:54:56 <cpressey> But there is some reason this 60-state NTM can't guess (and then simulate) arbitrarily large DTMs.
15:55:00 <cpressey> But I'm not seeing that reason.
15:55:19 <int-e> https://esolangs.org/logs/2020-03-02.html#lNe
15:55:48 <int-e> cpressey: The bound (whatever it is) must be enforced by the NTM.
15:57:43 <int-e> cpressey: I doubt that the number of states corresponds to the number of cards in any nice fashion. But I also don't really care about that aspect of the problem.
15:58:28 <int-e> My interest is really this: My initial reaction to the idea that you can iterate the BB function was that this can't be done. No way. Then I homed in on alternation as a possibility, and then I realized that plain non-determinism is enough.
15:59:12 <int-e> Which was a new insight for me. And I'm still enjoying that.
15:59:41 <int-e> All the TWM and M:tG details... meh I just assume they work out somehow.
16:00:00 <int-e> And if they don't work out, that's no skin off my nose either.
16:00:23 <cpressey> Whhhh
16:01:00 -!- sprocklem has joined.
16:04:38 <cpressey> "if there is a line that does more damage we will take it", but "if that amount of damage is unbounded, the deck is disqualified.", so basically this is ruling out any sequence that grows forever.
16:05:19 <int-e> Yes. This is the same as ruling out an NTM that produces unbounded results.
16:09:33 <cpressey> OK, that makes sense I guess.
16:11:09 -!- wib_jonas has quit (Remote host closed the connection).
16:15:21 <cpressey> I can't quite convince myself of it.
16:20:59 <cpressey> "Let m be the number of steps taken. Guess a TM B of size m." ... the NTM has to allow guessing a TM as large as m, without knowing how big m is beforehand, but also has to prevent guessing arbitrarily large TMs.
16:21:42 <int-e> A is *deterministic*
16:22:09 <int-e> So it either fails to terminate (and we're good, the run will be discarded) or produce a fixed result.
16:22:19 <int-e> Same for B.
16:22:23 <cpressey> Back up
16:22:43 <int-e> m is bounded by BB(10^100).
16:23:06 <cpressey> I *understand* that A is deterministic; in fact I am assuming that the NTM correctly guessed the DTM which computes BB(10^100).
16:23:37 <int-e> So in that case m equals BB(10^100) by the point we're guessing B.
16:24:25 <int-e> So that's not arbitrarily large anymore?
16:24:33 <cpressey> Okay.
16:24:49 <int-e> (Though obviously so insanely large that it makes no difference in practice.)
16:25:16 <int-e> (Where "practice" refers to the scenario where we actually play out one of those runs with concrete choices for A and B)
16:29:51 <cpressey> OK, so there's a deck of 60 cards where there's a possible play that writes a TM A of size 10^100 to the tape and then simulates it to obtain m = BB(10^100) and then writes another TM, this one of size m, to the tape, and then simulates it to obtain BB(m), i.e. BB(BB(10^100)), and then does that much damage.
16:30:39 <int-e> Yeah, that's the mental model I have of this.
16:30:40 <cpressey> I think I understand it now.
16:31:32 <int-e> I'm hazy about the actual models of computation (TWM is involved, but it's used to implement a universal machine, and that may be something entirely else still).
16:31:40 <cpressey> Now that I have explained it to myself in terms that do not involve an NTM.
16:33:01 <int-e> The important bits to me is that the outer model is non-deterministic (you prefer input, we disagree, let's not reopen that discussion), and that the innner thing that the BB() function is based on is deterministic (so that non-termination of the simulated machine manifests as non-termination of the whole thing).
16:36:54 -!- imode has joined.
16:52:55 -!- sprocklem has quit (Ping timeout: 255 seconds).
16:55:29 <cpressey> You *could* do the steps the other way around. You could write a TM B of size BB(10^100) to the tape and simulates it to produce BB(BB(10^100)), then write a TM A that computes BB(10^100) to obtain m, then aborts if TM B consists of more than m states (but it doesn't so you're ok and you output BB(BB(10^100)).)
16:56:15 <cpressey> I'm not sure why I mention this.
16:57:25 <Taneb> (I don't get how people are computing BB(BB(x)) given BB(x))
16:58:01 <tromp> that's not possible:(
16:58:44 <cpressey> They're basically getting very, very lucky, if you want to think of it as something that could actually happen.
16:59:33 <tromp> a lucky NTM of 1 or 2 states can also output BB(10^100) :)
17:01:51 <cpressey> For obscure reasons, we also want to also disallow NTMs that can produce arbitrarily large numbers.
17:04:14 <cpressey> Details are available in the scrollback, if they can be extracted from the painful misunderstandings.
17:05:30 <cpressey> I'm still digesting it, myself.
17:05:43 -!- xelxebar has quit (Ping timeout: 240 seconds).
17:06:06 -!- ArthurStrong has joined.
17:06:30 -!- xelxebar has joined.
17:13:05 <int-e> cpressey: It's not all that obscure... it's fairly easy to do unbounded damage in M:tG.
17:13:30 <cpressey> For reasons that will be obscure to anyone who doesn't care much about the MtG angle.
17:13:59 <int-e> (Use any of https://hobbylark.com/card-games/best-infinite-mana-combos-mtg to fuel a Fireball, which does X damage for 1 red and X other mana.)
17:14:44 <int-e> cpressey: But it also makes sense to do that when trying to define the busy beaver function for NTMs ;)
17:15:08 <int-e> (Because what would the point be if the value can be infinite...)
17:17:16 <int-e> cpressey: The reason is not that dissimilar to that 2-state NTM you had earlier... non-determinism means you can expect to turn an infinite loop into an unbounded one very easily.
17:18:05 <int-e> And for some reason the M:tG designers don't consider infinite loops to be a design flaw in the cards... as long as they either don't do anything useful, or are expensive to set up.
17:19:17 <cpressey> Fine, how would you like to me say it?
17:19:40 <cpressey> tromp: For reasons that int-e will be happy to explain, we want to avoid NTMs that produce arbitrarily large numbers.
17:20:04 <cpressey> Have a good weekend.
17:20:09 -!- cpressey has quit (Quit: A la prochaine.).
17:48:25 -!- b_jonas has joined.
17:51:00 <esowiki> [[User:PythonshellDebugwindow]] M https://esolangs.org/w/index.php?diff=70189&oldid=70178 * PythonshellDebugwindow * (-56)
18:05:04 <esowiki> [[User:PythonshellDebugwindow]] M https://esolangs.org/w/index.php?diff=70190&oldid=70189 * PythonshellDebugwindow * (+15)
18:06:16 -!- imode has quit (Ping timeout: 255 seconds).
18:09:15 -!- LKoen has joined.
18:09:17 -!- sprocklem has joined.
18:11:21 <esowiki> [[MyScript]] N https://esolangs.org/w/index.php?oldid=70191 * PythonshellDebugwindow * (+131) Created page with "'''MyScript''' is an esolang created by [[User:PythonshellDebugwindow]]. ==Examples== ===[[Hello, World!]]=== say "Hello, World!""
18:13:44 -!- Phantom_Hoover has joined.
18:51:20 -!- zseri has joined.
19:16:50 -!- LKoen has quit (Remote host closed the connection).
19:29:12 -!- LKoen has joined.
19:47:41 -!- Lord_of_Life_ has joined.
19:48:49 -!- Lord_of_Life has quit (Ping timeout: 265 seconds).
19:49:00 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
19:49:57 -!- FreeFull has joined.
19:53:48 -!- imode has joined.
19:59:53 -!- ArthurStrong has quit (Quit: leaving).
20:58:54 <esowiki> [[DINAC]] M https://esolangs.org/w/index.php?diff=70192&oldid=70187 * PythonshellDebugwindow * (+5)
21:11:38 -!- zseri has quit (*.net *.split).
21:11:39 -!- moony has quit (*.net *.split).
21:11:39 -!- arseniiv has quit (*.net *.split).
21:11:39 -!- atslash has quit (*.net *.split).
21:11:39 -!- heroux has quit (*.net *.split).
21:11:39 -!- longname has quit (*.net *.split).
21:11:39 -!- BWBellairs has quit (*.net *.split).
21:11:39 -!- ineiros has quit (*.net *.split).
21:11:39 -!- myname has quit (*.net *.split).
21:11:39 -!- rodgort has quit (*.net *.split).
21:11:39 -!- diginet has quit (*.net *.split).
21:11:39 -!- relrod has quit (*.net *.split).
21:11:39 -!- lifthrasiir has quit (*.net *.split).
21:12:38 -!- zseri has joined.
21:12:38 -!- moony has joined.
21:12:38 -!- arseniiv has joined.
21:12:38 -!- atslash has joined.
21:12:38 -!- heroux has joined.
21:12:38 -!- longname has joined.
21:12:38 -!- BWBellairs has joined.
21:12:38 -!- ineiros has joined.
21:12:38 -!- myname has joined.
21:12:38 -!- rodgort has joined.
21:12:38 -!- diginet has joined.
21:12:38 -!- relrod has joined.
21:12:38 -!- lifthrasiir has joined.
21:13:38 -!- moony has quit (Max SendQ exceeded).
21:13:38 -!- rodgort has quit (Max SendQ exceeded).
21:13:39 -!- diginet has quit (Max SendQ exceeded).
21:13:55 -!- rodgort has joined.
21:14:01 -!- moony has joined.
21:14:10 -!- diginet has joined.
21:40:21 <zzo38> I think they should add a dot command in the SQLite command-line interface for editing the definition of a view or trigger using an external editor.
21:42:54 -!- xkapastel has quit (Quit: Connection closed for inactivity).
21:49:39 -!- Phantom_Hoover has quit (Ping timeout: 268 seconds).
21:59:53 -!- Phantom_Hoover has joined.
22:19:51 -!- LKoen has quit (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”).
22:38:52 <zseri> I think it would be interesting to invent a programming language which supports a metatype above "type kinds". ref = https://github.com/YZITE/rfcs/blob/master/proglangs/0004-typelang.md
23:11:22 <arseniiv> posted a thing to ##math to no avail, maybe #esoteric-setminus-##math people will make something of it:
23:11:22 <arseniiv> hey hey you probably know that solutions to ordinary differential equations like P dx + Q dy = 0 are integral curves. The previous night it occurred to me that one could take 2-forms (and higher ones) instead of 1-forms and make an equation like α := P dx∧dy + Q dy∧dz + R dz∧dx = 0 whose solutions would be “integral surfaces” (resp. submanifolds of higher dimension). But I haven’t seen an equation like that anywhere. Do you know why?
23:11:22 <arseniiv> the thing doesn’t seem ill-defined: as with integral curves, every point P of an integral surface should have a tangent bivector A such that α(P, A) = 0. One can also think about nonlinear higher-order equations, again in the same way as for the ordinary “1-form equations”. WDYT?
23:11:56 <b_jonas> differential equations question? no thanks
23:13:10 * arseniiv cries silently
23:21:02 <zseri> (@arsentiv) I don't really know how to interpret your question, but that might be because I don't really know how to translate your "textification" of integral formulas back into the standard notation. hm. ref = https://en.wikipedia.org/wiki/Surface_integral
23:35:18 -!- zseri has quit (Quit: zseri).
23:46:01 -!- Phantom_Hoover has quit (Ping timeout: 255 seconds).
23:50:43 -!- tromp has quit (Remote host closed the connection).
23:56:05 <arseniiv> hehe those weren’t integrals, those were differential form fields (equated to zero), but there is a hidden argument to which they are applied to: a vector field, or a bivector field in the second case. So a solution will consist of points with tangent (bi)vectors sticking out of them, and as fields by usual definition are smooth, these points would (in most cases?) make a curve, a surface etc.
23:56:57 <arseniiv> zseri: if you are reading logs ← here’s a mention to simplify the search
23:57:55 <arseniiv> also a person said me that in general there should probably be jets instead of forms
23:58:46 <arseniiv> but I don’t know if they cover k-forms for k ≥ 2
←2020-03-05 2020-03-06 2020-03-07→ ↑2020 ↑all