Re: embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ computes the mapping from its input to Ĥ.qn

Am Thu, 01 Aug 2024 06:49:13 -0500 schrieb olcott:

On 8/1/2024 2:44 AM, Mikko wrote:

On 2024-07-31 17:27:33 +0000, olcott said:

On 7/31/2024 2:32 AM, Mikko wrote:

On 2024-07-30 14:16:20 +0000, olcott said:

On 7/30/2024 1:37 AM, Mikko wrote:

On 2024-07-29 16:16:13 +0000, olcott said:

On 7/28/2024 3:02 AM, Mikko wrote:

On 2024-07-27 14:08:10 +0000, olcott said:

On 7/27/2024 2:21 AM, Mikko wrote:

On 2024-07-26 14:08:11 +0000, olcott said:

When we compute the mapping from the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
to the behavior specified by this input we know that embedded_H is
correct to transition to Ĥ.qn.

>
The meaning of "correct" in this context is that if the transition
of embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn is correct if H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions
to H.qn but incorrect otherwise.

>
No you are wrong.

Which dictionary (or other authority) disagrees?

>
The common knowledge that a decider computes the mapping from its
input finite string...
This is almost always the same as the direct execution of the machine
represented by this finite string.

Not "almost". Otherwise it is doing something different.

None of above indicates any disagreement by any authority.

Everyone (even Linz) has the wrong headed idea that a halt decider must
report on the behavior of the computation that itself is contained
within. This has always been wrong.

Dude. The halting problem /specifically/ asks about a machine simulating
itself.

A halt decider must always report on the behavior that its finite string
specifies. This is different only when an input invokes its own decider.

Um, no? Then it is making a mistake.

The one rare exception is shown above where Ĥ ⟨Ĥ⟩ halts and the input
to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach its own final state of
⟨Ĥ.qn⟩ when embedded_H acts as if it was a UTM.

H is not an UTM, though.

That is not supported by any anuthority.
 

The authority says *given an input of the function domain it*
*can return the corresponding output*

Which authority? Not that that would be a valid argument.

In other words all deciders compute the mapping from their input (finite
string) to an accept or reject state.
This means that they do not compute the mapping of the executing process
of themselves.

They do, if those happen to coincide.

I am the first person in the world that noticed these two could be
different. Everyone that has disagreed with me is disagreeing with the
semantics of the x86 language.

What are the semantics that you disagree 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.