00:03:31 -!- mtm has quit (Ping timeout: 272 seconds).
00:06:15 -!- mtm has joined.
00:15:33 -!- Noisytoot has quit (Remote host closed the connection).
00:16:08 -!- Noisytoot has joined.
00:16:58 <Sgeo> If you were looking at assembly code for a machine you were unfamiliar with, what might "BRG" mean?
00:17:38 <Sgeo> In context it seems like it puts the value from memory into a register, but I don't see where the register is specified
00:18:32 <b_jonas> does it seem to have a branch target label as operand?
00:18:52 <Sgeo> It has a label as operand
00:19:17 <Sgeo> BRG SAVERP Restore A
00:19:23 <b_jonas> if it starts with B then it's always a branch, but I'm not sure about the greater part
00:19:32 <Sgeo> BRG SAVEAR and R Registers
00:19:52 <b_jonas> hmm, I wonder if RG stands for "registers"
00:20:22 <Sgeo> NJP is some sort of conditional procedure call, NZJ is a conditional jump
00:20:35 <Sgeo> https://ntrs.nasa.gov/api/citations/19680001402/downloads/19680001402.pdf page 55 of the PDF. Assembly for a General Mills computer.
00:20:41 <Sgeo> Because General Mills made computers for NASA.
00:21:58 <b_jonas> dunno, old instruction mnemonics are sometimes weird, like in one of those PDP-? machines the load instruction is called clear and accumulate
00:22:04 -!- Noisytoot has quit (Ping timeout: 268 seconds).
00:27:00 -!- Noisytoot has joined.
00:30:21 <Sgeo> My confusion is mainly about the same op being called and doing different things
00:30:41 -!- Evylah has joined.
00:31:12 -!- Noisytoot has quit (Remote host closed the connection).
00:31:43 -!- X-Scale has quit (Quit: Client closed).
00:34:44 -!- X-Scale has joined.
00:37:36 -!- Noisytoot has joined.
00:38:57 <Sgeo> FWIW here's some details: 37-bit words, instructions are always 6 bits op code and 12 bits address
00:41:44 <fizzie> Vaguely think I've seen "bring" used as the opposite of "store" somewhere.
00:43:46 <fizzie> The "STA SAVEAP / STR SAVERP" ... "BRG SAVERP / BRG SAVEAR" pair with comments "Save A and R Registers" and "Restore A and R Registers" suggests that sort of thing, except if so then it's odd there isn't an A/R indication in the latter, the same way there is in the former.
00:55:21 <fizzie> Just ask Eugene? ;) https://www.linkedin.com/in/geneprocknow says he "co-developed a machine language for a General Mills AD/ECS-37A computer system" in the 70s.
00:58:32 -!- Evylah has quit (Quit: Client closed).
01:02:57 <Sgeo> fizzie, I emailed earlier today
01:03:05 <fizzie> Also, "BRG COUNT / ADD ONE / STA COUNT2 is used to "Increment Count" on PDF-page 58, so I do think it's some sort of a load instruction, though still odd that it doesn't seem to say where to put the loaded value.
01:04:58 <fizzie> Is it possible that STA/STR store not only the value but also the register identity at the label they target? Do you know how big those registers are?
01:05:55 -!- X-Scale has quit (Quit: Client closed).
01:19:12 <Sgeo> "Each bit had a foot square card and 37 cards for each register (accumulator, etc.)" -- from Eugene Procknow's reply to me
01:27:36 <esolangs> [[Cantor]] https://esolangs.org/w/index.php?diff=133016&oldid=133013 * Joe * (+153)
01:28:43 <Sgeo> Could BRG move A->R and mem->A?
01:29:21 <zzo38> It is what I thought at first, too.
01:29:29 <zzo38> But, it says SAVEAP for the save but SAVEAR is used for restoring, so it is different but the "SAVERP" is the same in both.
01:30:15 <Sgeo> I didn't notice that
01:37:02 <Sgeo> Oh, the brochure would be helpful, derp
01:37:06 <Sgeo> http://www.bitsavers.org/pdf/generalMills/GeneralMillsComputerBrochure_1961.pdf
01:37:38 <Sgeo> "Bring (m) to register A" is an instruction
01:38:40 <Sgeo> What's the difference between m and M. And I don't see how to load R with anything
01:42:12 <Sgeo> Unless R is the I/O connected register?
01:45:04 <zzo38> I don't know if "M" is a printing error, or if the program shown in there itself has printing errors (although it says "it is not intended as an operational program")
01:50:33 <fizzie> Nice to have a dedicated "Ring Bell" instruction, don't see that sort of thing in modern computers.
01:53:06 -!- Noisytoot has quit (Ping timeout: 256 seconds).
02:10:24 <Sgeo> What is a "computational mode"?
02:10:49 <shachaf> I suppose it means the most common computation.
02:34:57 -!- X-Scale has joined.
03:47:12 -!- X-Scale has quit (*.net *.split).
03:47:25 -!- chiselfuse has quit (*.net *.split).
03:52:48 -!- chiselfuse has joined.
04:33:56 -!- anomalous has joined.
05:24:18 <zzo38> Is there a simple short way to use Windows Powershell to send a binary file using a raw TCP socket?
05:24:51 <zzo38> (that I can then receive on this computer using netcat)
05:32:56 <esolangs> [[Rizzlang]] https://esolangs.org/w/index.php?diff=133017&oldid=132979 * ZachChecksOutEsolangs * (+318)
05:33:28 <esolangs> [[Rizzlang]] https://esolangs.org/w/index.php?diff=133018&oldid=133017 * ZachChecksOutEsolangs * (+3)
05:44:26 <shachaf> There must be, since I think Powershell can call Windows APIs.
06:17:07 <Sgeo> AD/ECS-37 has a "B" buffer that it can use for output.
06:17:45 <Sgeo> And a "BI" buffer for input
06:20:57 <Sgeo> The NASA document has a reference to "SDS- 9 30 and AD/ ECS Interface
06:21:05 <Sgeo> But I don't think I can find that document
06:22:07 <Sgeo> "Command Next PCM/DHE to RA Transfer " so R+A might be a combined register?
06:27:21 <Sgeo> EXM = 0o61 (in the configuration NASA was using)
06:46:10 -!- tromp has joined.
07:26:26 -!- ais523 has joined.
07:54:06 -!- cpressey has joined.
07:57:33 -!- __monty__ has joined.
08:12:27 -!- cpressey has quit (Ping timeout: 246 seconds).
08:12:47 -!- dbohdan has quit (Server closed connection).
08:13:07 -!- dbohdan has joined.
08:19:12 -!- cpressey has joined.
08:26:54 -!- Franciman has joined.
08:28:25 -!- Franciman has left.
08:38:48 <cpressey> "Where's Waldo?", except it's an audiobook
08:44:44 <ais523> I guess you'd need a definition for what Waldo sounds like?
08:45:05 <ais523> and try to pick him out among a conversation
08:46:22 <ais523> hmm, maybe Haskell is missing a combinator there
08:55:00 <ais523> anyway, I had a conceptual issue with Turing-completeness: suppose we have a language that would otherwise be Turing-complete, but it defines a) provable infinite loops or b) any infinite loop to be undefined behaviour
08:55:24 <ais523> does this negate the Turing-completeness?
08:55:38 <ais523> (where "provable" means that the interpreter can prove that an infinite loop exists)
08:55:45 <ais523> (but you don't know the interpreter's proof ability)
08:57:59 <cpressey> Unless the interpreter has an oracle for halting, there will be infinite loops that the interpreter can't prove are infinite. So I guess the interesting case is, the interpreter does have such an oracle.
08:58:36 <ais523> well, if you can observably trigger the oracle, then the language is then super-Turing, isn't it? but the problem is that undefined behaviour isn't observable
08:58:43 <ais523> because it might just do whatever you were expecting
09:01:32 <ais523> hmm, if you know the logic that the interpreter is using for proving loops to be infinite, then you can write a program that simultaneously a) runs a program and b) searches for a proof that it will halt
09:01:42 <cpressey> If you can observably trigger the oracle then I guess the language is super-Turing, but that doesn't seem too surprising, since we said it had access to that oracle and we know the oracle can do something Turing machines can't
09:01:45 <ais523> if you succed in either, then you halt, so there's no infinite loop
09:02:03 <ais523> and if neither is possible, then the program runs forever but the interpreter can't prove that it does
09:02:17 <ais523> as such, it's only the oracle case that matters
09:02:41 <ais523> or the case where you don't know how the interpreter is proving things, but that isn't obviously different from an oracle
09:03:29 <cpressey> If it has an oracle but goes out of its way to hide it and act (as far as anyone can observe) like a TM, then it's not exhibiting super-Turing behaviour - it's indistinguishable from a TM without such an oracle.
09:04:45 <ais523> well, I'm partly thinking of languages like C++, which defines an infinite loop to be undefined behaviour unless it has some observable side effect
09:04:58 <ais523> although you can easily work around that one simply by writing to a volatile variable
09:05:40 <ais523> that problem is easily fixable, but the implications are still pretty amazing
09:08:43 <cpressey> So the TM has an oracle. The oracle says "This will loop forever." So the TM just spins instead of running the program. If you can detect that the TM is spinning instead of running teh program, then yes. You've caught it out, you can tell it must have an oracle.
09:11:06 <cpressey> If the TM does something other than "just spin", e.g. maybe it runs some *other* program that it knows will never halt... that becomes harder to detect
09:11:29 <ais523> I have an interpreter for The Waterfall Model which detects certain infinite loops and deadlocks rather than running at 100% CPU power, that's easily detectable
09:11:34 <ais523> although, of course it isn't a full oracle
09:12:06 <ais523> ooh, what about this: you design the program to, when it halts, print the number of execution steps it took it to halt
09:12:27 <ais523> then, you run the program – if it halts, you run it again with a step limit that's higher than the number it printed
09:12:38 <ais523> if the program halts, then both runs halt, and the second run finishes in time
09:13:06 <ais523> if the program doesn't halt, then regardless of what the first run does, you discover in the second run that the first run didn't halt properly, so the halt must have been due to UB
09:13:52 <ais523> as long as you can bound the UB to some extent (i.e. have a reliable way to get the interpreter back to a sane state, and don't get killed by the demons that come out of your nose), I think this makes it possible to build a TC system out of the UB-on-infinite-loop interpreter
09:14:10 <ais523> but, because UB prevents you reasoning about the program's behaviour at all, you need a manual restarting step to clear the UB
09:19:42 <cpressey> Which sounds awfully close to giving a definition for undefined behaviour in your language :)
09:24:47 <ais523> I think bounded UB is quite common in esolang implementations, though – along the lines of "the program could loop forever or hold, and could produce arbitrary output of the form it normally produces, but won't do anything else"
09:25:12 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
09:26:40 <cpressey> *poorly* defined behaviour is quite common :) "Not fully defined behaviour" is common too, it's basically what abstraction is.
09:27:40 <esolangs> [[User talk:Ais523]] M https://esolangs.org/w/index.php?diff=133019&oldid=132971 * Ais523 * (-4) /* Delete pages */ fix formatting
09:28:01 <cpressey> You Are Reading the Name of this Esolang also requires an interpreter to be able to detect *some* infinite loops. But not all of them. So it doesn't strictly require an oracle.
09:28:55 <cpressey> What you're calling UB I guess I'm now trying to think of as an abstraction
09:29:58 <ais523> John Regehr has done a lot of research on the mathematical basis behind compiler optimizations, and UB is formalized as part of that, along the lines of "a program has a set of legal behaviours, an optimization must transform it to a program that has a subset of its original behaviours"
09:30:18 <ais523> so UB gives the optimizer license to do anything in a situation where UB would occur
09:33:19 <esolangs> [[User talk:Ais523]] https://esolangs.org/w/index.php?diff=133020&oldid=133019 * Ais523 * (+772) /* Delete pages */ some thoughts
09:39:57 -!- X-Scale has joined.
09:43:01 -!- X-Scale70 has joined.
09:44:49 -!- X-Scale has quit (Ping timeout: 256 seconds).
09:45:08 -!- tromp has joined.
09:47:07 <cpressey> In conventional mathematics, the result of dividing by zero is undefined. But this is not usually taken as meaning that after I've divided by zero, I can submit any answer I want and carry on :) It's usually more like, we shan't go down that path as we won't get any sensible answers there.
09:48:04 <ais523> right – programming language specification designers possibly went too far with that one
09:48:54 <ais523> interestingly, in declarative languages, division by zero can have a sensible definition that's consistent with the rest of the language: Y is X / 0 produces an assertion that X is 0, but no assertions on Y
09:49:03 <ais523> although, generally they don't seem to use that definition in practice
09:49:54 -!- Sgeo has quit (Read error: Connection reset by peer).
10:00:41 -!- X-Scale70 has quit (Ping timeout: 256 seconds).
10:01:53 -!- cpressey has quit (Ping timeout: 258 seconds).
10:21:09 -!- X-Scale has joined.
10:32:58 <int-e> many theorem provers agree that x/0 = 0 :P
10:34:04 <int-e> And quite a few people take great issue with that.
10:39:19 -!- cpressey has joined.
10:42:18 <int-e> Oh there's some pushback about some of the more egregious cases of undefined behavior, nice! https://isocpp.org/files/papers/P2809R3.html
10:47:22 <int-e> TC-ness is an annoyingly informal concept. Which /may/ be unavoidable because you want to leave so many aspects of models of computation open.
10:50:56 <int-e> Hmm... what if you run the machine only once? You could output a trace of the execution and then an LBA can verify that (that's almost cheating since the trace by its nature will be padded sufficiently). Can we go below that for verification?
10:53:16 <ais523> you can verify an appropriately encoded execution trace with two PDAs
10:53:38 <ais523> i.e. if they both accept the trace it's valid
10:53:46 <int-e> I was headed for co-NPDA
10:54:43 <ais523> where co-nondeterministic means that every possible execution has to accept, not just one?
10:55:04 <ais523> yes I think that works
10:55:13 <int-e> Intersection of just two CFGs, I have to think about that.
10:57:11 -!- GregorR has quit (Server closed connection).
10:57:24 -!- GregorR has joined.
10:57:37 <int-e> (The encoding I have in mind is for a single tape TM and records symbols written, symbols read, and moving left and right. Is there more useful information that one can add?)
10:58:17 <int-e> Oh you can target a two-counter machine I guess? So one PDA checks one counter and the other checks the second one.
10:59:31 -!- anomalous has quit (Ping timeout: 260 seconds).
11:00:17 <int-e> that makes a nice puzzle actually
11:00:49 <cpressey> Intersection of two CFGs is undecidable, there's a famous proof of that one
11:00:56 -!- cpressey has quit (Quit: WeeChat 4.3.0).
11:00:57 <esolangs> [[Talk:!aoQ):]] N https://esolangs.org/w/index.php?oldid=133021 * Gggfr * (+231) Created page with "Thos os turing complete right? Like the bf loop is there there is ^ and V which is the same as < and > on a stack {1}+ is + in bf {1}- is - in bf right?? Idk ~~~~"
11:01:08 <int-e> Ah, you can do the same thing with a tape because it's two stacks.
11:01:12 -!- cpressey has joined.
11:01:27 <int-e> That... could've been quicker :)
11:02:47 <cpressey> I'm sorry, I'm not following that closely
11:03:33 <int-e> (also the execution trace could record states too for convenience, but the PDAs can keep track of that with ease)
11:03:56 <int-e> cpressey: I think I went off a tangent anyway.
11:06:24 <ais523> the encoding I had in mind is Thue-like: a PDA can check one step of Thue evaluation, if one of the "before" or "after" states is written backwards (but then it forgets what the string is)
11:06:51 <ais523> so with two PDAs, one can check the odd steps and the other the even steps
11:07:12 <ais523> if every second step is written backwards
11:07:20 <int-e> my two PDAs are deterministic now :)
11:07:39 <int-e> though you can do that for Thue if you leave a few extra markers
11:08:30 <ais523> this is my favourite way to show "try to prove this grammar ambiguous" to be an interpreter for a TC language
11:09:15 <cpressey> I've not quite followed what we're trying to achieve here, but the relevant thing about the intersection-of-CFGs-proof is (quoting WP here) "the language of non-accepting computation histories of a Turing machine M on input w is a context-free language recognizable by a non-deterministic pushdown automaton."
11:09:38 -!- cpressey has quit (Quit: WeeChat 4.3.0).
11:09:53 -!- cpressey has joined.
11:09:54 <int-e> that was the co-NPDA, more or less
11:10:11 <int-e> (but without consulting wikipedia)
11:10:12 <cpressey> doesn't help that my connection keeps hiccupping
11:10:36 <int-e> cpressey: yeah, but we do have logs, as I'm sure you're aware
11:10:47 <cpressey> Per the Computation histories article on WP, "the language of non-accepting computation histories of a Turing machine M on input w is a context-free language recognizable by a non-deterministic pushdown automaton."
11:11:10 <int-e> Yes that message made it through.
11:11:12 <cpressey> that's the nub of the intersection-of-CFLs-is-undecidable proof
11:11:43 <cpressey> How it relates to ais523's idea, I'm less certain
11:13:11 <cpressey> I didn't intend to consult Wikipedia btw, it was just easier to cite than my original reference, which is a textbook
11:13:23 <int-e> ais523: Oh do you make one language for even steps, and one for odd steps, add checks for initial and final strings s and t and then the grammar is ambiguous only iff s ->* t in the underlying Thue system?
11:14:01 <int-e> or semi-thue system
11:14:35 <int-e> maybe I should say SRS since that's the terminology I'm actually familiar with :P
11:15:48 <int-e> cpressey: At the moment I'm basically taking ais523's statements and treating them as puzzles. My computability theory brain is a bit rusty.
11:16:13 <int-e> Though nmaybe not as rusty as I thought.
11:16:37 -!- X-Scale has quit (Ping timeout: 256 seconds).
11:18:30 <cpressey> "Things with undefined behaviour" and "things with oracles" are two different categories in my mind, so I find this pretty difficult to think about.
11:18:57 <int-e> . o O ( things with undefined oracles )
11:20:28 <int-e> AIUI the oracle was an implementation detail of the infinite-loops-are-undefined-behavior machine.
11:20:45 <int-e> So not something you have to worry about to understand the setting.
11:22:21 <cpressey> I'm not so sure about that (or I don't understand the setting).
11:23:05 <cpressey> "Undefined behaviour" is something that occurs in a specification. What is the specification of this machine?
11:23:23 <cpressey> "If the program goes into a loop, the behaviour of the machine is undefined"?
11:23:40 <int-e> Whenever the behavior on an input is an infinite loop (non-termination) the machine can substitute any other behavior it wants (including maintaining that infinite loop).
11:24:07 -!- Noisytoot has joined.
11:25:04 <cpressey> OK. I think the question was whether this is "super-Turing behaviour"? I think my answer is the same, it's only super-Turing if it has an oracle that can divine halting, and in that case, it's not surprising
11:25:31 <cpressey> Otherwise, you have a machine that analyses its program, determines that it's an infinite loop, does whatever it likes if so
11:25:44 <int-e> It's not necessarily super-Turing because the machine can just maintain the ordinary Turing machine (or another model of computation) behavior.
11:26:10 <cpressey> But if you can't tell that it's doing that, it's not observably super-Turing
11:26:29 <esolangs> [[Talk:!aoQ):]] https://esolangs.org/w/index.php?diff=133022&oldid=133021 * Gggfr * (+1)
11:26:34 <ais523> <int-e> ais523: Oh do you make one language for even steps, and one for odd steps, add checks for initial and final strings s and t and then the grammar is ambiguous only iff s ->* t in the underlying Thue system? ← right, and have a grammar that can act as either language
11:27:43 <ais523> and (on the original topic) I was more interested in if this is sub-Turing due to no infinite loops, but maybe it isn't
11:29:02 <esolangs> [[Funciton]] https://esolangs.org/w/index.php?diff=133023&oldid=132494 * Timwi * (-286) I wish to move away from including pseudocode representations of the function declarations and instead have the comments describe just what the functions do
11:29:59 <int-e> Maybe you could ask whether (total) recursive functions are less powerful than partial recursve ones... and the answer is, I think, no, because that would imply that would make recursively enumerable sets recursive.
11:31:30 <int-e> (It's a different question.)
11:33:15 <esolangs> [[Funciton]] M https://esolangs.org/w/index.php?diff=133024&oldid=133023 * Timwi * (-18) Fix link to Hello world program in esoteric languages
11:33:44 <cpressey> Different, but also interesting. Is the set of Turing machines that do not have halt states, equivalent to the set of Turing machines that sometimes halt? I would say no.
11:36:25 <int-e> Well you can always tweak the acceptance condition in your model of computation.
11:37:03 <int-e> You need /some/ discernable observation of course.
11:38:35 <ais523> I think it depends on the definition of "equivalent"
11:39:03 <ais523> it is under the "tight loop = halt" model that is sometimes used
11:39:30 <ais523> (where a tight loop repeats the entire state of the interpreter exactly)
11:40:44 <esolangs> [[Funciton/Digital root calculator]] https://esolangs.org/w/index.php?diff=133025&oldid=108709 * Timwi * (+132) I wish to move away from including pseudocode representations of the function declarations and instead have the comments describe just what the functions do
11:42:21 <int-e> Along with "accept if it ever writes $" "accept if it ever moves to the left of the starting point" and many others. There's a vague connection to Rice' theorem here.
11:44:34 <ais523> I like the "left of the start" rule because it's even somewhat justifiable
11:46:55 <int-e> You should be able to do silly things like "accept when all states have been entered an odd number of times".
11:47:49 <int-e> (that one could be tedious, especially if you work with only two symbols)
11:48:42 <esolangs> [[User:MihaiEso]] https://esolangs.org/w/index.php?diff=133026&oldid=131165 * MihaiEso * (+132) /* Some bonus stuff */
11:56:36 <int-e> ais523: Oh this is also related: https://en.wikipedia.org/wiki/Computably_inseparable ...if you make a TM that accepts all provable theorems and rejects all disprovable theorems, and leave the other cases undefined but terminating, that will be super-TC.
11:57:11 <int-e> (That concept also connects to Rice' theorem, of course.)
12:00:04 -!- X-Scale has joined.
12:00:06 <int-e> And now for something entirely different... do you think that YT's new "stable volume" feature (aka Dynamic Range Compression) increases the average length of auto-play chains that people subject themselves to?
12:01:18 <int-e> (for me it's yet another thing to routinely disable when using YT)
12:04:11 -!- mtm has quit (Ping timeout: 264 seconds).
12:04:33 -!- cpressey has quit (Ping timeout: 245 seconds).
12:06:18 -!- mtm has joined.
12:06:30 -!- cpressey has joined.
12:06:51 <cpressey> int-e: I would imagine that was their goal in implementing it, yes
12:11:40 <cpressey> So the way I see Rice's theorem is, it's based on a defined condition, right? "Reaching a certain state that we call a halt state" is one such condition. Many models of computation define such a condition. But there are also models of computation that do not, by themselves, define any such condition.
12:14:46 <cpressey> If we think up a condition and impose it on such a model, is it the same model? I would say no, you've defined a new model by adding your condition.
12:15:48 -!- chiselfuse has quit (Remote host closed the connection).
12:16:07 -!- X-Scale has quit (Ping timeout: 256 seconds).
12:16:12 -!- chiselfuse has joined.
12:16:39 <int-e> Well the connection is loose. The thing about Rice is that it's extensional... you look at languages accepted by a machine rather than what it does internally.
12:17:56 <int-e> So to apply Rice directly you'll have to define languages that include a description of a Turing machine or other type of program.
12:17:57 <cpressey> To even say "this machine accepts a language" you need to refer to defined conditions, like a halt state
12:18:15 <int-e> But of course you *can* define such languages.
12:19:49 <int-e> Hah this literally says "extensional". https://en.wikipedia.org/wiki/Rice's_theorem#Formal_statement
12:20:31 <int-e> (I'm more familiar with the index set formulation - which correspond to formal languages.)
12:41:38 -!- cpressey has quit (Ping timeout: 245 seconds).
12:43:54 -!- cpressey has joined.
12:52:06 -!- cpressey has quit (Ping timeout: 246 seconds).
12:54:12 -!- cpressey has joined.
12:59:49 <b_jonas> ais523 "when it halts, print the number of execution steps it took […] then, you run the program – if it halts, you run it again with a step limit that's higher than the number it printed" => that works if the UB of the first program is sandboxed so it can't do anything worse than print the wrong result. David Madore had a few puzzles related to this recently, let me find them. In practice, that UB
12:59:55 <b_jonas> can do worse things, like loop infinitely, explode the reactor, give you cancer, or modify what the second run will do.
13:00:17 <b_jonas> http://www.madore.org/~david/weblog/d.2023-12-24.2774.dragon-riddle.html is the puzzle
13:00:30 -!- cpressey has quit (Ping timeout: 246 seconds).
13:02:14 <b_jonas> sometimes it's useful to define something such that it doesn't give full UB, just, say, puts an arbitrary integer into the output register
13:03:32 <b_jonas> but UB is necessary in practice simply because our computer architectures are such that if your code accesses memory through stray pointers it can usually run arbitrary code
13:03:44 <b_jonas> so if you don't want full UB, you need memory safety
13:05:04 <b_jonas> "many theorem provers agree that x/0 = 0" => yes, I think that's a practical way to define division in many cases, and I wish more libraries or languges defined it that way
13:07:23 -!- myname has quit (Server closed connection).
13:07:25 <b_jonas> push-down automata reading the same trace for verifying it => that's an interesting idea
13:07:39 -!- myname has joined.
13:10:34 -!- Noisytoot has quit (Remote host closed the connection).
13:11:18 -!- Noisytoot has joined.
13:14:44 -!- X-Scale has joined.
13:15:11 -!- cpressey has joined.
13:15:40 -!- ais523 has quit (Remote host closed the connection).
13:16:54 -!- ais523 has joined.
13:19:45 -!- cpressey has quit (Ping timeout: 246 seconds).
13:21:41 -!- Thelie has joined.
13:48:07 -!- ais523 has quit (Ping timeout: 264 seconds).
13:49:03 -!- X-Scale has quit (Ping timeout: 256 seconds).
14:07:41 -!- Noisytoot has quit (Excess Flood).
14:09:15 -!- ais523 has joined.
14:09:25 <ais523> b_jonas: right, I mentioned that the UB has to be bounded somewhat
14:09:53 -!- Noisytoot has joined.
14:10:03 <ais523> a concept of "bounded UB" is useful in many languages, I think – it doesn't really work in C where the consequence of UB can be "runs arbitrary code", which might do anything within the power of the computer it's running on
14:10:16 <ais523> but lots of languages will be able to bound the UB to at least some extent
14:18:34 -!- X-Scale has joined.
14:21:57 <ais523> (reading int-e's link from earlier) huh, C11 also has a forward progress guarantee
14:22:08 <ais523> although it's not quite the same as C++'s
14:23:26 <b_jonas> oh nice, spam email in czech. I don't get that often somehow.
14:26:43 <ais523> I've had quite a few foreign-language spam emails but I don't remember any in Czech specifically
14:27:42 <ais523> Chinese/Japanese and Arabic seem to be the most common (although I can normally distinguish Chinese from Japanese given sufficient amounts of text and staring at it for a while, I don't generally go to that much effort with spam emails)
14:30:00 <ais523> I cleared out my spam recently, and currently have 15 spam emails that got far in enough in the sending process to not be rejected before they were fully sent (although most were caught by a statistical spam filter that runs afterwards); 11 are in English, two in Arabic, one in Polish, and one in German (but that claims to have been sent from Chile)
14:30:25 -!- X-Scale has quit (Ping timeout: 256 seconds).
14:30:54 <ais523> I guess maybe the Chinese/Japanese aren't that common, but I see them more often than most spam because they sort to the end in Unicode order
14:35:33 <b_jonas> English seems to be the most common for me
14:35:53 <b_jonas> but maybe I just notice it more because it takes more time to recognize it's spam
14:36:51 <ais523> admittedly, I haven't tried translating most of the foreign-language emails in languages I don't know in order to ensure they're not spam
14:37:28 <b_jonas> for some of the Hungarian ones it's even harder to tell if they're spam, but I get fewer of those.
14:37:30 <ais523> I know at least a small amount (and in some cases almost a medium amount) of most Western European languages, which is normally enough to verify that emails in those are spam
14:38:21 <ais523> I would expect English to be more common than Hungarian for spam, even sent to a Hungarian address, due to substantially more spammers knowing it and that outweighing the influence of language-based spam targeting
14:40:20 <b_jonas> there's a lot of Hungarian spam that are sent from shops or websites that I've actually interacted with, either "newsletters" or personalized reminders to recommend buying the products for which I've opened the description page
14:40:34 <b_jonas> but those are not the ones where it's hard to tell it's spam
14:41:14 <b_jonas> where it can be hard to tell is email pretending to come from the few banks or telephone companies or similar
14:43:00 <ais523> b_jonas: IMO, spam from people you've interacted with should be categorized differently from randomly targeted spam (although I can see reasons to make both illegal, the arguments are likely different in the two cases)
14:45:33 <esolangs> [[(,!)]] https://esolangs.org/w/index.php?diff=133027&oldid=132389 * Gggfr * (+312)
14:48:01 <esolangs> [[(,!)]] https://esolangs.org/w/index.php?diff=133028&oldid=133027 * Gggfr * (+49)
14:50:44 -!- X-Scale has joined.
15:05:45 <esolangs> [[(,!)]] https://esolangs.org/w/index.php?diff=133029&oldid=133028 * Gggfr * (+52)
15:08:32 <esolangs> [[Talk:!aoQ):]] https://esolangs.org/w/index.php?diff=133030&oldid=133022 * Ais523 * (+831) r to [[User:Gggfr]]
15:15:06 <esolangs> [[Special:Log/delete]] delete * Ais523 * deleted "[[]]": Copyright violation: contains a substantial quote from a Chinese song that will not be public domain until 2045 (and I am annoyed that I had to try to figure this one out)
15:18:16 <esolangs> [[User talk:PrySigneToFry]] https://esolangs.org/w/index.php?diff=133031&oldid=132324 * Ais523 * (+374) /* Copyright violations */ new section
15:18:49 <korvo> ais523: I think you know this, but quick double-check: there's also a power *ceiling* on approaching TC via proofs about program properties.
15:19:25 <ais523> korvo: I'm not fully clear on what you mean
15:19:28 <korvo> The most potent version of this is from Conway, who gave FRACTRAN as constructive proof that Collatz-style and Goldbach-style problems are as hard as TC problems to humans.
15:20:19 <ais523> although, what Fractran, Tip, etc. prove is just that some generalized Collatz programs are hard – it doesn't necessarily prove that the original Collatz problem is one of them
15:20:22 <korvo> I can sit anybody down and convince them that the original Collatz is true. We have the numeric evidence. But we don't have *proof*, and so we could very well be hilariously horribly wrong because we were blinded by the hope for beautiful maths.
15:21:14 <ais523> I remember a post on one of the mathematics stack exchanges where the author asked whether there were any numbers with a particular property, and if not, why not
15:21:52 <korvo> Yeah. What's interesting is the nature of the evidence. For *any* given nat, I can show you that it can't possibly be part of a cycle using a templated proof search. So, does that template constitute a proof? Gödel said nope.
15:22:00 <ais523> where the property in question was satisfying two other properties simultaneously
15:22:55 <ais523> and they said, effectively, "if you take random properties with the same density in the integers of a given size and check to see whether they're true simultaneously, the expected number of counterexamples is «some small number, IIRC less than 1» so it's possible that your conjecture is true for no reason"
15:22:57 <ais523> and that really stuck with me#
15:23:58 <korvo> Hah, yeah. The nats are weird that way because they're *the* nats, and so facts about them don't really have a basis.
15:24:14 <ais523> korvo: do you know about omega-inconsistency? the idea is that a formal system might be able to simultaneously prove the statements "X is true for at least one integer", and, for each specific integer n, "X is false for n"
15:24:45 <korvo> All I really had wanted to point out was that if you had a way to transform TC problems so that we *could* decide Goldbach-style problems, then that would suggest that Goldbach was easy and we were holding it upside-down all along.
15:24:50 <ais523> and yet, if the proofs aren't constructive, this might not necessarily be an inconsistency in the system because you haven't actually proved both a statement and its negation
15:25:13 <korvo> Which, from what we know of NP-completeness, is just not very likely. It's more likely that TC is a hard-edged ceiling with nothing dangling down from it.
15:25:48 <ais523> NP-completeness is weird because it applies to so many problems, *but* there are higher complexity classes
15:25:59 <korvo> ais523: Yes! Exactly. That's the Gödelian machinery I was thinking of. Same situation. We have a proof of Collatz but no omega-proof.
15:26:03 <ais523> Turing-completeness being the highest practically realisable computability class at least makes some sort of sense
15:27:20 <korvo> NPC and TC make a lot of sense as *categories* with poly- and computable reductions respectively as their arrows. From that perspective P=NP is ridiculous; the entirety of PH should manifest.
15:28:12 <ais523> oh no – I know a lot of category theory, I have used it at work –but I find it so hard to reason about in my head because there are so many different relevant levels of abstraction
15:28:25 -!- Thelie has quit (Ping timeout: 265 seconds).
15:28:35 <ais523> it is very easy to get multiple levels of abstraction confused, and having something new to put on the arrows makes it so much harder
15:29:31 <ais523> there is a good intuition for this sort of puzzle/game – if it is possible to do a move, and later to do the inverse of the same move, and accomplish something in the process, it is probably PSPACE-complete; otherwise, it is probably NP-complete
15:29:58 <ais523> in cases where it isn't, it normally isn't too hard to find a fast general solution
15:30:12 <korvo> Whoa, that's a big statement. Sounds kind of like finding a group.
15:30:23 <ais523> I think there was one which turned out to be EXPSPACE-complete but that was a bit of an anomaly
15:30:32 <FreeFull> On the other hand, integer factorisation might be easier than NP, we don't know
15:30:56 <ais523> I remember when primality testing was discovered to be possible in polynomial time
15:31:06 <korvo> Think of factorizing as in BQP, and think of BQP vs NP as the open question.
15:32:21 <ais523> although, interestingly we don't actually know the order of polynomial for certain even for some of the existing algorithms
15:32:31 <korvo> ais523: So, with all this out there, one thought I've had about both NPC and TC is: what if Rice's logic only applies to uniform encodings?
15:32:49 <ais523> it's along the lines of "best case O(n^6), worst case O(n^12), but we don't know whether any values actually hit the worst case"
15:33:13 <esolangs> [[User:Yayimhere/Sandbox]] https://esolangs.org/w/index.php?diff=133032&oldid=132559 * Gggfr * (+617) /* Idea 3 */
15:33:18 <korvo> My running example is Traveling Salesman in NPC. There's a really nice heuristic approach that runs fairly fast, and it's what actual logistics firms use around the world.
15:34:15 <korvo> On one hand, this heuristic fails as Salesman approaches the limiting cases of Hamiltonian cycles, and that's the standard way of showing it's NPC. On the other hand, some other problems might be well-optimized by the Salesman heuristic.
15:35:14 <ais523> for Travelling Salesman, IIRC there's an algorithm that's guaranteed to be within 150% of optimal
15:35:24 <korvo> Maybe this applies to TC too. Like, sure, we can't prove Collatz in The Waterfall Model directly because the matrix will just grow without bound, but maybe we can prove it in some other TC language.
15:35:26 <ais523> or, well, I know the algorithm is correct but forget whether the 150% is the correct factor
15:35:37 <FreeFull> Is there a name for problems that can be solved in faster than linear time?
15:35:46 <ais523> probably just "sublinear"?
15:36:18 <ais523> such problems are rare because you don't actually get to read the entire input, you have to skip parts of it
15:36:24 <FreeFull> What about "faster than any non-constant polynomial"?
15:36:30 <korvo> Our current techniques for migrating within TC are all compiler-oriented. We add a bunch of interpretative overhead ("managed runtime") to the compiler outputs, and so we end up emulating the original Rice logic.
15:37:11 <korvo> So we'd need some new way of transforming within TC which genuinely exposes the underlying objects of a computation. I have no idea how to think about this.
15:37:33 <ais523> it's not quite the same thing, but one of my favourite computer performance results is based on the hashing algorithm MD4 – it is faster to find a collision in MD4 than it is to actually calculate the hash of a given string
15:38:12 <ais523> it is not surprising that some hashing algorithms are broken, but it is surprising that some hashing algorithms that were used seriously are *that* broken
15:38:20 <korvo> FreeFull: Like ais523 says, we usually care about log space, rather than log time. That class is often called L in literature.
15:39:05 <korvo> Well, we haven't even proven that one-way functions exist. We're still guessing what a hash looks like.
15:39:42 <FreeFull> Right, proving that one-way functions exist would be a huge result
15:40:02 <ais523> that mostly doesn't matter – what's practically relevant is not whether the inverse function exists but whether anyone find sit
15:40:57 -!- Thelie has joined.
15:41:48 <FreeFull> If you prove it doesn't exist, then you don't have to worry about people finding it, assuming you can actually construct the one-way function
15:42:52 <ais523> well, the problem there is that most practically defined hashing algorithms produce finite-length output
15:43:28 <ais523> so we *know* that the inverse function exists (assuming that "no inverse" is a possible output), if only as an arbitrary list of cases that would take impossibly long to find
15:47:01 <ais523> I assume the "one-way functions exist" conjecture has some way to define them precisely in a way that avoids the attack, perhaps by using an infinite domain and codomain
15:48:19 <b_jonas> ais"I remember when primality testing was discovered to be possible in polynomial time" => I remember I heard of this when it was still kind of a new result, you know, with the internet not spreading every news instantly, and math papers not becoming obsolete in half a year like biology papers do, so it still counted as new a few years later. but the result was from 2002, so I don't think I ever knew
15:48:25 <b_jonas> this as an open question, wuth deterministic composite testing and proven good random prime testing available.
15:49:53 <b_jonas> kind of like the strong perfect graph theorem
15:51:36 <b_jonas> "faster than any non-constant polynomial" => you mean like sorting variable-length strings?
15:51:40 <korvo> ais523: The modern definition is in terms of the smallest circuit that computes the inverse.
15:52:12 <korvo> Or, non-uniformly, the family of circuits, one for each size of input and output.
15:53:04 -!- Thelie has quit (Ping timeout: 265 seconds).
15:53:25 <ais523> korvo: ah, I see – the inverse is allowed to exist, it just has to be "much" more complicated
15:53:51 <b_jonas> "it is faster to find a collision in MD4 than it is to actually calculate the hash of a given string" => oh, is that why https://valerieaurora.org/hash.html has a "Collisions generated by hand / Expert reaction: Memorize as fun party trick for next faculty mixer" as a status for cryptgraphgic hash functions?
15:54:44 -!- X-Scale has quit (Quit: Client closed).
15:55:04 <korvo> ais523: Right. It also doesn't say too much about interactive approaches, like the family of WEP-cracking algorithms.
15:58:14 <korvo> b_jonas: Yeah, although at this level of detail, we start to need definitions of randomness. IIRC the current definition of one-way uses pseudorandomness in terms of Kolmogorov complexity?
16:03:14 <ais523> I strongly suspect that calculating Kolmogorov complexity precisely is uncomputable
16:03:24 <ais523> (although it is trivial to get an upper and lower bound)
16:03:38 <ais523> I guess that probably doesn't matter for the conjecture, though
16:04:32 <ais523> hmm, it's interesting that I can't trivially *prove* it's uncomputable
16:04:50 -!- Thelie has joined.
16:05:14 <ais523> there are lots of programs for which we can't compute/prove whether they produce a specific output or not – but are there any such programs for which there isn't a shorter program that also produces that output?
16:05:55 <FreeFull> To prove that a shorter program doesn't produce the same output, you have to prove that it halts
16:05:59 <ais523> intuitively, it feels like "do something of unprovable halting status + produce this output" should lead to a longer program than just printing the output
16:06:33 <ais523> FreeFull: no, the conjecture is "program X halts and produces Y, and no shorter program halts and produces Y" – you can disprove that by finding a shorter program that halts and produces Y even if you can't prove that X halts
16:07:19 <FreeFull> I'm not talking about X but about the shorter program
16:07:38 <ais523> ah right, there might be a shorter program that we also can't prove whether that one halts
16:07:45 <ais523> but then the same argument can be applied recursively
16:08:08 <ais523> that said, suppose there's an odd perfect number – a program that brute-forces the smallest odd perfect number probably is the shortest way to represent it
16:08:35 <ais523> because we know that any odd perfect numbers must be incredibly large, and it'd be very surprising if there were a shorter way to encode it
16:08:51 <FreeFull> The busy beaver numbers are related
16:10:33 -!- sprout has quit (Ping timeout: 256 seconds).
16:10:50 <ais523> ah right, because for busy beaver candidates there might be some that do in fact halt, and the numbers those programs output are going to be extremely large and those programs are going to be the shortest way to encode them, but also hard to prove they halt
16:12:16 <ais523> oh wow! the busy beaver number for 2-color 5-state Turing machines has been discovered (on July 2, so very recently)
16:12:38 <ais523> https://discuss.bbchallenge.org/t/july-2nd-2024-we-have-proved-bb-5-47-176-870/237 (requires JavaScript)
16:16:02 <b_jonas> "we know that any odd perfect numbers must be incredibly large" => wait, do we know that? how large?
16:16:49 <int-e> https://scottaaronson.blog/?p=8088 ...hmm somehow it didn't register with me how recent that was when I saw it
16:17:11 <b_jonas> yeah, I did mention that in the channel when I saw it at https://scottaaronson.blog/?p=8088
16:17:30 <b_jonas> I'm considering to use it as the next month's password
16:17:41 <int-e> b_jonas: Wikipedia mentions N > 10^1500 as a lower bound.
16:18:06 <int-e> which may or may not be "incredibly large" by your standards :)
16:19:04 <b_jonas> yeah, that's large but not really incredibly large
16:19:17 <ais523> I agree – I misremembered
16:19:21 <ais523> it is not up to googology levels
16:19:39 <int-e> Well, googol is 10^100.
16:19:41 <ais523> I thought the known bound was larger, but apparently not
16:19:45 <int-e> It's not googol-plexy
16:20:24 <int-e> that bound is from 2012, people may have pushed it further
16:21:30 <Thelie> Nockiro, versuch mal ssh bei 2a03:9b40:237e:e600:82d:451e:f104:833e
16:21:45 -!- X-Scale has joined.
16:21:57 <Thelie> whoops wrong channel, sorry 😬
16:21:58 <ais523> Thelie: wrong channel? there isn't a Nockiro in this channel
16:22:12 <b_jonas> compare this to the next Fermat prime, which must be at least 2**(2**33)
16:22:16 <int-e> and now that IP is permanently logged, yay
16:22:42 <ais523> also I love the use of "bei" with an IP address – it makes sense now that I've seen it but it was a little surprising
16:22:57 <b_jonas> still not googology large, but at least significantly larger
16:23:03 <ais523> b_jonas: isn't that cheating, because it's fairly early in the *sequence* of Fermat primes
16:23:04 <Thelie> Eh not that bad it's a public server anyways
16:23:09 <ais523> or, well, Fermat numbers
16:23:13 <Thelie> but still a bit of a fuckup
16:23:29 <Thelie> Anyways, sorry for the interruption!
16:23:30 <int-e> eh it's amusing to us :)
16:23:34 <b_jonas> ais523: yes, but that's kind of the point, if there's a next Fermat prime, I expect it to have the form 2**(2**k) where k is small, so the smallest program generating it will likely just hard-code k
16:23:40 <int-e> (pretty sure it's not just me)
16:23:52 <b_jonas> well, not certain, because a slow trial division algorithm might be faster
16:24:06 <b_jonas> but still, the one that hard-codes k might be competitive
16:24:34 <b_jonas> whereas the odd perfect numbers don't have such a restricted form, so you might have to search for some random ass-pull combination to find it for all we know
16:24:46 <ais523> b_jonas: I guess the problem there is that the 2**(2**…) bit is likely to be hardcoded in both the search program and the hardcode-the-value program
16:24:46 <b_jonas> but then maybe it does have a nice special form, we just can't prove that
16:24:57 <ais523> so the real question is whether the k is smaller than the search algorithm
16:25:36 <b_jonas> not really, if you write the general search program then hard-coding 2**k+1 is enough
16:25:52 <ais523> I guess there's also the separate problem of "if we are given an odd perfect number / a large Fermat prime and tasked with discovering the shortest program to find it, we would probably notice that it has the required unusual form"
16:26:19 <ais523> like, determining whether a program that finds the smallest N ever halts is much easier if you have an example of an N
16:27:01 <int-e> I guess the project that pushed this bound is defunct https://web.archive.org/web/20181106015226/http://oddperfect.org/ ... they got from 10^300 to 10^1500 which feels substantial to me.
16:29:25 <b_jonas> the reason why the existence of odd perfect numbers is such a famous open question is mostly because of how old it is. the others postdate year 1600, but this one is from before year 1
16:30:34 <b_jonas> it must be one of the oldest open problems in mathematics
16:31:33 <int-e> It's old, and it's elementary (you can explain the problem in full to a highschool student.)
16:32:25 <int-e> Plus there's some nice theory for the even number case... so there's something you can teach along with it :)
16:32:28 <ais523> and it's particularly infuriating because the even perfect numbers are so easy to characterize
16:32:40 <b_jonas> yeah. we have lots of elementary open problems, but not many that are so old.
16:34:13 <ais523> that said, we don't even know that there are infinitely many even perfect numbers, right?
16:36:33 <int-e> Well it's tied to Mersenne primes.
16:38:19 <b_jonas> apparently there are 51 Mersenne primes known at the moment
16:38:35 <ais523> yes, each even perfect number as a corresponding Mersenne prime and vice versa
16:39:47 <korvo> ais523: Oh! Okay, I thought you'd heard this news already. Sorry! Let me start again. Determining BB(6) will require solving a Collatz-style problem and BB(7) a Goldbach variant that the community calls "Bigfoot".
16:40:05 <korvo> https://wiki.bbchallenge.org/wiki/Cryptids is the full list. The BB(6) machine is "Antihydra". I've had a go at it and it is much tougher than it looks.
16:40:09 <ais523> korvo: it's recent and I don't check busy-beaver-related news that often
16:40:22 <ais523> I already opened the Cryptids page in a browser, but have not read it yet
16:41:07 <korvo> So yes, your intuition is spot-on, *and* it turns out that we just reached the last stair-step before the ceiling.
16:41:49 <b_jonas> hmm, maybe it isn't actually that old
16:42:38 <b_jonas> the definition of perfect numbers is that old, but I don't think they asked whether there were odd perfect numbers until like some time between 1400 and 1800
16:46:23 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
16:46:35 <ais523> hmm, Bigfoot reminds me a lot of the sort of things Conedy can calculate
16:47:23 <ais523> it isn't a Collatz function in the traditional sense because b clearly and obviously grows forever – it just causes a to change along the way, and the question is whether that ever gets down to 0
16:48:46 <korvo> Oh dang, they have a page for Conway's approach: https://wiki.bbchallenge.org/wiki/Probviously
16:49:11 <korvo> Which I guess we might call "omega-obviously" from earlier.
16:50:16 <korvo> Yeah, Bigfoot's weird. One approach from Collatz which helps a little is to consider *when* Bigfoot could have a lot of decreasing alpha.
16:51:10 <korvo> We can see that -- probviously -- any Bigfoot position which tends towards zero is going to be wound up like a capacitor.
16:51:31 -!- X-Scale has quit (Ping timeout: 256 seconds).
16:51:34 <korvo> And trivially, such capacitors are always finite by construction. If only it were that easy~
16:55:26 <ais523> one thing that interests me in the cryptids is that the small ones also seem easy to implement on counter machines
16:56:40 <ais523> I can directly implement Hydra in The Waterfall Model on seven clocks, I think (not completely sure as I haven't tried to do it yet), and it wouldn't surprise me if fewer are possible
16:56:56 <ais523> (that said, seven clocks is sufficient to implement a TC language, so…)
16:57:40 <korvo> Wait, Waterfall's not TC with fewer than seven? This is new to me.
16:58:13 <ais523> just, it gets hard to write UTMs in very few clocks
16:58:32 <korvo> Oh, it's still open. Okay. Sorry, I was ready to be excited for progress on mortal-matrix. Matrices are really hard.
16:59:11 <ais523> seven is the smallest number that's probably been proven ("probably" in that a proof exists but hasn't yet been thoroughly checked for mistakes)
17:00:07 <ais523> any Spiral Rise program compiles both into a 7-clock Waterfall Model program (thus a 7-fraction FRACTRAN program), and a 5-symbol tag system
17:00:31 <ais523> (which in turn implies that there's a 5-symbol universal tag system, although the production rules with that construction are exceedingly long)
17:02:39 <ais523> although, hmm, did I get the Waterfall→FRACTRAN compilation upside-down?
17:02:44 <ais523> will have to think more about this
17:02:48 <b_jonas> for the tag system, do you get to choose some large variable starting state besides the 5 symbols?
17:03:06 <ais523> oh, just put the steady decrement at the start :-)
17:03:45 <korvo> I wish I had a proper database for these sorts of facts. Like, I want a database that stores a poset and labels the ways that we can reduce one language to another. Maybe a graph DB?
17:03:47 <ais523> with the universality coming from an "any program maps to some starting state" (with the map being calculable primitive-recursively in order to prevent cheating with a complex map)
17:03:50 -!- tromp has joined.
17:04:27 <ais523> korvo: there's https://esolangs.org/wiki/EsoInterpreters but it isn't very well updated
17:05:49 <korvo> ais523: Yeah. There's also a couple one-off diagrams drawn for Complexity Zoo and nLab by that one guy. They're fine, but they're also bespoke DOT.
17:06:32 <ais523> I have a really long-standing goal that I haven't had much time to work on, of choosing a "central" esolang and writing interpreters between it and lots of other interesting esolangs both ways
17:06:51 <ais523> to make it possible to generate an interpreter for any of them in any other, or a compiler from any of them to any other
17:06:53 <korvo> I've made two attempts at this, klesi and zaha, and neither is good. zaha can represent functors between posets, but can't label arrows.
17:07:34 <korvo> I mean, there's always BLC, but I think that instead of centrality, we should have a central esolang-building system. Like a Nix flake or something else, like a Nix flake.
17:07:38 -!- errilaz_ has quit (Server closed connection).
17:07:44 -!- errilaz has joined.
17:07:45 <ais523> my plan for a long time was to use an Underload variant, although more recently I decided that I'd prefer a bespoke language and came up with https://esolangs.org/wiki/Esimpl
17:08:08 <korvo> That'd make it easier to study stuff like Busy Beaver or your earlier semi-halting stuff.
17:08:13 <esolangs> [[Rizzlang]] https://esolangs.org/w/index.php?diff=133033&oldid=133018 * ZachChecksOutEsolangs * (-318)
17:08:27 <ais523> although Esimpl is primarily designed to allow efficient implementations of other languages whilst being very easy to interpret and compile
17:08:37 <esolangs> [[Rizzlang]] https://esolangs.org/w/index.php?diff=133034&oldid=133033 * ZachChecksOutEsolangs * (-1)
17:11:15 <ais523> I wrote a BF interpreter in Esimpl already
17:11:26 <ais523> (it's in the same tarball as the interpreter linked from the article)
17:12:14 <ais523> although I haven't written Esimpl impls in any esolangs yet (including itself)
17:15:09 <ais523> one of the big early goals would be a self-interpreter, because that makes it possible to use compilers as interpreters (by compiling into Esimpl and then self-interpreting it) – after that point it would be possible to work entirely with compilers
17:15:27 <ais523> (which would make the BF interpreter redundant, but it was mostly there as a test of the language anyway rather than something to practically use)
17:15:35 <korvo> Ah, like a Futamura specializer?
17:18:35 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
17:23:57 <ais523> I think a minimal set of inputs required to be able to write a compiler from esolang A to esolang B in esolang C for any A, B, C is to have compilers to and from each esolang we care about to a common esolang, and one self-interpreter for that common esolang
17:24:37 <ais523> where the compilers themselves are written in the common esolang
17:24:44 <ais523> or, I guess they don't all have to be – just enough to bootstrap
17:26:03 <korvo> Aha. And that's the other part: they have to have a uniform sense of I/O, then.
17:26:58 <korvo> Like, a Waterfall Model program is a matrix of nats, right? But Brainfuck can't emit that directly. So there's also gotta be some sense of common encoding.
17:27:56 -!- Noisytoot has quit (Remote host closed the connection).
17:28:10 <ais523> right, or at least a decided convention for each language to represent a common encoding (but the way in which each language interprets the encoding doesn't have to match the other languages)
17:28:34 <ais523> in practice almost all esolangs have a defined way to represent programs as a sequence of bytes
17:29:24 <ais523> there are a few that intentionally leave the details open or consider them to be irrelevant, and have ended up with more than one commonly used encoding (e.g. FRACTRAN), but there are various solutions to that (e.g. by considering different encodings to be different variants of the language)
17:30:21 -!- Noisytoot has joined.
17:32:17 -!- sprout has joined.
17:37:55 -!- sprout has quit (Ping timeout: 264 seconds).
17:39:44 <korvo> That works. What do we do for binary lambda calculi or other bitwise encodings? I figure we just define another convention for padding.
17:39:58 -!- tromp has joined.
17:43:39 <ais523> right, or even just use a series of '0' and '1' characters
17:52:24 * korvo quietly chuckling to death
17:52:47 <korvo> Yeah, I guess. Whatever works.
17:53:22 <ais523> I was amused the first time I saw that, too (this is not the first time the problem has come up…)
17:54:44 <esolangs> [[User:Xff]] N https://esolangs.org/w/index.php?oldid=133035 * Xff * (+36) Created page with "this is a alt for [[User:Yayimhere]]"
17:55:07 <esolangs> [[User:Yayimhere/Sandbox]] https://esolangs.org/w/index.php?diff=133036&oldid=133032 * Xff * (+17)
17:55:41 <b_jonas> the "convention for padding" could be as simple as a single 1 bit followed by any number of 0 bits at the end, once you define bit order of course
17:56:49 <korvo> Well, I'm gonna stick to what I originally wanted to do, which is to contextualize the various BB results by automatically computing them and putting them up on a ruler.
17:57:23 <korvo> Compiling all the esolangs into each other can wait for another day. It's a fun thought, but sounds like a lot of work involving a lot of uninterested stakeholders.
18:00:31 <ais523> right, I think that's why it hasn't happened yet
18:01:07 <ais523> few people are interested, and most (probably all) of them have enough higher-priority things to do that they can't spent much time on it
18:01:16 <ais523> * spend much time on it
18:02:31 <ais523> b_jonas: sometimes a better padding convention can be created, depending on the language, e.g. binary lambda calculus is self-delimiting, and 7 pads with trailing 1 bits (because a 111 at the end of the program is a no-op and 11 and 1 are incomplete commands that can be ignored at the end of the program)
18:04:44 <esolangs> [[Titled]] M https://esolangs.org/w/index.php?diff=133037&oldid=122556 * EvyLah * (+6) minor changes
18:05:52 <esolangs> [[Brainfuck+2]] M https://esolangs.org/w/index.php?diff=133038&oldid=126003 * EvyLah * (+48) you should see these too
18:06:05 <esolangs> [[Fun 2 code]] N https://esolangs.org/w/index.php?oldid=133039 * Tommyaweosme * (+508) Created page with "Fun 2 code is a modification of [[Python]] where its like Fun 2 rhyme, a trendy song by Howard Moody. == How it works == First, you think up a swear word the first letter of the python command. Then, you write down 3 words that rhyme with it, seperated by new lin
18:07:44 <esolangs> [[Code your own instructions, lazyass]] M https://esolangs.org/w/index.php?diff=133040&oldid=124226 * EvyLah * (-428) /* Categories */ why is this here?
18:08:41 -!- Noisytoot has quit (Remote host closed the connection).
18:08:43 <korvo> Yeah. I guess we should call that Tromp BLC? And then there's e.g. Iota and Jot, which both need padding.
18:09:01 -!- Noisytoot has joined.
18:10:27 <esolangs> [[User:Yayimhere/Sandbox]] https://esolangs.org/w/index.php?diff=133041&oldid=133036 * Xff * (+548)
18:10:49 <esolangs> [[Anything]] https://esolangs.org/w/index.php?diff=133042&oldid=123134 * Tommyaweosme * (+25)
18:11:16 <esolangs> [[Burgercamp+/burgercamp+-]] https://esolangs.org/w/index.php?diff=133043&oldid=130681 * Tommyaweosme * (+23)
18:11:45 <esolangs> [[Wikipedia is stupid and dumb]] https://esolangs.org/w/index.php?diff=133044&oldid=130086 * Tommyaweosme * (+23)
18:16:19 <esolangs> [[User:Yayimhere/Sandbox]] https://esolangs.org/w/index.php?diff=133045&oldid=133041 * Xff * (+218) /* hexadecimal triangle */
18:16:19 <esolangs> [[User:Tommyaweosme/ESOLANG TOURNAMENT!!!]] N https://esolangs.org/w/index.php?oldid=133046 * Tommyaweosme * (+341) Created page with "PARTICIPANTS!!!: [[brainfuck]] - 01 [[befunge]] - 02 [[slashes]] - 03 [[thue]] - 04 [[2 Bits, 1 Byte]] - 05 [[3 Bits, 3 Bytes]] - 06 [[5 Bits, 20 Bytes]] - 07 [[0 Bits, 0 Bytes]] - 08 [[malbolge]] - 09 [[FIFTH]] - 10 [[HQ9+
18:17:14 <esolangs> [[User:Tommyaweosme/ESOLANG TOURNAMENT!!!]] https://esolangs.org/w/index.php?diff=133047&oldid=133046 * Tommyaweosme * (-2)
18:20:12 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=133048&oldid=90571 * Tommyaweosme * (+9) more info please
18:23:59 -!- Lord_of_Life has quit (Ping timeout: 264 seconds).
18:24:43 <b_jonas> for brainfuck you can just pad with > at the start or end
18:25:24 -!- Lord_of_Life has joined.
18:25:25 <esolangs> [[User:Yayimhere/Sandbox]] https://esolangs.org/w/index.php?diff=133049&oldid=133045 * Xff * (+350) /* CPU computer idea thing */
18:26:45 <esolangs> [[User:Yayimhere/Sandbox]] https://esolangs.org/w/index.php?diff=133050&oldid=133049 * Xff * (+92)
18:29:16 <esolangs> [[User:Yayimhere/Sandbox]] https://esolangs.org/w/index.php?diff=133051&oldid=133050 * Xff * (+127) /* CPU computer idea thing */
18:30:50 <ais523> b_jonas: I hate that those are equivalent
18:30:54 <ais523> they conceptually feel so different
18:32:20 <esolangs> [[User:Yayimhere/Sandbox]] https://esolangs.org/w/index.php?diff=133052&oldid=133051 * Xff * (+66) /* CPU computer idea thing */
18:32:27 -!- Sgeo has joined.
18:33:38 <esolangs> [[User:Yayimhere/Sandbox]] https://esolangs.org/w/index.php?diff=133053&oldid=133052 * Xff * (+41)
18:35:28 -!- anomalous has joined.
18:43:28 -!- X-Scale has joined.
18:47:12 -!- cpressey has joined.
18:56:58 -!- sprout has joined.
19:02:25 -!- X-Scale has quit (Ping timeout: 256 seconds).
19:03:54 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
19:07:04 <fizzie> Random stat: looking at last full week, out of the 3670822 HTTP requests to the wiki server, 1432542 (39.0%) were by Claudebot, 554884 (15.1%) by Bytespider, 151555 (4.1%) by Amazonbot, 85642 (2.3%) by GPTBot and 49429 (1.3%) by FriendlyCrawler; together those 5 AI trainers made up 2274052 (61.9%) requests.
19:07:21 <fizzie> Didn't count the 59635 (1.6%) and 25233 (0.7%) requests from Bingbot and Googlebot, respectively, since it's harder to split out AI and "traditional" crawling from those.
19:08:06 <fizzie> (Trying to ingest nginx logs into Loki, for graphing, to figure out that once-every-two-hours traffic spike, but got distracted.)
19:14:24 <fizzie> There's also an interesting user agent of "NotLoggedIn/MediaWiki::Butt", which is apparently a Ruby framework for MediaWiki API access, which -- once per day, exactly at UTC midnight -- does ~190 requests to /w/api.php from a random Yandex Cloud IP.
19:22:55 -!- cpressey has quit (Ping timeout: 264 seconds).
19:24:46 <ais523> I have a suspicion that training from the Esolang wiki may end up decreasing the quality of AIs rather than increasing it :-D
19:30:17 <fizzie> Actually, out of the 2269646 AI training requests with easily classifiable URLs (I didn't used to record the vhost), 2161186 (95.2%) were from hack.esolangs.org/repo aka the HackEso repository; 98237 (4.3%) were from the wiki, and the remaining 10223 (0.5%) from this channel's logs.
19:30:32 <fizzie> Not that training on the HackEso repository is going to help any more than training on the wiki would.
19:35:00 -!- cpressey has joined.
19:42:38 -!- V has quit (Server closed connection).
19:42:57 -!- V has joined.
19:48:46 -!- cpressey has quit (Ping timeout: 258 seconds).
19:53:33 <esolangs> [[Esolang talk:Categorization]] https://esolangs.org/w/index.php?diff=133054&oldid=132682 * Ais523 * (+298) /* Tacit programming */ concatenative?
20:15:34 -!- cpressey has joined.
20:25:10 <esolangs> [[Brainfuck+2]] M https://esolangs.org/w/index.php?diff=133055&oldid=133038 * PythonshellDebugwindow * (-1) /* External Resources */ Remove s
20:27:48 -!- cpressey has quit (Ping timeout: 246 seconds).
20:28:51 -!- Noisytoot has quit (Quit: ZNC 1.8.2 - https://znc.in).
20:28:58 -!- tromp has joined.
20:31:03 <esolangs> [[Eod]] M https://esolangs.org/w/index.php?diff=133056&oldid=116048 * PythonshellDebugwindow * (+67) Lowercase, grammar, categories
20:32:50 <esolangs> [[FakeScript]] M https://esolangs.org/w/index.php?diff=133057&oldid=108076 * PythonshellDebugwindow * (+63) Categories
20:32:53 -!- Noisytoot has joined.
20:33:24 <esolangs> [[FakeScript]] M https://esolangs.org/w/index.php?diff=133058&oldid=133057 * PythonshellDebugwindow * (+30) See also
20:34:00 <esolangs> [[XGCC]] https://esolangs.org/w/index.php?diff=133059&oldid=132996 * Zzo38 * (+1864)
20:35:16 <esolangs> [[Extension]] M https://esolangs.org/w/index.php?diff=133060&oldid=119875 * PythonshellDebugwindow * (+27) Category
20:35:53 -!- cpressey has joined.
20:39:41 -!- Thelie has quit (Ping timeout: 265 seconds).
20:49:50 -!- cpressey has quit (Ping timeout: 265 seconds).
20:52:26 -!- Thelie has joined.
20:58:27 -!- X-Scale has joined.
20:58:55 -!- Noisytoot has quit (Quit: ZNC 1.8.2 - https://znc.in).
20:59:43 -!- Noisytoot has joined.
21:11:00 -!- Thelie has quit (Remote host closed the connection).
21:11:17 -!- cpressey has joined.
21:11:59 -!- anomalous has quit (Quit: https://www.youtube.com/watch?v=TKfS5zVfGBc).
21:23:14 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
21:25:23 -!- cpressey has quit (Ping timeout: 245 seconds).
21:30:50 -!- X-Scale has quit (Quit: Client closed).
21:31:49 -!- ais523 has quit (Quit: quit).
21:55:06 -!- __monty__ has quit (Quit: leaving).
22:01:39 -!- DHeadshot has joined.
22:03:21 <fizzie> Now that's just real bizarre... got one of those hack.esolangs.org traffic spikes again, but it didn't get attributed to any known bot. So went to check the logs by manual inspection, and the user agents are like just a collection of "normal" browser except they're 100% lowercase, unlike what actual browsers do.
22:09:40 <fizzie> And the traffic is from 175 different addresses, belonging to random hosting companies (EGIHosting, Neptune-Networks-LLC, SpdNet, Bite Lietuva, 20 Point Networks, Intelligence Network Online), and the pages are just random /repo/file, /repo/comparison, /repo/shortlog, /repo/annotate paths.
22:12:48 <fizzie> Doesn't really feel like a DOS attempt because it's still pretty modest traffic (~10 qps). I guess it could be an AI scraper that just doesn't want to advertise what they're doing. But pretty weird.
22:15:41 <fizzie> Besides if they _really_ didn't want to look obvious, presumably they wouldn't do that all-lowercase weirdness.
22:18:50 -!- DHeadshot has quit (Remote host closed the connection).
23:19:05 -!- X-Scale has joined.
23:48:15 <esolangs> [[XGCC]] https://esolangs.org/w/index.php?diff=133061&oldid=133059 * Zzo38 * (+749)
23:51:35 -!- X-Scale has quit (Quit: Client closed).
23:56:33 -!- X-Scale has joined.