When simulating halt decider H correctly predicts that directly executed
D(D) would remain stuck in recursive simulation (run forever) unless H
aborts its simulation of D this directly applies to the halting theorem because H correctly determines:
from a description of an arbitrary computer program and an input,
whether the program will finish running, or continue to run forever.
For any program H that might determine whether programs halt,
a "pathological" program D, called with some input, can pass its
own source and its input to H and then specifically do the opposite
of what H predicts D will do. https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final state and stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach its own
final state at line 6 conclusively proves that this D does not halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from their
inputs to a final accept or reject state then it is understood that H
must only evaluate the behavior of its input and the behavior of non-
inputs is not allowed to be considered.
When simulating halt decider H correctly predicts that directly executed
D(D) would remain stuck in recursive simulation (run forever) unless H
aborts its simulation of D this directly applies to the halting theorem because H correctly determines:
from a description of an arbitrary computer program and an input,
whether the program will finish running, or continue to run forever.
For any program H that might determine whether programs halt,
a "pathological" program D, called with some input, can pass its
own source and its input to H and then specifically do the opposite
of what H predicts D will do. https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final state and stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach its own
final state at line 6 conclusively proves that this D does not halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from their
inputs to a final accept or reject state then it is understood that H
must only evaluate the behavior of its input and the behavior of non-
inputs is not allowed to be considered.
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly
executed D(D) would remain stuck in recursive simulation (run forever)
unless H aborts its simulation of D this directly applies to the
halting theorem because H correctly determines:
from a description of an arbitrary computer program and an input,
whether the program will finish running, or continue to run forever. >>
For any program H that might determine whether programs halt,
a "pathological" program D, called with some input, can pass its
own source and its input to H and then specifically do the opposite >> of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that
simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final state and
stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach its own
final state at line 6 conclusively proves that this D does not halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from their
inputs to a final accept or reject state then it is understood that H
must only evaluate the behavior of its input and the behavior of non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D
correctly simulated by any element of the infinite set of every possible
H cannot possibly reach past its own line 3.
When we combine this verified fact with the fact that halting requires reaching the final state, and stopping running for any other reason does
not count as halting then D correctly simulated by H cannot possibly
halt no matter what H does.
This conclusively proves that when H returns 0 it is only affirming the
above verified fact.
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly
executed D(D) would remain stuck in recursive simulation (run forever)
unless H aborts its simulation of D this directly applies to the
halting theorem because H correctly determines:
from a description of an arbitrary computer program and an input,
whether the program will finish running, or continue to run forever. >>
For any program H that might determine whether programs halt,
a "pathological" program D, called with some input, can pass its
own source and its input to H and then specifically do the opposite >> of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that
simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final state and
stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach its own
final state at line 6 conclusively proves that this D does not halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from their
inputs to a final accept or reject state then it is understood that H
must only evaluate the behavior of its input and the behavior of non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D
correctly simulated by any element of the infinite set of every possible
H cannot possibly reach past its own line 3.
When we combine this verified fact with the fact that halting requires reaching the final state, and stopping running for any other reason does
not count as halting then D correctly simulated by H cannot possibly
halt no matter what H does.
This conclusively proves that when H returns 0 it is only affirming the
above verified fact.
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly
executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly applies to
the halting theorem because H correctly determines:
from a description of an arbitrary computer program and an input, >>> whether the program will finish running, or continue to run forever. >>>
For any program H that might determine whether programs halt,
a "pathological" program D, called with some input, can pass its
own source and its input to H and then specifically do the opposite >>> of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that
simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final state and
stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach its own
final state at line 6 conclusively proves that this D does not halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from their
inputs to a final accept or reject state then it is understood that H
must only evaluate the behavior of its input and the behavior of non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D
correctly simulated by any element of the infinite set of every possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing hundreds many hundreds of times before they first notice that they have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly
executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly applies to
the halting theorem because H correctly determines:
from a description of an arbitrary computer program and an input, >>> whether the program will finish running, or continue to run forever. >>>
For any program H that might determine whether programs halt,
a "pathological" program D, called with some input, can pass its
own source and its input to H and then specifically do the opposite >>> of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that
simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final state and
stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach its own
final state at line 6 conclusively proves that this D does not halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from their
inputs to a final accept or reject state then it is understood that H
must only evaluate the behavior of its input and the behavior of non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D
correctly simulated by any element of the infinite set of every possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing hundreds many hundreds of times before they first notice that they have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
When we combine this verified fact with the fact that halting requires
reaching the final state, and stopping running for any other reason does
not count as halting then D correctly simulated by H cannot possibly
halt no matter what H does.
This conclusively proves that when H returns 0 it is only affirming the
above verified fact.
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly
executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly applies
to the halting theorem because H correctly determines:
from a description of an arbitrary computer program and an input, >>>> whether the program will finish running, or continue to run
forever.
For any program H that might determine whether programs halt,
a "pathological" program D, called with some input, can pass its >>>> own source and its input to H and then specifically do the opposite >>>> of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that
simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final state and >>>> stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach its own >>>> final state at line 6 conclusively proves that this D does not halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from their >>>> inputs to a final accept or reject state then it is understood that H
must only evaluate the behavior of its input and the behavior of non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D
correctly simulated by any element of the infinite set of every possible >>> H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing
hundreds many hundreds of times before they first notice that they have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a
rebuttal on the basis of these changed words is known as the strawman deception.
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly
executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly applies
to the halting theorem because H correctly determines:
from a description of an arbitrary computer program and an input, >>>>> whether the program will finish running, or continue to run
forever.
For any program H that might determine whether programs halt, >>>>> a "pathological" program D, called with some input, can pass its >>>>> own source and its input to H and then specifically do the
opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that
simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final state and >>>>> stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach its own >>>>> final state at line 6 conclusively proves that this D does not halt. >>>>>
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from their >>>>> inputs to a final accept or reject state then it is understood that H >>>>> must only evaluate the behavior of its input and the behavior of non- >>>>> inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D
correctly simulated by any element of the infinite set of every
possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing
hundreds many hundreds of times before they first notice that they have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a
rebuttal on the basis of these changed words is known as the strawman
deception.
When H(D,D) returns 0 to its caller it is merely affirming the above
verified fact, therefore H is necessarily correct and impossibly
incorrect.
On 3/17/2023 5:47 PM, olcott wrote:
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly
executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly applies >>>>>> to the halting theorem because H correctly determines:
from a description of an arbitrary computer program and an input, >>>>>> whether the program will finish running, or continue to run >>>>>> forever.
For any program H that might determine whether programs halt, >>>>>> a "pathological" program D, called with some input, can pass its >>>>>> own source and its input to H and then specifically do the
opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a) >>>>>> main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that
simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final state >>>>>> and
stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach its >>>>>> own
final state at line 6 conclusively proves that this D does not halt. >>>>>>
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from
their
inputs to a final accept or reject state then it is understood that H >>>>>> must only evaluate the behavior of its input and the behavior of non- >>>>>> inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D
correctly simulated by any element of the infinite set of every
possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing
hundreds many hundreds of times before they first notice that they have >>>> been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a
rebuttal on the basis of these changed words is known as the strawman
deception.
When H(D,D) returns 0 to its caller it is merely affirming the above
verified fact, therefore H is necessarily correct and impossibly
incorrect.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly
executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly applies
to the halting theorem because H correctly determines:
from a description of an arbitrary computer program and an input, >>>> whether the program will finish running, or continue to run
forever.
For any program H that might determine whether programs halt,
a "pathological" program D, called with some input, can pass its >>>> own source and its input to H and then specifically do the opposite >>>> of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that
simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final state and >>>> stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach its own >>>> final state at line 6 conclusively proves that this D does not halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from their >>>> inputs to a final accept or reject state then it is understood that H
must only evaluate the behavior of its input and the behavior of non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D
correctly simulated by any element of the infinite set of every possible >>> H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing
hundreds many hundreds of times before they first notice that they have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a
rebuttal on the basis of these changed words is known as the strawman deception.
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly
executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly applies
to the halting theorem because H correctly determines:
from a description of an arbitrary computer program and an input, >>>>> whether the program will finish running, or continue to run
forever.
For any program H that might determine whether programs halt, >>>>> a "pathological" program D, called with some input, can pass its >>>>> own source and its input to H and then specifically do the
opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that
simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final state and >>>>> stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach its own >>>>> final state at line 6 conclusively proves that this D does not halt. >>>>>
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from their >>>>> inputs to a final accept or reject state then it is understood that H >>>>> must only evaluate the behavior of its input and the behavior of non- >>>>> inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D
correctly simulated by any element of the infinite set of every
possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing
hundreds many hundreds of times before they first notice that they have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a
rebuttal on the basis of these changed words is known as the strawman
deception.
When H(D,D) returns 0 to its caller it is merely affirming the above
verified fact, therefore H is necessarily correct and impossibly
incorrect.
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly
executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly applies
to the halting theorem because H correctly determines:
from a description of an arbitrary computer program and an input, >>>>> whether the program will finish running, or continue to run
forever.
For any program H that might determine whether programs halt, >>>>> a "pathological" program D, called with some input, can pass its >>>>> own source and its input to H and then specifically do the
opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that
simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final state and >>>>> stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach its own >>>>> final state at line 6 conclusively proves that this D does not halt. >>>>>
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from their >>>>> inputs to a final accept or reject state then it is understood that H >>>>> must only evaluate the behavior of its input and the behavior of non- >>>>> inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D
correctly simulated by any element of the infinite set of every
possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing
hundreds many hundreds of times before they first notice that they have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a
rebuttal on the basis of these changed words is known as the strawman
deception.
When H(D,D) returns 0 to its caller it is merely affirming the above
verified fact, therefore H is necessarily correct and impossibly
incorrect.
On 3/17/2023 6:07 PM, olcott wrote:
On 3/17/2023 5:47 PM, olcott wrote:
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly
executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly
applies to the halting theorem because H correctly determines:
from a description of an arbitrary computer program and an >>>>>>> input,
whether the program will finish running, or continue to run >>>>>>> forever.
For any program H that might determine whether programs halt, >>>>>>> a "pathological" program D, called with some input, can pass its >>>>>>> own source and its input to H and then specifically do the >>>>>>> opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a) >>>>>>> main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that >>>>>>> simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final
state and
stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach
its own
final state at line 6 conclusively proves that this D does not halt. >>>>>>>
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from >>>>>>> their
inputs to a final accept or reject state then it is understood
that H
must only evaluate the behavior of its input and the behavior of >>>>>>> non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D >>>>>> correctly simulated by any element of the infinite set of every
possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing >>>>> hundreds many hundreds of times before they first notice that they
have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a
rebuttal on the basis of these changed words is known as the strawman
deception.
When H(D,D) returns 0 to its caller it is merely affirming the above
verified fact, therefore H is necessarily correct and impossibly
incorrect.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
Therefore any H(D,D) that returns 0 is necessarily correct.
Therefore any H(D,D) that returns 0 is necessarily correct.
Therefore any H(D,D) that returns 0 is necessarily correct.
Therefore any H(D,D) that returns 0 is necessarily correct.
Therefore any H(D,D) that returns 0 is necessarily correct.
On 3/17/2023 6:10 PM, olcott wrote:
On 3/17/2023 5:47 PM, olcott wrote:
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly
executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly
applies to the halting theorem because H correctly determines:
from a description of an arbitrary computer program and an >>>>>>> input,
whether the program will finish running, or continue to run >>>>>>> forever.
For any program H that might determine whether programs halt, >>>>>>> a "pathological" program D, called with some input, can pass its >>>>>>> own source and its input to H and then specifically do the >>>>>>> opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a) >>>>>>> main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that >>>>>>> simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final
state and
stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach
its own
final state at line 6 conclusively proves that this D does not halt. >>>>>>>
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from >>>>>>> their
inputs to a final accept or reject state then it is understood
that H
must only evaluate the behavior of its input and the behavior of >>>>>>> non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D >>>>>> correctly simulated by any element of the infinite set of every
possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing >>>>> hundreds many hundreds of times before they first notice that they
have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a
rebuttal on the basis of these changed words is known as the strawman
deception.
When H(D,D) returns 0 to its caller it is merely affirming the above
verified fact, therefore H is necessarily correct and impossibly
incorrect.
every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state Therefore any H(D,D) that returns 0 is necessarily correct.
every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state Therefore any H(D,D) that returns 0 is necessarily correct.
every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state Therefore any H(D,D) that returns 0 is necessarily correct.
every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state Therefore any H(D,D) that returns 0 is necessarily correct.
every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state Therefore any H(D,D) that returns 0 is necessarily correct.
On 3/17/2023 5:47 PM, olcott wrote:
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly
executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly applies >>>>>> to the halting theorem because H correctly determines:
from a description of an arbitrary computer program and an input, >>>>>> whether the program will finish running, or continue to run >>>>>> forever.
For any program H that might determine whether programs halt, >>>>>> a "pathological" program D, called with some input, can pass its >>>>>> own source and its input to H and then specifically do the
opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a) >>>>>> main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that
simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final state >>>>>> and
stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach its >>>>>> own
final state at line 6 conclusively proves that this D does not halt. >>>>>>
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from
their
inputs to a final accept or reject state then it is understood that H >>>>>> must only evaluate the behavior of its input and the behavior of non- >>>>>> inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D
correctly simulated by any element of the infinite set of every
possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing
hundreds many hundreds of times before they first notice that they have >>>> been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a
rebuttal on the basis of these changed words is known as the strawman
deception.
When H(D,D) returns 0 to its caller it is merely affirming the above
verified fact, therefore H is necessarily correct and impossibly
incorrect.
On 3/17/2023 6:41 PM, olcott wrote:
On 3/17/2023 6:10 PM, olcott wrote:
On 3/17/2023 5:47 PM, olcott wrote:
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly >>>>>>>> executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly
applies to the halting theorem because H correctly determines: >>>>>>>>
from a description of an arbitrary computer program and an >>>>>>>> input,
whether the program will finish running, or continue to run >>>>>>>> forever.
For any program H that might determine whether programs halt, >>>>>>>> a "pathological" program D, called with some input, can pass >>>>>>>> its
own source and its input to H and then specifically do the >>>>>>>> opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a) >>>>>>>> main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that >>>>>>>> simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final
state and
stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach >>>>>>>> its own
final state at line 6 conclusively proves that this D does not >>>>>>>> halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from >>>>>>>> their
inputs to a final accept or reject state then it is understood >>>>>>>> that H
must only evaluate the behavior of its input and the behavior of >>>>>>>> non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D >>>>>>> correctly simulated by any element of the infinite set of every
possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing >>>>>> hundreds many hundreds of times before they first notice that they >>>>>> have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a
rebuttal on the basis of these changed words is known as the strawman >>>>> deception.
When H(D,D) returns 0 to its caller it is merely affirming the above
verified fact, therefore H is necessarily correct and impossibly
incorrect.
every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state
Therefore any H(D,D) that returns 0 is necessarily correct.
every D correctly simulated by any H never halts
no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does
because halting requires reaching a final state
and D simulated by H never reaches its final state
no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does
Therefore any H(D,D) that returns 0 is necessarily correct.
On 3/17/2023 6:10 PM, olcott wrote:
On 3/17/2023 5:47 PM, olcott wrote:
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly
executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly
applies to the halting theorem because H correctly determines:
from a description of an arbitrary computer program and an >>>>>>> input,
whether the program will finish running, or continue to run >>>>>>> forever.
For any program H that might determine whether programs halt, >>>>>>> a "pathological" program D, called with some input, can pass its >>>>>>> own source and its input to H and then specifically do the >>>>>>> opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a) >>>>>>> main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that >>>>>>> simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final
state and
stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach
its own
final state at line 6 conclusively proves that this D does not halt. >>>>>>>
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from >>>>>>> their
inputs to a final accept or reject state then it is understood
that H
must only evaluate the behavior of its input and the behavior of >>>>>>> non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D >>>>>> correctly simulated by any element of the infinite set of every
possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing >>>>> hundreds many hundreds of times before they first notice that they
have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a
rebuttal on the basis of these changed words is known as the strawman
deception.
When H(D,D) returns 0 to its caller it is merely affirming the above
verified fact, therefore H is necessarily correct and impossibly
incorrect.
every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state Therefore any H(D,D) that returns 0 is necessarily correct.
On 3/17/2023 6:41 PM, olcott wrote:
On 3/17/2023 6:10 PM, olcott wrote:
On 3/17/2023 5:47 PM, olcott wrote:
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly >>>>>>>> executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly
applies to the halting theorem because H correctly determines: >>>>>>>>
from a description of an arbitrary computer program and an >>>>>>>> input,
whether the program will finish running, or continue to run >>>>>>>> forever.
For any program H that might determine whether programs halt, >>>>>>>> a "pathological" program D, called with some input, can pass >>>>>>>> its
own source and its input to H and then specifically do the >>>>>>>> opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a) >>>>>>>> main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that >>>>>>>> simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final
state and
stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach >>>>>>>> its own
final state at line 6 conclusively proves that this D does not >>>>>>>> halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from >>>>>>>> their
inputs to a final accept or reject state then it is understood >>>>>>>> that H
must only evaluate the behavior of its input and the behavior of >>>>>>>> non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D >>>>>>> correctly simulated by any element of the infinite set of every
possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing >>>>>> hundreds many hundreds of times before they first notice that they >>>>>> have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a
rebuttal on the basis of these changed words is known as the strawman >>>>> deception.
When H(D,D) returns 0 to its caller it is merely affirming the above
verified fact, therefore H is necessarily correct and impossibly
incorrect.
every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state
Therefore any H(D,D) that returns 0 is necessarily correct.
every D correctly simulated by any H never halts
no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does
because halting requires reaching a final state
and D simulated by H never reaches its final state
no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does
Therefore any H(D,D) that returns 0 is necessarily correct.
On 3/17/2023 6:41 PM, olcott wrote:
On 3/17/2023 6:10 PM, olcott wrote:
On 3/17/2023 5:47 PM, olcott wrote:
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly >>>>>>>> executed D(D) would remain stuck in recursive simulation (run
forever) unless H aborts its simulation of D this directly
applies to the halting theorem because H correctly determines: >>>>>>>>
from a description of an arbitrary computer program and an >>>>>>>> input,
whether the program will finish running, or continue to run >>>>>>>> forever.
For any program H that might determine whether programs halt, >>>>>>>> a "pathological" program D, called with some input, can pass >>>>>>>> its
own source and its input to H and then specifically do the >>>>>>>> opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving (a) >>>>>>>> main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that >>>>>>>> simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final
state and
stopping for any other reason does not count as halting then
The fact that D correctly simulated by H cannot possibly reach >>>>>>>> its own
final state at line 6 conclusively proves that this D does not >>>>>>>> halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping from >>>>>>>> their
inputs to a final accept or reject state then it is understood >>>>>>>> that H
must only evaluate the behavior of its input and the behavior of >>>>>>>> non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D >>>>>>> correctly simulated by any element of the infinite set of every
possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same thing >>>>>> hundreds many hundreds of times before they first notice that they >>>>>> have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a
rebuttal on the basis of these changed words is known as the strawman >>>>> deception.
When H(D,D) returns 0 to its caller it is merely affirming the above
verified fact, therefore H is necessarily correct and impossibly
incorrect.
every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state
Therefore any H(D,D) that returns 0 is necessarily correct.
every D correctly simulated by any H never halts
no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does
because halting requires reaching a final state
and D simulated by H never reaches its final state
no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does
Therefore any H(D,D) that returns 0 is necessarily correct.
On 3/17/2023 7:20 PM, olcott wrote:
On 3/17/2023 6:41 PM, olcott wrote:
On 3/17/2023 6:10 PM, olcott wrote:
On 3/17/2023 5:47 PM, olcott wrote:
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly >>>>>>>>> executed D(D) would remain stuck in recursive simulation (run >>>>>>>>> forever) unless H aborts its simulation of D this directly
applies to the halting theorem because H correctly determines: >>>>>>>>>
from a description of an arbitrary computer program and an >>>>>>>>> input,
whether the program will finish running, or continue to run >>>>>>>>> forever.
For any program H that might determine whether programs halt, >>>>>>>>> a "pathological" program D, called with some input, can >>>>>>>>> pass its
own source and its input to H and then specifically do the >>>>>>>>> opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving >>>>>>>>> (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that >>>>>>>>> simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final >>>>>>>>> state and
stopping for any other reason does not count as halting then >>>>>>>>>
The fact that D correctly simulated by H cannot possibly reach >>>>>>>>> its own
final state at line 6 conclusively proves that this D does not >>>>>>>>> halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping
from their
inputs to a final accept or reject state then it is understood >>>>>>>>> that H
must only evaluate the behavior of its input and the behavior >>>>>>>>> of non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D >>>>>>>> correctly simulated by any element of the infinite set of every >>>>>>>> possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same
thing
hundreds many hundreds of times before they first notice that
they have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a >>>>>> rebuttal on the basis of these changed words is known as the strawman >>>>>> deception.
When H(D,D) returns 0 to its caller it is merely affirming the above >>>>> verified fact, therefore H is necessarily correct and impossibly
incorrect.
every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state
Therefore any H(D,D) that returns 0 is necessarily correct.
every D correctly simulated by any H never halts
no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does
because halting requires reaching a final state
and D simulated by H never reaches its final state
no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does
Therefore any H(D,D) that returns 0 is necessarily correct.
Unless one rejects the notion of a UTM D correctly simulated by H
necessarily reports on the exact behavior that D specifies to H.
Unless one rejects the notion of a UTM D correctly simulated by H
necessarily reports on the exact behavior that D specifies to H.
Unless one rejects the notion of a UTM D correctly simulated by H
necessarily reports on the exact behavior that D specifies to H.
Unless one rejects the notion of a UTM D correctly simulated by H
necessarily reports on the exact behavior that D specifies to H.
Unless one rejects the notion of a UTM D correctly simulated by H
necessarily reports on the exact behavior that D specifies to H.
On 3/17/2023 7:20 PM, olcott wrote:
On 3/17/2023 6:41 PM, olcott wrote:
On 3/17/2023 6:10 PM, olcott wrote:
On 3/17/2023 5:47 PM, olcott wrote:
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly >>>>>>>>> executed D(D) would remain stuck in recursive simulation (run >>>>>>>>> forever) unless H aborts its simulation of D this directly
applies to the halting theorem because H correctly determines: >>>>>>>>>
from a description of an arbitrary computer program and an >>>>>>>>> input,
whether the program will finish running, or continue to run >>>>>>>>> forever.
For any program H that might determine whether programs halt, >>>>>>>>> a "pathological" program D, called with some input, can >>>>>>>>> pass its
own source and its input to H and then specifically do the >>>>>>>>> opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving >>>>>>>>> (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that >>>>>>>>> simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final >>>>>>>>> state and
stopping for any other reason does not count as halting then >>>>>>>>>
The fact that D correctly simulated by H cannot possibly reach >>>>>>>>> its own
final state at line 6 conclusively proves that this D does not >>>>>>>>> halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping
from their
inputs to a final accept or reject state then it is understood >>>>>>>>> that H
must only evaluate the behavior of its input and the behavior >>>>>>>>> of non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D >>>>>>>> correctly simulated by any element of the infinite set of every >>>>>>>> possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same
thing
hundreds many hundreds of times before they first notice that
they have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a >>>>>> rebuttal on the basis of these changed words is known as the strawman >>>>>> deception.
When H(D,D) returns 0 to its caller it is merely affirming the above >>>>> verified fact, therefore H is necessarily correct and impossibly
incorrect.
every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state
Therefore any H(D,D) that returns 0 is necessarily correct.
every D correctly simulated by any H never halts
no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does
because halting requires reaching a final state
and D simulated by H never reaches its final state
no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does
Therefore any H(D,D) that returns 0 is necessarily correct.
Unless one rejects the notion of a UTM D correctly simulated by H
necessarily derives the exact behavior that D specifies to H.
Unless one rejects the notion of a UTM D correctly simulated by H
necessarily derives the exact behavior that D specifies to H.
Unless one rejects the notion of a UTM D correctly simulated by H
necessarily derives the exact behavior that D specifies to H.
Unless one rejects the notion of a UTM D correctly simulated by H
necessarily derives the exact behavior that D specifies to H.
Unless one rejects the notion of a UTM D correctly simulated by H
necessarily derives the exact behavior that D specifies to H.
On 3/17/2023 7:20 PM, olcott wrote:
On 3/17/2023 6:41 PM, olcott wrote:
On 3/17/2023 6:10 PM, olcott wrote:
On 3/17/2023 5:47 PM, olcott wrote:
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that directly >>>>>>>>> executed D(D) would remain stuck in recursive simulation (run >>>>>>>>> forever) unless H aborts its simulation of D this directly
applies to the halting theorem because H correctly determines: >>>>>>>>>
from a description of an arbitrary computer program and an >>>>>>>>> input,
whether the program will finish running, or continue to run >>>>>>>>> forever.
For any program H that might determine whether programs halt, >>>>>>>>> a "pathological" program D, called with some input, can >>>>>>>>> pass its
own source and its input to H and then specifically do the >>>>>>>>> opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation: proving >>>>>>>>> (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that >>>>>>>>> simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final >>>>>>>>> state and
stopping for any other reason does not count as halting then >>>>>>>>>
The fact that D correctly simulated by H cannot possibly reach >>>>>>>>> its own
final state at line 6 conclusively proves that this D does not >>>>>>>>> halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping
from their
inputs to a final accept or reject state then it is understood >>>>>>>>> that H
must only evaluate the behavior of its input and the behavior >>>>>>>>> of non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D >>>>>>>> correctly simulated by any element of the infinite set of every >>>>>>>> possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same
thing
hundreds many hundreds of times before they first notice that
they have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a >>>>>> rebuttal on the basis of these changed words is known as the strawman >>>>>> deception.
When H(D,D) returns 0 to its caller it is merely affirming the above >>>>> verified fact, therefore H is necessarily correct and impossibly
incorrect.
every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state
Therefore any H(D,D) that returns 0 is necessarily correct.
every D correctly simulated by any H never halts
no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does
because halting requires reaching a final state
and D simulated by H never reaches its final state
no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does
Therefore any H(D,D) that returns 0 is necessarily correct.
On 3/17/2023 7:46 PM, olcott wrote:
On 3/17/2023 7:20 PM, olcott wrote:The notion of a UTM conclusively proves that D correctly simulated by H
On 3/17/2023 6:41 PM, olcott wrote:
On 3/17/2023 6:10 PM, olcott wrote:
On 3/17/2023 5:47 PM, olcott wrote:
On 3/17/2023 4:05 PM, olcott wrote:
On 3/17/2023 3:07 PM, olcott wrote:
On 3/17/2023 2:43 PM, olcott wrote:
On 3/17/2023 11:54 AM, olcott wrote:
When simulating halt decider H correctly predicts that
directly executed D(D) would remain stuck in recursive
simulation (run forever) unless H aborts its simulation of D >>>>>>>>>> this directly applies to the halting theorem because H
correctly determines:
from a description of an arbitrary computer program and an >>>>>>>>>> input,
whether the program will finish running, or continue to >>>>>>>>>> run forever.
For any program H that might determine whether programs halt, >>>>>>>>>> a "pathological" program D, called with some input, can >>>>>>>>>> pass its
own source and its input to H and then specifically do the >>>>>>>>>> opposite
of what H predicts D will do.
https://en.wikipedia.org/wiki/Halting_problem
01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Here is the sequence when H never aborts it simulation:
proving (a)
main() calls H(D,D) that simulates D(D) at line 11
keeps repeating: simulated D(D) calls simulated H(D,D) that >>>>>>>>>> simulates D(D) at line 03 ...
When it is understood that halting requires reaching a final >>>>>>>>>> state and
stopping for any other reason does not count as halting then >>>>>>>>>>
The fact that D correctly simulated by H cannot possibly reach >>>>>>>>>> its own
final state at line 6 conclusively proves that this D does not >>>>>>>>>> halt.
When H returns 0 it is only affirming this verified fact.
When it is understood that all deciders compute the mapping >>>>>>>>>> from their
inputs to a final accept or reject state then it is understood >>>>>>>>>> that H
must only evaluate the behavior of its input and the behavior >>>>>>>>>> of non-
inputs is not allowed to be considered.
Anyone with sufficient software engineering knowledge knows that D >>>>>>>>> correctly simulated by any element of the infinite set of every >>>>>>>>> possible
H cannot possibly reach past its own line 3.
People with attention deficit disorder have to be told the same >>>>>>>> thing
hundreds many hundreds of times before they first notice that
they have
been told this thing at least once.
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
every D correctly simulated by any H never halts
The above words are a verified fact, changing these words to form a >>>>>>> rebuttal on the basis of these changed words is known as the
strawman
deception.
When H(D,D) returns 0 to its caller it is merely affirming the above >>>>>> verified fact, therefore H is necessarily correct and impossibly
incorrect.
every D correctly simulated by any H never halts
no matter what H does because halting requires reaching a final state
Therefore any H(D,D) that returns 0 is necessarily correct.
every D correctly simulated by any H never halts
no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does
because halting requires reaching a final state
and D simulated by H never reaches its final state
no matter what H does
no matter what H does
no matter what H does
no matter what H does
no matter what H does
Therefore any H(D,D) that returns 0 is necessarily correct.
does derive the behavior that a simulating halt decider must measure.
The notion of a UTM conclusively proves that D correctly simulated by H
does derive the behavior that a simulating halt decider must measure.
The notion of a UTM conclusively proves that D correctly simulated by H
does derive the behavior that a simulating halt decider must measure.
Because all deciders must compute the mapping
from their inputs
from their inputs
from their inputs
from their inputs
from their inputs
To their own accept or reject state
anyone and anything that says that H must report on the
behavior of non-inputs contradicts the definition of a decider
anyone and anything that says that H must report on the
behavior of non-inputs contradicts the definition of a decider
anyone and anything that says that H must report on the
behavior of non-inputs contradicts the definition of a decider
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 366 |
Nodes: | 16 (2 / 14) |
Uptime: | 03:51:12 |
Calls: | 7,812 |
Files: | 12,924 |
Messages: | 5,749,465 |