Post by Fred. Zwartstypedef int (*ptr)(); // ptr is pointer to int function in C
00 int H(ptr p, ptr i);
01 int D(ptr p)
02 {
03 int Halt_Status = H(p, p);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 int main()
10 {
11 H(D,D);
12 return 0;
13 }
The above template refers to an infinite set of H/D pairs where D is
correctly simulated by pure function H. This was done because many
reviewers used the shell game ploy to endlessly switch which H/D was
being referred to.
*Correct Simulation Defined*
This is provided because every reviewer had a different notion of
correct simulation that diverges from this notion.
In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
*Execution Trace*
Line 11: main() invokes H(D,D); H(D,D) simulates lines 01, 02, and 03 of
D. This invokes H(D,D) again to repeat the process in endless recursive
simulation.
Olcott's own words are that the simulation of D never reaches past
line 03. So the lines following line 03 do not play a role and,
typedef int (*ptr)(); // ptr is pointer to int function in C
00 int H(ptr p, ptr i);
01 int D(ptr p)
02 {
03 return H(p, p);
04 }
05
06 int main()
07 {
08 H(D,D);
09 return 0;
10 }
Correct - as far as this specific thread is concerned. But PO's H and P
are intended to be part of a larger argument supposedly refuting the
standard halting problem (HP) proof (that no TM is a halt decider), e.g.
as covered in the Linz book. PO has created an extract of that proof as
a PDF that he sometimes links to.
*I renamed this thread to be more accurate*
*now that I got people's attention*
The material the you referenced is not appropriate for this group
and outside the scope of the same thread in the comp.theory group.
Also note that PO's claim (in this specific thread) is that the
*simulation* of D never reaches past line 03. That is not saying that
the *computation* D(D)
*No you are paraphrasing my words incorrectly*
*No you are paraphrasing my words incorrectly*
*No you are paraphrasing my words incorrectly*
*D correctly simulated by pure function H cannot*
*possibly reach its own line 06 and halt*
*Any change-of-subject away form those exact words is*
*an example of the strawman deception error of reasoning*
*Correct Simulation Defined*
This is provided because many reviewers had a different
notion of correct simulation that diverges from this notion.
A simulator is an x86 emulator that correctly emulates at least
one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H
in the order specified by the x86 instructions of H thus calling
H(D,D) in recursive simulation.
never proceeds past line 3 or that D(D) never
halts. (This is important in the wider HP proof context. PO is deeply
confused on this point.)
*Not at all you are simply not paying close enough attention*
*Not at all you are simply not paying close enough attention*
*Not at all you are simply not paying close enough attention*
Post by Fred. ZwartsWhat we see is that the only property of D that is used is that it is
a parameter duplicator. (Is that why it is called D?). H needs 2
parameters, but it can be given only one input parameter, so the
parameter duplicator is required to allow H to decide about itself.
Yes, but the rest of D is the key to its role in the HP proof - again,
not relevant for this specific thread.
*Exactly*
[In HP proof, D's role is to
calculate H's decision on whether D(D) halts and then behave in the
opposite fashion, providing a counterexample to the claim that H
correctly decides the halting behaviour of /all/ inputs (P,I). I.e. it
shows that H gets it wrong for the case P=I=D.]
Post by Fred. ZwartsOf the infinite set of H that simulate at least one step, none of
them, when simulated by H, halts, because none of them reaches its
final state. Olcott's claim is equivalent to the claim of non-halting
behaviour of H.
No - note my remarks above about the distinction between the behaviour
of the *computation* D(D) and the (partial) *simulation* of that
computation by H. H can simply choose to discontinue that simulation at
any point [aka "abort" the simulation, in PO's terms], but then H would
continue and halt.
*This is already specified as pure function H*
(1) the function return values are identical for identical
arguments (no variation with local static variables, non-local
variables, mutable reference arguments or input streams, i.e.,
referential transparency), and
(2) the function has no side effects (no mutation of local static
variables, non-local variables, mutable reference arguments or
input/output streams). https://en.wikipedia.org/wiki/Pure_function#
PO is pretty clueless about everything involved, and I believe he is
quite incapable of abstract thought, including what people would
generally regard as "logical reasoning", so there really is no point in
arguing with him. (I mean Really...)
Mike.
The actual truth is that the strawman deception change-the-subject
form of fake rebuttal is the only rebuttal ever provided.
Thanks for your time, I really appreciate it. You have provided
some excellent reviews of my work and resolved key unresolved
questions about my work that were left unresolved for two years.
On 3/1/2024 12:41 PM, Mike Terry wrote:
Message-ID: <rLmcnQQ3-***@brightview.co.uk>
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer