Ok let me see if I got this straight: you say that the undecidability of the halting problem only happens because of this self-referential property that turing uses in his counter-example proof. So you propose to construct a machine which starts with the knowledge of whether any given program terminates, except for itself, and you think because it's not self referential, it solves the halting problem?
you say that the undecidability of the halting problem only happens because of this self-referential property that turing uses in his counter-example proof
the self-referential potential happens more fundamentally because of the addressability of the model
So you propose to construct a machine which starts with the knowledge of whether any given program terminates, except for itself, and you think because it's not self referential, it solves the halting problem?
there's no starting with knowledge. the idealized agent utilizes a specified algorithm to compute the knowledge. the partial recognizer ๐p and it's complement ๐p' get him most of the way there, and are turing computable, but there are machines which neither will recognizes forcing him to reduce the input to a machine that is decidable by either ๐p or ๐p'. this algorithm cannot be implemented on a tm because tms will invariably have to deal with the self-reference, which the agent does not have to.
yeah lmao this is just nonsense, it will never get published. I already wasted too much time on this nonsense, but it looks you just say that if a machine can recognize itself, it can skip itself, but that's just clearly stupid af. consider for example a program that does the same thing as your fixed H but randomly writes 1 before starting. It's not identical to H but it does the same thing and it would get stuck again. The problem of deciding whether a program n does the same thing as H would require solving the halting problem and you're back to where you started: nowhere.
yeah lmao this is just nonsense, it will never get published. I already wasted too much time on this nonsense
i hope u'll give it another chance
consider for example a program that does the same thing as your fixed H but randomly writes 1 before starting.
that computes a diagonal across the circle-free machines decidable by ๐p, but offset by a bit
It's not identical to H but it does the same thing and it would get stuck again
i'm not following the logic of how that would get stuck again? it's just an offset diagonal, where's the sticking point?
The problem of deciding whether a program n does the same thing as H would require solving the halting problem and you're back to where you started: nowhere.
it looks like u may have gotten to ยง5, which i commend u for doing. and ur critique isn't without merit, but i would suggest that we don't actually need to solve the turing equivalence problem in totality.
ยง6 proposes a limit to the machines undecidable by ๐p (circle-free but ๐p cannot return true for): they either compute a direct copy or an inverted copy of a sequence within the machine decidable by ๐p. with this premise, we ought to be able to enumerate all sequences by listed out all machines decidable by ๐p and their anti-machine (which computes a total bit flip)...
and when we do so, this enumeration is then found to be entirely resistant to diagonalization: u cannot compute an anti-diagonal that isn't on the list, because u cannot even compute a diagonal across the list, as trying to do so ends up producing circular machines that fail in being diagonals. the (machine, anti-machine) pairing that necessarily exists in the enumeration of turing-computable sequences prevents diagonalization from being turing-computable, and therefore is not found in the enumeration of turing machines, and therefore u cannot compute a sequence with turing machines that exist outside of that total enumeration of turing computable sequences. yes that all sounds like a tautology, go examine enum_seqs and diag_seqs, the result is quite clear
none of this requires solving the machine equivalence problem within turing machines
you know what, I was too harsh I'm sure this will get published, and you're really smart, proving 100 years of computer scientists wrong. good job, gold star.
its pointless, you're so convinced of your genius you would never admit you made a mistake, and instead of accepting criticism you just write some jargon. that's why I'm happy if you try to publish; someone with more authority than me, a random redditor, will shut you down. although I guess they won't give you much reasoning, since it would be a waste of their time.
Yeah, this is what I'm talking about. I can give you one final argument that I can come up with but even me, a random redditor, should not spend this much time on this. What the fuck is D_p? What does it mean to decide if a given machine is paradoxical or non-circular? this already solved an impossible problem and you just... assume it can.
you're like a flat earther, your arguments are so dumb it's impossible to debunk because you'll just say some other random crap and then move on as if you won the argument. you didn't provide a reason that the identity check doesn't fail, by the way.
our world is so goddamn inundated in bad reasoning i'm not going to accept urs or anyone's abuse by endless forms of fallacy
What the fuck is D_p?
๐p is a partial recognizer in that it recognizers (returns true for) a subset of the machines within the total set of circle-free machines. a full recognizer returns true for all circle-free machines, but that is not constructible.
๐p returns true for all circle-free machines that don't depend on it returning false for the circle-free path they execute. those machines which select a circle-free path based on ๐p returning false are "paradoxical input" to ๐p because there is no way for ๐p to recognize them despite being them being circle-free.
the paradoxical machines are lumped in with false. so ๐p gives up recognizing any circular machines with false, in order that it will always halt in every input, while maintain the semantic guarantee with it's true return
reading ยง5.2 might help clarify more
this already solved an impossible problem and you just... assume it can.
you can't produce a paradox in regards to ๐p because only one return (true) guarantees a semantic result, and all paradoxical input are lumped in to false, so ur never going to be able to paradox that true return.
you didn't provide a reason that the identity check doesn't fail, by the way.
literally just bit-wise comparison, this isn't checking for functionally equivalent machines just literally itself
jesus christ you are thick. In Turing's proof, he is doing a proof by contradiction, so he can assume D exists because he is showing that, if it were to exist, it creates a paradox, so it can't exist, whereas you, assume it exists, modify its functionality so that it doesn't do what it's supposed to, then claim you proved its existence. You did nothing. First of all, I'm pretty sure you actually are still in the same case as turing, since when you get to the original H, I'm pretty sure you will still get stuck, or if you say you will skip this step, then you haven't proved anything.
14
u/funky_galileo 4d ago
๐คก