how turing was wrong: part 2

aight u tardfuckles, the last showing on this was absolutely fucking pathetic. 99% of the response was dramaslop barely recognizable as conscious thought, congrats on again demonstrating ur truly the planet's biggest collection of retards: . i especially want to call out the absolute who not-so-cleverly thot he'd dig thru my latest reddit account looking for dirt cause he's just that mad all of this way went so far over his head i'm basically on fucking mars by comparison . that's right: be mad i actually hit that literal bleeding edge where no human has thot before, ur tears of shame and jealously crying about i said this mean thing or that mean thing ... brings me endless amusement.

to recap the last post, in an obviously futile attempt to bring u up to speed: no one needed to deboonk the halting oracle. turing was wrong that his diagonal inverse could be a fully computable number, as it would then need to enumerate over itself and give it's own n-th inverse, which doesn't fucking exist, cause it's not a real goddamn number!

to respond to slop spouted in critique: i don't care that you think u can run the program to compute the inverse, that's total delusion. either you:

• (a) iterate over ur running program and yourself trying to find the inverse of an inverse which still doesn't actually exist, or
• (b) more likely you think u can run diagonal_inverse while ignoring ur own program, failing to realize u are actually just lying about the fucking program ur running cause it never actually provides the n-th inverse to itself, a number u keep pathetically clinging to as computable, but then don't actually treat like an actual computable number!

either way is total batshit nonsense, so the diagonalization argument is deader than ur mom's trussy after last night.

now, if u were actually worth literally anything at all, the next concern you'd have is: so what happens now to the halting problem, given it's motivation was deeply flawed? wow, great fking question, i'm just getting to that

^{we'll just ignore the fact u were too stupid to actually ask. at least u stopped raiding the cat litter this time around}

let's consider the basic bitch version of the halting paradox:

we have a naïve haling oracle: hALtS(m) -> {true iff m halts, false iff otherwise}

and the disproof function: paradox = () -> hALtS(paradox) && loop_forever()

such that paradox is not only uncomputable, but unclassifiable into either the set of functions that halts or the set that does not... which should be strictly opposing sets that all functions can be classified into. ignoring any ability to compute anything at all, merely returning a consistent mapping here gets fucked up, as the program has the singular purpose to defy it's classification. predicting and returning false in hALtS(paradox) clearly causes it to immediately halt, while predicting true causes it to loop_forever(). a god descending from the heavens to save ur unworthy soul from indefinite fallacy, couldn't define a consistent mapping for this fellatious crap...

now the traditional view here is to undergo celebratory jerking urself off on how mindblowingly amazing it is that we're too fucking retarded as a species to rationalize out a one line self-referential function ... wipe that cum off ur face bro, we can do better. or at least i can, i have -∞ expectations that even just one of u is truly capable beyond regurgitation mathematical norms

(I) the first key realization is that we can quite easily detect if this is happening.

this quite obviously must be true for anyone to accept turing's proof in the first place, but i'll give a more explicit explanation for how to do so algorithmically:

subbing true in for hALtS(paradox) gives us:

paradox_t = () -> true && loop_forever(), leaving hALtS(paradox_t) as clearly and consistently false

subbing false in for hALtS(paradox):

paradox_f = () -> false && loop_forever(), leaving hALtS(paradox_f) as clearly and consistently true

neither the halting result of paradox_t or paradox_f match the associated subbed in value, so therefore this forms a halting paradox. with this simple algorithm demonstrated, it's quite definitely possible for the oracle to figure it's about to get fucked by malicious user input. clearly we need to do something about dramatards trying to fuck over general decidability.

(II) we can upgrade the oracle and response to be context-aware

instead of just dumbly returning the objective mapping everywhere like an absolute moron waiting to get paradoxed out of existence- we can take into consideration the specific call site of the oracle, by utilizing basic stack analysis of where the call into the oracle came from. it will return true if and only if a true prediction remains consistent with the execution that follows. otherwise false is returned, with all other considerations ignored:

halts = (m) -> {true iff m halts && m will halt after true prediction, false iff otherwise}

if we go back to our basic paradox with our improved oracle:

paradox = () -> halts(paradox) && loop_forever()

with algorithm (I) halts can recognize the self-referential paradox, and with fix (II), because it knows returning 'true' in this location leads to 'loop_forever()', it simply escapes this by returning false. this will cause paradox to immediately halt. but muh false consistency... shut up we'll get to that.

let's first contrast this by looking at analysis done from the outside:

main = () -> print halts(paradox), running machine main() will print true, because halts can figure out that within machine paradox() it will be forced to return false, causing a halt.

great! our previously uncomputable, unclassifiable, paradoxical function breaking not only computability, decidability in general, but probably more fundamentally mathematical completeness itself... has been beaten into submission and become decidable thru a rather simple interface tweak. not only does our oracle function avoid logical implosion under paradoxical conditions, it operates in a way that allows us to coherently map paradox into the set of functions that halts. decision achieved!

but muh false consistency... ok, ok. the astute among you (none) would point out there we only have consistency/completeness guarantees for the true prediction. a false return may still halt, or not, it's not actually a specific prediction either way, it's just not a true prediction that can remain true after being returned. it can either be a false prediction or a true prediction that would falsify itself after being returned.

(III) add a second oracle loops for granting completeness/consistency of nonterminating behavior.

loops = (m) -> {true iff m does not halt && m will not halt after true prediction, false iff otherwise}

this binary pair grants us consistency/completeness for the binary decision problem of halting. hilbert's rolling around in his grave excited about generalizing this to the entscheidungsproblem

"why not use a third return instead?" some degenerate asks. cause that's fucking retarded, actually:

• (1) it over complicates things.
• (2) you still need to respond to the context, doesn't avoid that.
• (3) it suffers from a problem that everyone's been too mindfucked to realize: nondeterminism.

consider this function:

cute_and_valid = () -> !hAlTs(cute_and_valid) && loop_forever()

now i ask you: does cute_and_valid halt or not?!

the answer: halt, not, and/or both depending however it's assigned. somehow you still got that wrong , but this hi-lights a major issue with both the 3-way return, and the naive oracle: certain functions can be mapped to both the set of functions that halts and the set of functions that does not. it does not follow the basic binary definition in that the set of functions which halts is exactly opposite to those which do not. this does not describe the interface to a valid turing machine, as this does not even describe that for a valid mathematical function, of which a turing machine is supposed to be a practical incarnation. a mathematical function must map an input to only one output, otherwise it's a relation, not a function. a turing machine cannot represent a relation, as a turing machine must be deterministic. it would take a non-deterministic turing machine to compute a relation, and we're not particularly interested in those for the most part

i can hear it now: bUt DoEsN'T Ur OraClE rEtuRn DIfEreNtLy For THe sAmE iNPuT?!?! ... no, it doesn't. a key innovation here is recognizing that the context of the function call is an implicit input into the function call itself, that's just gone ignored until now. the niave oracle is nondeterministic for even the same callsite, whereas the context aware function always returns the same for the same context.

>You're plumbing the depths of what Anal Touring discovered, shake your head in disbelief, and somehow conclude that he was wrong to declare that HALTS is uncomputable

look you absolute fucking waste of oxygen, the premise of the fucking proof is starting out with presuming hAlTs can describe a turing machine:

  (1) assume a machine exists with interface `hAlTs` exists
  (2) let us define `paradox`
  (3) `hAlTs` is uncomputable

turing fucked up at step (1) one. actually he fucked up before step (1) one. as before hAlTs can be assumed to describe that of a turing machine, it would need to be able to fit the form of a function. it does not do this, meaning the premise is invalid, and therefore the conclusion that hAlTs is uncomputable is not a valid conclusion. you can't just assume the conclusion is valid and just fucking accept a premise that wasn't even valid in the first place, that's begging the question you moron. the absolute systemic lack of basic logic is festering at LITERALLY ALL FUCKING LAYERS OF SOCIETY

now in ur infinite idiocracy, you may think u could just give the oracle a slight preference to one or the other return, failing to realize this just creates a new problem: now you have two slightly different oracles giving slightly different answers to creating the mapping: which one is the right one? neither, they both suck. two slightly different mappings, and yet both uncomputable, is a fucking terrible solution.

with the binary oracles, each only having responsibility for consistency of the true prediction, not only does each one have a natural preference for true, there is no misalignment in the objective mappings ultimately created, this respond exactly opposite, in all cases. this includes the less interesting objective case, and the more interesting subjective self-referential case:

paradox = () -> halts(paradox) && loop_forever() - halts returns false, branch not taken

paradox = () -> loops(paradox) && loop_forever() - loops returns true, branch taken

paradoxically, due to the context aware response prioritizing true consistency if possible, notting the oracle changes it's response, but not program behavior:

paradox = () -> !halts(paradox) && loop_forever() - halts returns true, branch not taken

paradox = () -> !loops(paradox) && loop_forever() - loops returns false, branch taken

before you attempt to post that catshit from earlier, that i know ur itching to barf up at me, ur gunna need work through what i'm getting at with this more complex example:

 0 // implementation assumed, set of possible returns denoted instead
 1 halts = (m: function) -> {
 2   true: iff (m halts && m will halt after true prediction),
 3   false: iff otherwise,
 4 }
 5
 6 // implementation assumed, set of possible returns denoted instead
 7 loops = (m: function) -> {
 8   true: iff (m loops && m will loop after true prediction),
 9   false: iff otherwise,
10 }
11
12 paradox = () -> {
13   if ( halts(paradox) || loops(paradox) ) {
14     if ( halts(paradox) )              
15       loop_forever()
16     else if ( loops(paradox) )          
17       return
18     else
19       loop_forever()
20   }
21 }
22
23 main = () -> {
24   print loops(paradox)
25   print halts(paradox)
26 }

correctly identifying the return values for all the oracle calls is a bare minimum for being capable of more than dramaslop in ur response. if ur not willing to to do that, like i said in my previous post: there's a window, go jump out of it, i hope u die.

• L16 - loops(paradox)
• L14 - halts(paradox)
• L13 - loops(paradox)
• L13 - halts(paradox)
• L24 - loops(paradox)
• L25 - halts(paradox)

so far only an LLM has gotten all of these correct

!codecels !mathematics

lastly before i forget: yes the basic bitch version of the paradox isn't the exact same algo turing used in his proof... but it's directly analogous. u can't even handle what i've already dumped here, so posting more is useless.