Re: D correctly simulated by H proved for THREE YEARS --- losing a defamation case

On 6/9/24 11:21 PM, olcott wrote:

On 6/9/2024 10:09 PM, Richard Damon wrote:

On 6/9/24 10:53 PM, olcott wrote:

On 6/9/2024 9:45 PM, Richard Damon wrote:

On 6/9/24 10:39 PM, olcott wrote:

On 6/9/2024 9:16 PM, Richard Damon wrote:

On 6/9/24 9:48 PM, olcott wrote:

On 6/9/2024 8:36 PM, Richard Damon wrote:

On 6/9/24 9:23 PM, olcott wrote:

On 6/9/2024 8:10 PM, Richard Damon wrote:

On 6/9/24 8:56 PM, olcott wrote:

On 6/9/2024 7:41 PM, Richard Damon wrote:

On 6/9/24 8:26 PM, olcott wrote:

On 6/9/2024 7:23 PM, Richard Damon wrote:

On 6/9/24 8:02 PM, olcott wrote:

On 6/9/2024 2:13 PM, joes wrote:

Am Sun, 09 Jun 2024 13:23:04 -0500 schrieb olcott:

On 6/9/2024 12:59 PM, joes wrote:

Am Sun, 09 Jun 2024 11:07:19 -0500 schrieb olcott:

typedef void (*ptr)(); // pointer to void function 01 void HHH(ptr
P, ptr I)
02   {
03     P(I);
04     return;
05   }
06 07   void DDD(int (*x)())
08   {
09     HHH(x, x);
10     return;
11   }
12 13   int main()
14   {
15     HHH(DDD,DDD);
16   }
17

>

In the above Neither DDD nor HHH ever reach their own return statement
thus never halt.
Most of my reviewers incorrectly believe that when HH(DD,DD) aborts
its simulated input that this simulated input halts.

>
You chopped out the mandatory prerequisite.
Please go back and prove that you understand what infinite recursion is
before proceeding.

Dude, I've got nothing to prove to you.

>
OK then we are done talking.
>

You instead could explain how you
can call a simulation that differs from the direct execution "correct".
Or why H and HH are different.
>

>
I could but you refuse to go through the steps of the proof,
one-at-a-time with mutual agreement at each step.
>
I am not going to tolerate circular head games that never
result in any mutual agreement.
>

>
I.E. Someone else is calling you out on your incorrect logic, so you are threatening to take your ball and go home.,
>

>
We must go through the steps one-at-a-time and have mutual agreement
on each step to eliminate miscommunication intentional or otherwise.
>

>
So, when someone questions what you mean by something, you need to clearify the meaning of it.
>

>
When someone "questions what you mean by something"
by calling me a liar they may go to actual Hell.
>

>
I only call you after you repeat the same basic lie several times after being corrected.
>
That is a valid definition of a Liar, and you fit.
>

>
THIS IS AN OFFICIAL CEASE AND DESIST NOTIFICATION.
STOP CALLING ME A LIAR.
>
>

>
Then stop Lying!
>

>
*I never have lied and you know it*

>
Another Lie. (Read the message you trimed)
>

*THAT YOU REFUSE TO EVEN POINT OUT ANY 100% SPECIFIC MISTAKE*

>
Another Lie. (Read the messsage you trimed)
>

*AND PERSIST IN CALLING ME A LIAR AFTER A CEASE-AND-DESIST ORDER*
*WINS DEFAMATION CASES*

>
Nope, since my words are correct, you have no case.
>
Do you REALLY want to have to testify on the stand before a jury of "normal" people and try to explain your idea to them and convince tem that you are telling the truth.
>
Think you could stand the counter claims?
>

>
*I have proved that D is correctly simulated by H FOR THREE YEARS*

>
Nope, Never *PROVEN*
>
And not by the right defintion of "Correctly SImulated" to claim not-halting.
>

*I have proved that D is correctly simulated by H FOR THREE YEARS*
*I have proved that D is correctly simulated by H FOR THREE YEARS*
>
That D is correctly simulated by H is proved by the fact that
the x86 source-code of D exactly matches the two execution
traces that I provided. *It is much easier to see in Google Groups*

>
Nope, remember, you still havn't correctly simulated the call H instruction, and have instructions listed that were never actual gotten to again.
>

>
I think that found the spot in the source-code to insert the
display of the simulated lines of H simulated by H. This
might only be 100 pages of output.

>
So do it. And then provide an analysis where you show how you PROVE your statement. (And be clear exactly what statement you are claiming to prove)
>

Perhaps you have always been hiding your lack of sufficient
technical competence?
>
https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ
This has ALWAYS proved that D is correctly simulated by H.

>
Nope, Since D(D) Halts, the answer of 0 is NOT correct, and H has NOT proven that no such simulation can halt.
>

 *That you keep ignoring this is less than no rebuttal at all*
THE ONLY POSSIBLE WAY for D simulated by H to have the same
behavior as the directly executed D(D) is for the instructions
of D to be incorrectly simulated by H (details provided below).

So, you are admitting that in your mind it is impossible for "the input correctly simuated by H" to be the equivalent to "The derect execution of the input" and thus can not be used as a measurement criteria for a Halt Decider, which must do the later.
I guess you are pointing out that you work of the last 20 years is just based on Lies, or at the minimum, a fatal mistake that you just refused to acknoledge.

 _D()
[00000cfc](01)  55                      push ebp
[00000cfd](02)  8bec                    mov ebp,esp
[00000cff](03)  8b4508                  mov eax,[ebp+08]
[00000d02](01)  50                      push eax       ; push D
[00000d03](03)  8b4d08                  mov ecx,[ebp+08]
[00000d06](01)  51                      push ecx       ; push D
[00000d07](05)  e800feffff              call 00000b0c  ; call H
[00000d0c](03)  83c408                  add esp,+08
[00000d0f](02)  85c0                    test eax,eax
[00000d11](02)  7404                    jz 00000d17
[00000d13](02)  33c0                    xor eax,eax
[00000d15](02)  eb05                    jmp 00000d1c
[00000d17](05)  b801000000              mov eax,00000001
[00000d1c](01)  5d                      pop ebp
[00000d1d](01)  c3                      ret
Size in bytes:(0034) [00000d1d]
 In order for D simulated by H to have the same behavior as the
directly executed D(D) H must ignore the instruction at machine
address [00000d07]. *That is an incorrect simulation of D*
 

Do, you are admitting that your H, to be answering the Halting Question, which IS about the behavior of the directly executed D(D), must not correctly simulate its input, so you have been lying that your H is a correct halt decider.
Maybe you have a POOP decider, that uses your worthless criteria, but no one cares about that.