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

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:

On 11/6/2024 10:10 PM, Richard Damon wrote:

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

On 11/6/2024 9:42 PM, Richard Damon wrote:

On 11/6/24 10:09 PM, olcott wrote:

On 11/6/2024 6:45 PM, Richard Damon wrote:

On 11/6/24 8:16 AM, olcott wrote:

On 11/6/2024 5:37 AM, Richard Damon wrote:

On 11/5/24 10:28 PM, olcott wrote:

On 11/5/2024 7:50 PM, Richard Damon wrote:

On 11/5/24 8:22 PM, olcott wrote:

On 11/5/2024 6:04 PM, Richard Damon wrote:

On 11/5/24 12:08 PM, olcott wrote:

On 11/5/2024 6:03 AM, Richard Damon wrote:

On 11/4/24 10:15 PM, olcott wrote:

On 11/4/2024 8:42 PM, Richard Damon wrote:

On 11/4/24 8:32 PM, olcott wrote:

On 11/4/2024 6:21 PM, Richard Damon wrote:

On 11/4/24 7:48 AM, olcott wrote:

On 11/4/2024 6:07 AM, Richard Damon wrote:

On 11/3/24 11:03 PM, olcott wrote:

On 11/3/2024 9:57 PM, Richard Damon wrote:

On 11/3/24 10:19 PM, olcott wrote:

On 11/3/2024 7:46 PM, Richard Damon wrote:

On 11/3/24 8:38 PM, olcott wrote:

On 11/3/2024 7:26 PM, Richard Damon wrote:

On 11/3/24 8:21 PM, olcott wrote:

Would you two PLEASE trim your replies a little.

It isn't analyzing an "idealized" version of its input,
it is analyzing the input it is actually given, where DDD
calls the existing HHH, not the idealized version of it.

The paragraph that you said that I keep quoting is a
breakthrough. that you keep contradicting your own words
seems quite dumb to me.

How am I contradicting myself?
HHH doesn't need to actualy emulate DDD completely, just
determine, like HHH1 does, that it will reach the return
instruction.

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.

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.

(a) Finite string of x86 machine code DDD +

Which doesn't contain all the code of DDD, and thus saying it is
a representation of the PROGRAM DDD is just a lie.

(b) The semantics of the x86 language +

Which requires the code of *ALL* of the program, and the
unbounded emulation (or until it reaches a final state) of that
COMPLETE code.

(c) DDD is calling its own termination analyzer

Which isn't something that is part of the sematnics of the xx86
language, so irrelevent.
And, when you include it, since BY DEFINITION a termination
analyser must return an answer, shows that HHH(DDD) WILL return
to DDD, and thus DDD will halt.

DDD emulated by HHH will reach its own "return" instruction,
or are you trying to get away with equivocation?

DDD, when completly emulated by the other emulator

Is yet another equivocation, thus strawman deception.

Name it.

DDD emulated by HHH <is not> DDD emulated by HHH1.

So, you admit your criteria is not an objective property of DDD, and
thus CAN'T be made into a "Function", and thus not the target for a
decider to try to compute.

Gottem.

DDD emulated by HHH has the property that DDD

„emulated by” is not a property of a program

never reaches its "return" instruction final halt state.

That comes out as „HHH can’t simulate DDD”.

To ignore the effect of the pathological relationship (that DDD defines
relative to HHH) on the behavior of DDD is ridiculously stupid.

Yes, so why do keep insisting that DDD call some other simulator?

YOU are the liar using the strawman based on YOUR equivocation.

Any idiot knows that "the other emulator"
is not "one and the same emulator as HHH."

Which just shows that you concept fails by being based on subjective
logic.
What is True, is a universal fact, what is true for one thing to
decide, is true for all.

It is a universal fact that DDD emulated by HHH DOES NOT HALT.

A universal fact is that DDD does halt, so HHH is wrong.

There are ways of stating questions, such that they only have
subjective answers, but such questions are just invalid when talking
about what is actual Truth,
Sorry, you are just proving that your base foundation for your logic is
rotten to the core, and you just don't know what you are talking about.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.