On 1/30/2024 9:38 AM, immibis wrote:
> On 1/30/24 03:17, olcott wrote:
>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>> On 1/29/24 8:53 AM, olcott wrote:
>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>
>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>> halting problem is an ill-formed question.
>>>>>
>>>>> Doesn’t matter how you phrase it, the fact remains that there is no
>>>>> logically self-consistent answer to the problem. That’s what Turing
>>>>> proved, and you have done nothing to change that.
>>>>
>>>> Likewise there is no logically consistent answer to this question:
>>>> Is this sentence true or false: "this sentence is not true"?
>>>> It is undecidable because the question itself is incorrect.
>>>>
>>>> Every yes/no question defined to have no correct yes/no answer is an
>>>> incorrect question.
>>>>
>>>
>>> And the question, "Does the Computation defined by this input Halt?"
>>> always has a correct yes/no answer, so is a CORRECT question.
>>
>> Yet when H is asked this question it is an entirely different
>> question
>
> Wrong
>
>> because the context of who is asked the question
>> DOES CHANGE THE MEANING OF THE QUESTION.
>
> Wrong in mathematics

It is necessarily always right it is the case that math
guys hardly know any linguistics at all thus mistake their
own ignorance for knowledge.

The x86 machine code of D proves that it specifies recursive
simulation to H.

_D()
[00001c72] 55 push ebp
[00001c73] 8bec mov ebp,esp
[00001c75] 51 push ecx
[00001c76] 8b4508 mov eax,[ebp+08]
[00001c79] 50 push eax ; push D
[00001c7a] 8b4d08 mov ecx,[ebp+08]
[00001c7d] 51 push ecx ; push D
[00001c7e] e8bff8ffff call 00001542 ; call H
[00001c83] 83c408 add esp,+08
[00001c86] 8945fc mov [ebp-04],eax
[00001c89] 837dfc00 cmp dword [ebp-04],+00
[00001c8d] 7402 jz 00001c91
[00001c8f] ebfe jmp 00001c8f
[00001c91] 8b45fc mov eax,[ebp-04]
[00001c94] 8be5 mov esp,ebp
[00001c96] 5d pop ebp
[00001c97] c3 ret
Size in bytes:(0038) [00001c97]

>>
>> What correct Boolean value does H return when D is defined to do the
>> opposite of whatever value that H returns?" has no correct answer.
>>
>
> That is the POOP problem, not the halting problem. We are talking about
> the halting problem, which asks whether a Turing machine/input pair has
> an execution sequence that is infinite.

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

On 1/30/24 05:11, olcott wrote:
> On 1/29/2024 9:01 PM, Richard Damon wrote:
>> On 1/29/24 9:17 PM, olcott wrote:
>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>> On 1/29/24 8:53 AM, olcott wrote:
>>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>>
>>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>>> halting problem is an ill-formed question.
>>>>>>
>>>>>> Doesn’t matter how you phrase it, the fact remains that there is no
>>>>>> logically self-consistent answer to the problem. That’s what Turing
>>>>>> proved, and you have done nothing to change that.
>>>>>
>>>>> Likewise there is no logically consistent answer to this question:
>>>>> Is this sentence true or false: "this sentence is not true"?
>>>>> It is undecidable because the question itself is incorrect.
>>>>>
>>>>> Every yes/no question defined to have no correct yes/no answer is an
>>>>> incorrect question.
>>>>>
>>>>
>>>> And the question, "Does the Computation defined by this input Halt?"
>>>> always has a correct yes/no answer, so is a CORRECT question.
>>>
>>> Yet when H is asked this question it is an entirely different
>>> question because the context of who is asked the question
>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>
>> Why is it different?
>>
>> WHy does the behavior of D change because we ask H about it, since
>> that H was fully defined before D was created?
>>
>> (It had to be, due to causality)
>>
>>>
>>> What correct Boolean value does H return when D is defined to do the
>>> opposite of whatever value that H returns?" has no correct answer.
>>>
>>>
>>
>> That is NOT the question, just your POOP.
>
> That *IS* the question as long as you are not too ignorant
> to understand that the context of who is asked a question
> *DOES CHANGE THE MEANING OF THE QUESTION*
>

You are ignorant because the context of who is asked a mathematical
question *DOES NOT CHANGE THE MEANING OF THE QUESTION*

If I ask Susan whether the sequence [1,2,3,4,...] is infinite the
correct answer is the same as if I ask Joseph whether the sequence
[1,2,3,4,...] is infinite.

On 1/30/24 05:11, olcott wrote:
> the context of who is asked a question
> *DOES CHANGE THE MEANING OF THE QUESTION*
>
> The key example of this is: Are you a little girl?

Please express this question in ZFC

On 1/30/24 16:46, olcott wrote:
> On 1/30/2024 9:38 AM, immibis wrote:
>> On 1/30/24 03:17, olcott wrote:
>>> Yet when H is asked this question it is an entirely different
>>> question
>>
>> Wrong
>>
>>> because the context of who is asked the question
>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>
>> Wrong in mathematics
>
> It is necessarily always right it is the case that math
> guys hardly know any linguistics at all thus mistake their
> own ignorance for knowledge.

You hardly know any mathematics at all thus mistake your own ignorance
for knowledge.
>>> What correct Boolean value does H return when D is defined to do the
>>> opposite of whatever value that H returns?" has no correct answer.
>>
>> That is the POOP problem, not the halting problem. We are talking
>> about the halting problem, which asks whether a Turing machine/input
>> pair has an execution sequence that is infinite.

On 1/30/24 06:57, olcott wrote:
> On 1/29/2024 11:41 PM, Lawrence D'Oliveiro wrote:
>> On Mon, 29 Jan 2024 07:53:23 -0600, olcott wrote:
>>
>>> Every yes/no question defined to have no correct yes/no answer is an
>>> incorrect question.
>>
>> Can you prove that?
>
> I created the notion of an incorrect question back in 2015.
> (and in 2004)
>
> *The logical law of polar questions*
> *Peter Olcott Feb 20, 2015, 11:38:48 AM*
>
> When posed to a man whom has never been married,
> the question: Have you stopped beating your wife?
> Is an incorrect polar question because neither yes nor
> no is a correct answer.
>
> All polar questions (including incorrect polar questions)
> have exactly one answer from the following:
> 1) No
> 2) Yes
> 3) Neither // Only applies to incorrect polar questions
>
> As far as I know I am the original discoverer of the
> above logical law, thus copyright 2015 by Peter Olcott.
> https://groups.google.com/g/sci.lang/c/AO5Vlupeelo/m/nxJy7N2vULwJ
>

*The logical law of Olcott statements*
*Pseudonymous user "immibis" Jan 30 2024, 06:52:54 PM*

When posed to a Usenet newsgroup, any statement made by Peter Olcott is
an incorrect statement because it is the opposite of the truth.

All Olcott statements are at least two of the following:
1) Untrue
2) Stupid
3) Dishonest

As far as I know I am the original discoverer of the above logical law,
thus copyright 2024 by pseudonymous user "immibis".

On 1/30/24 10:46 AM, olcott wrote:
> On 1/30/2024 9:38 AM, immibis wrote:
>> On 1/30/24 03:17, olcott wrote:
>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>> On 1/29/24 8:53 AM, olcott wrote:
>>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>>
>>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>>> halting problem is an ill-formed question.
>>>>>>
>>>>>> Doesn’t matter how you phrase it, the fact remains that there is no
>>>>>> logically self-consistent answer to the problem. That’s what Turing
>>>>>> proved, and you have done nothing to change that.
>>>>>
>>>>> Likewise there is no logically consistent answer to this question:
>>>>> Is this sentence true or false: "this sentence is not true"?
>>>>> It is undecidable because the question itself is incorrect.
>>>>>
>>>>> Every yes/no question defined to have no correct yes/no answer is an
>>>>> incorrect question.
>>>>>
>>>>
>>>> And the question, "Does the Computation defined by this input Halt?"
>>>> always has a correct yes/no answer, so is a CORRECT question.
>>>
>>> Yet when H is asked this question it is an entirely different
>>> question
>>
>> Wrong
>>
>>> because the context of who is asked the question
>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>
>> Wrong in mathematics
>
> It is necessarily always right it is the case that math
> guys hardly know any linguistics at all thus mistake their
> own ignorance for knowledge.
>
> The x86 machine code of D proves that it specifies recursive
> simulation to H.

For this H, it specifies FINITE recursive simulation to H, so a HALTING
behavior.

>
> _D()
> [00001c72] 55         push ebp
> [00001c73] 8bec       mov ebp,esp
> [00001c75] 51         push ecx
> [00001c76] 8b4508     mov eax,[ebp+08]
> [00001c79] 50         push eax         ; push D
> [00001c7a] 8b4d08     mov ecx,[ebp+08]
> [00001c7d] 51         push ecx         ; push D
> [00001c7e] e8bff8ffff call 00001542    ; call H
> [00001c83] 83c408     add esp,+08
> [00001c86] 8945fc     mov [ebp-04],eax
> [00001c89] 837dfc00   cmp dword [ebp-04],+00
> [00001c8d] 7402       jz 00001c91
> [00001c8f] ebfe       jmp 00001c8f
> [00001c91] 8b45fc     mov eax,[ebp-04]
> [00001c94] 8be5       mov esp,ebp
> [00001c96] 5d         pop ebp
> [00001c97] c3         ret
> Size in bytes:(0038) [00001c97]
>
>
>>>
>>> What correct Boolean value does H return when D is defined to do the
>>> opposite of whatever value that H returns?" has no correct answer.
>>>
>>
>> That is the POOP problem, not the halting problem. We are talking
>> about the halting problem, which asks whether a Turing machine/input
>> pair has an execution sequence that is infinite.
>

On 1/30/2024 8:21 PM, Richard Damon wrote:
> On 1/30/24 10:46 AM, olcott wrote:
>> On 1/30/2024 9:38 AM, immibis wrote:
>>> On 1/30/24 03:17, olcott wrote:
>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>> On 1/29/24 8:53 AM, olcott wrote:
>>>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>>>
>>>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>>>> halting problem is an ill-formed question.
>>>>>>>
>>>>>>> Doesn’t matter how you phrase it, the fact remains that there is no
>>>>>>> logically self-consistent answer to the problem. That’s what Turing
>>>>>>> proved, and you have done nothing to change that.
>>>>>>
>>>>>> Likewise there is no logically consistent answer to this question:
>>>>>> Is this sentence true or false: "this sentence is not true"?
>>>>>> It is undecidable because the question itself is incorrect.
>>>>>>
>>>>>> Every yes/no question defined to have no correct yes/no answer is an
>>>>>> incorrect question.
>>>>>>
>>>>>
>>>>> And the question, "Does the Computation defined by this input
>>>>> Halt?" always has a correct yes/no answer, so is a CORRECT question.
>>>>
>>>> Yet when H is asked this question it is an entirely different
>>>> question
>>>
>>> Wrong
>>>
>>>> because the context of who is asked the question
>>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>>
>>> Wrong in mathematics
>>
>> It is necessarily always right it is the case that math
>> guys hardly know any linguistics at all thus mistake their
>> own ignorance for knowledge.
>>
>> The x86 machine code of D proves that it specifies recursive
>> simulation to H.
>
> For this H, it specifies FINITE recursive simulation to H, so a HALTING
> behavior.
>

When one understands that H is always correct to abort any
simulation that cannot possibly stop running unless aborted

01 int D(ptr x) // ptr is pointer to int function
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 }

As every H specified by the above template must do then each
and every element of this infinite set is correct to abort
its simulation and reject its input D as non-halting.

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

Op 31.jan.2024 om 04:53 schreef olcott:
> On 1/30/2024 8:21 PM, Richard Damon wrote:
>> On 1/30/24 10:46 AM, olcott wrote:
>>> On 1/30/2024 9:38 AM, immibis wrote:
>>>> On 1/30/24 03:17, olcott wrote:
>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>> On 1/29/24 8:53 AM, olcott wrote:
>>>>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>>>>
>>>>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>>>>> halting problem is an ill-formed question.
>>>>>>>>
>>>>>>>> Doesn’t matter how you phrase it, the fact remains that there is no
>>>>>>>> logically self-consistent answer to the problem. That’s what Turing
>>>>>>>> proved, and you have done nothing to change that.
>>>>>>>
>>>>>>> Likewise there is no logically consistent answer to this question:
>>>>>>> Is this sentence true or false: "this sentence is not true"?
>>>>>>> It is undecidable because the question itself is incorrect.
>>>>>>>
>>>>>>> Every yes/no question defined to have no correct yes/no answer is an
>>>>>>> incorrect question.
>>>>>>>
>>>>>>
>>>>>> And the question, "Does the Computation defined by this input
>>>>>> Halt?" always has a correct yes/no answer, so is a CORRECT question.
>>>>>
>>>>> Yet when H is asked this question it is an entirely different
>>>>> question
>>>>
>>>> Wrong
>>>>
>>>>> because the context of who is asked the question
>>>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>>>
>>>> Wrong in mathematics
>>>
>>> It is necessarily always right it is the case that math
>>> guys hardly know any linguistics at all thus mistake their
>>> own ignorance for knowledge.
>>>
>>> The x86 machine code of D proves that it specifies recursive
>>> simulation to H.
>>
>> For this H, it specifies FINITE recursive simulation to H, so a
>> HALTING behavior.
>>
>
> When one understands that H is always correct to abort any
> simulation that cannot possibly stop running unless aborted
>
> 01 int D(ptr x)  // ptr is pointer to int function
> 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 }
>
> As every H specified by the above template must do then each
> and every element of this infinite set is correct to abort
> its simulation and reject its input D as non-halting.
>

No, Han aborts is simulation, so it is not necessary to abort Dan, which
is based on Han, because it aborts itself already. Then it returns a
non-halting status and Dan continues with line 04.
Han(Dan,Dan) should decide for its input Dan, which aborts itself, not
for its non-input Dss which has an infinite recursion.

On 1/31/24 04:53, olcott wrote:
> On 1/30/2024 8:21 PM, Richard Damon wrote:
>> On 1/30/24 10:46 AM, olcott wrote:
>>> On 1/30/2024 9:38 AM, immibis wrote:
>>>> On 1/30/24 03:17, olcott wrote:
>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>> On 1/29/24 8:53 AM, olcott wrote:
>>>>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>>>>
>>>>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>>>>> halting problem is an ill-formed question.
>>>>>>>>
>>>>>>>> Doesn’t matter how you phrase it, the fact remains that there is no
>>>>>>>> logically self-consistent answer to the problem. That’s what Turing
>>>>>>>> proved, and you have done nothing to change that.
>>>>>>>
>>>>>>> Likewise there is no logically consistent answer to this question:
>>>>>>> Is this sentence true or false: "this sentence is not true"?
>>>>>>> It is undecidable because the question itself is incorrect.
>>>>>>>
>>>>>>> Every yes/no question defined to have no correct yes/no answer is an
>>>>>>> incorrect question.
>>>>>>>
>>>>>>
>>>>>> And the question, "Does the Computation defined by this input
>>>>>> Halt?" always has a correct yes/no answer, so is a CORRECT question.
>>>>>
>>>>> Yet when H is asked this question it is an entirely different
>>>>> question
>>>>
>>>> Wrong
>>>>
>>>>> because the context of who is asked the question
>>>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>>>
>>>> Wrong in mathematics
>>>
>>> It is necessarily always right it is the case that math
>>> guys hardly know any linguistics at all thus mistake their
>>> own ignorance for knowledge.
>>>
>>> The x86 machine code of D proves that it specifies recursive
>>> simulation to H.
>>
>> For this H, it specifies FINITE recursive simulation to H, so a
>> HALTING behavior.
>>
>
> When one understands that H is always correct to abort any
> simulation that cannot possibly stop running unless aborted
>
> 01 int D(ptr x)  // ptr is pointer to int function
> 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 }
>
> As every H specified by the above template must do then each
> and every element of this infinite set is correct to abort
> its simulation and reject its input D as non-halting.
>

When one understands that a non-halting machine has an infinite
execution sequence and a halting machine has a finite execution
sequence, one sees that you are wrong.

On 1/30/24 10:53 PM, olcott wrote:
> On 1/30/2024 8:21 PM, Richard Damon wrote:
>> On 1/30/24 10:46 AM, olcott wrote:
>>> On 1/30/2024 9:38 AM, immibis wrote:
>>>> On 1/30/24 03:17, olcott wrote:
>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>> On 1/29/24 8:53 AM, olcott wrote:
>>>>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>>>>
>>>>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>>>>> halting problem is an ill-formed question.
>>>>>>>>
>>>>>>>> Doesn’t matter how you phrase it, the fact remains that there is no
>>>>>>>> logically self-consistent answer to the problem. That’s what Turing
>>>>>>>> proved, and you have done nothing to change that.
>>>>>>>
>>>>>>> Likewise there is no logically consistent answer to this question:
>>>>>>> Is this sentence true or false: "this sentence is not true"?
>>>>>>> It is undecidable because the question itself is incorrect.
>>>>>>>
>>>>>>> Every yes/no question defined to have no correct yes/no answer is an
>>>>>>> incorrect question.
>>>>>>>
>>>>>>
>>>>>> And the question, "Does the Computation defined by this input
>>>>>> Halt?" always has a correct yes/no answer, so is a CORRECT question.
>>>>>
>>>>> Yet when H is asked this question it is an entirely different
>>>>> question
>>>>
>>>> Wrong
>>>>
>>>>> because the context of who is asked the question
>>>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>>>
>>>> Wrong in mathematics
>>>
>>> It is necessarily always right it is the case that math
>>> guys hardly know any linguistics at all thus mistake their
>>> own ignorance for knowledge.
>>>
>>> The x86 machine code of D proves that it specifies recursive
>>> simulation to H.
>>
>> For this H, it specifies FINITE recursive simulation to H, so a
>> HALTING behavior.
>>
>
> When one understands that H is always correct to abort any
> simulation that cannot possibly stop running unless aborted
>
> 01 int D(ptr x)  // ptr is pointer to int function
> 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 }
>
> As every H specified by the above template must do then each
> and every element of this infinite set is correct to abort
> its simulation and reject its input D as non-halting.
>

No, H is only correct to abort and report non-halting, if that exact
same program it was looking at (using the exact same H as that H was)
will not halt when run.

If the code of that H is coded to abort and return non-halting, then
that input will be Halting, and thus that H was wrong.

This goes back to the comments about the "Illusion of Truth", as, H,
isn't looking at the input that it was ACTUALLY given, but the
programmer of it was reasoning (not the program, as programs don't
"reason" only obey their programmong) if he wrote a different program,
that didn't abort, then the input IT was given (neglecting that this
input would be DIFFERENT, as it is based on a different H) must have its
simulation aborted. But since that is a different input, you can't
migrate that answer to the input it was actually given.

Your problem is you just don't understand the fundamental terms you are
using. Halting is about Specific input that decribe specific programs.
"Templates" themselves are NOT valid inputs, only ways to make valid
inputs.h
THe above is NOT such a valid input, but needs the definition of H
included. Once you define that this is using a specific H, you aren't
allowed to change that for this input, which your logic does.

Thus, you are just proving that all you are talking about is POOP and
not halting.

On 1/31/2024 3:38 AM, Fred. Zwarts wrote:
> Op 31.jan.2024 om 04:53 schreef olcott:
>> On 1/30/2024 8:21 PM, Richard Damon wrote:
>>> On 1/30/24 10:46 AM, olcott wrote:
>>>> On 1/30/2024 9:38 AM, immibis wrote:
>>>>> On 1/30/24 03:17, olcott wrote:
>>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>>> On 1/29/24 8:53 AM, olcott wrote:
>>>>>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>>>>>
>>>>>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>>>>>> halting problem is an ill-formed question.
>>>>>>>>>
>>>>>>>>> Doesn’t matter how you phrase it, the fact remains that there
>>>>>>>>> is no
>>>>>>>>> logically self-consistent answer to the problem. That’s what
>>>>>>>>> Turing
>>>>>>>>> proved, and you have done nothing to change that.
>>>>>>>>
>>>>>>>> Likewise there is no logically consistent answer to this question:
>>>>>>>> Is this sentence true or false: "this sentence is not true"?
>>>>>>>> It is undecidable because the question itself is incorrect.
>>>>>>>>
>>>>>>>> Every yes/no question defined to have no correct yes/no answer
>>>>>>>> is an
>>>>>>>> incorrect question.
>>>>>>>>
>>>>>>>
>>>>>>> And the question, "Does the Computation defined by this input
>>>>>>> Halt?" always has a correct yes/no answer, so is a CORRECT question.
>>>>>>
>>>>>> Yet when H is asked this question it is an entirely different
>>>>>> question
>>>>>
>>>>> Wrong
>>>>>
>>>>>> because the context of who is asked the question
>>>>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>>>>
>>>>> Wrong in mathematics
>>>>
>>>> It is necessarily always right it is the case that math
>>>> guys hardly know any linguistics at all thus mistake their
>>>> own ignorance for knowledge.
>>>>
>>>> The x86 machine code of D proves that it specifies recursive
>>>> simulation to H.
>>>
>>> For this H, it specifies FINITE recursive simulation to H, so a
>>> HALTING behavior.
>>>
>>
>> When one understands that H is always correct to abort any
>> simulation that cannot possibly stop running unless aborted
>>
>> 01 int D(ptr x)  // ptr is pointer to int function
>> 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 }
>>
>> As every H specified by the above template must do then each
>> and every element of this infinite set is correct to abort
>> its simulation and reject its input D as non-halting.
>>
>
> No, Han aborts is simulation, so it is not necessary to abort Dan, which

Below I reference an infinite set of simulating termination
analyzers that each correctly aborts its simulation of D
and correctly rejects D as non-halting.

When one understands that simulating termination analyzer H
is always correct to abort any simulation that cannot possibly
stop running unless aborted:

01 int D(ptr x) // ptr is pointer to int function
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 }

Then every simulating termination analyzer H specified by
the above template correctly aborts its simulation of D
and correctly rejects D as non-halting.

Pages 661 to 696 of Halt7.c specify the H that does this
https://github.com/plolcott/x86utm/blob/master/Halt7.c

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

On 1/31/2024 6:25 AM, immibis wrote:
> On 1/31/24 04:53, olcott wrote:
>> On 1/30/2024 8:21 PM, Richard Damon wrote:
>>> On 1/30/24 10:46 AM, olcott wrote:
>>>> On 1/30/2024 9:38 AM, immibis wrote:
>>>>> On 1/30/24 03:17, olcott wrote:
>>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>>> On 1/29/24 8:53 AM, olcott wrote:
>>>>>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>>>>>
>>>>>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>>>>>> halting problem is an ill-formed question.
>>>>>>>>>
>>>>>>>>> Doesn’t matter how you phrase it, the fact remains that there
>>>>>>>>> is no
>>>>>>>>> logically self-consistent answer to the problem. That’s what
>>>>>>>>> Turing
>>>>>>>>> proved, and you have done nothing to change that.
>>>>>>>>
>>>>>>>> Likewise there is no logically consistent answer to this question:
>>>>>>>> Is this sentence true or false: "this sentence is not true"?
>>>>>>>> It is undecidable because the question itself is incorrect.
>>>>>>>>
>>>>>>>> Every yes/no question defined to have no correct yes/no answer
>>>>>>>> is an
>>>>>>>> incorrect question.
>>>>>>>>
>>>>>>>
>>>>>>> And the question, "Does the Computation defined by this input
>>>>>>> Halt?" always has a correct yes/no answer, so is a CORRECT question.
>>>>>>
>>>>>> Yet when H is asked this question it is an entirely different
>>>>>> question
>>>>>
>>>>> Wrong
>>>>>
>>>>>> because the context of who is asked the question
>>>>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>>>>
>>>>> Wrong in mathematics
>>>>
>>>> It is necessarily always right it is the case that math
>>>> guys hardly know any linguistics at all thus mistake their
>>>> own ignorance for knowledge.
>>>>
>>>> The x86 machine code of D proves that it specifies recursive
>>>> simulation to H.
>>>
>>> For this H, it specifies FINITE recursive simulation to H, so a
>>> HALTING behavior.
>>>
>>
>> When one understands that H is always correct to abort any
>> simulation that cannot possibly stop running unless aborted
>>
>> 01 int D(ptr x)  // ptr is pointer to int function
>> 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 }
>>
>> As every H specified by the above template must do then each
>> and every element of this infinite set is correct to abort
>> its simulation and reject its input D as non-halting.
>>
>
> When one understands that a non-halting machine has an infinite
> execution sequence and a halting machine has a finite execution
> sequence, one sees that you are wrong.

Below I reference an infinite set of simulating termination
analyzers that each correctly aborts its simulation of D
and correctly rejects D as non-halting.

*When one understands that simulating termination analyzer H*
*is always correct to abort any simulation that cannot possibly*
*stop running unless aborted*

01 int D(ptr x) // ptr is pointer to int function
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 }

Then every simulating termination analyzer H specified by
the above template correctly aborts its simulation of D
and correctly rejects D as non-halting.

Pages 661 to 696 of Halt7.c specify the H that does this
https://github.com/plolcott/x86utm/blob/master/Halt7.c

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

On 1/31/2024 6:30 AM, Richard Damon wrote:
> On 1/30/24 10:53 PM, olcott wrote:
>> On 1/30/2024 8:21 PM, Richard Damon wrote:
>>> On 1/30/24 10:46 AM, olcott wrote:
>>>> On 1/30/2024 9:38 AM, immibis wrote:
>>>>> On 1/30/24 03:17, olcott wrote:
>>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>>> On 1/29/24 8:53 AM, olcott wrote:
>>>>>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>>>>>
>>>>>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>>>>>> halting problem is an ill-formed question.
>>>>>>>>>
>>>>>>>>> Doesn’t matter how you phrase it, the fact remains that there
>>>>>>>>> is no
>>>>>>>>> logically self-consistent answer to the problem. That’s what
>>>>>>>>> Turing
>>>>>>>>> proved, and you have done nothing to change that.
>>>>>>>>
>>>>>>>> Likewise there is no logically consistent answer to this question:
>>>>>>>> Is this sentence true or false: "this sentence is not true"?
>>>>>>>> It is undecidable because the question itself is incorrect.
>>>>>>>>
>>>>>>>> Every yes/no question defined to have no correct yes/no answer
>>>>>>>> is an
>>>>>>>> incorrect question.
>>>>>>>>
>>>>>>>
>>>>>>> And the question, "Does the Computation defined by this input
>>>>>>> Halt?" always has a correct yes/no answer, so is a CORRECT question.
>>>>>>
>>>>>> Yet when H is asked this question it is an entirely different
>>>>>> question
>>>>>
>>>>> Wrong
>>>>>
>>>>>> because the context of who is asked the question
>>>>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>>>>
>>>>> Wrong in mathematics
>>>>
>>>> It is necessarily always right it is the case that math
>>>> guys hardly know any linguistics at all thus mistake their
>>>> own ignorance for knowledge.
>>>>
>>>> The x86 machine code of D proves that it specifies recursive
>>>> simulation to H.
>>>
>>> For this H, it specifies FINITE recursive simulation to H, so a
>>> HALTING behavior.
>>>
>>
>> When one understands that H is always correct to abort any
>> simulation that cannot possibly stop running unless aborted
>>
>> 01 int D(ptr x)  // ptr is pointer to int function
>> 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 }
>>
>> As every H specified by the above template must do then each
>> and every element of this infinite set is correct to abort
>> its simulation and reject its input D as non-halting.
>>
>
>
> No, H is only correct to abort and report non-halting, if that exact
> same program it was looking at (using the exact same H as that H was)
> will not halt when run.

That you can't seem to fully grasp the concept of a program
template is your own short-coming and not mine.

Below I reference an infinite set of simulating termination
analyzers that each correctly aborts its simulation of D
and correctly rejects D as non-halting.

*When one understands that simulating termination analyzer H*
*is always correct to abort any simulation that cannot possibly*
*stop running unless aborted*

01 int D(ptr x) // ptr is pointer to int function
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 }

Then every simulating termination analyzer H specified by
the above template correctly aborts its simulation of D
and correctly rejects D as non-halting.

Pages 661 to 696 of Halt7.c specify the H that does this
https://github.com/plolcott/x86utm/blob/master/Halt7.c

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

On 1/31/24 16:36, olcott wrote:
> On 1/31/2024 6:25 AM, immibis wrote:
>> On 1/31/24 04:53, olcott wrote:
>>> On 1/30/2024 8:21 PM, Richard Damon wrote:
>>>> On 1/30/24 10:46 AM, olcott wrote:
>>>>> On 1/30/2024 9:38 AM, immibis wrote:
>>>>>> On 1/30/24 03:17, olcott wrote:
>>>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>>>> On 1/29/24 8:53 AM, olcott wrote:
>>>>>>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>>>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>>>>>>> halting problem is an ill-formed question.
>>>>>>>>>>
>>>>>>>>>> Doesn’t matter how you phrase it, the fact remains that there
>>>>>>>>>> is no
>>>>>>>>>> logically self-consistent answer to the problem. That’s what
>>>>>>>>>> Turing
>>>>>>>>>> proved, and you have done nothing to change that.
>>>>>>>>>
>>>>>>>>> Likewise there is no logically consistent answer to this question:
>>>>>>>>> Is this sentence true or false: "this sentence is not true"?
>>>>>>>>> It is undecidable because the question itself is incorrect.
>>>>>>>>>
>>>>>>>>> Every yes/no question defined to have no correct yes/no answer
>>>>>>>>> is an
>>>>>>>>> incorrect question.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And the question, "Does the Computation defined by this input
>>>>>>>> Halt?" always has a correct yes/no answer, so is a CORRECT
>>>>>>>> question.
>>>>>>>
>>>>>>> Yet when H is asked this question it is an entirely different
>>>>>>> question
>>>>>>
>>>>>> Wrong
>>>>>>
>>>>>>> because the context of who is asked the question
>>>>>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>>>>>
>>>>>> Wrong in mathematics
>>>>>
>>>>> It is necessarily always right it is the case that math
>>>>> guys hardly know any linguistics at all thus mistake their
>>>>> own ignorance for knowledge.
>>>>>
>>>>> The x86 machine code of D proves that it specifies recursive
>>>>> simulation to H.
>>>>
>>>> For this H, it specifies FINITE recursive simulation to H, so a
>>>> HALTING behavior.
>>>>
>>>
>>> When one understands that H is always correct to abort any
>>> simulation that cannot possibly stop running unless aborted
>>>
>>> 01 int D(ptr x)  // ptr is pointer to int function
>>> 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 }
>>>
>>> As every H specified by the above template must do then each
>>> and every element of this infinite set is correct to abort
>>> its simulation and reject its input D as non-halting.
>>>
>>
>> When one understands that a non-halting machine has an infinite
>> execution sequence and a halting machine has a finite execution
>> sequence, one sees that you are wrong.
>
>
> Below I reference an infinite set of simulating termination
> analyzers

yeah because if you referenced just one, it would be easy to prove you
are wrong. By referencing an infinite number at the same time, you make
the proof nonsensical, so it cannot be proven wrong because it doesn't
even make sense, like proving the colour blue wrong.

On 1/31/24 16:40, olcott wrote:
> On 1/31/2024 6:30 AM, Richard Damon wrote:
>> On 1/30/24 10:53 PM, olcott wrote:
>>> On 1/30/2024 8:21 PM, Richard Damon wrote:
>>>> On 1/30/24 10:46 AM, olcott wrote:
>>>>> On 1/30/2024 9:38 AM, immibis wrote:
>>>>>> On 1/30/24 03:17, olcott wrote:
>>>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>>>> On 1/29/24 8:53 AM, olcott wrote:
>>>>>>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>>>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>>>>>>> halting problem is an ill-formed question.
>>>>>>>>>>
>>>>>>>>>> Doesn’t matter how you phrase it, the fact remains that there
>>>>>>>>>> is no
>>>>>>>>>> logically self-consistent answer to the problem. That’s what
>>>>>>>>>> Turing
>>>>>>>>>> proved, and you have done nothing to change that.
>>>>>>>>>
>>>>>>>>> Likewise there is no logically consistent answer to this question:
>>>>>>>>> Is this sentence true or false: "this sentence is not true"?
>>>>>>>>> It is undecidable because the question itself is incorrect.
>>>>>>>>>
>>>>>>>>> Every yes/no question defined to have no correct yes/no answer
>>>>>>>>> is an
>>>>>>>>> incorrect question.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And the question, "Does the Computation defined by this input
>>>>>>>> Halt?" always has a correct yes/no answer, so is a CORRECT
>>>>>>>> question.
>>>>>>>
>>>>>>> Yet when H is asked this question it is an entirely different
>>>>>>> question
>>>>>>
>>>>>> Wrong
>>>>>>
>>>>>>> because the context of who is asked the question
>>>>>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>>>>>
>>>>>> Wrong in mathematics
>>>>>
>>>>> It is necessarily always right it is the case that math
>>>>> guys hardly know any linguistics at all thus mistake their
>>>>> own ignorance for knowledge.
>>>>>
>>>>> The x86 machine code of D proves that it specifies recursive
>>>>> simulation to H.
>>>>
>>>> For this H, it specifies FINITE recursive simulation to H, so a
>>>> HALTING behavior.
>>>>
>>>
>>> When one understands that H is always correct to abort any
>>> simulation that cannot possibly stop running unless aborted
>>>
>>> 01 int D(ptr x)  // ptr is pointer to int function
>>> 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 }
>>>
>>> As every H specified by the above template must do then each
>>> and every element of this infinite set is correct to abort
>>> its simulation and reject its input D as non-halting.
>>>
>>
>>
>> No, H is only correct to abort and report non-halting, if that exact
>> same program it was looking at (using the exact same H as that H was)
>> will not halt when run.
>
> That you can't seem to fully grasp the concept of a program
> template is your own short-coming and not mine.

Halting is about programs, not program templates. A program halts or
doesn't. A program template does neither because it is just a template.

On 1/31/24 10:18 AM, olcott wrote:
> On 1/31/2024 3:38 AM, Fred. Zwarts wrote:
>> Op 31.jan.2024 om 04:53 schreef olcott:
>>> On 1/30/2024 8:21 PM, Richard Damon wrote:
>>>> On 1/30/24 10:46 AM, olcott wrote:
>>>>> On 1/30/2024 9:38 AM, immibis wrote:
>>>>>> On 1/30/24 03:17, olcott wrote:
>>>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>>>> On 1/29/24 8:53 AM, olcott wrote:
>>>>>>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>>>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>>>>>>> halting problem is an ill-formed question.
>>>>>>>>>>
>>>>>>>>>> Doesn’t matter how you phrase it, the fact remains that there
>>>>>>>>>> is no
>>>>>>>>>> logically self-consistent answer to the problem. That’s what
>>>>>>>>>> Turing
>>>>>>>>>> proved, and you have done nothing to change that.
>>>>>>>>>
>>>>>>>>> Likewise there is no logically consistent answer to this question:
>>>>>>>>> Is this sentence true or false: "this sentence is not true"?
>>>>>>>>> It is undecidable because the question itself is incorrect.
>>>>>>>>>
>>>>>>>>> Every yes/no question defined to have no correct yes/no answer
>>>>>>>>> is an
>>>>>>>>> incorrect question.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And the question, "Does the Computation defined by this input
>>>>>>>> Halt?" always has a correct yes/no answer, so is a CORRECT
>>>>>>>> question.
>>>>>>>
>>>>>>> Yet when H is asked this question it is an entirely different
>>>>>>> question
>>>>>>
>>>>>> Wrong
>>>>>>
>>>>>>> because the context of who is asked the question
>>>>>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>>>>>
>>>>>> Wrong in mathematics
>>>>>
>>>>> It is necessarily always right it is the case that math
>>>>> guys hardly know any linguistics at all thus mistake their
>>>>> own ignorance for knowledge.
>>>>>
>>>>> The x86 machine code of D proves that it specifies recursive
>>>>> simulation to H.
>>>>
>>>> For this H, it specifies FINITE recursive simulation to H, so a
>>>> HALTING behavior.
>>>>
>>>
>>> When one understands that H is always correct to abort any
>>> simulation that cannot possibly stop running unless aborted
>>>
>>> 01 int D(ptr x)  // ptr is pointer to int function
>>> 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 }
>>>
>>> As every H specified by the above template must do then each
>>> and every element of this infinite set is correct to abort
>>> its simulation and reject its input D as non-halting.
>>>
>>
>> No, Han aborts is simulation, so it is not necessary to abort Dan, which
>
> Below I reference an infinite set of simulating termination
> analyzers that each correctly aborts its simulation of D
> and correctly rejects D as non-halting.
>
> When one understands that simulating termination analyzer H
> is always correct to abort any simulation that cannot possibly
> stop running unless aborted:

Nope, as the correct simulation of the input for any H that returns
non-halting is Halting (even if H can't do that simulation).

>
> 01 int D(ptr x)  // ptr is pointer to int function
> 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 }
>
> Then every simulating termination analyzer H specified by
> the above template correctly aborts its simulation of D
> and correctly rejects D as non-halting.

Nope, see other detailed post.

>
> Pages 661 to 696 of Halt7.c specify the H that does this
> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>
>

On 1/31/24 10:40 AM, olcott wrote:
> On 1/31/2024 6:30 AM, Richard Damon wrote:
>> On 1/30/24 10:53 PM, olcott wrote:
>>> On 1/30/2024 8:21 PM, Richard Damon wrote:
>>>> On 1/30/24 10:46 AM, olcott wrote:
>>>>> On 1/30/2024 9:38 AM, immibis wrote:
>>>>>> On 1/30/24 03:17, olcott wrote:
>>>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>>>> On 1/29/24 8:53 AM, olcott wrote:
>>>>>>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>>>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>>>>>>> halting problem is an ill-formed question.
>>>>>>>>>>
>>>>>>>>>> Doesn’t matter how you phrase it, the fact remains that there
>>>>>>>>>> is no
>>>>>>>>>> logically self-consistent answer to the problem. That’s what
>>>>>>>>>> Turing
>>>>>>>>>> proved, and you have done nothing to change that.
>>>>>>>>>
>>>>>>>>> Likewise there is no logically consistent answer to this question:
>>>>>>>>> Is this sentence true or false: "this sentence is not true"?
>>>>>>>>> It is undecidable because the question itself is incorrect.
>>>>>>>>>
>>>>>>>>> Every yes/no question defined to have no correct yes/no answer
>>>>>>>>> is an
>>>>>>>>> incorrect question.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And the question, "Does the Computation defined by this input
>>>>>>>> Halt?" always has a correct yes/no answer, so is a CORRECT
>>>>>>>> question.
>>>>>>>
>>>>>>> Yet when H is asked this question it is an entirely different
>>>>>>> question
>>>>>>
>>>>>> Wrong
>>>>>>
>>>>>>> because the context of who is asked the question
>>>>>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>>>>>
>>>>>> Wrong in mathematics
>>>>>
>>>>> It is necessarily always right it is the case that math
>>>>> guys hardly know any linguistics at all thus mistake their
>>>>> own ignorance for knowledge.
>>>>>
>>>>> The x86 machine code of D proves that it specifies recursive
>>>>> simulation to H.
>>>>
>>>> For this H, it specifies FINITE recursive simulation to H, so a
>>>> HALTING behavior.
>>>>
>>>
>>> When one understands that H is always correct to abort any
>>> simulation that cannot possibly stop running unless aborted
>>>
>>> 01 int D(ptr x)  // ptr is pointer to int function
>>> 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 }
>>>
>>> As every H specified by the above template must do then each
>>> and every element of this infinite set is correct to abort
>>> its simulation and reject its input D as non-halting.
>>>
>>
>>
>> No, H is only correct to abort and report non-halting, if that exact
>> same program it was looking at (using the exact same H as that H was)
>> will not halt when run.
>
> That you can't seem to fully grasp the concept of a program
> template is your own short-coming and not mine.

Excpet that Halting isn't about "Program Templates" but "Programs"

And thus you are caught in your LIE that you are actually working on the
Halting Problem.

You are just playing with your POOP.

>
> Below I reference an infinite set of simulating termination
> analyzers that each correctly aborts its simulation of D
> and correctly rejects D as non-halting.

So, you are just talking POOP, not Halting.

>
> *When one understands that simulating termination analyzer H*
> *is always correct to abort any simulation that cannot possibly*
> *stop running unless aborted*
>
> 01 int D(ptr x)  // ptr is pointer to int function
> 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 }
>
> Then every simulating termination analyzer H specified by
> the above template correctly aborts its simulation of D
> and correctly rejects D as non-halting.
>
> Pages 661 to 696 of Halt7.c specify the H that does this
> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>

Just more lies. See details elsewhere.

On 31/01/24 18:11, immibis wrote:
> On 1/31/24 16:40, olcott wrote:
>> On 1/31/2024 6:30 AM, Richard Damon wrote:
>>> On 1/30/24 10:53 PM, olcott wrote:
>>>> On 1/30/2024 8:21 PM, Richard Damon wrote:
>>>>> On 1/30/24 10:46 AM, olcott wrote:
>>>>>> On 1/30/2024 9:38 AM, immibis wrote:
>>>>>>> On 1/30/24 03:17, olcott wrote:
>>>>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>>>>> On 1/29/24 8:53 AM, olcott wrote:
>>>>>>>>>> On 1/29/2024 12:59 AM, Lawrence D'Oliveiro wrote:
>>>>>>>>>>> On Sun, 28 Jan 2024 09:20:46 -0600, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>> ... professor Hehner proves my 2004 claim that the
>>>>>>>>>>>> halting problem is an ill-formed question.
>>>>>>>>>>>
>>>>>>>>>>> Doesn’t matter how you phrase it, the fact remains that there
>>>>>>>>>>> is no
>>>>>>>>>>> logically self-consistent answer to the problem. That’s what
>>>>>>>>>>> Turing
>>>>>>>>>>> proved, and you have done nothing to change that.
>>>>>>>>>>
>>>>>>>>>> Likewise there is no logically consistent answer to this
>>>>>>>>>> question:
>>>>>>>>>> Is this sentence true or false: "this sentence is not true"?
>>>>>>>>>> It is undecidable because the question itself is incorrect.
>>>>>>>>>>
>>>>>>>>>> Every yes/no question defined to have no correct yes/no answer
>>>>>>>>>> is an
>>>>>>>>>> incorrect question.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And the question, "Does the Computation defined by this input
>>>>>>>>> Halt?" always has a correct yes/no answer, so is a CORRECT
>>>>>>>>> question.
>>>>>>>>
>>>>>>>> Yet when H is asked this question it is an entirely different
>>>>>>>> question
>>>>>>>
>>>>>>> Wrong
>>>>>>>
>>>>>>>> because the context of who is asked the question
>>>>>>>> DOES CHANGE THE MEANING OF THE QUESTION.
>>>>>>>
>>>>>>> Wrong in mathematics
>>>>>>
>>>>>> It is necessarily always right it is the case that math
>>>>>> guys hardly know any linguistics at all thus mistake their
>>>>>> own ignorance for knowledge.
>>>>>>
>>>>>> The x86 machine code of D proves that it specifies recursive
>>>>>> simulation to H.
>>>>>
>>>>> For this H, it specifies FINITE recursive simulation to H, so a
>>>>> HALTING behavior.
>>>>>
>>>>
>>>> When one understands that H is always correct to abort any
>>>> simulation that cannot possibly stop running unless aborted
>>>>
>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>> 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 }
>>>>
>>>> As every H specified by the above template must do then each
>>>> and every element of this infinite set is correct to abort
>>>> its simulation and reject its input D as non-halting.
>>>>
>>>
>>>
>>> No, H is only correct to abort and report non-halting, if that exact
>>> same program it was looking at (using the exact same H as that H was)
>>> will not halt when run.
>>
>> That you can't seem to fully grasp the concept of a program
>> template is your own short-coming and not mine.
>
> Halting is about programs, not program templates. A program halts or
> doesn't. A program template does neither because it is just a template.

Olcott was not able to respond to this.