Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.theory > #106778 > unrolled thread

Simplified proof that DDD correctly simulated by HHH does not halt

Back to article view | Back to comp.theory

Contents

  Simplified proof that DDD correctly simulated by HHH does not halt olcott <polcott333@gmail.com> - 2024-06-09 09:19 -0500
    Re: Simplified proof that DDD correctly simulated by HHH does not halt olcott <polcott333@gmail.com> - 2024-06-09 11:07 -0500
      Re: Simplified proof that DDD correctly simulated by HHH does not halt joes <noreply@example.com> - 2024-06-09 17:59 +0000
        Re: Simplified proof that DDD correctly simulated by HHH does not halt olcott <polcott333@gmail.com> - 2024-06-09 13:23 -0500
          Re: Simplified proof that DDD correctly simulated by HHH does not halt joes <noreply@example.com> - 2024-06-09 19:13 +0000
            Re: Simplified proof that DDD correctly simulated by HHH does not halt olcott <polcott333@gmail.com> - 2024-06-09 19:02 -0500
              Re: Simplified proof that DDD correctly simulated by HHH does not halt Richard Damon <richard@damon-family.org> - 2024-06-09 20:23 -0400
                Re: Simplified proof that DDD correctly simulated by HHH does not halt olcott <polcott333@gmail.com> - 2024-06-09 19:26 -0500
                  Re: Simplified proof that DDD correctly simulated by HHH does not halt Richard Damon <richard@damon-family.org> - 2024-06-09 20:41 -0400
                    Re: Simplified proof that DDD correctly simulated by HHH does not halt olcott <polcott333@gmail.com> - 2024-06-09 19:56 -0500
                      Re: Simplified proof that DDD correctly simulated by HHH does not halt Richard Damon <richard@damon-family.org> - 2024-06-09 21:10 -0400
                        Re: Simplified proof that DDD correctly simulated by HHH does not halt olcott <polcott333@gmail.com> - 2024-06-09 20:23 -0500
                          Re: Simplified proof that DDD correctly simulated by HHH does not halt Richard Damon <richard@damon-family.org> - 2024-06-09 21:36 -0400
                            D correctly simulated by H proved for THREE YEARS --- losing a defamation case olcott <polcott333@gmail.com> - 2024-06-09 20:48 -0500
                              Re: D correctly simulated by H proved for THREE YEARS --- losing a defamation case Richard Damon <richard@damon-family.org> - 2024-06-09 22:16 -0400
                                Re: D correctly simulated by H proved for THREE YEARS --- losing a defamation case olcott <polcott333@gmail.com> - 2024-06-09 21:39 -0500
                                  Re: D correctly simulated by H proved for THREE YEARS --- losing a defamation case Richard Damon <richard@damon-family.org> - 2024-06-09 22:45 -0400
                                    Re: D correctly simulated by H proved for THREE YEARS --- losing a defamation case olcott <polcott333@gmail.com> - 2024-06-09 21:53 -0500
                                      Re: D correctly simulated by H proved for THREE YEARS --- losing a defamation case Richard Damon <richard@damon-family.org> - 2024-06-09 23:09 -0400
                                        Re: D correctly simulated by H proved for THREE YEARS --- losing a defamation case olcott <polcott333@gmail.com> - 2024-06-09 22:21 -0500
                                          Re: D correctly simulated by H proved for THREE YEARS --- losing a defamation case Richard Damon <richard@damon-family.org> - 2024-06-10 07:16 -0400
                              Re: D correctly simulated by H proved for THREE YEARS --- losing a defamation case Alan Mackenzie <acm@muc.de> - 2024-06-10 08:35 +0000
                                Re: D correctly simulated by H proved for THREE YEARS --- verified fact for 3 years olcott <polcott333@gmail.com> - 2024-06-10 09:39 -0500
                                  Re: D correctly simulated by H proved for THREE YEARS --- verified fact for 3 years joes <noreply@example.com> - 2024-06-10 15:33 +0000
                                  Re: D correctly simulated by H proved for THREE YEARS --- verified fact for 3 years Richard Damon <richard@damon-family.org> - 2024-06-11 21:44 -0400
              Re: Simplified proof that DDD correctly simulated by HHH does not halt joes <noreply@example.com> - 2024-06-10 08:40 +0000
                Re: Simplified proof that DDD correctly simulated by HHH does not halt olcott <polcott333@gmail.com> - 2024-06-10 10:27 -0500

Page 1 of 2  [1] 2  Next page →

#106778 — Simplified proof that DDD correctly simulated by HHH does not halt

*You must know the C programming language to understand this*

typedef void (*ptr)(); // pointer to void function

void HHH(ptr P, ptr I)
{
   P(I);
   return;
}

void DDD(int (*x)())
{
   HHH(x, x);
   return;
}

int main()
{
   HHH(DDD,DDD);
}

In the above Neither DDD nor HHH ever reach their own return
statement thus never halt.

When HHH is a simulating halt decider then HHH sees that
DDD correctly simulated by HHH cannot possibly reach its
own return statement, AKA

    simulating halt decider HHH correctly simulates its input DDD
    until HHH correctly determines that its simulated DDD would never
    stop running unless aborted

*as defined here*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   If simulating halt decider H correctly simulates its input D
   until H correctly determines that its simulated D would never
   stop running unless aborted then

   H can abort its simulation of D and correctly report that D
   specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>


-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[toc] | [next] | [standalone]

#106790

On 6/9/2024 9:19 AM, olcott wrote:

*You must know the C programming language to understand this*

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

*The truth preserving transformations are anchored in the*
*semantics of the C programming language that specifies*
line 15 of main executes HHH(DDD,DDD);
line 03 of HHH  executes DDD(DDD)
line 09 of DDD  executes HHH(DDD,DDD);

This can be summed up as simply comprehending
infinite recursion <is> the proof that

In the above Neither DDD nor HHH ever reach their
own return statement thus never halt.

It is the exact same process that HH(DD,DD) recognizes
this exact same infinite recursion behavior pattern.

Most of my reviewers incorrectly believe that when HH(DD,DD)
aborts its simulated input that this simulated input halts.
That is not the case. In the theory of computation "halting"
essentially means "terminated normally" in software engineering.

When HHH is a simulating halt decider just like HH then
DDD correctly simulated by HHH cannot possibly terminate normally

> 
> When HHH is a simulating halt decider then HHH sees that
> DDD correctly simulated by HHH cannot possibly reach its
> own return statement, AKA
> 
>     simulating halt decider HHH correctly simulates its input DDD
>     until HHH correctly determines that its simulated DDD would never
>     stop running unless aborted
> 
> *as defined here*
> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>    If simulating halt decider H correctly simulates its input D
>    until H correctly determines that its simulated D would never
>    stop running unless aborted then
> 
>    H can abort its simulation of D and correctly report that D
>    specifies a non-halting sequence of configurations.
> </MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>
> 
> 

-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[toc] | [prev] | [next] | [standalone]

#106802

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.
If HH aborts the simulation of DD(DD), the call to itself also does, and
returns, making the whole chain terminate. Therefore the abortion was
premature.

> When HHH is a simulating halt decider just like HH then DDD correctly
> simulated by HHH cannot possibly terminate normally
HHH must be the same as HH. There is no distinction by simulation level.
That's the whole point of the argument.

>> When HHH is a simulating halt decider then HHH sees that DDD
>> cannot possibly reach its return statement, AKA
>>     simulating halt decider HHH simulates its input DDD
>>     until HHH determines that DDD would never
>>     stop running unless aborted
and aborts it.

-- 
joes

[toc] | [prev] | [next] | [standalone]

#106820

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.

-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[toc] | [prev] | [next] | [standalone]

#106828

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. You instead could explain how you
can call a simulation that differs from the direct execution "correct".
Or why H and HH are different.

-- 
joes

[toc] | [prev] | [next] | [standalone]

#106835

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.

-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[toc] | [prev] | [next] | [standalone]

#106839

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

You have a problem that multiple people are calling you out on.

Of course there will be no mutual agreement, because you are asking 
people to agree to your lies that you think you can prove with your own 
circular arguements.

You have proven that you are not above lying about things and claiom as 
veriried truths things you have no way to actually show.

At some point, you need to realize that all you circular arguments where 
you base your "proof" and assuming something that isn't actually true to 
be true that implies your claim are actually worthless, and start to 
look at the actual facts and try to see if the is anything useful in 
your discard pile of POOP.

The arguements keep on going in circles as every time someone challenges 
you on one of your made up facts, you need to just to the lies that you 
made to try to support it. and when that gets challenged, to the lies 
that that is based on, and this just goes around in your unsound logic loop.

[toc] | [prev] | [next] | [standalone]

#106840

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.

-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[toc] | [prev] | [next] | [standalone]

#106842

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.

People won't normally agree to something they don't fully understand, 
and even less if they think it is wrong.

To say people need to trust your meaning is a joke, as you have proven 
that you words is worthless, and you knowledge of what you talk about 
even less.

If your proof requires people to accept something with baddly defined 
terms only to have those term clarified later, either you can move that 
defintion up earler, or if that only works because you have gotten them 
to accept the poorly defined version, that shows that it was based on a 
circular definition, and thus doesn't actually meet even your definition 
of truth.

Since you can only prove things by connecting them to accepted truths, 
you start with the things that are near to the accepted truths and show 
their connections, and then move along.

If your proof has a loop, then it isn't actually a proof, but a unsound 
circular argument.

[toc] | [prev] | [next] | [standalone]

#106844

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.

-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[toc] | [prev] | [next] | [standalone]

#106846

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.

That will NOT send me to Hell, but your habitual disregard for the truth 
shows that it may well be your destination.

Of course, most people going there think they are not, because they 
never bothered to see what the real judgement was going to be on.

Your statement make it clear that you fall into that class.

[toc] | [prev] | [next] | [standalone]

#106848

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.


-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[toc] | [prev] | [next] | [standalone]

#106849

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!

Repeatedly repeating a statement that others have pointed out the errors 
in, without rebuting the errors pointed out (by going deeper and showing 
an actual acceptable basis of the statement, not just restating it) is 
lying by the reckless disregarding of the truth.

Example of this:

That the correct simulaton by your own definiton of your input when it 
does a call to H should not go into showing another copy of the 
simulaiton of that same input, but instead into the steps of the 
simulator doing that simulation.

Anything else is just a lie per your definition.

That Halting means anything other than the behavior of the actual 
machine directly executed, or some other method that gives the exact 
same answer.

Anything other than that is just a lie per the definiotn of the 
Computation Theory.

That Godel's "G" is just a statement of the liar's paradox.


Or any of a multitude of errors you make that you can not actualy show 
real cause for you to be correct (and not just that is has to be as that 
is the only thing that makes sense)/

[toc] | [prev] | [next] | [standalone]

#106851 — D correctly simulated by H proved for THREE YEARS --- losing a defamation case

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*
*THAT YOU REFUSE TO EVEN POINT OUT ANY 100% SPECIFIC MISTAKE*
*AND PERSIST IN CALLING ME A LIAR AFTER A CEASE-AND-DESIST ORDER*
*WINS DEFAMATION CASES*

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

On 5/29/2021 2:26 PM, olcott wrote:
[Would the simulation of D be infinitely nested unless simulating 
partial halt decider H terminated its simulation of D?]
https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ



-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[toc] | [prev] | [next] | [standalone]

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

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.

> 
> On 5/29/2021 2:26 PM, olcott wrote:
> [Would the simulation of D be infinitely nested unless simulating 
> partial halt decider H terminated its simulation of D?]
> https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ
> 

Which is  strawman question, which is just another form of deception.

[toc] | [prev] | [next] | [standalone]

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

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.

It is proven that the simulated H produces a correct execution
trace of D by the trace that is provided and the source-code of D.

It is proven that this is the simulated H by its different stack space.
That you simply ignored this proof and called me a liar on this
same issue WINS DEFAMATION CASES.

That your disregard for the truth is willful and INTENTIONAL
is conclusively proven by your refusal to look at these things now.

>>
>> On 5/29/2021 2:26 PM, olcott wrote:
>> [Would the simulation of D be infinitely nested unless simulating 
>> partial halt decider H terminated its simulation of D?]
>> https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ
>>
> 
> Which is  strawman question, which is just another form of deception.
> 
> 

-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[toc] | [prev] | [next] | [standalone]

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

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)

Note, showing that this H didn't simulate past the point, doesn't 
actually PROVE that no H can, and even if you do, that doesn't prove 
that the input is non-halting.

> 
> It is proven that the simulated H produces a correct execution
> trace of D by the trace that is provided and the source-code of D.

No, you might prove that THIS H produces a correct PARTIAL execution 
trace of D.

> 
> It is proven that this is the simulated H by its different stack space.
> That you simply ignored this proof and called me a liar on this
> same issue WINS DEFAMATION CASES.

Since you havn't provided sucn a trace, I can't have commented on it.

The traces you have provided previous, were CLEARLY not the traces you 
were claiming.

> 
> That your disregard for the truth is willful and INTENTIONAL
> is conclusively proven by your refusal to look at these things now.

Nope. Your inability to understand that your lies are lies does not make 
my statement lies.

> 
>>>
>>> On 5/29/2021 2:26 PM, olcott wrote:
>>> [Would the simulation of D be infinitely nested unless simulating 
>>> partial halt decider H terminated its simulation of D?]
>>> https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ
>>>
>>
>> Which is  strawman question, which is just another form of deception.
>>
>>
> 

[toc] | [prev] | [next] | [standalone]

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

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.

The derived execution trace of D simulated by H proves that
it simulated the steps correctly and in the correct order.

The H simulated by H produces another correct trace proves
that its trace is correct too.

-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[toc] | [prev] | [next] | [standalone]

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

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.

> 
> The derived execution trace of D simulated by H proves that
> it simulated the steps correctly and in the correct order.
> 
> The H simulated by H produces another correct trace proves
> that its trace is correct too.
> 

And your criterea for "Infinitely nested simulation are not proven to be 
correct.

In fact, I remember showing that with those rules, there can be an input 
whose "correct simulation" would halt, that being the simulation of 
utm(D,D) where D is built on your H.

Thus, it is proved that your pattern does NOT indicate that the input 
has "infinitely nested simulation", just perhaps that H can not simulate 
its input to its final return, which doesn't matter.

Since you reference "the halting problem" the definition of "correct 
simulation" must include that of a UTM on the input

So, all you are doing is proving that you have being lying about 
incorrect results for years.

[toc] | [prev] | [next] | [standalone]

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

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

_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*

-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[toc] | [prev] | [next] | [standalone]

Page 1 of 2  [1] 2  Next page →

Back to top | Article view | comp.theory

csiph-web