So, it's been a while, hasn't it? I'm 23 now, life has ended up kinda strange overall.
I recently stumbled on some notes I wrote in 2017 regarding some idea I had at the time – it was a kind of number where every number corresponds to a function across all the numbers of that type. It got quite wild and twisted, and I suspect that eventually it would've collapsed into weird paradoxes, but I never reached that point. Anyway, that inspired me to re-read Saibian's book again and before I knew it I was scribbling out new thoughts.
I guess, I left originally because I lost interest because Distortion-F didn't work out. I solved a heap of weird problems with it and came up with lots of cool stuff but, in the end, even more problems showed up. Distortion-F just kept hitting weird anomalies there nothing made sense, and there was no end in sight.
Part of it might've been arrogance, I guess – everything about Ultra-F was trying to one-up the guy who inspired me and his Hyper-E. I thought I could outdo Extended Cascading-E by nesting Ultra-F into itself. I imagined, taking some function f(X) to get some expression. Then, I imagined taking f(ω) to get some crazy ordinal which looks similar to the expression in X. Then, I could turn that ordinal into an unfathomably more complex and powerful function in X. That's the principle underpinning Distortion-F. A single step of that operation of that took me from the modest Awesome Varbleth (≈ Gugold in Hyper-E) to my ultimate googologism Endrallhyiighghsze (≈ Tethratope-by-hyperion in Hyper-E). If I could get it to work, I could jump way way way up all at once to something crazy powerful.
Another part of the reason is that Ultra-F is messy. My first attempt was the W function, which has neither neatness nor power nor simplicity nor expressibility. It was me playing with numbers. Not great mathematics, but it was a really important first step and I learned a lot. Then, there was PRBN, which prioiritised neatness – it was designed to agree with BEAF up to some point, although it was a lot weaker. In a way, I wanted to understand BEAF better, because it was kind of dark magic to me -- its linear arrays reached ω^ω while I could only ever get mine to reach ω^2 at best. Curiously, I /was/ able to nest PRBN into itself in a way, despite the fact that it wasn't really designed for it, and while that was fairly effective it was still very, very much weaker than I would've liked. For whatever I was doing, nesting it into itself didn't have the same effect for my weak notation that it would have for something like Hyper-E or BEAF.
A notation being "neat" versus "messy" is kind of subjective to some extent. It's fuzzy. Something like BEAF or Hyper-E or PRBN, you could probably consider "neat". Saibian was very zealous about ensuring his notation never had any "offsets" of +1 or -2 or -1 compared with BEAF, but, really, I don't think that has much of an effect on "neatness". In a way, a notation where a{c-2}b is a landmark googologism is not really any messier than one where a{c}b is one, because you could just use that as your standard and the rest of your system would continue to make just as much sense. The offset wouldn't ruin everything. On the other hand, Ultra-F is undeniably "messy", because its offsets and weirdness permeates to every level of the system. It often doesn't even have clean expressions for itself in terms of itself.
For Ultra-F, I wanted power and simplicity over all else, so I consciously sacrificed neatness. I also wanted it to /look cool/ -- I didn't want to create yet another generic-looking array notaiton which is barely distinguishable from all the others. I think I succeeded at that – it was the first time I was able to make something which kept pace with the early stages of BEAF and Hyper-E.
Problem was, once I reached Distortion-F, I didn't have the neatness I needed, so I kind of had to invent a parallel "clean" version of Ultra-F in an ad-hoc manner.
The other problem might be expressibility – on the journey from what I knew and understood in the earlier, fully-functional versions of Ultra-F upwards to glory, some of the subtly complex forms I encountered along the way didn't fit into the crude language of Distortion-F. With my invention of the "reformattor", I made Distortion-F kinda work for objects above F*3, probably up to F*n. After that, though, one runs into F*⊙ which, like, doesn't mean anything.
What can be done to achieve the power I imagined? I don't think I can salvage Distortion-F, it would need to be redesigned from the ground up, it's not built to take the nesting thingy.
What would it take to be capable of supporting the nesting thingy? Clearly, PRBN did, but it was /weak/ – even the best I could do with the nested form of PRBN could be defeated by the humble Scytronium from Ultra-F. Thus, if we have a really simple system which isn't capable of much to begin with, then, nesting it is relatively easy but yields smallish gains. To nest something on the same power level of BEAF or Hyper-E or Ultra-F is way, way, way harder and would be spectacularly more powerful.
Saibian briefly acknowledged the nesting thingy but never seemed to sincerely pursue it, instead seeking to progress Hyper-E into basically BEAF except with hyperions. I never liked that approach. Even if you can find a way to formalise the super-powerful levels of BEAF and even if you can somehow find a way to put hyperions into that without it breaking, then, congratulations, you've turned Hyper-E into a weak extension of BEAF.
I think expressibility is really important – one needs to be able to write down every step on the way from some insane megastructure, equivalent to some nutty ordinal, all the way down to the simplest building blocks of the notation and then to the final answer. Not only would it need to decompose nicely from the top to the bottom, it would need to be able to build nicely from the bottom to the top. One would have to design such a notation to do the nesting thing right from the early stages – if I were doing such a thing with Ultra-F, I'd start describing F-structures using the notation itself as early as multiplication. And it would need to continue to work all the way up. It would need to be able to express very general and abstract operations requiring many parameters as easily as it expresses unary operations. Is that even possible? Ideally, you'd want there to be some general principles guiding the whole thing. Is /that/ even possible? Consider the repeated ordinal tetration problem – you can build smoothly to F^^F and then to (F^^F)^^F and ((F^^F)^^F)^^F and so on, but unless you add some new rules you'll never get to F^^(F+1) or F^^(F*2). I ended up running with the Chris Bird convention and taking F^^(F*2) = (F^^F)^^F, which was already known to be suboptimal back then but I decided it didn't matter because I thought it would all even out in the long run once I got Distortion-F up and running to its full potential, which, of course, I never did. You've got Saibian's climbing method as a better solution, which I could never quite understand, at least not well enough to replicate for myself. Furthermore, both of them need some new rule added to everything that's come before. You need to add a special case for that kind of operation, it doesn't arise out of any greater principle which explains it and unifies it with everything else. It sucks. It's so murky and inelegant, but I think there's probably no way around it. Maybe it's possible to add a new rule which subsumes that weird rule and the existing rules in a way which isn't hopelessly weak, but I have no idea.
When I started to once again jot down ideas, I figured, let's have the level of operation be measured in terms of some structure thingy equivalent to an ordinal, then apply that to some argument. The goal, then, is to have both the operation and the argument be whatever structure thingies we want. But, wait, that's not expressible enough, better let the operation take two arguments. Also, hey, let's add a third argument to count how many times the operation gets applied to the two arguments, because, looking at Hyper-E, it makes sense: Hyper-E started with the nice simple concept of "base, determinant, replicator". Now, we need the replicator to be able to take a value that's a wacky structure thingy as well. Operation level and one argument clearly isn't enough, but maybe operation level, base, determinant and replicator might be? At this point I have the sinking feeling that I'm probably going to need an arbitrarily large number of arguments to attain the expressibility I'll need, and even that might not be enough. Of course, every single argument we come up with will probably need to eventually take ordinal-equivalent structure thingies, each one as crazy as I like, as values, if we wish to nest the notation!
I've started to scribble down this thing I call the "four-sided zeta-heart" system, which works on the "operation level, base, determinant, replicator" idea. I'm really not feeling hopeful, though.
Surely, somebody out there has had to have solved a similar problem with nesting things by now? I plan on putting some more effort into it, but I think it might be too hard for me.