XPost: comp.theory, sci.logic, sci.math
On 3/17/2022 5:30 PM, Richard Damon wrote:
On 3/17/22 5:30 PM, olcott wrote:
On 3/17/2022 3:36 PM, Richard Damon wrote:
On 3/17/22 4:00 PM, olcott wrote:
On 3/17/2022 2:30 PM, Richard Damon wrote:
On 3/17/22 10:06 AM, olcott wrote:
On 3/16/2022 10:02 PM, Richard Damon wrote:
Ĥ applied to ⟨Ĥ⟩ reaches its final state only when embedded_H >>>>>> applied to ⟨Ĥ⟩ ⟨Ĥ⟩ aborts its simulation.
Right, but it DOES reach its final state, so embedded_H, to be
correct, must take that into account. it doesn't, so it gives the
WRONG answer.
No BRAIN DEAD MORON the simulated ⟨Ĥ⟩ never reaches its own final >>>> state.
The CORRECT Simulation shows that it does.
H's simulation only doesn't reach that final state because H aborted
it simulation.
We are not talking about the simulation reaching the final state of
the simulation BRAIN DEAD MORON we are talking about the simulated
input reaching its own final state.
When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Then these steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
⟨Ĥ5⟩...
The simulated input never reaches its own final state whether or not
embedded_H aborts this simulation.
No, because if embedded_H aborts its simulation, then the trace must be:
When H^ is applied <H^>
H^0 copies its input <H^1> to <H^2> then H0 simulates <H^1> <H^2>
H^1 copies its input <H^2> to <H^3> then H1 simulates <H^2> <H^3>
H^2 copies its input <H^3> to <H^4> then H2 simulates <H^3> <H^4>
... n levels (to when H0 aborts
H0 goes to H0.Qn and H^0 HALTS.
Incorrect notation.
When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩...
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
When the original executing (not simulated) embedded_H sees the
infinitely repeating pattern then it aborts its simulation killing every simulation in the whole process tree.
I.E. if embedded_H will only simulate a finite number of iterations, and
them abort its simulation, there is NO infinite simulation that happens.
No BRAIN DEAD MORON the question is:
Can the simulated ⟨Ĥ⟩ possibly ever reach its own final state?
(a) embedded_H does not abort its simulation: NO
(b) embedded_H aborts its simulation: NO
It is all covered by the self-evidently correct general principle:
When-so-ever the simulation of any input to a simulating halt decider
must be aborted to prevent its infinite simulation this input is
correctly rejected as non-halting.
--
Copyright 2021 Pete Olcott
Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)