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:
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 simulated D does not halt.
*When H returns 0 it is only affirming this verified fact*
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 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.
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:
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 simulated D does not halt.
*When H returns 0 it is only affirming this verified fact*
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 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.
On 3/17/2023 8:13 PM, olcott wrote:
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:
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 simulated D does not
halt.
*When H returns 0 it is only affirming this verified fact*
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 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.
The notion of a UTM conclusively proves that D correctly simulated by H
does derive the behavior that a simulating halt decider must measure.
Dishonest people will form a rebuttal by changing the words and then rebutting these changed words.
On 3/17/2023 8:13 PM, olcott wrote:
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:
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 simulated D does not
halt.
*When H returns 0 it is only affirming this verified fact*
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 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.
The notion of a UTM conclusively proves that D correctly simulated by H
does derive the behavior that a simulating halt decider must measure.
On 3/17/2023 9:27 PM, olcott wrote:
On 3/17/2023 8:13 PM, olcott wrote:
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:
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 simulated D does not >>> halt.
*When H returns 0 it is only affirming this verified fact*
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 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.
The notion of a UTM conclusively proves that D correctly simulated by H
does derive the behavior that a simulating halt decider must measure.
I did not mention anything about deriving answer in the above sentence.
I did not mention anything about deriving answer in the above sentence.
I did not mention anything about deriving answer in the above sentence.
On 3/17/2023 9:27 PM, olcott wrote:
On 3/17/2023 8:13 PM, olcott wrote:
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:
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 simulated D does not >>> halt.
*When H returns 0 it is only affirming this verified fact*
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 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.
The notion of a UTM conclusively proves that D correctly simulated by H
does derive the behavior that a simulating halt decider must measure.
I did not mention anything about deriving answer in the above sentence.
I did not mention anything about deriving answer in the above sentence.
I did not mention anything about deriving answer in the above sentence.
On 3/17/2023 9:52 PM, olcott wrote:
On 3/17/2023 9:27 PM, olcott wrote:
On 3/17/2023 8:13 PM, olcott wrote:
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:
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 simulated D does
not
halt.
*When H returns 0 it is only affirming this verified fact*
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 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.
The notion of a UTM conclusively proves that D correctly simulated by H
does derive the behavior that a simulating halt decider must measure.
I did not mention anything about deriving answer in the above sentence.
I did not mention anything about deriving answer in the above sentence.
I did not mention anything about deriving answer in the above sentence.
To evaluate what I am saying the word-for-word statement must be
evaluated and no inference beyond what is directly stated can be included.
Does the behavior of the correct simulation of D by H provide the actual behavior that D specifies to H?
The notion of a UTM proves that it is.
A simulating halt decider (SHD) correctly predicts what the behavior of
its input would be if it never aborted the simulation of this input. It
does this by correctly recognizing several non-halting behavior patterns
in a finite number of steps of correct simulation. Inputs that do
terminate are simply simulated until they complete.
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:
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 we examine every element of the infinite set of H/D pairs such that
D is correctly simulated by H then every D correctly simulated by any H
never halts.
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 simulated D does not halt.
When H aborts its simulation and returns 0 it is only affirming this
verified fact
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 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.
On 3/17/2023 8:52 PM, olcott wrote:
A simulating halt decider (SHD) correctly predicts what the behavior of
its input would be if it never aborted the simulation of this input. It
does this by correctly recognizing several non-halting behavior patterns
in a finite number of steps of correct simulation. Inputs that do
terminate are simply simulated until they complete.
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:
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 we examine every element of the infinite set of H/D pairs such that
D is correctly simulated by H then every D correctly simulated by any H
never halts.
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 simulated D does not
halt.
When H aborts its simulation and returns 0 it is only affirming this
verified fact
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 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.
The behavior of directly executed D(D) is the same as the behavior of D correctly simulated by H1 yet different than the behavior of D correctly simulated by H.
The behavior of D correctly simulated by H is not the same as the
behavior of D correctly simulated by H1 because D was specifically
defined to have a pathological relationship to H and not to H1. This
changes the behavior of D relative to H and H1.
That the behavior is different can be empirically verified by examining
the execution trace of D correctly simulated by H compared to the
execution trace of D correctly simulated by H1.
None-the-less H must base its halt status decision on the actual
behavior that it actually sees and it sees the behavior of D correctly simulated by H.
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 366 |
Nodes: | 16 (2 / 14) |
Uptime: | 25:15:17 |
Calls: | 7,832 |
Calls today: | 1 |
Files: | 12,933 |
Messages: | 5,770,990 |