00:36:31 [[SECRET PUZZLE!]] N https://esolangs.org/w/index.php?oldid=163680 * Mouldyair * (+865) Created page with "SECRET PUZZLE is a simple text based programing language made by [[user:Mouldyair]]. ==SYNTAX== to write a program in SECRET PUZZLE you simply type the program into a blank text document, documents can use any unicode characters, have any number of lines, with e 00:37:58 [[User:Mouldyair]] M https://esolangs.org/w/index.php?diff=163681&oldid=163662 * Mouldyair * (+24) 00:50:49 b_jonas: normally both ends are marked but the jump target doesn't say where the jump source is, just that it is a jump target 00:53:25 -!- amby has quit (Remote host closed the connection). 01:03:59 -!- Melvar has joined. 01:09:20 ais523: no, they both say it just as much, there's a freeform label that's the same in both the jump and the target, so if there's no weird shenanigans like computed goto then the difference between a goto-label and a label-comefrom is just the keywords. though you could say that a label doesn't say how many gotos are pointing there, so you don't know when to stop searching for gotos. 01:09:45 ah, that's an interesting viewpoint 01:10:10 so I guess the interesting part of the design space is "linear labels" which you can only jump to from one location in the code 01:10:32 meaning that if there are multiple jumps to the same location, you have multiple labels next to each other to indicate that 01:10:44 come to think of it, that's pretty much what Incident does 01:11:28 I guess another asymmetry in most practical languages is that the behaviour of jumping out of scopes is much easier to define than the behaviour of jumping into scopes 01:12:00 (although there are challenges in both directions, and those challenges mirror each other to some extent, dropping an object that shouldn't exist is generally much easier than conjuring an object that should) 01:12:20 ais523: also that for a conditional jump you write the condition before the goto, not before the comefrom, so from that you can tell it's a goto statement 01:13:30 if condition { label:; } … comefrom label; has the right semantics, but the condition is still on the end you jump from 01:14:47 doing it at the other end would be something like label:; … nextfrom label; if condition { forget 1; } else { resume 1; } 01:15:14 which is how INTERCAL does conditionals, but I don't think anyone else does, and it's significantly different in the way it works 01:15:54 normally you'd write comefrom (condition ? label : invalidlabel), though in intercal in particular even the invalid label that never executes has to syntactically exist, and of course you have to write the conditional as an intercal expression which can be inconvenient 01:16:21 but a modern language with comefrom would just have convenient syntax for a conditional comefrom 01:16:22 no, for a computed comefrom, the label it computes to doesn't have to exist 01:16:36 it doesn't? 01:16:39 nice 01:17:02 that's a compile time check and you can't figure out what it would compute to at compile time 01:17:14 (if it were a runtime check, it would be hard to define exactly when it should run…) 01:17:45 the funny thing is that writing the conditional as an INTERCAL expression actually makes things easier, usually 01:18:00 compared to writing it using a variable-sized resume 01:18:45 because you can just do "jump if x is k" by mingling x and a constant, and then numbering the line to match the expected result 01:19:52 meanwhile the variable-sized resume generally requires you to convert the two possibilities to 1 and 2, which is doable but somewhat verbose as it isn't a trivial pair of numbers to produce with bitwise operations 01:22:00 (you can't resume 0 because that encounters error type 621) 01:22:54 …although it crosses my mind that a consistent way to resume 0 might be to jump to the line label that had been most recently forgotten 01:22:57 in an APL-like with come from, you'd use the compress verb to conditionally make the operand of the comefrom an empty array when the condition fails, and in the typical case when you compress a constant label, the interpreter would optimize this to only evaluate the condition at that one label 01:23:41 I mostly think of APL as a functional rather than imperative language, which makes goto/comefrom hard to imagine in it 01:23:46 ais523: can't you use FORGET with 0 or 1 instead? 01:23:57 b_jonas: yes, but that doesn't actually jump anywhere 01:24:11 sure, you follow it with a resume 1 01:24:13 I guess you could just use a variable forget followed by a hardcoded resume 1 01:24:17 yes 01:24:50 now that you mention it, I'm surprised that that isn't done more often 01:26:11 it's not done because next is too easy and is only there for historical reasons, real intercal programmers use only comefrom/nextfrom with possibly the from or the label computed 01:26:48 I genuinely find computed comefrom easier 01:27:08 than the intercal-72 method 01:27:17 (to write, at least – it is probably a little less readable, but it's close) 01:27:43 the expressions are more readable but they have the "random global side effect" issue that most of the things in INTERCAL do 01:28:10 C-INTERCAL also has computed create, which is underexplored I think 01:28:13 it might be good for jump tables 01:29:33 and there's also abstain/reinstate with a computed target 01:30:25 are those allowed to abstain/reinstate a nonexistent label? 01:31:02 I don't think C-INTERCAL allows you to compute the label of abstain/reinstate, but I'm not sure 01:31:31 it allows you to compute the *quantity* of abstain, e.g. you can triple-abstain things so that they need to be reinstated three times 01:31:54 (fun fact: this is the first time I stumbled across The Waterfall Model, but I didn't realise it at the time) 01:31:55 huh 01:32:05 interesting 01:32:51 I didn't know multiple abstain existed in the language 01:33:22 I added it because I was interested in seeing if INTERCAL could be TC even without expressions 01:33:42 [[Error: not a statement]] N https://esolangs.org/w/index.php?oldid=163682 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+1199) Created page with "'''Error: not a statement''' is a restricted subset of Java by [[User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff]], which only allows expressions statements that would no 01:33:48 and it seemed like the same sort of thing as computed forget 01:34:08 hmm 01:34:12 [[User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff]] https://esolangs.org/w/index.php?diff=163683&oldid=161377 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+99) 01:35:08 I mean it probably is, because there's stash/retreive to conveniently handle a stack of a finite alphabet 01:35:48 but what I ended up with was almost literally The Waterfall Model with different syntax (the only difference is that TWM has undefined behaviour on simultaneous zeroing whereas this has defined behaviour, and I hadn't realised at the time that usual practice would be to keep the abstain counts nonzero almost all the time) 01:36:23 I don't think stash/retrieve are useful without expressions, because you have no way to set or read the values you're stashing and retrieving 01:36:46 can you start with a statement multiple abstained, with something like `do not not not not not`? 01:37:01 no, although that's an interesting idea for an extension 01:37:18 normally a double negative in English negates the negative rather than intensifying it 01:37:32 so you would need to write the not in a language where double negation is stronger negation rather than negated negation 01:37:35 ais523: you can read the values as a forget or resume count, or by using it as an array index 01:38:22 array indexing is an expression 01:38:28 …as are forget and resume counts 01:38:29 oh, you ban that too, right 01:38:45 I guess I allowed the constant #1 in ABSTAIN #1 FROM 01:38:53 I assumed you only banned the mingle and select and the prefix bitwise operators 01:38:54 so maybe bare variables should be allowed too 01:39:51 syntax shouldn't be anything like `do not not` because that would be incompatible with existing syntax in a way that would affect a lot of... uh... production code or something, real world programs 01:40:28 I think it's currently a syntax error 01:40:38 (which, admittedly, could exist in current production programs) 01:42:38 oh! so maybe it wouldn't break many production programs 01:43:07 they'd result in different abstain state in some lines, but only in lines that the program wouldn't try to execute 01:43:41 well it's possible that the syntax errors would be being executed 01:44:02 things like DO REINSTATE COMMENTS DO NOT NOT FOO would act differently 01:44:31 …although DO REINSTATE COMMENTS is such a dubious construct I'm not even sure I've remember the syntax for it correctly 01:44:48 so in this multiple abstain/reinstate extension, is the abstain count capped to zero or more so if you reinstate more times than a statement is abstained then it's clamped to zero abstains? 01:45:31 it's clamped from below at 0 and can go "arbitrarily high" although C-INTERCAL doesn't actually use a bignum type 01:45:49 also, only multiple abstain is supported, you have to reinstate 1 at a time 01:46:00 oh 01:46:14 strange 01:46:36 if it starts making too much sense, you don't have INTERCAL any more :-D 01:47:27 [[GERMAN]] https://esolangs.org/w/index.php?diff=163684&oldid=110908 * Kaveh Yousefi * (+2309) Introduced an examples section comprehending three incipial members, added a hyperlink to my implementation on GitHub, and supplemented the Implemented page category tag. 01:47:51 yeah, but sometimes I'm thinking of which of these features could be lifted to a (likely esoteric in the broad sense) language that very much isn't intercal 01:48:22 oh, sure 01:48:39 I don't really want to program in intercal, but it can be useful to know ideas added into it in all the extensions 01:48:56 in that case you have all four of goto/comefrom/next/nextfrom, computed line labels everywhere, and full ability to compute abstain/reinstate amounts in addition to resume/forget amounts 01:49:47 also if the language isn't being intentionally perverse, it should probably make resume 0 a no-op, which is the behaviour that would actually be useful 01:51:08 ("resume" was presumably intentionally named so that resume 0 wouldn't make sense and thus it could be arbitrarily rejected) 01:51:48 hmm, back when PHP implemented INTERCAL's resume (as "break"), I wonder whether break 0 was an error or a no-op 01:51:50 possibly repeated line labels such that it's an error to go to a line label that appears multiple times but you can abstain/reinstate all statements with a certain label at the same time 01:52:16 I think it got removed when someone pointed out that it's almost never a good idea to use a computed expression as the number of levels to break 01:52:22 but it used to be possible 01:52:41 b_jonas: oh yes, repeated labels would make sense 01:52:50 but a goto should just go to all of them, creating multiple threads 01:52:57 (that's what multiple come froms do) 01:54:24 this is the esoteric syntax; in sane syntax if the label is repeated then when you refer to it you have to specify if you want to refer to the previous line or the next line with that label, so that you can use short label names locally 01:54:55 oh right, the 1b 1f thing from gas 01:55:09 I actually really like that method of doing things – it doesn't nest well but it otherwise composes well 01:55:16 but that makes more sense if you can't use numeric expressions as computed labels 01:55:50 maybe negative numbers jump backwards and positive numbers jump forwards? 01:58:01 I'm currently thinking that the columns serve as variable names esoteric language (which I'm naming "Enchain") will probably have gotos as one of its main control structure, in a somewhat similar way than the python goto extension that I had been thinking about. 02:00:22 how this would work is that there's a builtin syntax to make a label, which sets a variable to that label, but that assignment is executed at the start of the innermost surrounding function, not where the label builtin is written in the program, and there are other builtins that jump or conditionally jump if an integer operand is zero or nonzero 02:00:59 with maybe even an on-goto that takes any number of label operands and an index into them 02:02:04 but this wouldn't be the only control structure, because I absolutely want to have user-defined functions with multiple parameters and multiple return values, 02:02:34 ooh, so Zig has a command "defer" which, when encountered, runs the content of its block at the end of the scope – this feels like a mirror of it, it runs the command at the beginning of the scope 02:02:37 and I may or may not have a simple conditional that adds a condition to either one statement, or a condition to decide between two adjacent statements, based on an integer 02:02:42 although I'm not sure if there's a way to mirror the "when encountered" part 02:03:28 ais523: I don't really think of it like that 02:04:06 because in the common case you'll never reassign that variable, it just behaves as a constant label 02:04:18 though you are allowed to reassign it, in which case yes, the assignment is executed at the start 02:05:51 but in the common case, python already has syntactic effects that act from the start of the function: an equals sign assignment marks a variable as lexically local to the function, and it's lexically local even syntactically earlier than where that assignment is 02:06:48 and even in an ordinary language like C, a goto can refer to a label that hasn't executed yet 02:07:21 Vttoth's W is actually unusual in this respect, because its labels are assigned only when they execute, which seriously limits how you can use them 02:07:40 you can use W's labels to write a loop, but not easily to write a simple conditional 02:08:19 that is deliberate design in W, but in most languages you don't want that 02:12:11 also rust just lets you write `fn main() { println!("{}", M); const M: &str = "hello"; }` and it just works, you refer to M syntactically before you define it 02:12:29 you don't even have to predeclare it like you'd have to predeclare a function or class in C++ 02:15:46 well, C setjmp/longjmp also can't be jumped to until they've been set 02:16:17 I had used something like the DO RESUME #2 of INTERCAL in a program written in BASIC once, since if you RETURN from a GOSUB then you can optionally specify what label to return to, instead of necessarily where it was called from. (There is also a RESUME command in BASIC, to return from an error handler, and also can optionally specify what label to return to.) 02:17:32 yes, and even my idea for python goto and the current idea for Enchain would have some restrictions: you wouldn't be allowed to jump into a function. 02:18:24 that said, there is something about the python goto why you can legitimately think of it as executing the assignment at the start of the function: 02:19:54 when the assignment happens it behaves kind of like a scheme exit/cc in that it saves a reference to the current stack frame into that variable, so you can pass that variable into nested functions (even recursive entries to the same function) and you can goto that value to jump out from many scopes deep 02:20:17 you can't jump into a function, but you can jump out of as many as you wish 02:22:16 I should go to bed 02:22:22 -!- ais523 has quit (Quit: quit). 02:23:31 I have some doubts about the python thing because I realized that there are a lot of details about how python works that I don't understand, and while they don't come up in normal practical programs, they do come up when I want to add features to python 02:23:54 but I think the python goto thing is sound, and in the worst case it can be added to some other similar dynamic language 03:37:22 [[Error: not a statement]] https://esolangs.org/w/index.php?diff=163685&oldid=163682 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+11) /* Limitations */ 03:49:21 [[SECRET PUZZLE!]] M https://esolangs.org/w/index.php?diff=163686&oldid=163680 * Mouldyair * (+126) /* SYNTAX */ 05:08:53 -!- chiselfuse has quit (Remote host closed the connection). 05:09:14 -!- chiselfuse has joined. 06:53:14 -!- Sgeo has quit (Read error: Connection reset by peer). 06:58:26 -!- tromp has joined. 07:47:24 [[Unifuck]] N https://esolangs.org/w/index.php?oldid=163687 * SzszszszszszszsZ * (+4282) Created page with "Unifuck (a portmanteau of Unicode and [[brainfuck]]) is a Brainfuck derivative made by [[User:SzszszszszszszsZ]] where the regular instructions are changed this way: {| class="wikitable" |- ! ''n''%8 is !! Original |- | 0 || + |- | 1 || - |- | 2 || < |- | 3 | 07:48:15 [[User:SzszszszszszszsZ]] M https://esolangs.org/w/index.php?diff=163688&oldid=163521 * SzszszszszszszsZ * (+24) 07:50:16 Hi 08:19:06 [[Special:Log/newusers]] create * Hasin Israk Toaha * New user account 08:35:01 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…). 08:35:50 [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=163689&oldid=163636 * Hasin Israk Toaha * (+269) /* Introductions */ 08:40:42 -!- tromp has joined. 08:44:02 [[User:Hasin Israk Toaha]] N https://esolangs.org/w/index.php?oldid=163690 * Hasin Israk Toaha * (+6785) Created page with "{{infobox proglang |name=Tonnyi |paradigms=Imperative |author=[[User:Hasin Israk Toaha|Hasin Israk Toaha]] |year=2025 |class=[[:Category:Turing complete|Turing complete]] |files=.ton }} '''Tonnyi''' is an esoteric programming langu 09:11:00 [[User:Hasin Israk Toaha]] https://esolangs.org/w/index.php?diff=163691&oldid=163690 * Hasin Israk Toaha * (+124) 09:42:41 [[Special:Log/newusers]] create * Waso * New user account 09:54:07 [[Brainfuck]] M https://esolangs.org/w/index.php?diff=163692&oldid=163648 * RixTheTyrunt * (+18) /* Truth-machine */ 09:54:45 [[Esolang:Introduce yourself]] M https://esolangs.org/w/index.php?diff=163693&oldid=163689 * Waso * (+435) Added me 09:55:18 [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=163694&oldid=163693 * Waso * (+2) 10:06:07 [[Brainfuck algorithms]] https://esolangs.org/w/index.php?diff=163695&oldid=140168 * Waso * (+115) Added a Bitflip algorithm 10:10:45 [[Brainfuck algorithms]] https://esolangs.org/w/index.php?diff=163696&oldid=163695 * Waso * (-2) 10:20:23 [[Unstoppable]] https://esolangs.org/w/index.php?diff=163697&oldid=163671 * PkmnQ * (+12) I'll try proving soon 11:13:46 -!- wib_jonas has joined. 11:20:28 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…). 11:21:35 suppose I give in advance a finite alphabet H with an involution R : H→H. consider the following class of objects: finite simple graphs, represented as finite simple symmetric digraphs, with each arc marked by a weight from H, with the restriction that if an arc (u,v) has weight h then its reverse (v,u) must have weight R(h). what would be a good 11:21:36 concise name for these objects? I can't just call them finite simple graphs with weighted edges, because the weight of an edge may have a direction. 11:23:52 [[Inputbrain]] https://esolangs.org/w/index.php?diff=163698&oldid=148364 * ChuckEsoteric08 * (-1800) Blanked the page 11:24:27 -!- Lord_of_Life has quit (Ping timeout: 256 seconds). 11:26:52 -!- Lord_of_Life has joined. 11:28:16 or maybe, as a first simpler question before we tackle the whole thing, say I also give a finite simple graph in advance, and I consider the set of weightings (functions from the set of arcs to H) satisfying the above reversing condition. what would you call these weightings? 11:29:48 [[User:ChuckEsoteric08/Interpreters]] https://esolangs.org/w/index.php?diff=163699&oldid=163674 * ChuckEsoteric08 * (+0) /* brainfuck in Uppercase=Lowercase */ 11:30:37 [[Uppercase=Lowercase]] https://esolangs.org/w/index.php?diff=163700&oldid=163675 * ChuckEsoteric08 * (+0) /* brainfuck interpreter */ 11:47:27 [[Special:Log/move]] move * HaleyHalcyon * moved [[User:HaleyHalcyon/Sandbox/Sonjalang]] to [[Sonjalang]]: Feels complete enough to me 12:08:34 * APic → Bathtub 😌 🐋 12:46:33 -!- tromp has joined. 12:56:37 -!- wib_jonas has quit (Quit: Client closed). 13:02:05 [[Kak-]] M https://esolangs.org/w/index.php?diff=163703&oldid=141246 * Ractangle * (+327) /* Translation to Kak */ If this is valid, tell me in discord at mrglebsun or change the page category from Unimplemented to Implemented 13:04:27 [[Kak-]] M https://esolangs.org/w/index.php?diff=163704&oldid=163703 * Ractangle * (+13) /* Implementations */ did some modifacation to match the syntax of the language 13:10:31 -!- strerror has quit (Server closed connection). 13:10:46 -!- strerror has joined. 13:11:26 [[Ultimate bf instruction minimalization!]] https://esolangs.org/w/index.php?diff=163705&oldid=140964 * ChuckEsoteric08 * (+41) 14:19:25 -!- Sgeo has joined. 14:33:52 `olist 1332 14:33:54 olist : shachaf oerjan Sgeo boily nortti b_jonas Noisytoot 14:35:04 -!- wib_jonas has joined. 14:35:39 yep, that's exactly what I wanted to say 15:05:44 -!- wib_jonas has quit (Quit: Client closed). 15:21:39 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…). 15:39:13 [[Diophantine equation]] https://esolangs.org/w/index.php?diff=163706&oldid=154618 * Corbin * (+751) Combine some material from [[computable]] and normalize the presentation of equations. Lessons learned from Wilf et al, "A=B" https://www2.math.upenn.edu/~wilf/AeqB.html 15:40:12 [[Computable]] https://esolangs.org/w/index.php?diff=163707&oldid=163678 * Corbin * (-832) /* Via Diophantine equations */ Move the relevant intro to [[Diophantine equation]]. 15:45:29 -!- ais523 has joined. 15:53:57 [[Computable]] https://esolangs.org/w/index.php?diff=163708&oldid=163707 * Corbin * (+29) /* Via Diophantine equations */ Fix tiny typos which invalidated the maths. 15:57:14 -!- tromp has joined. 16:36:29 [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=163709&oldid=163694 * LOLrReD * (+113) introduced LOLrReD 16:53:49 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…). 17:16:25 -!- tromp has joined. 18:08:33 Good Night *, happy Weekends! 18:50:05 -!- ais523 has quit (Quit: quit). 19:16:43 [[TOPLWARLNTMIHTACAFFTPLAIHTASTNBIHTMAIAIU]] N https://esolangs.org/w/index.php?oldid=163710 * TeraByte * (+325) Create page 19:18:13 [[Language list]] M https://esolangs.org/w/index.php?diff=163711&oldid=163663 * TeraByte * (+47) Added TOPLWARLNTMIHTACAFFTPLAIHTASTNBIHTMAIAIU 19:24:24 `slashlearn rush job//A Rush job (named after Stockton Rush) is completing a task while cutting corners at all cost. 19:24:30 Learned 'rush job': A Rush job (named after Stockton Rush) is completing a task while cutting corners at all cost. 19:32:24 [[Kak-]] M https://esolangs.org/w/index.php?diff=163712&oldid=163704 * Ractangle * (-2) /* Implementations */ i guess it's accurate 19:53:10 [[TOPLWARLNTMIHTACAFFTPLAIHTASTNBIHTMAIAIU]] https://esolangs.org/w/index.php?diff=163713&oldid=163710 * TeraByte * (+2691) Extended 19:56:32 [[TOPLWARLNTMIHTACAFFTPLAIHTASTNBIHTMAIAIU]] https://esolangs.org/w/index.php?diff=163714&oldid=163713 * TeraByte * (+437) Extended library and fixed grammar issue 20:15:51 [[TOPLWARLNTMIHTACAFFTPLAIHTASTNBIHTMAIAIU]] https://esolangs.org/w/index.php?diff=163715&oldid=163714 * TeraByte * (+2505) Finished documentation and added a hello world program. This is no longer a work in progress! 20:18:18 [[TOPLWARLNTMIHTACAFFTPLAIHTASTNBIHTMAIAIU]] https://esolangs.org/w/index.php?diff=163716&oldid=163715 * TeraByte * (+84) Altered hello world program to make it more readable 20:21:49 [[Vyxal]] M https://esolangs.org/w/index.php?diff=163717&oldid=86395 * Ractangle * (+0) /* Links */ 20:22:18 [[Vyxal]] M https://esolangs.org/w/index.php?diff=163718&oldid=163717 * Ractangle * (+11) /* Links */ 20:24:58 [[TOPLWARLNTMIHTACAFFTPLAIHTASTNBIHTMAIAIU]] https://esolangs.org/w/index.php?diff=163719&oldid=163716 * TeraByte * (+584) Added abbreviation and pronounciation 20:25:27 [[TOPLWARLNTMIHTACAFFTPLAIHTASTNBIHTMAIAIU]] M https://esolangs.org/w/index.php?diff=163720&oldid=163719 * TeraByte * (-1) Splelnig is hrad 20:38:14 -!- op_4 has quit (Remote host closed the connection). 20:38:42 -!- op_4 has joined. 21:01:42 maybe I could say it's a symmetric digraph with antisymmetric arc weights 21:24:57 heh you could say it's antisymmetric and justify that by looking at the adjacency matrix 21:26:18 or maybe a pun on "undirected": antidirected graph 21:27:20 (I'm assuming you're going to actually define the term first. I haven't checked whether that has an established meaning... it might.) 21:35:26 [[Gur yvsr]] M https://esolangs.org/w/index.php?diff=163721&oldid=163641 * Placeholding * (-58) 21:51:37 -!- iovoid has quit (Server closed connection). 21:52:07 -!- iovoid has joined. 22:20:40 -!- yam04 has joined. 22:21:08 Hi Esolangers 22:23:05 I would like to post the version 6.0 of the hypercomplex numberr list 22:23:32 https://forums.futura-sciences.com/attachments/mathematiques-superieur/511512d1755817142-structures-de-numerotation-inhabituelles-exotiques-6-0-hipernombre_6_0.pdf 22:24:30 It 's a list of mathematical references, about different aspect of numbers 22:25:29 if you want to recommend some mathematical references do it at https://forums.futura-sciences.com/mathematiques-superieur/959505-structures-de-numerotation-inhabituelles-exotiques-6-0-a.html 22:26:13 [[Special:Log/newusers]] create * Purplelimon * New user account 22:26:54 Best Regardds 22:27:04 -!- yam04 has quit (Quit: Client closed). 22:31:13 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…). 22:34:10 [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=163722&oldid=163709 * Purplelimon * (+167) 22:45:24 iovoid: no, if I wanted to go even shorter I'd just omit the "symmetric" and hope that "antisymmetric edge weights" implies that the digraph is symmetric. 22:46:41 uh 22:46:43 wrong ping, sorry 22:46:45 int-e: ^ 22:52:59 b_jonas: Ah but I wanted to drop the mention of edge weights :P 22:53:50 (One could mix in "weighted" though to bring them back.) 23:05:58 (I was proposing terms, rather than self-contained descriptions) 23:06:04 if you drop the edge weight then these are just finite simple graphs, aka finite simple symmetric digraphs. I don't need a new name for that. 23:06:50 (some people represent graphs differently than in terms of symmetric digraphs, but here the digraph representation is convenient.) 23:07:28 Defintion: A weighted graph is called antidirectional if for each egde in the graph the opposite edge is also an edge with the opposite weight. 23:07:41 Something like that. 23:08:52 "antidirected" appears to have a meaning though which may make this confusing 23:08:59 I'm spitballing here. 23:10:11 I don't know what either of "antidirectional" or "antidirected" mean 23:11:08 Of course. The idea was to define it. 23:11:14 and I think I'm satisfied with "antisymmetric weight function" 23:11:24 As I said, it was supposed to be a term, not a description. 23:11:49 I also did not expect you to actually adopt it. 23:11:53 though not entirely 23:12:02 It was just a thought. 23:12:49 because antisymmetric is supposed to mean that the weight of the reverse arc is the negative of the weight of the arc, but I'm not sure R can be considered a negation when it has multiple fixed points 23:13:08 Apparently "antidirected" is used (in some niche, not widely) for graphs that have no directed paths of length 2. 23:13:31 but I don't think "hermitian" would work better either 23:13:48 I feel that it's fine to generalize it to an involution. 23:13:59 int-e: wouldn't no directed paths of length 2 just mean an oriented graph, at least among simple digraphs? 23:15:01 it rules out A --> B --> C 23:15:15 oh, you said path, not cycle! 23:15:24 but then is it just a bipartite digraph? 23:15:46 like, a digraph from which there's a homomorphism to the grpah with a single arc 23:15:48 Yeah, I think so. Well, with some ambiguity for unconnected vertices. 23:16:11 I'm just looking (very selectively) at https://arxiv.org/abs/2212.00769 23:16:27 because it's one of the hits for "antidirected". 23:16:37 It has no bearing on this discussion otherwise. 23:25:15 [[User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff]] https://esolangs.org/w/index.php?diff=163723&oldid=163683 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (-35) 23:26:06 [[Error: not a statement]] https://esolangs.org/w/index.php?diff=163724&oldid=163685 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (-1) /* A basic program */ 23:50:34 [[Error: not a statement]] https://esolangs.org/w/index.php?diff=163725&oldid=163724 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+257) /* So how do you do anything? */ 23:59:04 [[Error: not a statement]] https://esolangs.org/w/index.php?diff=163726&oldid=163725 * Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (+23) /* Limitations */