Re: My reviewers think that halt deciders must report on the behavior of their caller --- Mike

Op 11.jul.2025 om 04:33 schreef olcott:

On 7/10/2025 9:10 PM, Richard Damon wrote:

On 7/10/25 8:27 PM, olcott wrote:

On 7/10/2025 7:04 PM, Richard Damon wrote:

On 7/10/25 9:24 AM, olcott wrote:

On 7/10/2025 6:35 AM, Richard Damon wrote:

On 7/9/25 10:50 PM, olcott wrote:

On 7/9/2025 8:49 PM, Richard Damon wrote:

On 7/9/25 9:55 AM, olcott wrote:

On 7/9/2025 6:44 AM, Richard Damon wrote:

On 7/8/25 3:49 PM, olcott wrote:

On 7/8/2025 2:01 PM, Mike Terry wrote:

>
This is one of PO's practiced tactics - he makes a claim, and regardless of how patently false that claim appears, he refuses to logically defend the claim beyond saying "the claim is true, and if you understood xxx you would realise it is true".
>

>
All of my claims are easily verified facts to those
with the capacity to verify them.
>
void DDD()
{
   HHH(DDD);
   return;
}
>
_DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192  // push DDD
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]

>
Not a program, must include the code for HHH to be simulatable.
>

>
You must have dementia.
I have told you that HHH does emulate DDD
then it emulates itself emulating DDD 500 times now.
>

>
And thus you admit that you are lying.
>

>
*Here is the proof*
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf
>
>

>
SO, you admit that HHH fails to emulate JUST the input,

>
*I have told you that HHH does emulate DDD*
*then it emulates itself emulating DDD 500 times now*

>
And the question is HOW can it?
>
You claim it isn't part of the input, and thus it isn't AVAILABLE for HHH to emualate.
>
You don't seem to understand that HHH isn't ALLOWED to look at memory that isn't part of its input, without MAKING that memory part of its input.
>

>
*NOW I PROVED THAT*
*See if you can remember this by your next reply*
>

>
No, you are just proving that you don't understand how programs and input are defined, and thus make yourself into a liar.
>

>
*I just proved the fact that*
(1) HHH(DDD) is executed
(2) HHH emulates DDD
(3) emulated DDD calls an emulated HHH(DDD)
(4) emulated HHH emulates another instance of DDD
(5) this DDD calls HHH(DDD) again
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf
>
Its OK if you are no good with the x86 language
and can't understand the code. I began programming
way back when x86 programming was popular.
>
Alternatively the details of how multi-tasking
works are too difficult for you. They are probably
too difficult for most programmers.
>

>
And thus you have proven my point that either you definition of what the input is, or what HHH does is just a lie.
>
But, it seems you are too stupid to understand that problem.
>
Your claims are:
>
1) The input contains only the code shown, and thus does not contain the code of HHH.
>
2) That HHH is simulating the input given to it, and thus JUST that input.
>
3) That HHH simulates the code of HHH.
>

 The test program HHH is not the program under test DDD.
The program under test and the test program will never
stop running unless HHH aborts its DDD.
 

Another vague claim without evidence.
If DDD is under test, then also all function called by DDD are under test, including HHH.
You are confusing yourself with the construct where the program under test is in the same memory as the program being tested. It would be much easier to understand for you to keep the input for HHH separated from HHH, by using a copy of HHH in the input.