Re: The philosophy of computation reformulates existing ideas on a new basis ---x86 code is a liar?

On 11/11/24 9:58 AM, olcott wrote:

On 11/11/2024 4:54 AM, Mikko wrote:

On 2024-11-09 14:36:07 +0000, olcott said:
>

On 11/9/2024 7:53 AM, Mikko wrote:

On 2024-11-08 14:41:57 +0000, olcott said:
>

On 11/8/2024 3:57 AM, joes wrote:

Am Thu, 07 Nov 2024 15:56:31 -0600 schrieb olcott:

On 11/7/2024 3:24 PM, joes wrote:

Am Thu, 07 Nov 2024 10:31:41 -0600 schrieb olcott:

On 11/7/2024 5:56 AM, Richard Damon wrote:

On 11/6/24 11:39 PM, olcott wrote:

>

That is not what the machine code of DDD that calls the
machine code of HHH says.

The code by itself doesn’t say "do not return". That is a semantic
property.

The code itself does say that within the semantics of the x86 language
as I have been saying all long hundreds of times.

There is no "do not return" instruction.
>

Right, so that is part of the input, or it can't be
emulated.
The Machine code of HHH says that it will abort its
emulation and return, so that is the only correct result
per the x86 language.

Are you really so ignorant of these things that you think
that the fact that HHH returns to main() causes its emulated
DDD to reach its own final state?

Yes, because DDD calls HHH.
>

But the PROGRAM DDD, that it is emulating does. Just its own
PARTIAL emulation of it is aborted before it gets there.

Just repeating your errors, and not even trying to refute the
errors pointed out, I guess that means you accept these as
errors.

There is only one program DDD, although it is invoked multiple times.
We don’t care whether HHH actually simulates the return as long as it
actually derives (not guesses) the right result.

DDD emulated by HHH does have different behavior than DDD emulated by
HHH1 or directly executed DDD.
DDD emulated by CANNOT POSSIBLY HALT no matter WTF HHH does: abort or
NEVER abort.

When the instance of HHH that DDD calls aborts simulating, it returns
to the simulated DDD, which then halts.
>

There <is> a key distinguishing difference in the behavior of DDD
emulated by HHH and DDD emulated by HHH1 or directly executed. It is
ridiculously stupid to simply ignore this for three f-cking years.

That difference is not due to DDD.
>

>
The semantic property of the finite string pair: HHH/DDD
unequivocally entails that DDD never reaches its final halt state.

>
No, it does not. You might say that the semantic property of the
finite string "Olcott is an idiot" unequvocally entails that Olcott
is an idiot but it does not.

>
The semantic property of the finite string pair: HHH/DDD
unequivocally entails that DDD never reaches its final halt
state WITHIN THE SEMANTICS OF THE X86 LANGUAGE.

>
The expression "The semantic property" is incorrect when it is not
clear from context which semantic property is meant. Note that a
string per se does not have semantic properties, they all come
from interpretrations.
>

 That you pretend to not understand my clear words does
not mean that my words are not clear.
 The relevant semantic property of the finite string pair
HHH/DDD where DDD is emulated by HHH according to the
semantics of the x86 language is that DDD cannot possibly
reach its "return" instruction final halt state.
 

But the behaivor of DDD does.
What doesn't is the partial emulation that HHH does of DDD, but partial emulation do not define a semantic property, and thus do not define condtions that show "cannot possible reach..."
You are just proving (in finite steps) your stupidity.

The fact that DDD defines a pathological relationship with
HHH cannot be simply ignored and must be accounted for. The
actual computation itself does involve HHH emulating itself
emulating DDD. To simply pretend that this does not occur
seems dishonest.
 

Right, it needs to be taken into account by HHH, to see that if it aborts and returns that the HHH that DDD calls will also return.
If it is too stupid, just like you, to handle it, then it is its programmers fault (that would be you).
Your problem is you just don't understand the system you are claiming to make massive breakthroughs in, which just proves your stupidity.