00:03:03 -!- mtm has quit (Ping timeout: 260 seconds).
00:05:44 -!- mtm has joined.
00:19:45 -!- X-Scale has quit (Ping timeout: 256 seconds).
00:44:59 <esolangs> [[User talk:PrySigneToFry]] https://esolangs.org/w/index.php?diff=133062&oldid=133031 * PrySigneToFry * (+267)
00:56:46 -!- X-Scale has joined.
01:02:52 <esolangs> [[Sakana]] https://esolangs.org/w/index.php?diff=133063&oldid=132975 * TheCanon2 * (+484) Added a Parity calculator
01:05:53 <esolangs> [[Sakana]] M https://esolangs.org/w/index.php?diff=133064&oldid=133063 * TheCanon2 * (+39) Added detail
01:06:58 -!- lisbeths has joined.
01:28:38 <esolangs> [[ALWCIDFEC]] M https://esolangs.org/w/index.php?diff=133065&oldid=128968 * Timothytomato * (+7) link to disambugation page is no good
01:40:32 -!- zzo38 has quit (Ping timeout: 256 seconds).
01:42:33 <esolangs> [[Talk:ALWCIDFEC]] https://esolangs.org/w/index.php?diff=133066&oldid=105970 * Timothytomato * (+300) is it really turing complete bro?
01:42:49 <esolangs> [[ALWCIDFEC]] https://esolangs.org/w/index.php?diff=133067&oldid=133065 * Timothytomato * (-29)
01:50:05 -!- salpynx has joined.
01:58:06 <salpynx> recent comment on ALWCIDFEC about TCness got me thinking about 3 cell bf. I think that's been conclusively proven TC, but maybe that proof is not obviously linked?
01:58:23 <salpynx> Just looking at the specs, it seems like it's almost trivially TC when compared to 3 register Portable Minsky Machine Notation, which can directly implement a 2 reg Minsky machine.
01:58:34 <salpynx> A while back I wanted to prove the 2 register PMMN _wasn't_ TC, but came up with a sketch proof that is was, and then stalled because that didn't seem very interesting.... but wouldn't that be equivalent to proving 2 cell bf Turing complete, which _is_ interesting?
02:00:21 <salpynx> ... what is the current state of knowledge about 2 cell bf TCness?
02:05:03 -!- op_4 has quit (Remote host closed the connection).
02:05:33 -!- op_4 has joined.
02:10:55 <salpynx> the complicated bit was that with only two registers and while loops you wouldn't neccesarily be able to exit all loops, but there seems to be a way to rearrange things so that you keep going deeoer into loops, and can just hang there once all computation is complete, with that kind of halt-on-tight-loop convention mentioned here recently
02:21:49 <salpynx> clarification: you can't necessarily exit the current loop without losing current data, but you can still enter loops, so different halt conditions can be distinguished by different tight inner loops
02:26:58 <esolangs> [[List of ideas]] M https://esolangs.org/w/index.php?diff=133068&oldid=132883 * Timothytomato * (+62) BCT is basically godel numbering
02:31:55 -!- zzo38 has joined.
03:02:53 <korvo> I proved that the stationary distribution of Hydra and Antihydra is not just 50/50 even/odd, but evenly distributed mod 4, mod 8, etc. This makes it even more probvious to me that they don't halt.
03:26:32 -!- lisbeths has quit (Quit: Connection closed for inactivity).
04:24:53 -!- andyatalligin has quit (Server closed connection).
04:25:02 -!- andyatalligin has joined.
05:00:32 -!- yuu has quit (Server closed connection).
05:00:41 -!- yuu has joined.
05:08:21 -!- Hooloovoo has quit (Ping timeout: 272 seconds).
05:14:19 -!- Hooloovoo has joined.
05:54:40 -!- tromp has joined.
06:19:41 -!- Argorok has quit (Server closed connection).
06:19:52 -!- Argorok has joined.
06:30:39 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
06:33:39 -!- tromp has joined.
06:42:56 -!- Lymia has quit (Server closed connection).
06:43:08 <esolangs> [[Fun 2 code]] M https://esolangs.org/w/index.php?diff=133069&oldid=133039 * PythonshellDebugwindow * (+159) Categories
06:43:08 -!- Lymia has joined.
06:45:54 -!- __monty__ has joined.
07:19:30 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
08:13:03 -!- tromp has joined.
08:20:35 -!- dnm has quit (Server closed connection).
08:20:47 -!- dnm has joined.
08:34:19 -!- cpressey has joined.
08:44:54 -!- salpynx has quit (Remote host closed the connection).
08:45:17 -!- salpynx has joined.
08:46:56 -!- mich181189 has quit (Server closed connection).
08:47:07 -!- mich181189 has joined.
09:35:14 <tromp> BF can be made prefix-free by adding an unmatched ] to end the program
09:51:23 -!- zzo38 has quit (Ping timeout: 265 seconds).
09:55:08 -!- wryl has quit (Server closed connection).
09:55:19 -!- wryl has joined.
10:14:12 -!- Noisytoot has quit (Excess Flood).
10:15:30 -!- Noisytoot has joined.
10:20:52 -!- Noisytoot has quit (Ping timeout: 265 seconds).
10:26:59 -!- Noisytoot has joined.
10:29:05 -!- cpressey has quit (Ping timeout: 265 seconds).
10:29:39 -!- cpressey has joined.
11:12:22 -!- salpynx has quit (Remote host closed the connection).
11:24:27 -!- X-Scale has quit (Ping timeout: 256 seconds).
11:44:28 -!- Sgeo has quit (Read error: Connection reset by peer).
11:50:31 -!- jjrubes has joined.
11:55:20 <jjrubes> oh hey, i'm looking for an admin for esolangs.org
12:04:08 -!- mtm has quit (Ping timeout: 245 seconds).
12:06:45 -!- mtm has joined.
12:22:23 <int-e> Is it about the wiki or something else?
12:24:22 <int-e> (I'm not an admin, but I'm trying to figure out whom to possibly ping :) )
12:24:49 <jjrubes> it's about getting something removed from a wiki page and its history
12:25:28 <int-e> Okay ais523 helps the most with that. And has a tendency to pop in here if his name is mentioned, so maybe that works this time too.
12:30:08 -!- pikhq has quit (Server closed connection).
12:30:09 <b_jonas> tromp: yes, that works too
12:30:20 -!- pikhq has joined.
12:31:01 <tromp> what else makes it prefix free?
12:31:47 <tromp> i think only ] can serve as endmarker
12:32:30 <int-e> you can add a dedicated end symbol... which is of course more expensive if you count bits
12:34:57 <int-e> That extra ] is the simplest choice.
12:36:29 <int-e> I think I've written at least one BF interpreter that used that trick for terminating the program; it had a recursive function that executed everything from right after a [ to the matching ] once.
12:37:24 <int-e> (It's that, or I saw it in somebody else's interpreter. Quite possibly both.)
12:38:35 <int-e> But for making things prefix-free there's always the generic encoded length + string apprach with its many different encodings of natural numbers.
12:46:04 -!- X-Scale has joined.
13:15:47 -!- jjrubes has quit (Read error: Connection reset by peer).
13:34:08 -!- ais523 has joined.
13:38:16 -!- Noisytoot has quit (Ping timeout: 258 seconds).
13:41:59 -!- leah2 has quit (Ping timeout: 264 seconds).
13:45:39 -!- Noisytoot has joined.
13:47:38 -!- MizMahem has quit (Server closed connection).
13:47:49 -!- MizMahem has joined.
13:58:01 -!- X-Scale has quit (Ping timeout: 256 seconds).
14:00:40 -!- leah2 has joined.
14:16:13 -!- cpressey has quit (Ping timeout: 258 seconds).
14:23:31 -!- leah2 has quit (Ping timeout: 264 seconds).
14:44:07 -!- leah2 has joined.
15:05:07 -!- cpressey has joined.
15:05:50 -!- X-Scale has joined.
15:11:50 -!- cpressey has quit (Ping timeout: 265 seconds).
15:19:05 -!- slavfox has quit (Server closed connection).
15:19:26 -!- slavfox has joined.
15:32:39 -!- X-Scale has quit (Ping timeout: 256 seconds).
15:40:15 -!- X-Scale has joined.
15:40:51 -!- cpressey has joined.
16:00:25 -!- X-Scale has quit (Ping timeout: 256 seconds).
16:04:19 -!- cpressey has quit (Ping timeout: 264 seconds).
16:14:53 -!- cpressey has joined.
16:18:30 -!- X-Scale has joined.
16:30:43 -!- cpressey has quit (Ping timeout: 264 seconds).
16:42:21 -!- X-Scale has quit (Ping timeout: 256 seconds).
17:07:42 <esolangs> [[Esolang:Sandbox]] https://esolangs.org/w/index.php?diff=133070&oldid=132093 * Ais523 * (+6) /* Tests */ just making sure the wiki is still working, we haven't had any edits for a while
17:18:28 -!- cpressey has joined.
17:27:07 -!- cpressey has quit (Ping timeout: 264 seconds).
17:47:11 -!- zzo38 has joined.
18:03:32 <wryl> Anybody have any literature revolving around encoding labeled, directed graphs in unlabeled, undirected graphs?
18:04:48 <b_jonas> wryl: are the former vertex-labeled?
18:05:17 <wryl> Can either be vertex or edge labeled.
18:05:32 <wryl> But I'm working with vertex labeled.
18:06:08 <b_jonas> Hajnal Péter's book explains encoding unlabelled digraphs into labelled digraphs, for the purpose of showing that graph isomorphism is equally hard for them, but I don't think it has labelled
18:06:28 <b_jonas> perhaps the esowiki's article on Eodermdrone gives a hint?
18:07:13 <wryl> I've been rolling it around in my head for a bit. The criteria is that it needs to be able to be pattern-matched on.
18:08:16 <wryl> So I give you a list of variables, like `a b, b c, c d, d a`, and that defines a pattern that detects rings of 4 vertices.
18:09:16 <wryl> I imagine you could form vertex labels via taking complete graphs and using them in place of a labeled vertex.
18:10:49 <wryl> So `a b, a c, a d, b c, b d, c d`.
18:11:10 <wryl> Would match a complete graph of 4.
18:11:14 <b_jonas> what I would recommend is to turn each vertex of the old graph into a wheel, and each arc to a 3-path from an outer node of the wheel to an outer node of the second, plus an extra edge dangling from the middle node of that 3-path going to a 1-degree node, and with no outer node of the wheels reused. to decode, you find all the triangles in the new graph, these can only occurr inside the wheels, and get
18:11:20 <b_jonas> the connected components of these triangles which give the wheels. to encode the vertex labeling, make the wheel have more nodes than necessary.
18:13:10 <b_jonas> this should let you pattern-match on the new graph locally, since any two triangles that share a node must be in the same wheel and there's always two of these connecting any two outer nodes of the wheel, and also any node with degree 2 must be part of what an arc got turned to
18:14:53 <wryl> Need to chew on that.. thanks! That's certainly different than what I was thinking, trying to visualize it.
18:15:40 <b_jonas> it's not the only possible metho
18:16:14 <b_jonas> you can devise different ones depending on your requirements
18:17:05 <wryl> Yours is pretty interesting, though.
18:17:51 <ais523> oh, jjrubes isn't here
18:17:59 <ais523> I can help with that, but not if I don't know what the requested action is
18:23:27 <esolangs> [[Talk:ALWCIDFEC]] https://esolangs.org/w/index.php?diff=133071&oldid=133066 * Ais523 * (+343) proved TC via 3-cell brainfuck
18:23:31 -!- Lord_of_Life has quit (Ping timeout: 264 seconds).
18:23:31 -!- Lord_of_Life_ has joined.
18:23:35 <esolangs> [[3-cell brainfuck]] N https://esolangs.org/w/index.php?oldid=133072 * Ais523 * (+60) Redirected page to [[Collatz function#Reduction to 3-cell brainfuck]]
18:24:53 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
18:27:43 <esolangs> [[ALWCIDFEC]] https://esolangs.org/w/index.php?diff=133073&oldid=133067 * Ais523 * (+429) TCness proof, because one was requested in chat
18:27:53 -!- leah2 has quit (Ping timeout: 245 seconds).
18:32:50 -!- esolangs has quit (Server closed connection).
18:33:28 -!- esolangs has joined.
18:33:29 -!- ChanServ has set channel mode: +v esolangs.
18:43:55 -!- leah2 has joined.
18:51:25 -!- ais523 has quit (Remote host closed the connection).
18:52:39 -!- ais523 has joined.
19:01:59 -!- X-Scale has joined.
19:08:18 -!- leah2 has quit (Ping timeout: 245 seconds).
19:20:27 -!- X-Scale has quit (Ping timeout: 256 seconds).
19:21:00 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
19:21:43 -!- ais523 has quit (Ping timeout: 264 seconds).
19:22:51 -!- leah2 has joined.
19:41:06 -!- salpynx has joined.
19:48:59 -!- tromp has joined.
19:51:54 -!- cpressey has joined.
19:52:45 -!- tromp has quit (Client Quit).
19:53:23 <esolangs> [[Ractangle]] https://esolangs.org/w/index.php?diff=133074&oldid=132990 * Ractangle * (+42) /* Programlangs that i know how to program in them */
19:54:01 -!- tromp has joined.
20:00:21 -!- X-Scale has joined.
20:02:47 -!- Sgeo has joined.
20:12:03 <esolangs> [[Sakana]] M https://esolangs.org/w/index.php?diff=133075&oldid=133064 * TheCanon2 * (-6) Found shorter way to write XKCD Random Number
20:13:08 <esolangs> [[Fun 2 code]] https://esolangs.org/w/index.php?diff=133076&oldid=133069 * Tommyaweosme * (+666)
20:13:52 <esolangs> [[Fun 2 code]] https://esolangs.org/w/index.php?diff=133077&oldid=133076 * Tommyaweosme * (-33) /* Python interpreter */ tiny fixes
20:14:08 <esolangs> [[Fun 2 code]] https://esolangs.org/w/index.php?diff=133078&oldid=133077 * Tommyaweosme * (-2) it was implemented thank you
20:16:51 <esolangs> [[Esolang:Sandbox]] https://esolangs.org/w/index.php?diff=133079&oldid=133070 * Tommyaweosme * (+42) not related to esolangs
20:20:28 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
20:21:21 -!- mtm_ has joined.
20:21:55 -!- mtm has quit (Ping timeout: 258 seconds).
20:28:15 -!- mtm has joined.
20:30:07 -!- mtm_ has quit (Ping timeout: 264 seconds).
20:55:30 -!- tromp has joined.
21:01:06 -!- ais523 has joined.
21:06:36 -!- cpressey has quit (Ping timeout: 265 seconds).
21:14:31 <salpynx> Is 2 cell bf known to be TC or not?
21:17:17 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
21:18:33 -!- mtm has quit (Read error: Connection reset by peer).
21:19:02 -!- mtm has joined.
21:20:55 -!- lynndotpy has quit (Quit: bye bye).
21:21:05 <int-e> b_jonas: I've picked up this project again... it kind of works (it can make arbitrary shapes, but it still produces some garbage after switching between them... probably need to redo some of the synchronization logic): https://int-e.eu/~bf3/tmp/true-mam-wip.png https://int-e.eu/~bf3/tmp/true-mam-wip-wire.png (proportioned a bit like an iceberg)
21:21:51 -!- lynndotpy has joined.
21:24:22 <int-e> "arbitrary shapes" -- I have not tested this exhaustively. I made a rocket and two other tricky shapes, along with some simple ones. I mostly rely on the fact that the data in the huge ROM is machine generated.
21:26:26 <b_jonas> int-e: you want this true MAM to be strictly synchronized too? that'll be hard
21:27:08 <b_jonas> at what nominal and effective fps does it run?
21:27:49 <int-e> 60 for both, it's still below 10ms per tick for me
21:30:43 <int-e> b_jonas: It's not as bad as you may think; the recipes are fairly uniform
21:32:21 <wryl> int-e: What is this?
21:32:27 <int-e> I was surprised to find all the resources nearby
21:33:05 <int-e> wryl: a shapez.io factory, more or less automated to produce any possible shape that can be made in the game.
21:34:03 <wryl> salpynx: 2-counter automata are TC provided the counters are unbounded, so if your cells are unbounded, then most likely.
21:34:09 <int-e> something I've been thinking about off and on for a year now I guess... it's tedious to finish these things.
21:36:11 <int-e> 2 cell brainfuck is certainly not TC, as it effectively has only one counter because a cell need to be zero to exit a loop.
21:36:51 <wryl> Ah, I forgot about that, you'd need 3 cells..
21:37:20 <int-e> IIRC oerjan actually proved 3 cell BF to be TC? I may be misremembering.
21:40:12 <int-e> It only becomes easy at 4 cells I think, since then you have a cell that can be zero, another cell that can manage a program state for control flow, plus two counters.
21:41:52 <wryl> "We gave you a rock hammer instead of a toothpick."
21:42:12 <int-e> here's a brain to perform surgery on
21:46:32 <ais523> there's a TCness proof for 3 cell brainfuck on the wiki, although it's in the article about Collatz functions
21:48:24 <ais523> I added a redirect to it at https://esolangs.org/wiki/3_cell_brainfuck recently to make it easier to find
21:48:37 <ais523> [[e:3-cell brainfuck]]
21:48:43 <ais523> https://esolangs.org/wiki/3-cell_brainfuck
21:49:10 <int-e> Heh does "e:" work on the wiki?
21:49:26 <ais523> I don't think so, it's something I set up for my IRC client
21:49:42 <ais523> I link to Esolang often enough that I've had it set up for ages
21:49:47 <int-e> that would've been my second guess.
21:50:24 <ais523> but I don't use it often enough to motivate me to fix the bug where it doesn't work if you type space rather than underscore :-)
21:51:32 <int-e> And... that reduction was added by oerjan in 2011. :)
21:51:37 <ais523> proving that 2-cell BF is nontrivial – Minsky machines can be written to exit loops only when the cell is zero – but the problem is that to read the remainder of a divmod instruction you need multiple places where the loop can end
21:51:49 <ais523> * proving that 2-cell BF is Turing-incomplete
21:52:11 <ais523> it'd work if the loops terminated if the cell was less than some fixed integer, for fairly small integers (I think 3 might work)
21:52:21 <ais523> even if the cells weren't allowed to go negative
21:57:18 <int-e> I can believe 3, yeah. Possibly even 2, just enough to maintain 2 counters n, m, as 4^n 3^m and enable division by 2 and by 3 (noting that 4^n = 1 (mod 3)), but I'm not too sure about the control flow afterwards.
21:57:38 <ais523> oh, I meant 3 as in loop halts on 0, 1, 2
21:57:54 <ais523> thus letting you divide by 2 and 3 and still remember the remainder
21:57:56 <salpynx> thanks ais523 for adding that link, I knew 3cell bf was TC, but the proof was hard to find. I now see it _is_ linked from the bf article, but it's a big article
21:58:13 <ais523> but you're right, there are tricks to ensure the remainder is always 0 or 1
21:58:15 <int-e> ais523: what I'm saying is that you don't necessarily need all the remainders
21:58:43 <ais523> I know I've thought about that for TCness proofs before, but can't remember the last time I used it
21:58:50 <ais523> was it in the Netrunner TCness proof? or did that not need it?
21:59:09 <salpynx> I was thinking that you don't neccesarily need to exit all your loops to perform arbitrary computation, so 2 cell bf could be TC, with that caveat.
21:59:41 <salpynx> I was trying to show that 2 register PMMN wasn't TC back in 2022, but decided it was TC, with that trick
21:59:59 <ais523> a loop either gets exited eventually or only affects a finite portion of the program at the start
22:00:30 <ais523> so in a language that can initialize itself to an arbitrary state without loops (like BF can), a loop either gets exited or it doesn't contribute to the program's TCness
22:00:43 <ais523> https://esolangs.org/wiki/Portable_Minsky_Machine_Notation
22:00:57 <ais523> it's Minsky machines but with while rather than goto
22:01:03 <salpynx> if all possible end states are some internal loop you can have some finite number of end state classes, and one register can be unbounded at the 'end'
22:02:18 <int-e> PMMN has richer control flow than brainfuck
22:02:19 <ais523> I guess 2-cell BF might be TC if you allowed an infinite program
22:02:28 <salpynx> ais523, My hypothesis is either 2 reg PMMN is not TC, or 2 cell bf is TC. One of those is true. And I think they are both TC, with a trick.
22:02:30 <ais523> the ({})%-1 notation from BF Joust might be interesting
22:03:53 <ais523> salpynx: so the fundamental problem in proving 2-cell BF TC is that if you have a division loop, you need to know the remainder in advance, otherwise you can go past 0 by mistake if you get the remainder wrong
22:04:21 <ais523> that doesn't quite disprove the TCness of the language but it makes it seem unlikely
22:05:14 <ais523> (this is assuming that you need to record the result of the division somewhere, so you can't use the other cell as a way to escape an inner loop)
22:07:03 <salpynx> I have some code that decrements virtual prime encoded registers in one of the two registers, which I think works correctly, IIRC the only problem was exiting loops (as int-e mentioned)
22:07:51 <salpynx> I'll have to dust the code off and check whether it handles that division loop problem
22:07:55 <int-e> Well, 2-reg PMMN is TC, it can simulate a 2-reg Minsky machine with arbitrary state transitions.
22:08:33 <ais523> PMMN has if statements, which I think help in this situation?
22:09:27 <int-e> They allow you to structure your program as one while loop with a big switch() inside.
22:09:31 <salpynx> The point I wanted to make was that n reg PMMN can simulate n-1 Minsky Machines trivially,
22:10:15 <salpynx> One PMMN reg is needed to basically convert the while loops to arbitrary jumps. The if/else doesn't really help
22:10:37 -!- __monty__ has quit (Quit: leaving).
22:10:56 <int-e> Hmm. Maybe I'm missing something, let me think.
22:11:03 <salpynx> hmm.. int-e we seem to be disagreeing on that.
22:12:38 <salpynx> It was a while ago that I was working on this, I'm just picking it back up, so I could be mistaken also. Maybe I do need to formalise my idea
22:13:03 <ais523> oh! I think 2-register PMMN can do Spiral Rise
22:13:44 <ais523> because you can, when dividing one counter, conditionally add to the other
22:13:55 <ais523> although, maybe it can't because Spiral Rise needs to track two pieces of information between states
22:14:00 <ais523> err, between times things go zero
22:14:36 <wryl> I think I remember you working on this, salpynx.
22:14:59 <ais523> I don't think it does Spiral Rise, exactly – but it can do the "add the remainder of x onto y" trick
22:15:27 <int-e> Oh you have to add another level of the same trick. A single register can store both the counters and the state as well, say 2^a * 3^b * N + s, a and b being the counters and s being the state. Then your main loop can divide by N with remainder (tracked in control flow), then inside you can divide the counter by 2 or 3 if you're decrementing, and then you can make another look to multiply by N...
22:15:33 <int-e> ...and add the next state, and still exit the division loop. And then copy the new register back and repeat from the start.
22:16:53 <ais523> so my problem is that I can see how you can track the state in the remainder, and I can see how you can track the state in the control flow, but I can't easily see a way to take a state that's encoded in the remainder and use it to affect the control flow (rather than the remainder)
22:17:38 <int-e> you can nest the conditionals
22:17:46 <ais523> because, at the point where you leave a while loop, the tested counter is 0 and the control flow is always in the same place, so the only place you have to store data is the remainder of the other counter
22:17:59 <ais523> (and the counter itself, obviously)
22:18:24 <ais523> oh right, you just get the inner conditional to multiply/divide the other counter
22:21:06 <salpynx> I have this comment in my code: The only way to break out of the outer while() which contains inner while()s acting as v.reg if()s is to have both physical registers zeroed. One register must be 0 to break out of the last inner while (testing a v.reg), and the other must be zero to break out of the main program loop, indicating a HALT condition has been reached.
22:22:05 <ais523> I suspect the pattern that makes PMMN work is along the lines of an outer while that contains if/else statements, and all the inner whiles are inside else blocks
22:22:32 <salpynx> The not being able to break out of the outher while seemed like a problem, but it seems like you can just branch inwards, and never leave the other loops, but still complete useful computation
22:23:25 <ais523> if the program is finitely long there's a limit to how much you can branch inwards
22:25:21 <salpynx> ais523, I was worried about that, there are only finite many of these internal looped end states that can be in the source... I thought the saving aspect would be the remaining required state could be encoded in virtual registers, which is unbounded.
22:26:26 <ais523> ah, so the idea is that you branch inwards to some extent and encode state into the other register while you're doing it
22:27:08 <ais523> I think the problem there is the control flow while registers have large valeus
22:27:09 <salpynx> Well this has convinced that I should probably keep going and clarify things, at least make my ideas clear, or show I've missed something
22:27:41 <ais523> like, in any TC calculation there will be a point where both registers have values much larger than the length of your program
22:28:23 <ais523> and once such a point is reached, you end up funneling into an innermost loop and getting stuck there until one register has entirely drained into the other – which usually means knowing what the remainders are at that point
22:28:55 <ais523> so I guess the innermost loop has to be a simple "add (an integer multiple of) one register to the other, without dividing"?
22:28:55 <salpynx> I was using prime encoded virtual registers, so you get a finite number of those that you encode into your program, and each is unbounded.
22:29:19 <ais523> I am not convinced the registers are readable
22:30:37 <salpynx> This is some of my old code which tests vreg incs and decs using 2 reg PMMN: https://github.com/hornc/py_program_machine/blob/master/tests/test_2register.py
22:32:11 <salpynx> I'm going to go through and create some more usable vreg helpers... I thought implementing the Ackermann function would force me to make sure everything works. (That might be stupidly ambitious)
22:33:39 <ais523> OK, so the idea is that you are purely doing inc and dec, not inc and dec-and-test, so you do know the remainder because you know you aren't decrementing 0
22:34:39 <ais523> but I cannot see a way to run this conditionally
22:34:51 <salpynx> .. I'm hoping there is a way to do dec-and-test, looking at it a fresh I noticed that wasn't demonstrated clearly, so I need to do that
22:35:07 <ais523> based on the value of a vreg
22:35:53 <ais523> the test is the hard part
22:36:30 <ais523> I suspect that if it's possible at all, it will involve a loop that swaps the value between the two counters on every iteration
22:36:42 <salpynx> I think L243 is supposed to show a virtual test occurring... but I agree it's not clear, so I need to double check it
22:37:10 <ais523> oh, you are using if statements
22:37:33 <ais523> I was thinking about 2-cell BF rather than PMMN in the discussion above
22:37:47 <ais523> with if statements (and particularly else statements) it's much easier
22:38:47 <ais523> oh, the loop that swaps the value between two counters doesn't work because it would have nowhere to store the quotient
22:39:10 <salpynx> Maybe I am mixing my 2 cell bf and PMMN now, I wasn't when I wrote this code originally. The similarity between 2 cell bf and PMMN only just struck me recently.
22:44:32 <salpynx> Thanks all for the comments, it's given me the inspiration to think on this more and I'll try to clarify my work with some examples
22:48:09 <salpynx> My summary: Conventional take is that 2 reg PMMN is TC, and that 2 cell bf is not (primarily because it can't do if/else?).
22:49:25 <salpynx> if I think it's more complicated than that, I need to be clear about what I'm saying, and an explicit 2 reg PMMN TC proof wouldn't hurt regardless.
23:03:01 <int-e> Here's a prototype; it simulates a simple loop that moves one register to another, and you can see that it successfully converts 2^7 (7 in first register) to 3^7 (7 in second register): https://paste.debian.net/1323292/
23:04:29 <ais523> ooh, postdecrement operator
23:10:41 -!- ais523 has quit (Quit: quit).
23:12:09 <int-e> It's relatively easy to modify this such that it can actually terminate; just move the final inc(a) to where the new a is computed. It's not obvious to me whether you can exfiltrate more than finitely many values from such a computation.
23:13:55 -!- X-Scale has quit (Ping timeout: 256 seconds).
23:18:07 -!- cpressey has joined.
23:44:32 <int-e> Anyway that PMMN construction makes heavy use of if-then-else, and 2-cell BF doesn't give you an `else`; it hardly even gives you an 'if' (since you can only exit blocks when the current cell is 0)