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 Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
The above is merely simplified syntax for the top of page 3
https://www.liarparadox.org/Linz_Proof.pdf
The above is the whole original Linz proof.
And even more simplified semantics.
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
(e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>> (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(g) goto (d) with one more level of simulation
You are supposed to evaluate the above as a contiguous
sequence of moves such that non-halting behavior is
identified.
The above is an obvious tight loop of (d), (e), (f), and (g).
Its relevance (it any) to the topic of the discussion is not
obvious.
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.
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 Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
The above is merely simplified syntax for the top of page 3
https://www.liarparadox.org/Linz_Proof.pdf
The above is the whole original Linz proof.
And even more simplified semantics.
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
(e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>> (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(g) goto (d) with one more level of simulation
You are supposed to evaluate the above as a contiguous
sequence of moves such that non-halting behavior is
identified.
The above is an obvious tight loop of (d), (e), (f), and (g).
Its relevance (it any) to the topic of the discussion is not
obvious.
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?
Computable functions are the formalized analogue of the
intuitive notion of algorithms, in the sense that a function
is computable if there exists an algorithm that can do the
job of the function, i.e. *given an input of the function*
*domain it can return the corresponding output* https://en.wikipedia.org/wiki/Computable_function
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.
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.
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 Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>
The above is merely simplified syntax for the top of page 3
https://www.liarparadox.org/Linz_Proof.pdf
The above is the whole original Linz proof.
And even more simplified semantics.
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
(e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>> (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(g) goto (d) with one more level of simulation
You are supposed to evaluate the above as a contiguous
sequence of moves such that non-halting behavior is
identified.
The above is an obvious tight loop of (d), (e), (f), and (g).
Its relevance (it any) to the topic of the discussion is not
obvious.
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?
Computable functions are the formalized analogue of the
intuitive notion of algorithms, in the sense that a function
is computable if there exists an algorithm that can do the
job of the function, i.e. *given an input of the function*
*domain it can return the corresponding output*
https://en.wikipedia.org/wiki/Computable_function
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.
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.
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.
On 8/2/2024 1:28 AM, Mikko wrote:
On 2024-08-01 11:49:13 +0000, olcott said:
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 Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>>>
The above is merely simplified syntax for the top of page 3 >>>>>>>>>>> https://www.liarparadox.org/Linz_Proof.pdf
The above is the whole original Linz proof.
And even more simplified semantics.
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
(e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(g) goto (d) with one more level of simulation
You are supposed to evaluate the above as a contiguous
sequence of moves such that non-halting behavior is
identified.
The above is an obvious tight loop of (d), (e), (f), and (g). >>>>>>>>>> Its relevance (it any) to the topic of the discussion is not >>>>>>>>>> obvious.
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?
Computable functions are the formalized analogue of the
intuitive notion of algorithms, in the sense that a function
is computable if there exists an algorithm that can do the
job of the function, i.e. *given an input of the function*
*domain it can return the corresponding output*
https://en.wikipedia.org/wiki/Computable_function
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.
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.
What does "must" mean above? How does that relate to what Linz
really says?
A decider computes the mapping from a finite string.
A decider does not compute the mapping from an execution machine.
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.
The input string cannot "invoke". It only specifies.
In the x86 language emulated DDD calls and emulated HHH(DDD).
The same thing occurs when Linz Ĥ ⟨Ĥ⟩ transitions to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 715 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 150:03:42 |
| Calls: | 12,091 |
| Calls today: | 4 |
| Files: | 15,000 |
| Messages: | 6,517,591 |