What if the address of H in the simulator is the address of a different
routine in the simulated program? The simulator will think it calls H
but it actually calls something else.

On 1/13/2024 6:22 AM, immibis wrote:
> What if the address of H in the simulator is the address of a different
> routine in the simulated program?

That is like asking: What if you are not yourself?

> The simulator will think it calls H
> but it actually calls something else.

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

On 1/13/24 17:51, olcott wrote:
> On 1/13/2024 6:22 AM, immibis wrote:
>> What if the address of H in the simulator is the address of a
>> different routine in the simulated program?
>
> That is like asking: What if you are not yourself?
>
>> The simulator will think it calls H but it actually calls something else.
>

So a correct simulation can return a different value just because I
change the addresses even if the program doesn't read its own addresses?

On 1/14/2024 2:04 AM, immibis wrote:
> On 1/13/24 17:51, olcott wrote:
>> On 1/13/2024 6:22 AM, immibis wrote:
>>> What if the address of H in the simulator is the address of a
>>> different routine in the simulated program?
>>
>> That is like asking: What if you are not yourself?
>>
>>> The simulator will think it calls H but it actually calls something
>>> else.
>>
>
> So a correct simulation can return a different value just because I
> change the addresses even if the program doesn't read its own addresses?

In my process only the correct addresses can be provided
because my system looks at the COFF object file x86 machine
code produced by the compiler.

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

On 1/14/24 10:52 AM, olcott wrote:
> On 1/14/2024 2:04 AM, immibis wrote:
>> On 1/13/24 17:51, olcott wrote:
>>> On 1/13/2024 6:22 AM, immibis wrote:
>>>> What if the address of H in the simulator is the address of a
>>>> different routine in the simulated program?
>>>
>>> That is like asking: What if you are not yourself?
>>>
>>>> The simulator will think it calls H but it actually calls something
>>>> else.
>>>
>>
>> So a correct simulation can return a different value just because I
>> change the addresses even if the program doesn't read its own addresses?
>
> In my process only the correct addresses can be provided
> because my system looks at the COFF object file x86 machine
> code produced by the compiler.
>

Try and show how to do that for H1 being the EXACT same source code, and
H1 doesn't use anything that wasn't an actual input to it (and thus not
take its own address).

Either H1 will need to refer to H1, or it will use an instruction that
converts the PC ad

On 1/14/24 16:52, olcott wrote:
> On 1/14/2024 2:04 AM, immibis wrote:
>> On 1/13/24 17:51, olcott wrote:
>>> On 1/13/2024 6:22 AM, immibis wrote:
>>>> What if the address of H in the simulator is the address of a
>>>> different routine in the simulated program?
>>>
>>> That is like asking: What if you are not yourself?
>>>
>>>> The simulator will think it calls H but it actually calls something
>>>> else.
>>>
>>
>> So a correct simulation can return a different value just because I
>> change the addresses even if the program doesn't read its own addresses?
>
> In my process only the correct addresses can be provided
> because my system looks at the COFF object file x86 machine
> code produced by the compiler.
>

and if the compiler uses different addresses for the same program which
does not read its own address, the program can do something different?

On 1/14/2024 12:14 PM, immibis wrote:
> On 1/14/24 16:52, olcott wrote:
>> On 1/14/2024 2:04 AM, immibis wrote:
>>> On 1/13/24 17:51, olcott wrote:
>>>> On 1/13/2024 6:22 AM, immibis wrote:
>>>>> What if the address of H in the simulator is the address of a
>>>>> different routine in the simulated program?
>>>>
>>>> That is like asking: What if you are not yourself?
>>>>
>>>>> The simulator will think it calls H but it actually calls something
>>>>> else.
>>>>
>>>
>>> So a correct simulation can return a different value just because I
>>> change the addresses even if the program doesn't read its own addresses?
>>
>> In my process only the correct addresses can be provided
>> because my system looks at the COFF object file x86 machine
>> code produced by the compiler.
>>
>
> and if the compiler uses different addresses for the same program which
> does not read its own address, the program can do something different?

It consistently works the same way for all COFF object files.
No compiler can produce a correct COFF object file with more
than one physical address per function.

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

On 1/14/24 19:28, olcott wrote:
> On 1/14/2024 12:14 PM, immibis wrote:
>> On 1/14/24 16:52, olcott wrote:
>>> On 1/14/2024 2:04 AM, immibis wrote:
>>>> On 1/13/24 17:51, olcott wrote:
>>>>> On 1/13/2024 6:22 AM, immibis wrote:
>>>>>> What if the address of H in the simulator is the address of a
>>>>>> different routine in the simulated program?
>>>>>
>>>>> That is like asking: What if you are not yourself?
>>>>>
>>>>>> The simulator will think it calls H but it actually calls
>>>>>> something else.
>>>>>
>>>>
>>>> So a correct simulation can return a different value just because I
>>>> change the addresses even if the program doesn't read its own
>>>> addresses?
>>>
>>> In my process only the correct addresses can be provided
>>> because my system looks at the COFF object file x86 machine
>>> code produced by the compiler.
>>>
>>
>> and if the compiler uses different addresses for the same program
>> which does not read its own address, the program can do something
>> different?
>
> It consistently works the same way for all COFF object files.
> No compiler can produce a correct COFF object file with more
> than one physical address per function.
>

There's more than one program in the world. If I take a copy of the
input and change the addresses, is it the same program?

On 1/14/24 1:28 PM, olcott wrote:
> On 1/14/2024 12:14 PM, immibis wrote:
>> On 1/14/24 16:52, olcott wrote:
>>> On 1/14/2024 2:04 AM, immibis wrote:
>>>> On 1/13/24 17:51, olcott wrote:
>>>>> On 1/13/2024 6:22 AM, immibis wrote:
>>>>>> What if the address of H in the simulator is the address of a
>>>>>> different routine in the simulated program?
>>>>>
>>>>> That is like asking: What if you are not yourself?
>>>>>
>>>>>> The simulator will think it calls H but it actually calls
>>>>>> something else.
>>>>>
>>>>
>>>> So a correct simulation can return a different value just because I
>>>> change the addresses even if the program doesn't read its own
>>>> addresses?
>>>
>>> In my process only the correct addresses can be provided
>>> because my system looks at the COFF object file x86 machine
>>> code produced by the compiler.
>>>
>>
>> and if the compiler uses different addresses for the same program
>> which does not read its own address, the program can do something
>> different?
>
> It consistently works the same way for all COFF object files.
> No compiler can produce a correct COFF object file with more
> than one physical address per function.
>

And you are just verifying that your decider isn't complete.

A more proper decider would have the input program be expressed as the
COFF object that contains all the code of the program to decide on, not
need that input program be improperly mixed with the decider.

Of course, you found you couldn't do this, because it breaks your
"trick" to detect the copy of the decider (since it stops being a copy)
as your "input" is no longer a complete input.

Of course, since you admit that your decider doesn't decide on PROGRAMS
but TEMPLATES (which is foreign to Computation Theory) you have admitted
you are working on the Halting Problem anyway.