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 }

H is a simulating abort decider that supposed to
correctly determine whether or not it needs to abort
the simulation of any pathological inputs that are
attempting to thwart this abort decision.

H must abort every simulated input that would not
otherwise halt to prevent its own non-termination.

It is a self-evident verified fact that every H(D,D)
that decides to abort its simulated D(D) is correct
in doing so because this does prevent its own
non-termination.

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

On 3/22/2024 1:58 PM, wij wrote:
> On Fri, 2024-03-22 at 13:41 -0500, olcott wrote:
>> 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 }
>>
>> H is a simulating abort decider that supposed to
>> correctly determine whether or not it needs to abort
>> the simulation of any pathological inputs that are
>> attempting to thwart this abort decision.
>>
>> H must abort every simulated input that would not
>> otherwise halt to prevent its own non-termination.
>>
>> It is a self-evident verified fact that every H(D,D)
>> that decides to abort its simulated D(D) is correct
>> in doing so because this does prevent its own
>> non-termination.
>>
>
> In you program listing above (1) H can only return 0, it does not determine anything.

I never mentioned any return value and return values are out-of-scope
for this post.

In this post we are only looking for a counter-example that can thwart
simulating abort decider H.

It is a self-evidently correct verified fact that every implementation
of H(D,D) that aborts its simulation to prevent its otherwise non-
termination is correct in doing so.

> (2) and, H is empty, there is no code to determine "pathological input", and who
> decide "pathological", you or program?
>

It is stipulated that every implementation of H(D,D) simulates
its input D(D).

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

On 3/22/2024 2:16 PM, wij wrote:
> On Fri, 2024-03-22 at 14:10 -0500, olcott wrote:
>> On 3/22/2024 1:58 PM, wij wrote:
>>> On Fri, 2024-03-22 at 13:41 -0500, olcott wrote:
>>>> 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 }
>>>>
>>>> H is a simulating abort decider that supposed to
>>>> correctly determine whether or not it needs to abort
>>>> the simulation of any pathological inputs that are
>>>> attempting to thwart this abort decision.
>>>>
>>>> H must abort every simulated input that would not
>>>> otherwise halt to prevent its own non-termination.
>>>>
>>>> It is a self-evident verified fact that every H(D,D)
>>>> that decides to abort its simulated D(D) is correct
>>>> in doing so because this does prevent its own
>>>> non-termination.
>>>>
>>>
>>> In you program listing above (1) H can only return 0, it does not determine anything.
>>
>> I never mentioned any return value and return values are out-of-scope
>> for this post.
>>
>> In this post we are only looking for a counter-example that can thwart
>> simulating abort decider H.
>>
>> It is a self-evidently correct verified fact that every implementation
>> of H(D,D) that aborts its simulation to prevent its otherwise non-
>> termination is correct in doing so.
>>
>>> (2) and, H is empty, there is no code to determine "pathological input", and who
>>> decide "pathological", you or program?
>>>
>>
>> It is stipulated that every implementation of H(D,D) simulates
>> its input D(D).
>>
>
> Agree what you say here and now.
> One thing I care about is that if you insist that POOH solves the halting problem,
> there would be many problems.
>

No one can understand that until they first understand that
H(D,D) is a correct abort decider.

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

On 3/22/2024 2:25 PM, wij wrote:
> On Fri, 2024-03-22 at 14:21 -0500, olcott wrote:
>> On 3/22/2024 2:16 PM, wij wrote:
>>> On Fri, 2024-03-22 at 14:10 -0500, olcott wrote:
>>>> On 3/22/2024 1:58 PM, wij wrote:
>>>>> On Fri, 2024-03-22 at 13:41 -0500, olcott wrote:
>>>>>> 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 }
>>>>>>
>>>>>> H is a simulating abort decider that supposed to
>>>>>> correctly determine whether or not it needs to abort
>>>>>> the simulation of any pathological inputs that are
>>>>>> attempting to thwart this abort decision.
>>>>>>
>>>>>> H must abort every simulated input that would not
>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>
>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>> that decides to abort its simulated D(D) is correct
>>>>>> in doing so because this does prevent its own
>>>>>> non-termination.
>>>>>>
>>>>>
>>>>> In you program listing above (1) H can only return 0, it does not determine anything.
>>>>
>>>> I never mentioned any return value and return values are out-of-scope
>>>> for this post.
>>>>
>>>> In this post we are only looking for a counter-example that can thwart
>>>> simulating abort decider H.
>>>>
>>>> It is a self-evidently correct verified fact that every implementation
>>>> of H(D,D) that aborts its simulation to prevent its otherwise non-
>>>> termination is correct in doing so.
>>>>
>>>>> (2) and, H is empty, there is no code to determine "pathological input", and who
>>>>> decide "pathological", you or program?
>>>>>
>>>>
>>>> It is stipulated that every implementation of H(D,D) simulates
>>>> its input D(D).
>>>>
>>>
>>> Agree what you say here and now.
>>> One thing I care about is that if you insist that POOH solves the halting problem,
>>> there would be many problems.
>>>
>>
>> No one can understand that until they first understand that
>> H(D,D) is a correct abort decider.
>>
>
> What you just now said is OK for me.
>

If H(D,D) is correct to abort its simulation to prevent
it own non-halting behavior then this by itself conclusively
proves that D specifies non-halting behavior to H.

Because every halt decider must compute the mapping from their
inputs to their own accept or reject state on the basis of the
behavior that their input specifies then H(D,D) is necessarily
correct to reject D as non-halting.

Same halting problem, different results because H(D,D) shows
all of the details that have never been seen before.

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

On 22/03/24 19:41, olcott wrote:
> 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 }

Incomplete program. When you run it, it prints "Error: Undefined
function H" and then halts.

On 3/22/2024 2:44 PM, immibis wrote:
> On 22/03/24 19:41, olcott wrote:
>> 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 }
>
> Incomplete program. When you run it, it prints "Error: Undefined
> function H" and then halts.
>

That you ignore what I say seems far too Trollish
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 22/03/24 20:33, olcott wrote:
> If H(D,D) is correct to abort its simulation to prevent
> it own non-halting behavior

this sentence does not make any sense

On 22/03/24 20:47, olcott wrote:
> On 3/22/2024 2:44 PM, immibis wrote:
>> On 22/03/24 19:41, olcott wrote:
>>> 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 }
>>
>> Incomplete program. When you run it, it prints "Error: Undefined
>> function H" and then halts.
>>
>
> That you ignore what I say seems far too Trollish
> https://github.com/plolcott/x86utm/blob/master/Halt7.c

That's a different program that cannot be translated to a Turing machine.

On 3/22/2024 3:33 PM, immibis wrote:
> On 22/03/24 20:33, olcott wrote:
>> If H(D,D) is correct to abort its simulation to prevent
>> it own non-halting behavior
>
> this sentence does not make any sense
>

Sure it does and you lie about it.

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

On 3/22/2024 3:34 PM, immibis wrote:
> On 22/03/24 20:47, olcott wrote:
>> On 3/22/2024 2:44 PM, immibis wrote:
>>> On 22/03/24 19:41, olcott wrote:
>>>> 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 }
>>>
>>> Incomplete program. When you run it, it prints "Error: Undefined
>>> function H" and then halts.
>>>
>>
>> That you ignore what I say seems far too Trollish
>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>
> That's a different program that cannot be translated to a Turing machine.

If a counter-example exists for abort decider H in C then it
exists for TM H. Only the C version can show every single detail.

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

On 22/03/24 21:53, olcott wrote:
> On 3/22/2024 3:34 PM, immibis wrote:
>> On 22/03/24 20:47, olcott wrote:
>>> On 3/22/2024 2:44 PM, immibis wrote:
>>>> On 22/03/24 19:41, olcott wrote:
>>>>> 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 }
>>>>
>>>> Incomplete program. When you run it, it prints "Error: Undefined
>>>> function H" and then halts.
>>>>
>>>
>>> That you ignore what I say seems far too Trollish
>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>
>> That's a different program that cannot be translated to a Turing machine.
>
> If a counter-example exists for abort decider H in C then it
> exists for TM H. Only the C version can show every single detail.
>
Only the Turing machine version can show every single detail of the
Turing machine...

On 22/03/24 21:49, olcott wrote:
> On 3/22/2024 3:33 PM, immibis wrote:
>> On 22/03/24 20:33, olcott wrote:
>>> If H(D,D) is correct to abort its simulation to prevent
>>> it own non-halting behavior
>>
>> this sentence does not make any sense
>
> Sure it does and you lie about it.

It does not and you lie about it.

On 3/22/2024 4:19 PM, immibis wrote:
> On 22/03/24 21:53, olcott wrote:
>> On 3/22/2024 3:34 PM, immibis wrote:
>>> On 22/03/24 20:47, olcott wrote:
>>>> On 3/22/2024 2:44 PM, immibis wrote:
>>>>> On 22/03/24 19:41, olcott wrote:
>>>>>> 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 }
>>>>>
>>>>> Incomplete program. When you run it, it prints "Error: Undefined
>>>>> function H" and then halts.
>>>>>
>>>>
>>>> That you ignore what I say seems far too Trollish
>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>
>>> That's a different program that cannot be translated to a Turing
>>> machine.
>>
>> If a counter-example exists for abort decider H in C then it
>> exists for TM H. Only the C version can show every single detail.
>>
> Only the Turing machine version can show every single detail of the
> Turing machine...

In other words you agree that abort deciders cannot possibly be
thwarted.

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

On 22/03/24 22:24, olcott wrote:
> On 3/22/2024 4:19 PM, immibis wrote:
>> On 22/03/24 21:53, olcott wrote:
>>> On 3/22/2024 3:34 PM, immibis wrote:
>>>> On 22/03/24 20:47, olcott wrote:
>>>>> On 3/22/2024 2:44 PM, immibis wrote:
>>>>>> On 22/03/24 19:41, olcott wrote:
>>>>>>> 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 }
>>>>>>
>>>>>> Incomplete program. When you run it, it prints "Error: Undefined
>>>>>> function H" and then halts.
>>>>>>
>>>>>
>>>>> That you ignore what I say seems far too Trollish
>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>
>>>> That's a different program that cannot be translated to a Turing
>>>> machine.
>>>
>>> If a counter-example exists for abort decider H in C then it
>>> exists for TM H. Only the C version can show every single detail.
>>>
>> Only the Turing machine version can show every single detail of the
>> Turing machine...
>
> In other words you agree that abort deciders cannot possibly be
> thwarted.

In other words I agree that C half-programs are not Turing machines
unless they can be proven to be.

On 3/22/2024 8:00 PM, immibis wrote:
> On 22/03/24 22:24, olcott wrote:
>> On 3/22/2024 4:19 PM, immibis wrote:
>>> On 22/03/24 21:53, olcott wrote:
>>>> On 3/22/2024 3:34 PM, immibis wrote:
>>>>> On 22/03/24 20:47, olcott wrote:
>>>>>> On 3/22/2024 2:44 PM, immibis wrote:
>>>>>>> On 22/03/24 19:41, olcott wrote:
>>>>>>>> 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 }
>>>>>>>
>>>>>>> Incomplete program. When you run it, it prints "Error: Undefined
>>>>>>> function H" and then halts.
>>>>>>>
>>>>>>
>>>>>> That you ignore what I say seems far too Trollish
>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>
>>>>> That's a different program that cannot be translated to a Turing
>>>>> machine.
>>>>
>>>> If a counter-example exists for abort decider H in C then it
>>>> exists for TM H. Only the C version can show every single detail.
>>>>
>>> Only the Turing machine version can show every single detail of the
>>> Turing machine...
>>
>> In other words you agree that abort deciders cannot possibly be
>> thwarted.
>
> In other words I agree that C half-programs are not Turing machines
> unless they can be proven to be.

If a C program can compute a function that a TM can't then
that refutes Church-Turing.

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

On 3/22/24 2:41 PM, olcott wrote:
> 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 }
>
> H is a simulating abort decider that supposed to
> correctly determine whether or not it needs to abort
> the simulation of any pathological inputs that are
> attempting to thwart this abort decision.
>
> H must abort every simulated input that would not
> otherwise halt to prevent its own non-termination.
>
> It is a self-evident verified fact that every H(D,D)
> that decides to abort its simulated D(D) is correct
> in doing so because this does prevent its own
> non-termination.
>

Except that it FAILS to meet your agreed upon definition of correctly
deciding to abort, and uses the INVALID logic of comparing itself to a
DIFFERENT machine.

On 3/22/2024 9:10 PM, Richard Damon wrote:
> On 3/22/24 2:41 PM, olcott wrote:
>> 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 }
>>
>> H is a simulating abort decider that supposed to
>> correctly determine whether or not it needs to abort
>> the simulation of any pathological inputs that are
>> attempting to thwart this abort decision.
>>
>> H must abort every simulated input that would not
>> otherwise halt to prevent its own non-termination.
>>
>> It is a self-evident verified fact that every H(D,D)
>> that decides to abort its simulated D(D) is correct
>> in doing so because this does prevent its own
>> non-termination.
>>
>
> Except that it FAILS to meet your agreed upon definition of correctly
> deciding to abort, and uses the INVALID logic of comparing itself to a
> DIFFERENT machine.

On 3/20/2024 6:02 PM, Richard Damon wrote:
> On 3/20/24 6:01 PM, olcott wrote:
>> Every H(D,D) that doesn't abort its simulated input
>> never stops running.
>
> Yep, shows that H's that don't abort the D built on
> them won't be deciders...

Therefore Every H(D,D) that does abort its simulated input
is necessarily correct.

I take your stalling tactic to indicate that a universal abort
decider may very well exist.

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

On 3/22/24 10:22 PM, olcott wrote:
> On 3/22/2024 9:10 PM, Richard Damon wrote:
>> On 3/22/24 2:41 PM, olcott wrote:
>>> 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 }
>>>
>>> H is a simulating abort decider that supposed to
>>> correctly determine whether or not it needs to abort
>>> the simulation of any pathological inputs that are
>>> attempting to thwart this abort decision.
>>>
>>> H must abort every simulated input that would not
>>> otherwise halt to prevent its own non-termination.
>>>
>>> It is a self-evident verified fact that every H(D,D)
>>> that decides to abort its simulated D(D) is correct
>>> in doing so because this does prevent its own
>>> non-termination.
>>>
>>
>> Except that it FAILS to meet your agreed upon definition of correctly
>> deciding to abort, and uses the INVALID logic of comparing itself to a
>> DIFFERENT machine.
>
> On 3/20/2024 6:02 PM, Richard Damon wrote:
> > On 3/20/24 6:01 PM, olcott wrote:
> >> Every H(D,D) that doesn't abort its simulated input
> >> never stops running.
> >
> > Yep, shows that H's that don't abort the D built on
> > them won't be deciders...
>
> Therefore Every H(D,D) that does abort its simulated input
> is necessarily correct.

Nope.

Try to show an actual proof of that.

It is INVALID to use the behavior of a DIFFERENT program to prove
something about this program.

Just shows you have no idea on how to actually do correct logic, you use
about every fallacy in the book, thinking they are correct logic.

>
> I take your stalling tactic to indicate that a universal abort
> decider may very well exist.
>

Nope, but that is just your own stupidity talking.

On 3/22/2024 9:52 PM, Richard Damon wrote:
> On 3/22/24 10:22 PM, olcott wrote:
>> On 3/22/2024 9:10 PM, Richard Damon wrote:
>>> On 3/22/24 2:41 PM, olcott wrote:
>>>> 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 }
>>>>
>>>> H is a simulating abort decider that supposed to
>>>> correctly determine whether or not it needs to abort
>>>> the simulation of any pathological inputs that are
>>>> attempting to thwart this abort decision.
>>>>
>>>> H must abort every simulated input that would not
>>>> otherwise halt to prevent its own non-termination.
>>>>
>>>> It is a self-evident verified fact that every H(D,D)
>>>> that decides to abort its simulated D(D) is correct
>>>> in doing so because this does prevent its own
>>>> non-termination.
>>>>
>>>
>>> Except that it FAILS to meet your agreed upon definition of correctly
>>> deciding to abort, and uses the INVALID logic of comparing itself to
>>> a DIFFERENT machine.
>>
>> On 3/20/2024 6:02 PM, Richard Damon wrote:
>>  > On 3/20/24 6:01 PM, olcott wrote:
>>  >> Every H(D,D) that doesn't abort its simulated input
>>  >> never stops running.
>>  >
>>  > Yep, shows that H's that don't abort the D built on
>>  > them won't be deciders...
>>
>> Therefore Every H(D,D) that does abort its simulated input
>> is necessarily correct.
>
> Nope.
>
> Try to show an actual proof of that.

A proof that applies to an entire class of objects
necessarily applies to each element of this class.

*You already agreed to this, thus cannot*
*get away saying that you don't understand*

>
> It is INVALID to use the behavior of a DIFFERENT program to prove
> something about this program.
>
>
> Just shows you have no idea on how to actually do correct logic, you use
> about every fallacy in the book, thinking they are correct logic.
>
>>
>> I take your stalling tactic to indicate that a universal abort
>> decider may very well exist.
>>
>
> Nope, but that is just your own stupidity talking.
>
>

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

On 23/03/24 02:33, olcott wrote:
> On 3/22/2024 8:00 PM, immibis wrote:
>> On 22/03/24 22:24, olcott wrote:
>>> On 3/22/2024 4:19 PM, immibis wrote:
>>>> On 22/03/24 21:53, olcott wrote:
>>>>> On 3/22/2024 3:34 PM, immibis wrote:
>>>>>> On 22/03/24 20:47, olcott wrote:
>>>>>>> On 3/22/2024 2:44 PM, immibis wrote:
>>>>>>>> On 22/03/24 19:41, olcott wrote:
>>>>>>>>> 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 }
>>>>>>>>
>>>>>>>> Incomplete program. When you run it, it prints "Error: Undefined
>>>>>>>> function H" and then halts.
>>>>>>>>
>>>>>>>
>>>>>>> That you ignore what I say seems far too Trollish
>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>
>>>>>> That's a different program that cannot be translated to a Turing
>>>>>> machine.
>>>>>
>>>>> If a counter-example exists for abort decider H in C then it
>>>>> exists for TM H. Only the C version can show every single detail.
>>>>>
>>>> Only the Turing machine version can show every single detail of the
>>>> Turing machine...
>>>
>>> In other words you agree that abort deciders cannot possibly be
>>> thwarted.
>>
>> In other words I agree that C half-programs are not Turing machines
>> unless they can be proven to be.
>
> If a C program can compute a function that a TM can't then
> that refutes Church-Turing.
>
It's not about what they can compute, it's about what you can prove
about them.

A Turing program can be proven to compute some function.

A C program can hack into the prover to make it always give wrong
proofs, then delete your operating system and replace it with a virus.
How can you prove anything then?

Op 22.mrt.2024 om 19:41 schreef olcott:
> 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 }
>
> H is a simulating abort decider that supposed to
> correctly determine whether or not it needs to abort
> the simulation of any pathological inputs that are
> attempting to thwart this abort decision.
>
> H must abort every simulated input that would not
> otherwise halt to prevent its own non-termination.
>
> It is a self-evident verified fact that every H(D,D)
> that decides to abort its simulated D(D) is correct
> in doing so because this does prevent its own
> non-termination.
>

It is self-evident that when H is programmed to abort and return false,
then D will halt (unless aborted). So, no abort is needed and H is wrong
to abort this D. Running D itself, or simulating it with a correct
simulator proves it. It is a verified fact. If olcott requires that a
decider should only decide about it own behaviour, then he closes his
eyes for the correct simulation.

On 3/23/2024 2:23 AM, immibis wrote:
> On 23/03/24 02:33, olcott wrote:
>> On 3/22/2024 8:00 PM, immibis wrote:
>>> On 22/03/24 22:24, olcott wrote:
>>>> On 3/22/2024 4:19 PM, immibis wrote:
>>>>> On 22/03/24 21:53, olcott wrote:
>>>>>> On 3/22/2024 3:34 PM, immibis wrote:
>>>>>>> On 22/03/24 20:47, olcott wrote:
>>>>>>>> On 3/22/2024 2:44 PM, immibis wrote:
>>>>>>>>> On 22/03/24 19:41, olcott wrote:
>>>>>>>>>> 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 }
>>>>>>>>>
>>>>>>>>> Incomplete program. When you run it, it prints "Error:
>>>>>>>>> Undefined function H" and then halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> That you ignore what I say seems far too Trollish
>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>
>>>>>>> That's a different program that cannot be translated to a Turing
>>>>>>> machine.
>>>>>>
>>>>>> If a counter-example exists for abort decider H in C then it
>>>>>> exists for TM H. Only the C version can show every single detail.
>>>>>>
>>>>> Only the Turing machine version can show every single detail of the
>>>>> Turing machine...
>>>>
>>>> In other words you agree that abort deciders cannot possibly be
>>>> thwarted.
>>>
>>> In other words I agree that C half-programs are not Turing machines
>>> unless they can be proven to be.
>>
>> If a C program can compute a function that a TM can't then
>> that refutes Church-Turing.
>>
> It's not about what they can compute, it's about what you can prove
> about them.
>

Unless you are stupid the actual working code proves what
the actual working code does.

> A Turing program can be proven to compute some function.
>
> A C program can hack into the prover to make it always give wrong
> proofs, then delete your operating system and replace it with a virus.
> How can you prove anything then?

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

On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
> Op 22.mrt.2024 om 19:41 schreef olcott:
>> 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 }
>>
>> H is a simulating abort decider that supposed to
>> correctly determine whether or not it needs to abort
>> the simulation of any pathological inputs that are
>> attempting to thwart this abort decision.
>>
>> H must abort every simulated input that would not
>> otherwise halt to prevent its own non-termination.
>>
>> It is a self-evident verified fact that every H(D,D)
>> that decides to abort its simulated D(D) is correct
>> in doing so because this does prevent its own
>> non-termination.
>>
>
> It is self-evident that when H is programmed to abort and return false,
> then [the simulated] D will

immediately stop running never having reached its last instruction to
halt. You and others keep trying to get away with the strawman deception
and refer to a D that does not even exist in this computation.

> halt (unless aborted). So, no abort is needed and H is wrong
> to abort this D. Running D itself, or simulating it with a correct
> simulator proves it. It is a verified fact. If olcott requires that a
> decider should only decide about it own behaviour, then he closes his
> eyes for the correct simulation.

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

On 3/22/24 10:58 PM, olcott wrote:
> On 3/22/2024 9:52 PM, Richard Damon wrote:
>> On 3/22/24 10:22 PM, olcott wrote:
>>> On 3/22/2024 9:10 PM, Richard Damon wrote:
>>>> On 3/22/24 2:41 PM, olcott wrote:
>>>>> 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 }
>>>>>
>>>>> H is a simulating abort decider that supposed to
>>>>> correctly determine whether or not it needs to abort
>>>>> the simulation of any pathological inputs that are
>>>>> attempting to thwart this abort decision.
>>>>>
>>>>> H must abort every simulated input that would not
>>>>> otherwise halt to prevent its own non-termination.
>>>>>
>>>>> It is a self-evident verified fact that every H(D,D)
>>>>> that decides to abort its simulated D(D) is correct
>>>>> in doing so because this does prevent its own
>>>>> non-termination.
>>>>>
>>>>
>>>> Except that it FAILS to meet your agreed upon definition of
>>>> correctly deciding to abort, and uses the INVALID logic of comparing
>>>> itself to a DIFFERENT machine.
>>>
>>> On 3/20/2024 6:02 PM, Richard Damon wrote:
>>>  > On 3/20/24 6:01 PM, olcott wrote:
>>>  >> Every H(D,D) that doesn't abort its simulated input
>>>  >> never stops running.
>>>  >
>>>  > Yep, shows that H's that don't abort the D built on
>>>  > them won't be deciders...
>>>
>>> Therefore Every H(D,D) that does abort its simulated input
>>> is necessarily correct.
>>
>> Nope.
>>
>> Try to show an actual proof of that.
>
> A proof that applies to an entire class of objects
> necessarily applies to each element of this class.

Right, Every H that doen't have the abort code that gets activiated by
this input, fails to be a Decider for the input based on IT, an H that
fails to abort for this input, and thus actually needed to abort.

That applies to EVERY H, THAT DOESN'T ABORT, that is looking at in input
based on an H that doesn't abrt.

Hs that do abort, looking at inputs based on Hs that abort, are not in
that class.

>
> *You already agreed to this, thus cannot*
> *get away saying that you don't understand*

And why do Hs that abort belong to the class of Hs that do not abort?

Remember, you AGREE that the input is different for different Hs, and
thus we can't look that the other class of inputs for the answer.

>
>>
>> It is INVALID to use the behavior of a DIFFERENT program to prove
>> something about this program.

Pointing this out again, your logical fallacy.

>>
>>
>> Just shows you have no idea on how to actually do correct logic, you
>> use about every fallacy in the book, thinking they are correct logic.
>>
>>>
>>> I take your stalling tactic to indicate that a universal abort
>>> decider may very well exist.
>>>
>>
>> Nope, but that is just your own stupidity talking.
>>
>>
>

On 3/23/24 9:46 AM, olcott wrote:
> On 3/23/2024 2:23 AM, immibis wrote:
>> On 23/03/24 02:33, olcott wrote:
>>> On 3/22/2024 8:00 PM, immibis wrote:
>>>> On 22/03/24 22:24, olcott wrote:
>>>>> On 3/22/2024 4:19 PM, immibis wrote:
>>>>>> On 22/03/24 21:53, olcott wrote:
>>>>>>> On 3/22/2024 3:34 PM, immibis wrote:
>>>>>>>> On 22/03/24 20:47, olcott wrote:
>>>>>>>>> On 3/22/2024 2:44 PM, immibis wrote:
>>>>>>>>>> On 22/03/24 19:41, olcott wrote:
>>>>>>>>>>> 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 }
>>>>>>>>>>
>>>>>>>>>> Incomplete program. When you run it, it prints "Error:
>>>>>>>>>> Undefined function H" and then halts.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> That you ignore what I say seems far too Trollish
>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>
>>>>>>>> That's a different program that cannot be translated to a Turing
>>>>>>>> machine.
>>>>>>>
>>>>>>> If a counter-example exists for abort decider H in C then it
>>>>>>> exists for TM H. Only the C version can show every single detail.
>>>>>>>
>>>>>> Only the Turing machine version can show every single detail of
>>>>>> the Turing machine...
>>>>>
>>>>> In other words you agree that abort deciders cannot possibly be
>>>>> thwarted.
>>>>
>>>> In other words I agree that C half-programs are not Turing machines
>>>> unless they can be proven to be.
>>>
>>> If a C program can compute a function that a TM can't then
>>> that refutes Church-Turing.
>>>
>> It's not about what they can compute, it's about what you can prove
>> about them.
>>
>
> Unless you are stupid the actual working code proves what
> the actual working code does.

Yes, it sats that a Halting Input is Non-Halting.

Proving that its programmer is a LIAR.

>
>> A Turing program can be proven to compute some function.
>>
>> A C program can hack into the prover to make it always give wrong
>> proofs, then delete your operating system and replace it with a virus.
>> How can you prove anything then?
>