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.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/17/23 9: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.
>

Yes, just rwo year old behavior repeating the same flawed arguements
over and over.

See other reply.

(or almost any of the replies, as he just keep recycling the same bad
arguments)

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.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/17/23 10: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.

No, it says that H could derive its answer by looking at what it
predicts a UTM would do with the input. Since the H that answer is NOT a
UTM, it can't just look at the behavior of H.

Note, D doesn't call a UTM, but the H that is actually deciding it.

The fact that UTM(D,D) will Halt since H(D,D) returns 0 says the notion
of a UTM also shows H to be wrong.

>
> Dishonest people will form a rebuttal by changing the words and then
> rebutting these changed words.
>

Right, which is what you have been doing for decades.

The WORDS say the decider must answer based on the actual behavior of
the actual machine given the input.

You agree that D(D) will Halt since H(D,D) returns 0, thus you have
effectively agreed that the answer by the definition that H needs to
return is Halting, but you claim non-halting must be right because you
"change the words".

Yes, we can look at a simulation instead of the actual behavior, and
H(M,d) can answer based on it determination of the behavior of UTM(M,d),
or for this particualr problem UTM(D,D).

Note, D does NOT call UTM(D,D) but H(D,D), so you can't make that as a
replacement. H answer based on its PREDICTION of what the UTM will do,
not "become" a UTM for awhile (which is a logical impossibility).

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.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/17/23 10: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.
>
>

Then how does H use the concept of a UTM? by ESP?

Maybe your problem is you just don't understand what "Prove" means.
You've made that error many times in the past.

All the concept of a UTM says is that it is POSSIBLE to convert any
Turing Machine into a description that it is possible to build a
"Universal Turing Machine" could process to get the same results.

This doesn't say anything that means that if H aborts its simulation
that it means the input was non-halting.

It also doesn't mean that a "Simulating Halt Decider" gets to replace
copies of itself in its input with a UTM instead of itself, as the
decider isn't actually a UTM.

Your just proving that you are clueless about what you are talking about.

This is just accentutd by your childish "responding to answers but not
actually responding".

Shows your mental age, its like 2 or 3.

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.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/17/23 11:46 PM, olcott wrote:
> 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.
>

No, it cant, because H is a SPECIFIC program and so is D, so therefore
it is NOT a fact that H correctly simulates D by the definition of
"Correctly Simulates" that relates the result of the simulation to the
halting behavior of machine it is doing, that of a UTM.

Since H isn't a UTM, we have no simulation BY a UTM, so no evidence at
all to make the claim, only to show that you are totally ignorant of
what you talk about.

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.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/18/23 11:00 AM, olcott wrote:
> 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.
>

Then the simulation by H is NOT correct.

PERIOD.

> 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.

Nope, the behavior of the correct simulation of a machine is identical
to the direct execution of the machine.

>
> 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.
>

So, SHOW the actual step that is ACTUALLY CORRECTLY SIMULATED where
there actions differ.

THe problem is that H just aborts its simulation at a point when H1
continues and that doesn't prove a different correct simulation.

> 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.
>
>

No, to be CORRECT, it must base its decision on the actual behavior of
the machine describe by the input.

If it can't do that, it is just wrong.