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

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

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.

No, since the sematic property of the finite string pair: HHH/DDD is the actual behavior of a full emulaition of the program described by it (DDD) and that DOES reach the finite return instruction if HHH(DDD) gives and answer, no HHH(DDD) that returns the value of 0 is correct.

 Why is everyone here a damned liar regarding DDD emulated
by HHH according to the semantics of the x86 language never
reaching its own "return" instruction final halt state?

Because DDD emulated by HHH is NOT the semantic meaning of the string pair HHH/DDD.
But, you seem to be too stupid to understand that.

 I am sure that everyone here knows that they are a damned
liar about this because no one has even attempted to show
*EXACTLY HOW IT IS NOT TRUE*
 

No, everyone here (but you) is talking the truth,
YOU are the DAMNED LIAR because you are the one not using the words correctly.
We *HAVE* shown exactly how it is not true, by showing the actual meaning of the words you are using.
If you lie to yourself about the meaning of the words, of course you end up lying with the words you are using.