Warning: mysqli::__construct(): (HY000/1203): User howardkn already has more than 'max_user_connections' active connections in D:\Inetpub\vhosts\howardknight.net\al.howardknight.net\includes\artfuncs.php on line 21
Failed to connect to MySQL: (1203) User howardkn already has more than 'max_user_connections' active connectionsPath: ...!weretis.net!feeder9.news.weretis.net!i2pn.org!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon
Newsgroups: comp.theory,sci.logic
Subject: Re: Can D simulated by H terminate normally?
Date: Sat, 18 May 2024 09:11:56 -0400
Organization: i2pn2 (i2pn.org)
Message-ID:
References:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Sat, 18 May 2024 13:11:56 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1471737"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To:
X-Spam-Checker-Version: SpamAssassin 4.0.0
Bytes: 6253
Lines: 100
On 5/1/24 8:10 PM, Richard Damon wrote:
> But you refuse to listen.
>
> Remember, YOU are the one saying you are needing to change the
> definition from the classical theory, where we have things well defined.
>
> YOU have decider that H is just whatever C code you want to write for
> it, and D is the input proved. (which doesn't actually match the Linz or
> Sipser proof, but fairly close).
>
> With THAT set of definitions we have a lot of options that break your
> incorrectly assumed results.
>
> The first method has been discussed here by Flibble. While the final
> answer he got to doesn't fit the requirements, the first part of the
> method DOES show that it is possible for an H to simulate to past line 3.
>
> THe basic idea is that if H(M,d) finds that its simulation of M(d) get
> to a call to H(M,d) then rather that your idea of just saying it will
> get stuck and declair the input invalid, since there ARE a number of
> possible inputs that there is a "correct" answer that H can give to
> match the behavior of the direct execution of M(d), what H does is fork
> its simulation into two threads.
>
> Thread 1 continues the simulation assuming that the call to H(M,d) will
> return a 1, and if that simulation reaches a halting state, then 1 is
> the answer, and thread 2 can be abandoned.
>
> Thread 2 continues the simulation assuming that the call to H(M,d) will
> return a 0, and if that simulation reaches a provable non-halting
> pattern, then 0 is the answer, and thread 1 can be abandoned.
>
> It may be the case that BOTH answer could be correct, in which case
> depending on exactly how the forking works and how long it takes each to
> get to the answer, either answer might be given, but then, both are
> correct.
>
> It may be the case that neither answer can be shown correct, if Thread
> one can prove that it will be non-halting and Thread 2 halts, then the
> decider has proven the machine to be "contrary" to it. But it might be
> the case that it never can figure that out, and it just doesn't answer.
>
> But, in all cases, it gets past the call to H(M,d), so your criteria,
> that NO H can get there is not meet.
>
>
> The second method uses the fact that you have not restricted what H is
> allowed to do, and thus H can remember that it is simulating, and if a
> call to H shows that it is currently doing a simulation, just
> immediately return 0. Thus, H can actually correct simulate the
> instruction at the call to H, as they will execute just a few
> instructions testing that condition and returning, and thus not run into
> the problem you ran into where H just couldn't simulate itself because
> it got bogged down.
>
> In this case it is actually true that the direct execution of D(D)
> differs from the correct simulation of the input by H, as H is no longer
> a "Computation" per the rules of Computation Theory, but you have
> admitted that you are abandoning those, so it doesn't matter (of course
> that make trying to get your results to apply to something similar
> harder, but that is why you need to try to come up with some actual
> definitons.)
>
> So, by the rules of Compuation Theory, your H is not correct, but by
> your lack of rules, your conclusion that H can not simulate past the
> call are incorrect, so you proof is also broken.
>
above is the part of the message where I proved your claim wrong.
Note in particular, the second method.
H just begins with the code:
int H(ptr x, ptr y) {
static int flag = 0;
if (flag) return 0;
flag = 1
/* rest of H as is, but disabling the skipping of the simulation of H
itself */
}
Note, This makes H not a "pure function" but that was explicitly NOT a
requirement of you claim, only that no C function "H" could simulated
the provided D past its call to H.
This H does, and because your structure explicitly puts H in the same
execution context as D, they share that static value of flag, so the D
call sees the flag as 1 and thus it returns immediately, and then D will
reach its end state,
Thus, your claim that this is categorically impossible is disproven, and
you are proven to not have sufficent understanding of the semantics of
the C programing language, and that you habitually claim as obviously or
self-evident truth things that are not, so any such statement from you
is likely a LIE.