Re: The philosophy of computation reformulates existing ideas on a new basis ---

On 11/4/24 6:56 PM, olcott wrote:

On 11/4/2024 5:42 PM, Andy Walker wrote:

On 04/11/2024 14:05, Mikko wrote:

[...] The statement itself does not change
when someone states it so there is no clear advantage in
saying that the statement was not a lie until someone stated
it.

    Disagree.  There is a clear advantage in distinguishing those
who make [honest] mistakes from those who wilfully mislead.

That is not a disagreement.

    I disagree. [:-)]

Then show how two statements about distinct topics can disagree.

>
     You've had the free, introductory five-minute argument;  the
half-hour argument has to be paid for. [:-)]
>
     [Perhaps more helpfully, "distinct" is your invention.  One same
statement can be either true or false, a mistake or a lie, depending on
the context (time. place and motivation) within which it is uttered.
Plenty of examples both in everyday life and in science, inc maths.  Eg,
"It's raining!", "The angles of a triangle sum to 180 degrees.", "The
Sun goes round the Earth.".  Each of those is true in some contexts, false
and a mistake in others, false and a lie in yet others.  English has clear
distinctions between these, which it is useful to maintain;  it is not
useful to describe them as "lies" in the absence of any context, eg when
the statement has not yet been uttered.]
>

 No one here has ever been interested in truth (besides me).
I use the x86 language and C because it exposes key details
that are glossed over when examining these things and other way.

No, you have shown no intereset in the truth, in part because you don't understand what it is, and that truth requires you to be willing to follow the rules of the system.

 I use the DDD / HHH example because its the simplest example
that is isomorphic to the HP counter-example when a simulating
termination analyzer is applied to this input.

But it ISN'T isomorphic, but you have made yourself to stupid to understand the essential difference that break the isomorphism.

 void DDD()
{
   HHH(DDD);
   return;
}
 _DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]
 As long as it is understood that it has always simply been
incorrect to construe that behavior of the input finite
string as anything other than the actual behavior that this
finite string specifies which includes HHH emulating itself
emulating DDD then I have refuted the original proofs.

But you don't understand that the "Actual Behavior" is NOT what the decider does to it, but what the input does by its definition, that is the FULL emulation of it,

 (a) Finite string of x86 machine code DDD +

WHich is incomplete

(b) The semantics of the x86 language +

Which says we need the rest of DDD, and you can't stop the emulation and actually get the full semantics.

(c) DDD is calling its own termination analyzer

WHich is irrelevent at the x86 langugage semantics.

∴ HHH is correct to reject its input as non-halting

Therefore, you are proving youself to be just a pathological liar.

 We can only get to the behavior of the directly
executed DDD() by ignoring (b).
>

No, because the direct exection of DDD *IS* the definition of the x86 semantics of it.
'