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_inversewhile 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.
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 
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.
Jump in the discussion.
No email address required.
You're using this to argue the wider point that mathematics is decidable, but even if you're right about the halting problem (you aren't) this doesn't change anything about the rest of mathematics.
The halting problem was historically significant as the first example of an undecidable problem, but it isn't the only example. To actually prove anything about mathematics, you would first need to overturn every single undecidable problem, and then come up with some new proof which shows that undeciable problems cannot exist.
You fundamentally misunderstand the idea of Turing's proof. Theorem: Something is computable iff it is computable on a Turing machine. Turing then assumes that HALTS is a turing machine, striving for a contradiction. He then reaches the same conclusion as you - that HALTS cannot be a Turing machine, which means that the halting problem is not computable. You can try to make HALTS more complex, but it will always have the fundamental issue that its truth value depends on its truth value - which is the perfect scenario to construct a paradox.
Jump in the discussion.
No email address required.
i'm telling u upfront: you can't give a credible critique until u correctly answer the oracle calls as stipulated by line numbers at the end. i appreciate ur trying to say something useful in response, but if ur not willing to put in the effort to do that... why bother?
probably all of those undecidable problem stem from not handling self-referential contexts properly.
but really... it's not my job to single handedly fix the incompleteness of mathematics, that's just stupid. it's far boarder in scope than any single individuals has expertise in. my goal at the moment is catalyze a group to do this. not here necessarily, but tbh i haven't the foggiest clue where.
bro did u get the point where i brought up begging the question? y do u think i did that?
u can't construct a paradox when then oracle makes no consistency guarantee for the non-
truevalue.why? because constructing a basic
true/falseparadox requires thatfalsevalue has meaning, and then contradicting it within the associated execution branch.but if the oracle is more intelligently defined to guarantee consistency in meaning only for the
truevalue, then it can see the falsification coming from a mile away, and just returnfalsewithout giving a shit... leaving u with nothing proven by ur paradox attempt.Jump in the discussion.
No email address required.
Because I'm a mathematician, not a programmer. My expertise is in proofs and arguments, not analysing code, so I'm much more likely to make a mistake there based purely on my own lack of knowledge in that specific area. Anyway, I disagree that analysing code is the only meaningful critique to be made - if the underlying argument is wrong then the code in support of that argument is immaterial.
None of the undecidable problems in topology or analysis listed (which are what I'm most familiar with) are to do with self-referential constructions - they're just difficult problems which can be shown to be undecidable in the general case
It's not begging the question, it's striving for a contradiction. There's a huge difference between the two, and the fact you don't realise this shows a serious lack of understanding of the nature of mathematical proofs. Begging the question involves assuming your conclusion to be true in support of your conclusion, so something like "Assuming A is true, we can show that A is true". A proof by contradiction is almost the complete opposite, and is something like "Assuming A to be true, we show that A being true necessarily leads to a contradiction. Therefore A must be false (and ¬A must be true) in order to avoid this contradiction" In this case, Turing assumes that HALTS is a Turing machine, and in doing so finds a contradiction, so concludes that HALTS cannot be a Turing machine (and so is uncomputable). This is a clear proof by contradiction, not begging the question in the slightest.
Then your oracle doesn't solve the halting problem. A program either halts or it doesn't halt, there are no other options (by the Law of the Excluded Middle). The halting problem asks if there is an algorithm that can ALWAYS decide whether a program will halt or not halt. That is, a required property of any algorithm that solves the halting problem is that it returns
trueiff the input program halts, andfalseiff the input program doesn't halt. If it doesn't meet both of these criteria, then it doesn't solve the halting problem. So while your oracle may avoid a paradox, in doing so it no longer solves the original problem.Jump in the discussion.
No email address required.
one oracle is responsible for the set of halting functions, the other oracle is responsible the set for the non-halting function. through the combination of oracles, the problem is fully decidable, as no contradiction can be possible.
it's just not shoveled through a unified interface, because it's the niave interface itself that allows the contradiction to be made.
if was multiple ways to define the answer to a question... with one being paradox-prone, and the other not... then obviously we much choose the answer not paradox prone.
it is when u use acceptance of non-computability to simply wash over the fact the niave interface doesn't fit the proper form of a mathematical function. we have no business building computability proofs, for turing machines, using an interface that doesn't guarantee mapping input to a singular output. Ur assuming the conclusion of non-computability implies other problems would exist, which is just r-slurred.
computational undecidability is not the same as "hard", that's complexity theory, which is a different issue. a problem being decidable does not make it easy, for example anything in the np-complete complexity class like prime factorization.
an undecidable problem involves answers that are somehow impossible, not just "hard". computational undecidability comes exclusively from set-classification paradoxes, where some entity is assigned some set categorization, and then that categorization is read back and abused by a computation purposefully built to defy that categorization. these can very likely be resolved by utilizing an oracles defined to make these paradoxes not possible. this would not necessarily make such decisions easy, merely possible giving some unbounded finite time.
if u accept the status quo then u must accept ur system of proofs and argument as necessarily incomplete, and possibly insufficient for understanding what i'm trying to say. in fact, i'm almost sure they are because godel used self-reference to claim mathematics is incomplete, and it is self-reference based limitations that i'm trying to address.
therefore i will reiterate: i cannot at present convey the innovation i'm trying to open up through raw proofs/arguments alone. comprehending the code is necessary to see how self-reference can be handled in a more complete and consistent manner. this is not production code my dude, we're talking like 13 lines of pseudo-code. it's meant for u to work out how we take a complex undecidable situation and turn it into something we can make a decision on.
Jump in the discussion.
No email address required.
Ok, I actually read your code and it took like two seconds to find the problem. I seriously can't believe you even wrote this without immediately seeing the issue.
How the fuck do you know whether m will or will not halt after a true prediction??? Did you just completely forget that this is in fact the problem you're trying to solve? Your algorithm for deciding the halting problem literally assumes that you already have a solution for it. Retard.
Jump in the discussion.
No email address required.
i'm not giving an algorithm to do halting analysis. that is has already been solved other than the undecidable cases, so it's not actually novel or interesting.
this post is on how to take an undecidable paradox and turn it into a decidable situation, which is actually novel and interesting.
answers to oracle calls listed by line numbers please
Jump in the discussion.
No email address required.
So your algorithm only works when the input is decidable, not in the general case. Which means your "solution" is totally irrelevant to the general halting problem.
You've found a complicated way of running an algorithm that already exists, and you think it makes you smarter than a century of mathematicians and computer scientists. In reality you're an r-slur that can't even understand the idea of a proof by contradiction, but you think you're smart because you can write novels of pseudo-intellectual nonsense and dunk on dramar-slurs for not understanding it perfectly.
Jump in the discussion.
No email address required.
just keep yourself safe for being so r-slurred.
u didn't deserve to read this post in the first place, u had nothing to offer me.
ur education is nothing more than raw regurgitation, u lack any innovative insight.
literally will be replaced by ai
Jump in the discussion.
No email address required.
More options
Context
and
cause ur literally incapable of being anything more than a dribbling r-slur until u post correct answers.
Jump in the discussion.
No email address required.
More options
Context
More options
Context
More options
Context
More options
Context
More options
Context
More options
Context
More options
Context
More options
Context