On 2021-08-31 08:24, olcott wrote:
On 8/30/2021 11:45 PM, André G. Isaak wrote:
In computability theory, the halting problem is the
problem of determining, from a description of an
arbitrary computer program and an input, whether the
program will finish running, or continue to run forever.
https://en.wikipedia.org/wiki/Halting_problem
The halting problem is always about program descriptions
not running programs. This means that it is always about
the input to the halt decider not the direct execution
of the program.
This is, of course, errant nonsense. The input to a halt decider is
simply data. Data doesn't *have* halting behaviour. Only the actual computation described by that data can have halting behaviour. Your
inability to comprehend simple definitions is not the basis for a
coherent argument.
The most straight forward way to get the actual behavior of a program
description is to simulate it.
No. The most straightforward way, and the ONLY 100% reliable way to get
the actual behaviour of a program description is to run the program it describes.
A pure simulation would have identical halting behaviour as the
actual computation, but the question isn't about simulations. It's
about actual computations. It isn't about what happens inside some
decider; it's about actual computations.
When an "actual computation" has different behavior than the
simulation of the input to the halt decider this proves that the
actual computation is a different computation than the input to the
halt decider thus not relevant to the halting problem.
No, it proves that the 'simulation' performed by your halt decider is
not an accurate simulation.
André
On Tuesday, 31 August 2021 at 20:11:39 UTC+1, olcott wrote:
On 8/31/2021 1:40 PM, André G. Isaak wrote:So that's the central point. If H(P,P) from the root is a different computation
H(P,P) specifies the invocation order of H(P,P) then P(P).
It makes no reference at all to the "relative invocation order" of H
with respect to P. It makes no reference to H at all.
If its answer doesn't correspond to the behaviour of P(P) which is a
halting computation, then its answer is *wrong*.
If P did not have the pathological self-reference error the invocation
would not matter. Because P does have the pathological self-reference
error the invocation order does matter.
It is very diffcult to correctly handle incorrect input.
The key irrefutable point is that H(P,P) then P(P) is an entirely
different computation than P(P) then H(P,P)
to H(P,P),called from P, then indeed you can provide a counter-example to
the Linz proof.
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 365 |
Nodes: | 16 (0 / 16) |
Uptime: | 10:18:10 |
Calls: | 7,758 |
Calls today: | 1 |
Files: | 12,897 |
Messages: | 5,744,455 |