typedef int (*ptr)(); // ptr is pointer to int function in C[...]
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 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 }
On 5/23/2024 12:25 PM, olcott wrote:
On 5/23/2024 2:22 PM, Bonita Montero wrote:[...]
You're really insane.
You might guess that by making sure to ignore
what I said. I am now offering a cash reward
of $10.
lol!
This is the worst chunk of code I've seen in at least fifteen years. It
shows a complete lack of understanding of fundamental principles of C and
C++.
It is the computer science of the Peter Linz halting
problem proof translated into C. This too is a template:
Can we please get back to the C or do you really want
to stay off topic?
As I already explained, it's syntactically invalid C, that no self-
respecting C compiler will accept as well-formed code.
Fibber !
On 5/20/2024 9:23 PM, Keith Thompson wrote:
The code as presented is a valid C *translation unit*, but it is
not a valid *program*, and it has no behavior.
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 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.
On 5/24/2024 7:10 AM, Richard Harnden wrote:
On 23/05/2024 17:52, olcott wrote:Thanks.
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 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.
So, you have: main -> H -> D -> H -> D -> ... -> H -> D until you run
out of stack?
No return statement is ever reached.
Line 3 never completes.
Halt_Status at line 3 never gets a value.
</shrug>
Proving that D correctly simulated by H never reaches its final
state at line 06 and halts.
Thus proving that the halting problem's
counter-example input D would be correctly determined to be non-halting
by its simulating termination analyzer H.
Please stop accusing Mr. Thompson. He's only telling you the truth: the
shown code "is not a valid *program*". Which part of that you did not >understand? If you don't believe me, just ask Keith Thompson.
That should be the last word on this: your code is not a valid program.
Thank you for playing. You can go home now.
On 5/24/2024 7:10 AM, Richard Harnden wrote:
On 23/05/2024 17:52, olcott wrote:Thanks.
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 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.
So, you have: main -> H -> D -> H -> D -> ... -> H -> D until you run
out of stack?
No return statement is ever reached.
Line 3 never completes.
Halt_Status at line 3 never gets a value.
</shrug>
Proving that D correctly simulated by H never reaches its final
state at line 06 and halts. Thus proving that the halting problem's counter-example input D would be correctly determined to be non-halting
by its simulating termination analyzer H.
On 5/24/2024 7:10 AM, Richard Harnden wrote:
On 23/05/2024 17:52, olcott wrote:Thanks.
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 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.
So, you have: main -> H -> D -> H -> D -> ... -> H -> D until you run
out of stack?
No return statement is ever reached.
Line 3 never completes.
Halt_Status at line 3 never gets a value.
</shrug>
Proving that D correctly simulated by H never reaches its final
state at line 06 and halts. Thus proving that the halting problem's counter-example input D would be correctly determined to be non-halting
by its simulating termination analyzer H.
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 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.
On 5/23/2024 8:10 PM, Sam wrote:
olcott writes:
This is the worst chunk of code I've seen in at least fifteen years. It >>>> shows a complete lack of understanding of fundamental principles of C and >>>> C++.
It is the computer science of the Peter Linz halting
problem proof translated into C. This too is a template:
It's completely wrong. It suffers from a fundamental flaw of using an
inverse logical loop that makes its boolean logic produce an irrational
identity matrix.
The shown code is worthless. It'll never work. Try again, from step 1. Start >> with the K&R book, beginning with Chapter 1.
Can we please get back to the C or do you really want
to stay off topic?
As I already explained, it's syntactically invalid C, that no
It is not syntactically invalid C, why lie about this?
On 5/24/2024 10:01 AM, Fred. Zwarts wrote:
Op 23.mei.2024 om 18:52 schreef olcott:
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 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.
The case can be simplified even more (D is not needed):
We are ONLY asking about whether D correctly simulated by pure function
H can possibly reach its own final state at line 06 and halt.
Because H is a pure function we know that H halts. https://en.wikipedia.org/wiki/Pure_function#
Every H of the above H/D pairs returns the meaningless value of 56.
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 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.
On 5/24/2024 7:10 AM, Richard Harnden wrote:
On 23/05/2024 17:52, olcott wrote:Thanks.
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�������� 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.
So, you have: main -> H -> D -> H -> D -> ... -> H -> D until you run
out of stack?
No return statement is ever reached.
Line 3 never completes.
Halt_Status at line 3 never gets a value.
</shrug>
Proving that D correctly simulated by H never reaches its final
state at line 06 and halts. Thus proving that the halting problem's counter-example input D would be correctly determined to be non-halting
by its simulating termination analyzer H.
On 5/24/2024 10:01 AM, Fred. Zwarts wrote:
Op 23.mei.2024 om 18:52 schreef olcott:
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�������� 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.
The case can be simplified even more (D is not needed):
We are ONLY asking about whether D correctly simulated by pure function
H can possibly reach its own final state at line 06 and halt.
Because H is a pure function we know that H halts.
*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.
Op 24.mei.2024 om 18:57 schreef olcott:
On 5/24/2024 10:01 AM, Fred. Zwarts wrote:
Op 23.mei.2024 om 18:52 schreef olcott:
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�������� 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.
The case can be simplified even more (D is not needed):
We are ONLY asking about whether D correctly simulated by pure function
H can possibly reach its own final state at line 06 and halt.
Because H is a pure function we know that H halts.
https://en.wikipedia.org/wiki/Pure_function#
Every H of the above H/D pairs returns the meaningless value of 56.
Maybe if you simplify your question, the answer is easier to find:
The case can be simplified by eliminating the complexity of the template D:
typedef int (*ptr)(); // ptr is pointer to int function in C
00 int H(ptr p, ptr i);
01 int main()
02 {
03 H(H,H);
04 return 0;
05 }
Of the infinite set of H that simulate at least one step of its input,
none of them, when simulated by H, halts, because none of them possibly reaches its final state.
So, does H correctly recognize non-halting behaviour in H?
D is an unneeded complexity, because the only property of D that is
needed is that it calls H, so why not using H as input directly?
Op 23.mei.2024 om 18:52 schreef olcott:
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�������� 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, therefore, can be removed without changing the claim. This leads to:
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������ }
What 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.
Of 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.
On 5/25/2024 4:59 AM, Mikko wrote:
On 2024-05-24 16:57:36 +0000, olcott said:
On 5/24/2024 10:01 AM, Fred. Zwarts wrote:
Op 23.mei.2024 om 18:52 schreef olcott:
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�������� 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.
The case can be simplified even more (D is not needed):
We are ONLY asking about whether D correctly simulated by pure function
H can possibly reach its own final state at line 06 and halt.
Because H is a pure function we know that H halts.
We don't know that H halts. The OP said the opposite:
The above references *pure function* H thus we do know
that the spec *requires* H to halt. https://en.wikipedia.org/wiki/Pure_function
On 2024-05-23 16:52:21 +0000, olcott said:
*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.
To repeat in endless recursve simulation makes halting impossible.
Apparently OP's interpretation of "pure function" does not imply
halting.
Every H is required to halt and return a value.
To make things simple every H returns the meaningless 56.
It is endless recursive simulation until H halts.
On 5/25/2024 2:32 AM, Fred. Zwarts wrote:
Op 23.mei.2024 om 18:52 schreef olcott:
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 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,
therefore, can be removed without changing the claim. This leads to:
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 }
What 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.
Of 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.
This means that a simulating halt-decider is a bad idea, because the
decider itself does not halt.
Not at all.
A simulator is an x86 emulator that correctly emulates 1 to N of the
x86 instructions of D in the order specified by the x86 instructions
of D. This may include M recursive emulations of H emulating itself
emulating D.
This means that D cannot possibly reach its own line 06 and halt
in any finite steps of correct simulation. H is free to halt at
any time after these N finite steps of correct simulation.
On 5/25/2024 2:32 AM, Fred. Zwarts wrote:
Op 23.mei.2024 om 18:52 schreef olcott:
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 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,
therefore, can be removed without changing the claim. This leads to:
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 }
What 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.
Of 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.
This means that a simulating halt-decider is a bad idea, because the
decider itself does not halt.
The simplification is valid.
01 int D(ptr p)
02 {
03 H(p, p);
04 return 0;
05 }
This is a better simplification because it now has an actual
identifiable final state that can be separately referred to.
It is not true that H never halts. H is required to be a pure
function. https://en.wikipedia.org/wiki/Pure_function
On 5/26/2024 6:01 AM, Fred. Zwarts wrote:
Op 26.mei.2024 om 06:19 schreef olcott:
On 5/25/2024 2:32 AM, Fred. Zwarts wrote:
Op 23.mei.2024 om 18:52 schreef olcott:
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 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,
therefore, can be removed without changing the claim. This leads to:
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 }
What 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.
Of 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.
This means that a simulating halt-decider is a bad idea, because the
decider itself does not halt.
Not at all.
A simulator is an x86 emulator that correctly emulates 1 to N of the >>> x86 instructions of D in the order specified by the x86 instructions >>> of D. This may include M recursive emulations of H emulating itself >>> emulating D.
This means that D cannot possibly reach its own line 06 and halt
in any finite steps of correct simulation. H is free to halt at
any time after these N finite steps of correct simulation.
D does not reach it own line 04 because the simulation of H does not
return to D. So, it shows that the simulation of H does not reach it
final state, which proves that H does not halt.
Your transformation would have been acceptable if you retained the
fact that H is a pure function that always halts and returns some value.
On 5/26/2024 9:43 AM, Fred. Zwarts wrote:
Op 26.mei.2024 om 15:20 schreef olcott:
On 5/26/2024 6:01 AM, Fred. Zwarts wrote:
Op 26.mei.2024 om 06:19 schreef olcott:
On 5/25/2024 2:32 AM, Fred. Zwarts wrote:
Op 23.mei.2024 om 18:52 schreef olcott:
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 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,
therefore, can be removed without changing the claim. This leads to: >>>>>>
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 }
What 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. >>>>>>
Of 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.
This means that a simulating halt-decider is a bad idea, because
the decider itself does not halt.
Not at all.
A simulator is an x86 emulator that correctly emulates 1 to N >>>>> of the
x86 instructions of D in the order specified by the x86
instructions
of D. This may include M recursive emulations of H emulating
itself
emulating D.
This means that D cannot possibly reach its own line 06 and halt >>>>> in any finite steps of correct simulation. H is free to halt at >>>>> any time after these N finite steps of correct simulation.
D does not reach it own line 04 because the simulation of H does not
return to D. So, it shows that the simulation of H does not reach it
final state, which proves that H does not halt.
Your transformation would have been acceptable if you retained the
fact that H is a pure function that always halts and returns some value. >>>
Since H is required to halt, but H shows that H does not halt (because
the simulation of H never reaches its final state), the conclusion
must be that there is no such H.
When D correctly simulated by pure simulator H remains stuck in infinite recursive simulation then we also know that D never reaches its own line
06 and halts in less than an infinite number of correctly simulated
steps.
This is what I had in mind all along. Because I am a relatively terrible communicator it takes me a very long time to translate my intuitions
into simple words.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 715 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 10:14:03 |
| Calls: | 12,100 |
| Files: | 15,003 |
| Messages: | 6,517,975 |