Re: Proof that DDD specifies non-halting behavior --- point by point --- in our head

On 8/15/24 12:51 PM, olcott wrote:

On 8/15/2024 6:03 AM, Richard Damon wrote:

On 8/14/24 11:12 PM, olcott wrote:

On 8/14/2024 10:01 PM, Richard Damon wrote:

On 8/14/24 10:38 PM, olcott wrote:

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

On 8/14/24 10:20 PM, olcott wrote:

On 8/14/2024 9:11 PM, Richard Damon wrote:

On 8/14/24 10:03 PM, olcott wrote:

On 8/14/2024 6:40 PM, Richard Damon wrote:

On 8/14/24 9:34 AM, olcott wrote:

On 8/14/2024 6:22 AM, Richard Damon wrote:

On 8/14/24 12:24 AM, olcott wrote:

On 8/13/2024 11:04 PM, Richard Damon wrote:

On 8/13/24 11:48 PM, olcott wrote:

On 8/13/2024 10:21 PM, Richard Damon wrote:

On 8/13/24 10:38 PM, olcott wrote:

On 8/13/2024 9:29 PM, Richard Damon wrote:

On 8/13/24 8:52 PM, olcott wrote:

void DDD()
{
   HHH(DDD);
   return;
}
>
_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]
>
A simulation of N instructions of DDD by HHH according to
the semantics of the x86 language is necessarily correct.
>

>
Nope, it is just the correct PARTIAL emulation of the first N instructions of DDD, and not of all of DDD,

>
That is what I said dufuss.

>
Nope. You didn't. I added clairifying words, pointing out why you claim is incorrect.
>
For an emulation to be "correct" it must be complete, as partial emulations are only partially correct, so without the partial modifier, they are not correct.
>

>
A complete emulation of one instruction is
a complete emulation of one instruction

>
>
>

>

>

>

A correct simulation of N instructions of DDD by HHH is
sufficient to correctly predict the behavior of an unlimited
simulation.

>
Nope, if a HHH returns to its caller,

>
*Try to show exactly how DDD emulated by HHH returns to its caller*
(the first one doesn't even have a caller)
Use the above machine language instructions to show this.
>

>
Remember how English works:
>
When you ask "How DDD emulated by HHH returns to its callers".

>
Show the exact machine code trace of how DDD emulated
by HHH (according to the semantics of the x86 language)
reaches its own machine address 00002183

>
No. The trace is to long,

>
Show the Trace of DDD emulated by HHH
and show the trace of DDD emulated by HHH
emulated by the executed HHH
Just show the DDD code traces.
>

>
First you need to make a DDD that meets the requirements, and that means that it calls an HHH that meets the requirements.
>

>
_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]
>
The is a hypothetical mental exercise and can be
accomplished even if the only DDD in the world
was simply typed into a word processor and never run.

>
But, must behave the rules of Computation Theory.
>
That means DDD, to be a program, includes the code of HHH, and that HHH obeys the requirements of programs in computation theory, which means that it always produces the same answer to its caller for the same input.
>
>
Note, its "Behavior" is defined as what it would do when run, even if it never is,
>

>
No that is the big mistake of comp theory where it violates
its own rules.
>

>
WHAT rule does it violate? And where do you get it from?
>

>
You have proven that you don't care.
You are like a bot programmed in rebuttal mode.
>

>
>
I guess you don't have an answer, AGAIN.
>

>
Go back and look at the last 500 times
that I answer it.
>

>
You make the claim, but can't show a reliable source for it.
>

>
I make a claim and prove that it is correct
and you change the subject and form a rebuttal
of the changed subject.
>

>
No, you make a claim and present a false argument, not a proof.
>

 A simulation of N instructions of DDD by HHH according to
the semantics of the x86 language is necessarily correct.

It is a simuolation of *ONLY* the first N instructions of DDD, and thus NOT a *CORRECT* simulation of DDD, which must be cor
A part is not the whole, unless you agree that your foot is you. (maybe that explains why you put your foot in your mouth so much with your lies).

 A correct simulation of N instructions of DDD by HHH is
sufficient to correctly predict the behavior of an unlimited
simulation.

Nope, try to prove it,
Remembver, "Simulation of DDD" means the simulaiton of the PROGRAM DDD, which means it includes ALL the code that DDD uses, including the HHH that it calls, and different version of HHH give different DDDs to be talked about.

 Semantic tautologies prove themselves true entirely
on the basis of the meaning of their words.
 

Nope, you are just proving you don't understand how logic works, what the actual definitions are of what you are talking about, or what a "Proof" actualy intails.
Sorry, you are just proving how utterly stupid you are, and that you don't even understand how stupid you are, which is the worse kind of stupid.
You don't even seem to understand that claims need to have backing from the logic system you claim to be working from, but since you intentionally made yourself ignorant of it, that has become a very hard thing for you to do, which is why you just resort to your lies, because it is all you have to go on.