Re: Can D simulated by H terminate normally?

On 5/6/24 12:02 PM, olcott wrote:

On 5/6/2024 10:05 AM, Mikko wrote:

On 2024-05-05 14:28:42 +0000, olcott said:
>

On 5/5/2024 3:01 AM, Mikko wrote:

On 2024-05-04 13:49:24 +0000, olcott said:
>

On 5/4/2024 4:23 AM, Mikko wrote:

On 2024-05-03 12:36:55 +0000, olcott said:
>

On 5/2/2024 8:48 PM, Richard Damon wrote:

On 5/2/24 10:50 AM, olcott wrote:

On 5/2/2024 4:16 AM, Mikko wrote:

On 2024-05-02 03:22:29 +0000, olcott said:
>

When I had to make changes to Bank's the VISA credit card system
I had to re-read the VISA change document fifteen times before
I was confident that I understood every relevant detail.

>
It's only because there was no detail that you could not accept.
Had there been one you could have stopped reading as soon you
found it, perhaps even before reading first time to the end.
>

>
It was because 99% of the details did not apply to my system
that I had to carefully study all of the details to see which
ones applied.

>
Because your system doesn't meet the basic requirement of the problem.
>

>

Likewise with your proofs: as soon as one error is found there
is no need to read further in order to determine that the proof
is erroneous.
>

>
There is no error in this and it is a verified fact not requiring
any subjective judgement call:
>
(a) It is a verified fact that D(D) simulated by H cannot
possibly reach past line 03 of D(D) simulated by H whether H
aborts its simulation or not.
>

>
Proven wrong, and you have FAILED to even attempt to rebut that proof, thus you have accepted that your claim is baseless and are just being a pathological liar by repeating it.
>

>
00 int H(ptr x, ptr x)  // ptr is pointer to int function
01 int D(ptr x)
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 void main()
10 {
11   H(D,D);
12 }
>
Post the exact time date stamp and quote where you proved it wrong.
>
In one case it is ridiculous nonsense that you proved (a) is wrong.
You must show a counter example where 1 to N steps of D(D) are
simulated by H and the simulated D(D) reaches past its own line 03.
>
You are ahead of Mikko he has no idea what D(D) simulated by H means.

>
I certainly have, nore than you. One posiible interpretation is
'the direct execution of the same D as H was simulationg with the
same D as input' but there are other possibilities. But one can
also say that H may simulate any program with any input so "simulated
by H" can be anything.

>
<sarcasm>
Sure D simulated by H might mean play a game of tic-tac-toe
and then get into an infinite loop
</sarcasm>

>
No, you have restricted D to mean constructed with the pattern above.
There is no place for a game of tic-tac-toe unless H plays it. The
infinite loop is there, so going there is no problem.
>

Richard "interpreted"
*D simulated by H* to mean
*D NEVER simulated by H*

>
No, he interpreted it to mean 'simulation some finite number of steps
(possibly zero) by H of the execution of D'. That is not his usual
interpretation.

>
The spec did not allow for zero steps.

>
Irrelevant. We were not discussiong spec but your claim about Richard.
>

 My claim to Richard
 *Every D simulated by H that cannot*
*possibly stop running unless aborted by H*
 Cannot be correctly interpreted as
*Any D NEVER simulated by H*
 The only way to get that interpretation
is gross negligence or dishonesty.
 *It is looking a lot like more gross negligence now*
 On 5/1/2024 7:28 PM, Richard Damon wrote:
 > On 5/1/24 11:51 AM, olcott wrote:
 >> *I HAVE SAID THIS AT LEAST 10,000 TIMES NOW*
 >> Every D simulated by H that cannot possibly stop running unless
 >> aborted by H does specify non-terminating behavior to H. When
 >> H aborts this simulation that does not count as D halting.
 >
 > Which is just meaningless gobbledygook by your definitions.
 >
 > It means that
 >
 > int H(ptr m, ptr d) {
 > return 0;
 > }
 >
 > is always correct, because THAT H can not possible simulate
 > the input to the end before it aborts it, and that H is all
 > that that H can be, or it isn't THAT H.
  

Which just shows that you don't understand what you are talking about.
First, the above program isn't refuting that H can't simualte past the line 3, but that by your current stated definition in that statement, if your H is correct in saying D(D) is non-halting, by the same basic logic and different machine sets (since the statement doesn't restrict what H can be other than a simulating termination analyzer) we can make a machihne that must be considered CORRECT in deciding most inputs. If you want to define that it must do at least 1 step of simulation to be a simulator, then a few must be found halting.
In a DIFFERENT proof, I showed that you claim that you can't make an infinite set of some H that simulate 1 to an infinte number of steps of the D(D) that calls that H to reach the end is incorrect.
I can make a simple version of H that will simulate that D to its end.
Thus, your claim is invalid.