Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.software-eng > #3666 > unrolled thread

Simulating Halt Deciders Defeat the Halting Theorem V2

Back to article view | Back to comp.software-eng

Contents

  Simulating Halt Deciders Defeat the Halting Theorem V2 olcott <polcott2@gmail.com> - 2023-02-20 12:39 -0600
    Re: Simulating Halt Deciders Defeat the Halting Theorem V2 Richard Damon <Richard@Damon-Family.org> - 2023-02-20 19:20 -0500
    Re: Simulating Halt Deciders Defeat the Halting Theorem V2 olcott <polcott2@gmail.com> - 2023-02-20 18:46 -0600
      Re: Simulating Halt Deciders Defeat the Halting Theorem V2 olcott <polcott2@gmail.com> - 2023-02-20 19:10 -0600
        Re: Simulating Halt Deciders Defeat the Halting Theorem V2 olcott <polcott2@gmail.com> - 2023-02-20 20:22 -0600
          Re: Simulating Halt Deciders Defeat the Halting Theorem V2 Richard Damon <Richard@Damon-Family.org> - 2023-02-20 21:32 -0500
          Re: Simulating Halt Deciders Defeat the Halting Theorem V2 olcott <polcott2@gmail.com> - 2023-02-20 20:53 -0600
            Re: Simulating Halt Deciders Defeat the Halting Theorem V2 Richard Damon <Richard@Damon-Family.org> - 2023-02-20 22:06 -0500
            Re: Simulating Halt Deciders Defeat the Halting Theorem V2 olcott <polcott2@gmail.com> - 2023-02-20 21:28 -0600
              Re: Simulating Halt Deciders Defeat the Halting Theorem V2 Richard Damon <Richard@Damon-Family.org> - 2023-02-20 22:38 -0500
              Re: Simulating Halt Deciders Defeat the Halting Theorem V2 olcott <polcott2@gmail.com> - 2023-02-20 22:08 -0600
                Re: Simulating Halt Deciders Defeat the Halting Theorem V2 Richard Damon <Richard@Damon-Family.org> - 2023-02-20 23:21 -0500
                Re: Simulating Halt Deciders Defeat the Halting Theorem V2 olcott <polcott2@gmail.com> - 2023-02-20 22:44 -0600
                  Re: Simulating Halt Deciders Defeat the Halting Theorem V2 Richard Damon <Richard@Damon-Family.org> - 2023-02-21 07:03 -0500
                  Re: Simulating Halt Deciders Defeat the Halting Theorem V2 olcott <polcott2@gmail.com> - 2023-02-21 09:38 -0600
                    Re: Simulating Halt Deciders Defeat the Halting Theorem V2 Richard Damon <Richard@Damon-Family.org> - 2023-02-21 18:45 -0500
      Re: Simulating Halt Deciders Defeat the Halting Theorem V2 Richard Damon <Richard@Damon-Family.org> - 2023-02-20 20:54 -0500

#3666 — Simulating Halt Deciders Defeat the Halting Theorem V2

int D(int (*x)())
{
   int Halt_Status = H(x, x);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

When simulating halt decider H is applied to the conventional (otherwise
impossible) input D ordinary software engineering conclusively proves
that D correctly simulated by H cannot possibly reach its own return
statement and terminate normally (AKA halt).

A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.

The ultimate measure of a correct simulation is that the execution trace
behavior of the simulated input exactly matches the behavior that the
input machine code specifies.

https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem

Disagreeing with the above verified facts is only possible through
dishonesty or incompetence.

Whether or not the above directly applies to the halting theorem is the
only actually open issue.

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

[toc] | [next] | [standalone]

#3667

On 2/20/23 1:39 PM, olcott wrote:
> int D(int (*x)())
> {
>    int Halt_Status = H(x, x);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
> 
> When simulating halt decider H is applied to the conventional (otherwise
> impossible) input D ordinary software engineering conclusively proves
> that D correctly simulated by H cannot possibly reach its own return
> statement and terminate normally (AKA halt).

Nope, since D(D) Halt, by the conventional definition of a "Correct 
Simulation", such a COrrect Simulation must indicate that D(D) will 
Halt, thus and simulation that show otherwise is BY DEFINITION incorrect.

> 
> A simulating halt decider H correctly predicts whether or not D
> correctly simulated by H would ever reach its own final state.

So, since in computability theory, the halting problem is the problem of 
determining, from a description of an arbitrary computer program and an 
input, whether the program will finish running, or continue to run 
forever. And we know that D(D) Halts, the correct answer for a Halt 
Decider given a description of D(D) would be halting, if H is "correct" 
to say non-halting, it must not be a Halt Decider/

> 
> The ultimate measure of a correct simulation is that the execution trace
> behavior of the simulated input exactly matches the behavior that the
> input machine code specifies.
> 

And H mis-simulates the call to H, as it seem to assume it is calling a 
function that behaves differently than what H actually does.

That or it starts from a "Correct" (but incomplete) simulation and then 
does not "Correctly Determine" the results from there.


> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
> 
> Disagreeing with the above verified facts is only possible through
> dishonesty or incompetence.

Disagreeing with the verified fact that D(D) Halts and thus the only 
correct answer for H(D,D) if H is actually a Halt Decider is Halting 
shows that YOU are dishonest AND incompetent.

> 
> Whether or not the above directly applies to the halting theorem is the
> only actually open issue.
> 

So, you ADMIT that you don't know if it applies to the Halting Theorem, 
even though you claim it to be a correct answer for something you claim 
is a Halt Decider by the definition of the Problem (which it isn't).

You adding this disclaim is just proof that you know your logic is 
false, and you are trying to leave some weasle room to get out of your 
bald faced lies.

[toc] | [prev] | [next] | [standalone]

#3668

On 2/20/2023 12:39 PM, olcott wrote:
> int D(int (*x)())
> {
>    int Halt_Status = H(x, x);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
> 
> When simulating halt decider H is applied to the conventional (otherwise
> impossible) input D ordinary software engineering conclusively proves
> that D correctly simulated by H cannot possibly reach its own return
> statement and terminate normally (AKA halt).
> 
> A simulating halt decider H correctly predicts whether or not D
> correctly simulated by H would ever reach its own final state.
> 
> The ultimate measure of a correct simulation is that the execution trace
> behavior of the simulated input exactly matches the behavior that the
> input machine code specifies.
> 
> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
> 
> Disagreeing with the above verified facts is only possible through
> dishonesty or incompetence.
> 
> Whether or not the above directly applies to the halting theorem is the
> only actually open issue.
> 

*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the execution
trace of the simulated input exactly matches the behavior that the input
machine description specifies then: It is an easily verified fact that
every counter-example input to the halting theorem D cannot possibly
reach its own simulated final state in any finite number of steps.

Most of my reviewers deceptively talk about non-inputs when they already
know that deciders only operate on inputs.


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

[toc] | [prev] | [next] | [standalone]

#3669

On 2/20/2023 6:46 PM, olcott wrote:
> On 2/20/2023 12:39 PM, olcott wrote:
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> When simulating halt decider H is applied to the conventional (otherwise
>> impossible) input D ordinary software engineering conclusively proves
>> that D correctly simulated by H cannot possibly reach its own return
>> statement and terminate normally (AKA halt).
>>
>> A simulating halt decider H correctly predicts whether or not D
>> correctly simulated by H would ever reach its own final state.
>>
>> The ultimate measure of a correct simulation is that the execution trace
>> behavior of the simulated input exactly matches the behavior that the
>> input machine code specifies.
>>
>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>
>> Disagreeing with the above verified facts is only possible through
>> dishonesty or incompetence.
>>
>> Whether or not the above directly applies to the halting theorem is the
>> only actually open issue.
>>
> 
> *I had to tighten my language a little bit*

When the ultimate measure of correct simulation is that the execution
trace of the simulated input exactly matches the behavior that the input
machine description specifies then: It is an easily verified fact that
every counter-example input to the halting theorem D cannot possibly
reach its own simulated final state in any finite number of steps when
correctly simulated by  simulating halt decider H.

> Most of my reviewers deceptively talk about non-inputs when they already
> know that deciders only operate on inputs.
> 
> 

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

[toc] | [prev] | [next] | [standalone]

#3671

On 2/20/2023 7:10 PM, olcott wrote:
> On 2/20/2023 6:46 PM, olcott wrote:
>> On 2/20/2023 12:39 PM, olcott wrote:
>>> int D(int (*x)())
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> When simulating halt decider H is applied to the conventional (otherwise
>>> impossible) input D ordinary software engineering conclusively proves
>>> that D correctly simulated by H cannot possibly reach its own return
>>> statement and terminate normally (AKA halt).
>>>
>>> A simulating halt decider H correctly predicts whether or not D
>>> correctly simulated by H would ever reach its own final state.
>>>
>>> The ultimate measure of a correct simulation is that the execution trace
>>> behavior of the simulated input exactly matches the behavior that the
>>> input machine code specifies.
>>>
>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>
>>> Disagreeing with the above verified facts is only possible through
>>> dishonesty or incompetence.
>>>
>>> Whether or not the above directly applies to the halting theorem is the
>>> only actually open issue.
>>>
>>
>> *I had to tighten my language a little bit*
> 
> When the ultimate measure of correct simulation is that the execution
> trace of the simulated input exactly matches the behavior that the input
> machine description specifies then: It is an easily verified fact that
> every counter-example input to the halting theorem D cannot possibly
> reach its own simulated final state in any finite number of steps when
> correctly simulated by  simulating halt decider H.

Any alternative definition for "correct simulation" that contradicts the
above definition necessary requires that D simulated by H derives an
execution trace that is not specified by its input...


>> Most of my reviewers deceptively talk about non-inputs when they already
>> know that deciders only operate on inputs.
>>
>>
> 

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

[toc] | [prev] | [next] | [standalone]

#3672

On 2/20/23 9:22 PM, olcott wrote:
> On 2/20/2023 7:10 PM, olcott wrote:
>> On 2/20/2023 6:46 PM, olcott wrote:
>>> On 2/20/2023 12:39 PM, olcott wrote:
>>>> int D(int (*x)())
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> When simulating halt decider H is applied to the conventional 
>>>> (otherwise
>>>> impossible) input D ordinary software engineering conclusively proves
>>>> that D correctly simulated by H cannot possibly reach its own return
>>>> statement and terminate normally (AKA halt).
>>>>
>>>> A simulating halt decider H correctly predicts whether or not D
>>>> correctly simulated by H would ever reach its own final state.
>>>>
>>>> The ultimate measure of a correct simulation is that the execution 
>>>> trace
>>>> behavior of the simulated input exactly matches the behavior that the
>>>> input machine code specifies.
>>>>
>>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>>
>>>> Disagreeing with the above verified facts is only possible through
>>>> dishonesty or incompetence.
>>>>
>>>> Whether or not the above directly applies to the halting theorem is the
>>>> only actually open issue.
>>>>
>>>
>>> *I had to tighten my language a little bit*
>>
>> When the ultimate measure of correct simulation is that the execution
>> trace of the simulated input exactly matches the behavior that the input
>> machine description specifies then: It is an easily verified fact that
>> every counter-example input to the halting theorem D cannot possibly
>> reach its own simulated final state in any finite number of steps when
>> correctly simulated by  simulating halt decider H.
> 
> Any alternative definition for "correct simulation" that contradicts the
> above definition necessary requires that D simulated by H derives an
> execution trace that is not specified by its input...

Nope. You don't seem to know what "Specified by its input" actually means.

The whole value of Pi can be considered "Specified by the input" "Pi".

Since the DEFINITION of what a Halt Decider is supposed to answer is the 
behavior of the actual machine specified by its input, THAT behavior is 
what the input specifies, even if H can't actually compute that.

You seem to confuse "Specified" and "Is Computable"

I guess that just shows your ignorance.

> 
> 
>>> Most of my reviewers deceptively talk about non-inputs when they already
>>> know that deciders only operate on inputs.
>>>
>>>
>>
> 

[toc] | [prev] | [next] | [standalone]

#3673

On 2/20/2023 8:22 PM, olcott wrote:
> On 2/20/2023 7:10 PM, olcott wrote:
>> On 2/20/2023 6:46 PM, olcott wrote:
>>> On 2/20/2023 12:39 PM, olcott wrote:
>>>> int D(int (*x)())
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> When simulating halt decider H is applied to the conventional 
>>>> (otherwise
>>>> impossible) input D ordinary software engineering conclusively proves
>>>> that D correctly simulated by H cannot possibly reach its own return
>>>> statement and terminate normally (AKA halt).
>>>>
>>>> A simulating halt decider H correctly predicts whether or not D
>>>> correctly simulated by H would ever reach its own final state.
>>>>
>>>> The ultimate measure of a correct simulation is that the execution 
>>>> trace
>>>> behavior of the simulated input exactly matches the behavior that the
>>>> input machine code specifies.
>>>>
>>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>>
>>>> Disagreeing with the above verified facts is only possible through
>>>> dishonesty or incompetence.
>>>>
>>>> Whether or not the above directly applies to the halting theorem is the
>>>> only actually open issue.
>>>>
>>>
>>> *I had to tighten my language a little bit*
>>
>> When the ultimate measure of correct simulation is that the execution
>> trace of the simulated input exactly matches the behavior that the input
>> machine description specifies then: It is an easily verified fact that
>> every counter-example input to the halting theorem D cannot possibly
>> reach its own simulated final state in any finite number of steps when
>> correctly simulated by  simulating halt decider H.
> 
> Any alternative definition for "correct simulation" that contradicts the
> above definition necessary requires that D simulated by H derives an
> execution trace that is not specified by its input...
> 

Anyone with sufficient software engineering skill knows that
*D simulated by H cannot possibly correctly reach its ret instruction*
Everyone else lacks sufficient software engineering skill or lies

_D()
[00001d12] 55         push ebp
[00001d13] 8bec       mov ebp,esp
[00001d15] 51         push ecx
[00001d16] 8b4508     mov eax,[ebp+08]
[00001d19] 50         push eax       // push D
[00001d1a] 8b4d08     mov ecx,[ebp+08]
[00001d1d] 51         push ecx       // push D
[00001d1e] e83ff8ffff call 00001562  // call H
[00001d23] 83c408     add esp,+08
[00001d26] 8945fc     mov [ebp-04],eax
[00001d29] 837dfc00   cmp dword [ebp-04],+00
[00001d2d] 7402       jz 00001d31
[00001d2f] ebfe       jmp 00001d2f
[00001d31] 8b45fc     mov eax,[ebp-04]
[00001d34] 8be5       mov esp,ebp
[00001d36] 5d         pop ebp
[00001d37] c3         ret


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

[toc] | [prev] | [next] | [standalone]

#3674

On 2/20/23 9:53 PM, olcott wrote:
> On 2/20/2023 8:22 PM, olcott wrote:
>> On 2/20/2023 7:10 PM, olcott wrote:
>>> On 2/20/2023 6:46 PM, olcott wrote:
>>>> On 2/20/2023 12:39 PM, olcott wrote:
>>>>> int D(int (*x)())
>>>>> {
>>>>>    int Halt_Status = H(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return Halt_Status;
>>>>> }
>>>>>
>>>>> When simulating halt decider H is applied to the conventional 
>>>>> (otherwise
>>>>> impossible) input D ordinary software engineering conclusively proves
>>>>> that D correctly simulated by H cannot possibly reach its own return
>>>>> statement and terminate normally (AKA halt).
>>>>>
>>>>> A simulating halt decider H correctly predicts whether or not D
>>>>> correctly simulated by H would ever reach its own final state.
>>>>>
>>>>> The ultimate measure of a correct simulation is that the execution 
>>>>> trace
>>>>> behavior of the simulated input exactly matches the behavior that the
>>>>> input machine code specifies.
>>>>>
>>>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>>>
>>>>> Disagreeing with the above verified facts is only possible through
>>>>> dishonesty or incompetence.
>>>>>
>>>>> Whether or not the above directly applies to the halting theorem is 
>>>>> the
>>>>> only actually open issue.
>>>>>
>>>>
>>>> *I had to tighten my language a little bit*
>>>
>>> When the ultimate measure of correct simulation is that the execution
>>> trace of the simulated input exactly matches the behavior that the input
>>> machine description specifies then: It is an easily verified fact that
>>> every counter-example input to the halting theorem D cannot possibly
>>> reach its own simulated final state in any finite number of steps when
>>> correctly simulated by  simulating halt decider H.
>>
>> Any alternative definition for "correct simulation" that contradicts the
>> above definition necessary requires that D simulated by H derives an
>> execution trace that is not specified by its input...
>>
> 
> Anyone with sufficient software engineering skill knows that
> *D simulated by H cannot possibly correctly reach its ret instruction*
> Everyone else lacks sufficient software engineering skill or lies

Which means you are admitting that you are not working on the Halting 
Probelem.

Remeber, in computability theory, the halting problem is the problem of 
determining, from a description of an arbitrary computer program and an 
input, whether the program will finish running, or continue to run forever.

Thus, the Halting Problem isn't about the simulation done by the 
decider, but the actual behavior of the program in question.

Since D(D) will "Halt" since H(D,D) will return 0 by your stipulation, 
this means that the CORRECT answer by the definition is Halting.

Since your definition says the correct answer for your problem is 
non-halting, it can't actually be the Halting Problem.


You seem to not understand that a problem with a conflicting answer 
can't be the same as the original problem, thus your problem is shown to 
just be a POOPy strawman and all you work to be worthless.

> 
> _D()
> [00001d12] 55         push ebp
> [00001d13] 8bec       mov ebp,esp
> [00001d15] 51         push ecx
> [00001d16] 8b4508     mov eax,[ebp+08]
> [00001d19] 50         push eax       // push D
> [00001d1a] 8b4d08     mov ecx,[ebp+08]
> [00001d1d] 51         push ecx       // push D
> [00001d1e] e83ff8ffff call 00001562  // call H
> [00001d23] 83c408     add esp,+08
> [00001d26] 8945fc     mov [ebp-04],eax
> [00001d29] 837dfc00   cmp dword [ebp-04],+00
> [00001d2d] 7402       jz 00001d31
> [00001d2f] ebfe       jmp 00001d2f
> [00001d31] 8b45fc     mov eax,[ebp-04]
> [00001d34] 8be5       mov esp,ebp
> [00001d36] 5d         pop ebp
> [00001d37] c3         ret
> 
> 

[toc] | [prev] | [next] | [standalone]

#3675

On 2/20/2023 8:53 PM, olcott wrote:
> On 2/20/2023 8:22 PM, olcott wrote:
>> On 2/20/2023 7:10 PM, olcott wrote:
>>> On 2/20/2023 6:46 PM, olcott wrote:
>>>> On 2/20/2023 12:39 PM, olcott wrote:
>>>>> int D(int (*x)())
>>>>> {
>>>>>    int Halt_Status = H(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return Halt_Status;
>>>>> }
>>>>>
>>>>> When simulating halt decider H is applied to the conventional 
>>>>> (otherwise
>>>>> impossible) input D ordinary software engineering conclusively proves
>>>>> that D correctly simulated by H cannot possibly reach its own return
>>>>> statement and terminate normally (AKA halt).
>>>>>
>>>>> A simulating halt decider H correctly predicts whether or not D
>>>>> correctly simulated by H would ever reach its own final state.
>>>>>
>>>>> The ultimate measure of a correct simulation is that the execution 
>>>>> trace
>>>>> behavior of the simulated input exactly matches the behavior that the
>>>>> input machine code specifies.
>>>>>
>>>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>>>
>>>>> Disagreeing with the above verified facts is only possible through
>>>>> dishonesty or incompetence.
>>>>>
>>>>> Whether or not the above directly applies to the halting theorem is 
>>>>> the
>>>>> only actually open issue.
>>>>>
>>>>
>>>> *I had to tighten my language a little bit*
>>>
>>> When the ultimate measure of correct simulation is that the execution
>>> trace of the simulated input exactly matches the behavior that the input
>>> machine description specifies then: It is an easily verified fact that
>>> every counter-example input to the halting theorem D cannot possibly
>>> reach its own simulated final state in any finite number of steps when
>>> correctly simulated by  simulating halt decider H.
>>
>> Any alternative definition for "correct simulation" that contradicts the
>> above definition necessary requires that D simulated by H derives an
>> execution trace that is not specified by its input...
>>
> 
> Anyone with sufficient software engineering skill knows that
> *D simulated by H cannot possibly correctly reach its ret instruction*
> Everyone else lacks sufficient software engineering skill or lies
> 
> _D()
> [00001d12] 55         push ebp
> [00001d13] 8bec       mov ebp,esp
> [00001d15] 51         push ecx
> [00001d16] 8b4508     mov eax,[ebp+08]
> [00001d19] 50         push eax       // push D
> [00001d1a] 8b4d08     mov ecx,[ebp+08]
> [00001d1d] 51         push ecx       // push D
> [00001d1e] e83ff8ffff call 00001562  // call H
> [00001d23] 83c408     add esp,+08
> [00001d26] 8945fc     mov [ebp-04],eax
> [00001d29] 837dfc00   cmp dword [ebp-04],+00
> [00001d2d] 7402       jz 00001d31
> [00001d2f] ebfe       jmp 00001d2f
> [00001d31] 8b45fc     mov eax,[ebp-04]
> [00001d34] 8be5       mov esp,ebp
> [00001d36] 5d         pop ebp
> [00001d37] c3         ret
> 
> 

*THIS IS NOW A VERIFIED FACT*
Because H and D have the required "do the opposite of whatever the halt
decider decides" relationship H does correctly determine the halt status
of the halting problem proof's previously impossible input.

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

[toc] | [prev] | [next] | [standalone]

#3676

On 2/20/23 10:28 PM, olcott wrote:
> On 2/20/2023 8:53 PM, olcott wrote:
>> On 2/20/2023 8:22 PM, olcott wrote:
>>> On 2/20/2023 7:10 PM, olcott wrote:
>>>> On 2/20/2023 6:46 PM, olcott wrote:
>>>>> On 2/20/2023 12:39 PM, olcott wrote:
>>>>>> int D(int (*x)())
>>>>>> {
>>>>>>    int Halt_Status = H(x, x);
>>>>>>    if (Halt_Status)
>>>>>>      HERE: goto HERE;
>>>>>>    return Halt_Status;
>>>>>> }
>>>>>>
>>>>>> When simulating halt decider H is applied to the conventional 
>>>>>> (otherwise
>>>>>> impossible) input D ordinary software engineering conclusively proves
>>>>>> that D correctly simulated by H cannot possibly reach its own return
>>>>>> statement and terminate normally (AKA halt).
>>>>>>
>>>>>> A simulating halt decider H correctly predicts whether or not D
>>>>>> correctly simulated by H would ever reach its own final state.
>>>>>>
>>>>>> The ultimate measure of a correct simulation is that the execution 
>>>>>> trace
>>>>>> behavior of the simulated input exactly matches the behavior that the
>>>>>> input machine code specifies.
>>>>>>
>>>>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>>>>
>>>>>> Disagreeing with the above verified facts is only possible through
>>>>>> dishonesty or incompetence.
>>>>>>
>>>>>> Whether or not the above directly applies to the halting theorem 
>>>>>> is the
>>>>>> only actually open issue.
>>>>>>
>>>>>
>>>>> *I had to tighten my language a little bit*
>>>>
>>>> When the ultimate measure of correct simulation is that the execution
>>>> trace of the simulated input exactly matches the behavior that the 
>>>> input
>>>> machine description specifies then: It is an easily verified fact that
>>>> every counter-example input to the halting theorem D cannot possibly
>>>> reach its own simulated final state in any finite number of steps when
>>>> correctly simulated by  simulating halt decider H.
>>>
>>> Any alternative definition for "correct simulation" that contradicts the
>>> above definition necessary requires that D simulated by H derives an
>>> execution trace that is not specified by its input...
>>>
>>
>> Anyone with sufficient software engineering skill knows that
>> *D simulated by H cannot possibly correctly reach its ret instruction*
>> Everyone else lacks sufficient software engineering skill or lies
>>
>> _D()
>> [00001d12] 55         push ebp
>> [00001d13] 8bec       mov ebp,esp
>> [00001d15] 51         push ecx
>> [00001d16] 8b4508     mov eax,[ebp+08]
>> [00001d19] 50         push eax       // push D
>> [00001d1a] 8b4d08     mov ecx,[ebp+08]
>> [00001d1d] 51         push ecx       // push D
>> [00001d1e] e83ff8ffff call 00001562  // call H
>> [00001d23] 83c408     add esp,+08
>> [00001d26] 8945fc     mov [ebp-04],eax
>> [00001d29] 837dfc00   cmp dword [ebp-04],+00
>> [00001d2d] 7402       jz 00001d31
>> [00001d2f] ebfe       jmp 00001d2f
>> [00001d31] 8b45fc     mov eax,[ebp-04]
>> [00001d34] 8be5       mov esp,ebp
>> [00001d36] 5d         pop ebp
>> [00001d37] c3         ret
>>
>>
> 
> *THIS IS NOW A VERIFIED FACT*
> Because H and D have the required "do the opposite of whatever the halt
> decider decides" relationship H does correctly determine the halt status
> of the halting problem proof's previously impossible input.
> 

Nope, remember In computability theory, the halting problem is the 
problem of determining, from a description of an arbitrary computer 
program and an input, whether the program will finish running, or 
continue to run forever.

Thus, it doesn't actually matter what H decides about the simulation it 
does, what matters is what the machine described by the input does. 
SInce D(D) Halts, the only correcgt answer is Halting, so H can not be a 
correct halt decider since it says non-halting.

Thus, you are shown just to be a pathological liar that continually 
claims that Non-Halting is the correct answer to a problem whose answer 
is Halting.

You do it based on your LIE that your strawman criteria is somehow 
"equivalent" to the Halting critiria even though you acknoledge that 
there answers are different for this problem.

Things that have a noticable difference are not equivalent about the 
thing that they differ in. Your thinking that they are is in fact, one 
of the definitions of insanity, in this case, I think it is a 
pathological inabilitty to actually understand what is Truth.

[toc] | [prev] | [next] | [standalone]

#3677

On 2/20/2023 9:28 PM, olcott wrote:
> On 2/20/2023 8:53 PM, olcott wrote:
>> On 2/20/2023 8:22 PM, olcott wrote:
>>> On 2/20/2023 7:10 PM, olcott wrote:
>>>> On 2/20/2023 6:46 PM, olcott wrote:
>>>>> On 2/20/2023 12:39 PM, olcott wrote:
>>>>>> int D(int (*x)())
>>>>>> {
>>>>>>    int Halt_Status = H(x, x);
>>>>>>    if (Halt_Status)
>>>>>>      HERE: goto HERE;
>>>>>>    return Halt_Status;
>>>>>> }
>>>>>>
>>>>>> When simulating halt decider H is applied to the conventional 
>>>>>> (otherwise
>>>>>> impossible) input D ordinary software engineering conclusively proves
>>>>>> that D correctly simulated by H cannot possibly reach its own return
>>>>>> statement and terminate normally (AKA halt).
>>>>>>
>>>>>> A simulating halt decider H correctly predicts whether or not D
>>>>>> correctly simulated by H would ever reach its own final state.
>>>>>>
>>>>>> The ultimate measure of a correct simulation is that the execution 
>>>>>> trace
>>>>>> behavior of the simulated input exactly matches the behavior that the
>>>>>> input machine code specifies.
>>>>>>
>>>>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>>>>
>>>>>> Disagreeing with the above verified facts is only possible through
>>>>>> dishonesty or incompetence.
>>>>>>
>>>>>> Whether or not the above directly applies to the halting theorem 
>>>>>> is the
>>>>>> only actually open issue.
>>>>>>
>>>>>
>>>>> *I had to tighten my language a little bit*
>>>>
>>>> When the ultimate measure of correct simulation is that the execution
>>>> trace of the simulated input exactly matches the behavior that the 
>>>> input
>>>> machine description specifies then: It is an easily verified fact that
>>>> every counter-example input to the halting theorem D cannot possibly
>>>> reach its own simulated final state in any finite number of steps when
>>>> correctly simulated by  simulating halt decider H.
>>>
>>> Any alternative definition for "correct simulation" that contradicts the
>>> above definition necessary requires that D simulated by H derives an
>>> execution trace that is not specified by its input...
>>>
>>
>> Anyone with sufficient software engineering skill knows that
>> *D simulated by H cannot possibly correctly reach its ret instruction*
>> Everyone else lacks sufficient software engineering skill or lies
>>
>> _D()
>> [00001d12] 55         push ebp
>> [00001d13] 8bec       mov ebp,esp
>> [00001d15] 51         push ecx
>> [00001d16] 8b4508     mov eax,[ebp+08]
>> [00001d19] 50         push eax       // push D
>> [00001d1a] 8b4d08     mov ecx,[ebp+08]
>> [00001d1d] 51         push ecx       // push D
>> [00001d1e] e83ff8ffff call 00001562  // call H
>> [00001d23] 83c408     add esp,+08
>> [00001d26] 8945fc     mov [ebp-04],eax
>> [00001d29] 837dfc00   cmp dword [ebp-04],+00
>> [00001d2d] 7402       jz 00001d31
>> [00001d2f] ebfe       jmp 00001d2f
>> [00001d31] 8b45fc     mov eax,[ebp-04]
>> [00001d34] 8be5       mov esp,ebp
>> [00001d36] 5d         pop ebp
>> [00001d37] c3         ret
>>
>>
> 
> *THIS IS NOW A VERIFIED FACT*
> Because H and D have the required "do the opposite of whatever the halt
> decider decides" relationship H does correctly determine the halt status
> of the halting problem proof's previously impossible input.
> 

Now that the previously impossible input has been correctly determined
to be non-halting the halting theorem loses its entire basis.

The halting theorem does not prove that a set of input pairs cannot be
divided into halting and not halting. It only proves that one criterion
measure for dividing these pairs does not always work.

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

[toc] | [prev] | [next] | [standalone]

#3678

On 2/20/23 11:08 PM, olcott wrote:
> On 2/20/2023 9:28 PM, olcott wrote:
>> On 2/20/2023 8:53 PM, olcott wrote:
>>> On 2/20/2023 8:22 PM, olcott wrote:
>>>> On 2/20/2023 7:10 PM, olcott wrote:
>>>>> On 2/20/2023 6:46 PM, olcott wrote:
>>>>>> On 2/20/2023 12:39 PM, olcott wrote:
>>>>>>> int D(int (*x)())
>>>>>>> {
>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>    if (Halt_Status)
>>>>>>>      HERE: goto HERE;
>>>>>>>    return Halt_Status;
>>>>>>> }
>>>>>>>
>>>>>>> When simulating halt decider H is applied to the conventional 
>>>>>>> (otherwise
>>>>>>> impossible) input D ordinary software engineering conclusively 
>>>>>>> proves
>>>>>>> that D correctly simulated by H cannot possibly reach its own return
>>>>>>> statement and terminate normally (AKA halt).
>>>>>>>
>>>>>>> A simulating halt decider H correctly predicts whether or not D
>>>>>>> correctly simulated by H would ever reach its own final state.
>>>>>>>
>>>>>>> The ultimate measure of a correct simulation is that the 
>>>>>>> execution trace
>>>>>>> behavior of the simulated input exactly matches the behavior that 
>>>>>>> the
>>>>>>> input machine code specifies.
>>>>>>>
>>>>>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>>>>>
>>>>>>> Disagreeing with the above verified facts is only possible through
>>>>>>> dishonesty or incompetence.
>>>>>>>
>>>>>>> Whether or not the above directly applies to the halting theorem 
>>>>>>> is the
>>>>>>> only actually open issue.
>>>>>>>
>>>>>>
>>>>>> *I had to tighten my language a little bit*
>>>>>
>>>>> When the ultimate measure of correct simulation is that the execution
>>>>> trace of the simulated input exactly matches the behavior that the 
>>>>> input
>>>>> machine description specifies then: It is an easily verified fact that
>>>>> every counter-example input to the halting theorem D cannot possibly
>>>>> reach its own simulated final state in any finite number of steps when
>>>>> correctly simulated by  simulating halt decider H.
>>>>
>>>> Any alternative definition for "correct simulation" that contradicts 
>>>> the
>>>> above definition necessary requires that D simulated by H derives an
>>>> execution trace that is not specified by its input...
>>>>
>>>
>>> Anyone with sufficient software engineering skill knows that
>>> *D simulated by H cannot possibly correctly reach its ret instruction*
>>> Everyone else lacks sufficient software engineering skill or lies
>>>
>>> _D()
>>> [00001d12] 55         push ebp
>>> [00001d13] 8bec       mov ebp,esp
>>> [00001d15] 51         push ecx
>>> [00001d16] 8b4508     mov eax,[ebp+08]
>>> [00001d19] 50         push eax       // push D
>>> [00001d1a] 8b4d08     mov ecx,[ebp+08]
>>> [00001d1d] 51         push ecx       // push D
>>> [00001d1e] e83ff8ffff call 00001562  // call H
>>> [00001d23] 83c408     add esp,+08
>>> [00001d26] 8945fc     mov [ebp-04],eax
>>> [00001d29] 837dfc00   cmp dword [ebp-04],+00
>>> [00001d2d] 7402       jz 00001d31
>>> [00001d2f] ebfe       jmp 00001d2f
>>> [00001d31] 8b45fc     mov eax,[ebp-04]
>>> [00001d34] 8be5       mov esp,ebp
>>> [00001d36] 5d         pop ebp
>>> [00001d37] c3         ret
>>>
>>>
>>
>> *THIS IS NOW A VERIFIED FACT*
>> Because H and D have the required "do the opposite of whatever the halt
>> decider decides" relationship H does correctly determine the halt status
>> of the halting problem proof's previously impossible input.
>>
> 
> Now that the previously impossible input has been correctly determined
> to be non-halting the halting theorem loses its entire basis.
> 
> The halting theorem does not prove that a set of input pairs cannot be
> divided into halting and not halting. It only proves that one criterion
> measure for dividing these pairs does not always work.
> 

Remeber, In computability theory, the halting problem is the problem of 
determining, from a description of an arbitrary computer program and an 
input, whether the program will finish running, or continue to run forever.

So the division into Halting and Not Halting is based on the direct 
execution of the machine described, not some simulation that shows 
something different.

Thus you have NOT shown that the problem can be solved, you have only 
showed that you are too stupid to understand the problem.

Since D(D) Halts, it can not be correct for H(D,D) to say non-halting, 
BY DEFINITION, and any claim otherwise is just proven to be a LIE, and 
you to be an ignorant pathological lying idiot.

All you have done over the last decades is to prove that you don't knwo 
a thing about all the stuff you have been talking about.

Even if at some point there were some interesting points in your 
arguments, you have posioned them with your pathetic lying.

[toc] | [prev] | [next] | [standalone]

#3679

On 2/20/2023 10:08 PM, olcott wrote:
> On 2/20/2023 9:28 PM, olcott wrote:
>> On 2/20/2023 8:53 PM, olcott wrote:
>>> On 2/20/2023 8:22 PM, olcott wrote:
>>>> On 2/20/2023 7:10 PM, olcott wrote:
>>>>> On 2/20/2023 6:46 PM, olcott wrote:
>>>>>> On 2/20/2023 12:39 PM, olcott wrote:
>>>>>>> int D(int (*x)())
>>>>>>> {
>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>    if (Halt_Status)
>>>>>>>      HERE: goto HERE;
>>>>>>>    return Halt_Status;
>>>>>>> }
>>>>>>>
>>>>>>> When simulating halt decider H is applied to the conventional 
>>>>>>> (otherwise
>>>>>>> impossible) input D ordinary software engineering conclusively 
>>>>>>> proves
>>>>>>> that D correctly simulated by H cannot possibly reach its own return
>>>>>>> statement and terminate normally (AKA halt).
>>>>>>>
>>>>>>> A simulating halt decider H correctly predicts whether or not D
>>>>>>> correctly simulated by H would ever reach its own final state.
>>>>>>>
>>>>>>> The ultimate measure of a correct simulation is that the 
>>>>>>> execution trace
>>>>>>> behavior of the simulated input exactly matches the behavior that 
>>>>>>> the
>>>>>>> input machine code specifies.
>>>>>>>
>>>>>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>>>>>
>>>>>>> Disagreeing with the above verified facts is only possible through
>>>>>>> dishonesty or incompetence.
>>>>>>>
>>>>>>> Whether or not the above directly applies to the halting theorem 
>>>>>>> is the
>>>>>>> only actually open issue.
>>>>>>>
>>>>>>
>>>>>> *I had to tighten my language a little bit*
>>>>>
>>>>> When the ultimate measure of correct simulation is that the execution
>>>>> trace of the simulated input exactly matches the behavior that the 
>>>>> input
>>>>> machine description specifies then: It is an easily verified fact that
>>>>> every counter-example input to the halting theorem D cannot possibly
>>>>> reach its own simulated final state in any finite number of steps when
>>>>> correctly simulated by  simulating halt decider H.
>>>>
>>>> Any alternative definition for "correct simulation" that contradicts 
>>>> the
>>>> above definition necessary requires that D simulated by H derives an
>>>> execution trace that is not specified by its input...
>>>>
>>>
>>> Anyone with sufficient software engineering skill knows that
>>> *D simulated by H cannot possibly correctly reach its ret instruction*
>>> Everyone else lacks sufficient software engineering skill or lies
>>>
>>> _D()
>>> [00001d12] 55         push ebp
>>> [00001d13] 8bec       mov ebp,esp
>>> [00001d15] 51         push ecx
>>> [00001d16] 8b4508     mov eax,[ebp+08]
>>> [00001d19] 50         push eax       // push D
>>> [00001d1a] 8b4d08     mov ecx,[ebp+08]
>>> [00001d1d] 51         push ecx       // push D
>>> [00001d1e] e83ff8ffff call 00001562  // call H
>>> [00001d23] 83c408     add esp,+08
>>> [00001d26] 8945fc     mov [ebp-04],eax
>>> [00001d29] 837dfc00   cmp dword [ebp-04],+00
>>> [00001d2d] 7402       jz 00001d31
>>> [00001d2f] ebfe       jmp 00001d2f
>>> [00001d31] 8b45fc     mov eax,[ebp-04]
>>> [00001d34] 8be5       mov esp,ebp
>>> [00001d36] 5d         pop ebp
>>> [00001d37] c3         ret
>>>
>>>
>>
>> *THIS IS NOW A VERIFIED FACT*
>> Because H and D have the required "do the opposite of whatever the halt
>> decider decides" relationship H does correctly determine the halt status
>> of the halting problem proof's previously impossible input.
>>
> 
> Now that the previously impossible input has been correctly determined
> to be non-halting the halting theorem loses its entire basis.
> 
> The halting theorem does not prove that a set of input pairs cannot be
> divided into halting and not halting. It only proves that one criterion
> measure for dividing these pairs does not always work.
> 

The halting theorem does not prove that a set of input pairs cannot be
divided into halting and not halting. It only proves that one criterion
measure for dividing these pairs does not always work.

*A famous theorem with a false conclusion ceases to be a famous theorem*


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

[toc] | [prev] | [next] | [standalone]

#3680

On 2/20/23 11:44 PM, olcott wrote:
> On 2/20/2023 10:08 PM, olcott wrote:
>> On 2/20/2023 9:28 PM, olcott wrote:
>>> On 2/20/2023 8:53 PM, olcott wrote:
>>>> On 2/20/2023 8:22 PM, olcott wrote:
>>>>> On 2/20/2023 7:10 PM, olcott wrote:
>>>>>> On 2/20/2023 6:46 PM, olcott wrote:
>>>>>>> On 2/20/2023 12:39 PM, olcott wrote:
>>>>>>>> int D(int (*x)())
>>>>>>>> {
>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>    if (Halt_Status)
>>>>>>>>      HERE: goto HERE;
>>>>>>>>    return Halt_Status;
>>>>>>>> }
>>>>>>>>
>>>>>>>> When simulating halt decider H is applied to the conventional 
>>>>>>>> (otherwise
>>>>>>>> impossible) input D ordinary software engineering conclusively 
>>>>>>>> proves
>>>>>>>> that D correctly simulated by H cannot possibly reach its own 
>>>>>>>> return
>>>>>>>> statement and terminate normally (AKA halt).
>>>>>>>>
>>>>>>>> A simulating halt decider H correctly predicts whether or not D
>>>>>>>> correctly simulated by H would ever reach its own final state.
>>>>>>>>
>>>>>>>> The ultimate measure of a correct simulation is that the 
>>>>>>>> execution trace
>>>>>>>> behavior of the simulated input exactly matches the behavior 
>>>>>>>> that the
>>>>>>>> input machine code specifies.
>>>>>>>>
>>>>>>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>>>>>>
>>>>>>>> Disagreeing with the above verified facts is only possible through
>>>>>>>> dishonesty or incompetence.
>>>>>>>>
>>>>>>>> Whether or not the above directly applies to the halting theorem 
>>>>>>>> is the
>>>>>>>> only actually open issue.
>>>>>>>>
>>>>>>>
>>>>>>> *I had to tighten my language a little bit*
>>>>>>
>>>>>> When the ultimate measure of correct simulation is that the execution
>>>>>> trace of the simulated input exactly matches the behavior that the 
>>>>>> input
>>>>>> machine description specifies then: It is an easily verified fact 
>>>>>> that
>>>>>> every counter-example input to the halting theorem D cannot possibly
>>>>>> reach its own simulated final state in any finite number of steps 
>>>>>> when
>>>>>> correctly simulated by  simulating halt decider H.
>>>>>
>>>>> Any alternative definition for "correct simulation" that 
>>>>> contradicts the
>>>>> above definition necessary requires that D simulated by H derives an
>>>>> execution trace that is not specified by its input...
>>>>>
>>>>
>>>> Anyone with sufficient software engineering skill knows that
>>>> *D simulated by H cannot possibly correctly reach its ret instruction*
>>>> Everyone else lacks sufficient software engineering skill or lies
>>>>
>>>> _D()
>>>> [00001d12] 55         push ebp
>>>> [00001d13] 8bec       mov ebp,esp
>>>> [00001d15] 51         push ecx
>>>> [00001d16] 8b4508     mov eax,[ebp+08]
>>>> [00001d19] 50         push eax       // push D
>>>> [00001d1a] 8b4d08     mov ecx,[ebp+08]
>>>> [00001d1d] 51         push ecx       // push D
>>>> [00001d1e] e83ff8ffff call 00001562  // call H
>>>> [00001d23] 83c408     add esp,+08
>>>> [00001d26] 8945fc     mov [ebp-04],eax
>>>> [00001d29] 837dfc00   cmp dword [ebp-04],+00
>>>> [00001d2d] 7402       jz 00001d31
>>>> [00001d2f] ebfe       jmp 00001d2f
>>>> [00001d31] 8b45fc     mov eax,[ebp-04]
>>>> [00001d34] 8be5       mov esp,ebp
>>>> [00001d36] 5d         pop ebp
>>>> [00001d37] c3         ret
>>>>
>>>>
>>>
>>> *THIS IS NOW A VERIFIED FACT*
>>> Because H and D have the required "do the opposite of whatever the halt
>>> decider decides" relationship H does correctly determine the halt status
>>> of the halting problem proof's previously impossible input.
>>>
>>
>> Now that the previously impossible input has been correctly determined
>> to be non-halting the halting theorem loses its entire basis.
>>
>> The halting theorem does not prove that a set of input pairs cannot be
>> divided into halting and not halting. It only proves that one criterion
>> measure for dividing these pairs does not always work.
>>
> 
> The halting theorem does not prove that a set of input pairs cannot be
> divided into halting and not halting. It only proves that one criterion
> measure for dividing these pairs does not always work.
> 
> *A famous theorem with a false conclusion ceases to be a famous theorem*
> 
> 

So, you don't understand the meaning of "Definition".

Yes, if you redefine to something worthless, what "Hatling" Means, 
perhaps you can show that one proof doesn't work, but you have NOT shown 
that you can actually solve your POOPy Haltig Problem.

Some simple tests show that by YOUR definition, your Halt Decider does 
not halt for a large class of input, at least by its own criteria, so 
that means it claims that it is not a decider.



Note also, You still haven't shown that the existing proof is invalid, 
as you can still not gove an actual correct answer per its definition. 
so your final statement is shown to be incorrect. You have NOT shown its 
conclusion to be incorrect, just that you can't read its statement and 
understand what it says, because you are just too stupid.

Are we allowed to redefine YOUR statements in the same way to show who 
you actually are?

[toc] | [prev] | [next] | [standalone]

#3681

On 2/20/2023 10:44 PM, olcott wrote:
> On 2/20/2023 10:08 PM, olcott wrote:
>> On 2/20/2023 9:28 PM, olcott wrote:
>>> On 2/20/2023 8:53 PM, olcott wrote:
>>>> On 2/20/2023 8:22 PM, olcott wrote:
>>>>> On 2/20/2023 7:10 PM, olcott wrote:
>>>>>> On 2/20/2023 6:46 PM, olcott wrote:
>>>>>>> On 2/20/2023 12:39 PM, olcott wrote:
>>>>>>>> int D(int (*x)())
>>>>>>>> {
>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>    if (Halt_Status)
>>>>>>>>      HERE: goto HERE;
>>>>>>>>    return Halt_Status;
>>>>>>>> }
>>>>>>>>
>>>>>>>> When simulating halt decider H is applied to the conventional 
>>>>>>>> (otherwise
>>>>>>>> impossible) input D ordinary software engineering conclusively 
>>>>>>>> proves
>>>>>>>> that D correctly simulated by H cannot possibly reach its own 
>>>>>>>> return
>>>>>>>> statement and terminate normally (AKA halt).
>>>>>>>>
>>>>>>>> A simulating halt decider H correctly predicts whether or not D
>>>>>>>> correctly simulated by H would ever reach its own final state.
>>>>>>>>
>>>>>>>> The ultimate measure of a correct simulation is that the 
>>>>>>>> execution trace
>>>>>>>> behavior of the simulated input exactly matches the behavior 
>>>>>>>> that the
>>>>>>>> input machine code specifies.
>>>>>>>>
>>>>>>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>>>>>>
>>>>>>>> Disagreeing with the above verified facts is only possible through
>>>>>>>> dishonesty or incompetence.
>>>>>>>>
>>>>>>>> Whether or not the above directly applies to the halting theorem 
>>>>>>>> is the
>>>>>>>> only actually open issue.
>>>>>>>>
>>>>>>>
>>>>>>> *I had to tighten my language a little bit*
>>>>>>
>>>>>> When the ultimate measure of correct simulation is that the execution
>>>>>> trace of the simulated input exactly matches the behavior that the 
>>>>>> input
>>>>>> machine description specifies then: It is an easily verified fact 
>>>>>> that
>>>>>> every counter-example input to the halting theorem D cannot possibly
>>>>>> reach its own simulated final state in any finite number of steps 
>>>>>> when
>>>>>> correctly simulated by  simulating halt decider H.
>>>>>
>>>>> Any alternative definition for "correct simulation" that 
>>>>> contradicts the
>>>>> above definition necessary requires that D simulated by H derives an
>>>>> execution trace that is not specified by its input...
>>>>>
>>>>
>>>> Anyone with sufficient software engineering skill knows that
>>>> *D simulated by H cannot possibly correctly reach its ret instruction*
>>>> Everyone else lacks sufficient software engineering skill or lies
>>>>
>>>> _D()
>>>> [00001d12] 55         push ebp
>>>> [00001d13] 8bec       mov ebp,esp
>>>> [00001d15] 51         push ecx
>>>> [00001d16] 8b4508     mov eax,[ebp+08]
>>>> [00001d19] 50         push eax       // push D
>>>> [00001d1a] 8b4d08     mov ecx,[ebp+08]
>>>> [00001d1d] 51         push ecx       // push D
>>>> [00001d1e] e83ff8ffff call 00001562  // call H
>>>> [00001d23] 83c408     add esp,+08
>>>> [00001d26] 8945fc     mov [ebp-04],eax
>>>> [00001d29] 837dfc00   cmp dword [ebp-04],+00
>>>> [00001d2d] 7402       jz 00001d31
>>>> [00001d2f] ebfe       jmp 00001d2f
>>>> [00001d31] 8b45fc     mov eax,[ebp-04]
>>>> [00001d34] 8be5       mov esp,ebp
>>>> [00001d36] 5d         pop ebp
>>>> [00001d37] c3         ret
>>>>
>>>>
>>>
>>> *THIS IS NOW A VERIFIED FACT*
>>> Because H and D have the required "do the opposite of whatever the halt
>>> decider decides" relationship H does correctly determine the halt status
>>> of the halting problem proof's previously impossible input.
>>>
>>
>> Now that the previously impossible input has been correctly determined
>> to be non-halting the halting theorem loses its entire basis.
>>
>> The halting theorem does not prove that a set of input pairs cannot be
>> divided into halting and not halting. It only proves that one criterion
>> measure for dividing these pairs does not always work.
>>
> 
> The halting theorem does not prove that a set of input pairs cannot be
> divided into halting and not halting. It only proves that one criterion
> measure for dividing these pairs does not always work.
> 
> *A famous theorem with a false conclusion ceases to be a famous theorem*

The halting theorem does not prove that a set of input pairs cannot be
divided into halting and not halting. It only proves that one criterion
measure for dividing these pairs does not always work.

*A famous theorem with a false conclusion ceases to be a famous theorem*

It is a verified fact that H correctly predicts that D correctly
simulated by H would never reach its own final state and terminate
normally, thus H does correctly decide halting for its input D.

Every counter-example input to every proof of the halting theorem can be 
treated this same way.



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

[toc] | [prev] | [next] | [standalone]

#3684

On 2/21/23 10:38 AM, olcott wrote:
> On 2/20/2023 10:44 PM, olcott wrote:
>> On 2/20/2023 10:08 PM, olcott wrote:
>>> On 2/20/2023 9:28 PM, olcott wrote:
>>>> On 2/20/2023 8:53 PM, olcott wrote:
>>>>> On 2/20/2023 8:22 PM, olcott wrote:
>>>>>> On 2/20/2023 7:10 PM, olcott wrote:
>>>>>>> On 2/20/2023 6:46 PM, olcott wrote:
>>>>>>>> On 2/20/2023 12:39 PM, olcott wrote:
>>>>>>>>> int D(int (*x)())
>>>>>>>>> {
>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>    if (Halt_Status)
>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>    return Halt_Status;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> When simulating halt decider H is applied to the conventional 
>>>>>>>>> (otherwise
>>>>>>>>> impossible) input D ordinary software engineering conclusively 
>>>>>>>>> proves
>>>>>>>>> that D correctly simulated by H cannot possibly reach its own 
>>>>>>>>> return
>>>>>>>>> statement and terminate normally (AKA halt).
>>>>>>>>>
>>>>>>>>> A simulating halt decider H correctly predicts whether or not D
>>>>>>>>> correctly simulated by H would ever reach its own final state.
>>>>>>>>>
>>>>>>>>> The ultimate measure of a correct simulation is that the 
>>>>>>>>> execution trace
>>>>>>>>> behavior of the simulated input exactly matches the behavior 
>>>>>>>>> that the
>>>>>>>>> input machine code specifies.
>>>>>>>>>
>>>>>>>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>>>>>>>
>>>>>>>>> Disagreeing with the above verified facts is only possible through
>>>>>>>>> dishonesty or incompetence.
>>>>>>>>>
>>>>>>>>> Whether or not the above directly applies to the halting 
>>>>>>>>> theorem is the
>>>>>>>>> only actually open issue.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *I had to tighten my language a little bit*
>>>>>>>
>>>>>>> When the ultimate measure of correct simulation is that the 
>>>>>>> execution
>>>>>>> trace of the simulated input exactly matches the behavior that 
>>>>>>> the input
>>>>>>> machine description specifies then: It is an easily verified fact 
>>>>>>> that
>>>>>>> every counter-example input to the halting theorem D cannot possibly
>>>>>>> reach its own simulated final state in any finite number of steps 
>>>>>>> when
>>>>>>> correctly simulated by  simulating halt decider H.
>>>>>>
>>>>>> Any alternative definition for "correct simulation" that 
>>>>>> contradicts the
>>>>>> above definition necessary requires that D simulated by H derives an
>>>>>> execution trace that is not specified by its input...
>>>>>>
>>>>>
>>>>> Anyone with sufficient software engineering skill knows that
>>>>> *D simulated by H cannot possibly correctly reach its ret instruction*
>>>>> Everyone else lacks sufficient software engineering skill or lies
>>>>>
>>>>> _D()
>>>>> [00001d12] 55         push ebp
>>>>> [00001d13] 8bec       mov ebp,esp
>>>>> [00001d15] 51         push ecx
>>>>> [00001d16] 8b4508     mov eax,[ebp+08]
>>>>> [00001d19] 50         push eax       // push D
>>>>> [00001d1a] 8b4d08     mov ecx,[ebp+08]
>>>>> [00001d1d] 51         push ecx       // push D
>>>>> [00001d1e] e83ff8ffff call 00001562  // call H
>>>>> [00001d23] 83c408     add esp,+08
>>>>> [00001d26] 8945fc     mov [ebp-04],eax
>>>>> [00001d29] 837dfc00   cmp dword [ebp-04],+00
>>>>> [00001d2d] 7402       jz 00001d31
>>>>> [00001d2f] ebfe       jmp 00001d2f
>>>>> [00001d31] 8b45fc     mov eax,[ebp-04]
>>>>> [00001d34] 8be5       mov esp,ebp
>>>>> [00001d36] 5d         pop ebp
>>>>> [00001d37] c3         ret
>>>>>
>>>>>
>>>>
>>>> *THIS IS NOW A VERIFIED FACT*
>>>> Because H and D have the required "do the opposite of whatever the halt
>>>> decider decides" relationship H does correctly determine the halt 
>>>> status
>>>> of the halting problem proof's previously impossible input.
>>>>
>>>
>>> Now that the previously impossible input has been correctly determined
>>> to be non-halting the halting theorem loses its entire basis.
>>>
>>> The halting theorem does not prove that a set of input pairs cannot be
>>> divided into halting and not halting. It only proves that one criterion
>>> measure for dividing these pairs does not always work.
>>>
>>
>> The halting theorem does not prove that a set of input pairs cannot be
>> divided into halting and not halting. It only proves that one criterion
>> measure for dividing these pairs does not always work.
>>
>> *A famous theorem with a false conclusion ceases to be a famous theorem*
> 
> The halting theorem does not prove that a set of input pairs cannot be
> divided into halting and not halting. It only proves that one criterion
> measure for dividing these pairs does not always work.

Ad that ONE criteria is the actual criteria for a machine halt, BY 
DEFINITOIN.

> 
> *A famous theorem with a false conclusion ceases to be a famous theorem*

And a FALSE theorem based on a FALSE premsie is jus FALSE.

> 
> It is a verified fact that H correctly predicts that D correctly
> simulated by H would never reach its own final state and terminate
> normally, thus H does correctly decide halting for its input D.

Nope, H does NOT correctly predict what its correct prediction would do, 
since it doesn't do what it is predicted to do.

You are just proving your insanity.

> 
> Every counter-example input to every proof of the halting theorem can be 
> treated this same way.
> 

Nope, which also shows your stupidity.

How does your idea handle the Busy Beaver issue?

[toc] | [prev] | [next] | [standalone]

#3670

On 2/20/23 7:46 PM, olcott wrote:
> On 2/20/2023 12:39 PM, olcott wrote:
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> When simulating halt decider H is applied to the conventional (otherwise
>> impossible) input D ordinary software engineering conclusively proves
>> that D correctly simulated by H cannot possibly reach its own return
>> statement and terminate normally (AKA halt).
>>
>> A simulating halt decider H correctly predicts whether or not D
>> correctly simulated by H would ever reach its own final state.
>>
>> The ultimate measure of a correct simulation is that the execution trace
>> behavior of the simulated input exactly matches the behavior that the
>> input machine code specifies.
>>
>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>
>> Disagreeing with the above verified facts is only possible through
>> dishonesty or incompetence.
>>
>> Whether or not the above directly applies to the halting theorem is the
>> only actually open issue.
>>
> 
> *I had to tighten my language a little bit*
> When the ultimate measure of correct simulation is that the execution
> trace of the simulated input exactly matches the behavior that the input
> machine description specifies then: It is an easily verified fact that
> every counter-example input to the halting theorem D cannot possibly
> reach its own simulated final state in any finite number of steps.

Which it isn't if you want to use the fact that "Correct Simulation" 
gives the same resutls as direct execution, so you are admitting you 
aren't actually working on the Halting Problem anymore, since you are no 
longer using a critiria that is equivalnt to Halting.

Remember, I\in computability theory, the halting problem is the problem 
of determining, from a description of an arbitrary computer program and 
an input, whether the program will finish running, or continue to run 
forever.

Thus, it is ALWAYS the behavior of the actual execution of the program 
that matters, anything else is only usable if it is actually equivalent.

> 
> Most of my reviewers deceptively talk about non-inputs when they already
> know that deciders only operate on inputs.
> 
> 
No, YOU talk about "Non-Inputs", since the H that your H assumes it sees 
is not the H that is actually given, thus it isn't answering about the 
input that was actually given. (Remember, the code of the H that D calls 
is part of the input)

The "Input" is the description of the Turing Machine and Input to be 
decided on, and the problem is to determine what that Turing Machine 
would do when given that input.

it is NOT about some non-UTM partial simulation of the input done by the 
decider, THAT is just your POOP.

[toc] | [prev] | [standalone]

Back to top | Article view | comp.software-eng

csiph-web