Re: Indirect Reference Changes the Behavior of DDD() relative to DDD emulated by HHH

On 2024-08-31 12:50:34 +0000, olcott said:

On 8/30/2024 8:31 AM, Mikko wrote:

On 2024-08-29 14:04:05 +0000, olcott said:
 

On 8/29/2024 3:00 AM, Mikko wrote:

On 2024-08-28 11:46:58 +0000, olcott said:
 

On 8/28/2024 2:33 AM, Mikko wrote:

On 2024-08-27 13:04:26 +0000, olcott said:
 

On 8/27/2024 12:45 AM, joes wrote:

Am Mon, 26 Aug 2024 18:03:41 -0500 schrieb olcott:

On 8/26/2024 7:42 AM, Ben Bacarisse wrote:

Mike Terry <news.dead.person.stones@darjeeling.plus.com> writes:

On 23/08/2024 22:07, Ben Bacarisse wrote:

 

We don't really know what context Sipser was given.  I got in touch
at the time so I do know he had enough context to know that PO's
ideas were "wacky" and that had agreed to what he considered a "minor
remark". Since PO considers his words finely crafted and key to his
so-called work I think it's clear that Sipser did not take the "minor
remark" he agreed to to mean what PO takes it to mean!  My own take
if that he (Sipser) read it as a general remark about how to
determine some cases, i.e. that D names an input that H can partially
simulate to determine it's halting or otherwise.  We all know or
could construct some such cases.

 Exactly my reading.  It makes Sipser's agreement natural, because it
is both correct [with sensible interpretation of terms], and moreover
describes an obvious strategy that a partial decider might use that
can decide halting for some specific cases.  No need for Sipser to be
deceptive or misleading here, when the truth suffices.  (In particular
no need to employ "tricksy" vacuous truth get out clauses just to get
PO off his back as some have suggested.)

 Yes, and it fits with his thinking it a "trivial remark".

 

That aside, it's such an odd way to present an argument: "I managed to
trick X into saying 'yes' to something vague".  In any reasonable
collegiate exchange you'd go back and check: "So even when D is
constructed from H, H can return based on what /would/ happen if H did
not stop simulating so that H(D,D) == false is correct even though D(D)
halts?".  Just imagine what Sipser would say to that!

Is this an accurate phrasing, pete?

 Deciders never compute the mapping of the computation
that they themselves are contained within.

 Why not? A decider always either accepts or rejects its input.

 The computation that they themselves are contained within cannot
possibly be an input.

 What would prevent that if the input language permits computations?
 

 When a TM takes its own machine description as input
this is not always that same behavior as the direct
execution of the machine. It is not the same because
it is one level of indirect reference away.

 Now you contradict what you said above. You said that deciders never
conpute the mapping of the computation they themselves are contained
within.

 Although deciders cannot possibly see their own behavior
other people can see this behavior.

The designer of the decider knows the intended behavour of the decider
and may design the decider to contain and use that knowledge.

Now you are saying that they do in a way that might not be
as expected.

 If is a verified fact that DDD has different behavior
before it is aborted in the same way that people are
hungry before they eat.

Different from what?
The behaviour of DDD before the point where the simulation is aborted
is a part of the behaviour of DDD. If the simulator simulates aoother
behaviour then the simulator does not simulate correctly.

than the behavior of DDD after it has been aborted,
people are not hungry after they eat.

That is not a sentence. Looks like an editing error.

The direct execution of DDD includes the behavior
of the emulated DDD after it has been aborted.

Both the directly executed DDD and the emulated DDD are DDD and
therefore the same, and its behaviour is the behaviour of DDD
regradless how you call it.

The emulation of DDD includes the behavior of DDD
before it has been aborted.

Which, if the emulation is correct, is a part of the behaviour of
DDD.

The behavior of infinite recursion is different
before its second recursive call has been aborted
than after this second call has been aborted.

A finitely recursive simulation is neither infinite nor recursion.
--
Mikko