Re: Can D simulated by H terminate normally?

On 5/5/24 1:38 PM, olcott wrote:

On 5/5/2024 11:55 AM, Richard Damon wrote:

On 5/5/24 10:28 AM, olcott wrote:

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.

>
The original spec did not prohibit it.
>

 *Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
 Does prohibit it. If you are having a hard time paying
attention to words that is not the same thing as lying.

Nope, one of my examples still works there where H just simulates every instruction it sees until it gets to the return instruction.
So, it is clear you still haven't found the the problem with my counter example.
Willing to make the promise that if I can show how to write an H as a valid C subroutine (similar to your published H) that CAN simulate the input D to a final state that you will give up your tirades here and accept defeat?

 

>
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.
>
>

>