# THE TETRADECAL, Calculated in Snap!

do you like it?
tell me if i made any mistakes on the 4-entry beaf function.

Is it deliberate that D has to be 1, 2, or 3? If I'm understanding the code correctly, higher values of D never escape the recursion.

In the A{B}C block, the final REPORT shouldn't have to check for B=0 again, because that would have been caught earlier.

Do you need all those special cases, such as {{1}} and {{2}}? Wouldn't the recursive case end up doing the same things? I suppose maybe it's faster this way.

You shouldn't need all those WARP blocks. If you just WARP the top-level function, anything it calls will be warped too.

1. the preset values (1,2,3) and the beaf reporter should make it so that if d = 4, return a{{{{c}}}}b
Edit: I've run into a problem where anything beyond d = 3 returns a value where d = 1. (not saying d = 3 returns d = 1 itself)
2. I'll fix that
3. yes {{1}} but maybe not {{2}} because {{1}} repeats a{c}a{c}... b times so it can help the {{n}} function understand what to do. It's like how i did for {1} and {2} with addition and multiplication. The whole function wouldn't have worked if i didn't put both!
4. The warp function has a limit which is about 300,000 computations /s, but adding multiple warp blocks will not change the final result.
The reason I want the warp blocks is for other people to use the other googological functions. It was just that i realized i could make tetradecal once i reached {{{n}}}.

it's inside a warp function in the actual

This is what makes the {c}, {{c}} and {{{c}}} functions work
but anything beyond d = 3 will make it equal to a{c}b instead of a{{{{c}}}}b
for example, i put {3,3,1,3} it does what i want, but goes for googological amount of time.
i put {3,3,1,4}, it does {3,3,1} or {3,3} which is 27, which i don't want.
Here's what the Googology wiki says:
BEAF Explanation
You might not be a googologist, but do you think you can help me fix the 4-entry beaf function in the reporter?

Also i updated it so that -1 does addition and 0 does multiplication, so 1 should do exponentiation like in the original BEAF.

I may be wrong about this -- I haven't studied the underlying math problem and the mutual recursions give me a headache -- but I think that you're not realizing that the ringed function in there remembers the version of the variables, and in particular D, at the point where the ring is created, not the point where it's actually invoked. That's why I think that if D>3 then it never changes through all the recursive calls.

Or am I confused?

Note that my function only goes with 4-arrays and not greater, so basically this but only with 4 arrays

maybe I made a mistake on it

Okay, I believe you. :~)