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,

HHH can be purely imaginary yet must emulate the
above code and itself according to the semantics
of the x86 language. In this case HHH is a pure
emulator.

No, it must emulate ALL the code of the PROGRAM DDD, which include the
code of HHH.

That, or you never had a PROGRAM DDD to give to HHH and you whole
hypothetical blows up as a LIE.

On this basis we know that such an HHH would
emulate the first four instructions of DDD.

This includes a calls from the emulated DDD
to an emulated HHH(DDD).

This emulated HHH would emulate the first
four instructions of DDD.

And the emulating HHH, needs to trace how that HHH does its emulation,
not the results of the emulation, as that is what the code of "DDD"

We can do that all in our head never needing
any actually existing HHH.

And eitehr HHH CONDITIONALLY emulates DDD, and thus can break out of the
loop, or it can't.

If it can, and it will, then DDD is Halting.

If it can't, then HHH can NEVER answer, and thus isn't a decider.

All other points are moot and will simply be erased
until we have mutual agreement on this point.

No, you NEED to answer the problems shown, or you are just admitting
that you idea is all just a pathetic lie.

This seems to be your fundamental problem (or as one friend of mine
calls it, a FUNNY-MENTAL problem) that you don't understand the
fundamental definitions of what you are talking about.

Halting is a property of FULL PROGRAMS, and by the rules of Compuation
Theory programs include ALL of the code they use, and their behavior can
only depend on that code and the data explicitly given as the input.

You "DDD" that contains only those byte specified, just isn't a program,
so you lost the argument at your first paragraph.

The fact that you don't understand this, and refuse to learn or accept
it does mean that you have a "funny-mental" problem that just proves you
are incapable of dealing with the topic you are trying to talk about,
and just failing horribly.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

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?


This is just your ignorance speaking.

Deciders need to try to compute the Mapping that is defined MATHEMATICALLY.

For Halting, that mapping is from the behavior of the program the input describes to whether it Halts or Not.

What rule does that break?

Nothing in the definition says that the decider needs to actually be
able to compute that results, and in fact, the big question is if there
exists a program that can.

Thus, "Non-computable" functions are a thing, and fully proper.

Halting turns out to be one of them.

The mapping that a given program produces shows what it does decide, if
that doesn't match the mapping it is supposed to produce, it just isn't correct.

Something you don't seem to be able to understand, that things can be incorrect.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

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.

That isn't evidence of anything but your own ignorance.

Sorry, YOU are not a "expert source" to be proof of what you asy.

That you think you are, just shows your utter stupidity.

Go ahead, try to prove me wrong.

YOu are just showing you are a stupid and ignorant liar.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

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.


Just shows you like making up stuff because you don't care if your words
are actually True, since you don't care about that.

You are just proving teo the world that you have nothi9ng to back
yourself, nd all you can do is go to insults.

When you don't have the facts, you just start slinging mud, but that
just gets YOUR dirty.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-15 02:03:44 +0000, olcott said:

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.

The big mistake is yours where you violate the rules of computation
theory and honest discussion.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/14/24 11:13 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.

Look at Mike's correction of Joes.

Not a "Proof" of your claim, but then you don't know what that is
because you are too stupid,

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Op 15.aug.2024 om 18:51 schreef olcott:

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.

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

It is not the simulation of these N instructions that cause the
prediction, but it is the reason why the simulation is aborted.
You hide the algorithm by which HHH decides to abort. That algorithm
does the prediction, not the simulation of a few instructions.
We cannot tell you how that algorithm is wrong, but we can say that it
is wrong, because it predicts an non-halting behaviour when the
simulated HHH is only one cycle from its end and an complete simulation,
such as done by HHH1, shows that the simulation of HHH halts.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

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

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

On 8/14/24 11:13 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.

Look at Mike's correction of Joes.

Not a "Proof" of your claim, but then you don't know what that is
because you are too stupid,

It is a correction of Joes error.
You may be making this same mistake.

But, that is just your strawman showing that you don't actually have
anything to base your claims on.

Sorry, you are just proving that you made your self ignorant of the
topic and because of that totally stupid, and so stupid you can't
understand your errors, which is just the worse kind of stupid.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/15/24 10:28 PM, olcott wrote:

On 8/15/2024 8:57 PM, Richard Damon wrote:

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

On 8/15/2024 5:32 AM, Mikko wrote:

On 2024-08-15 02:03:44 +0000, olcott said:

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

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.

The big mistake is yours where you violate the rules of computation
theory and honest discussion.

It is at least the case that conventional halting
problem proofs violate one of the rules of the theory
of computation.

And what rule is that?

Go back and see the last 500 times that I explained this.

You have NEVER referenced a source for your rule, just described
something that just isn;t true.

There is no "rule" that says that a decider can't be asked to decide on
a program that uses a copy of itself.

So, you are just proving yourself to be a LIAR.

Please point to ONE of the 500 times you explained it where you gave an
actual defined rule, with a source that says it is such a rule.

YOU are not an "Expert", unless you mean an ex-spurt and can show
something (family friendly) that you used to spurt out that yo you
nolonger do.. (and I don't mean what you did with the Child Porn you
were caught with)

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-15 16:26:21 +0000, olcott said:

On 8/15/2024 5:32 AM, Mikko wrote:

On 2024-08-15 02:03:44 +0000, olcott said:

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

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.

The big mistake is yours where you violate the rules of computation
theory and honest discussion.

It is at least the case that conventional halting
problem proofs violate one of the rules of the theory
of computation.

At least the proof by Linz does not violate the rules as specified in
Linz' book. Other authors may specify different rules for the theory
of computation.

Anyway, a vague cliam like that does not really mean anything. If it
were about a specific violation of a specific rule then it might be
worth of some consideration.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)