When simulating halt decider H examines the behavior of D correctly
simulated by H it correctly determines that D(D) would never stop
running unless H aborts its simulation of D.

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

*D simulated by H cannot correctly reach its ret instruction and halt*

_D()
[00001d12] 55 push ebp
[00001d13] 8bec mov ebp,esp
[00001d15] 51 push ecx
[00001d16] 8b4508 mov eax,[ebp+08] // move 1st argument to eax
[00001d19] 50 push eax // push D
[00001d1a] 8b4d08 mov ecx,[ebp+08] // move 1st argument to ecx
[00001d1d] 51 push ecx // push D
[00001d1e] e83ff8ffff call 00001562 // call H same as H(D,D)
[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

*Simulating Halt Deciders Defeat the Halting Theorem*
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem

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

On 2/25/23 2:31 PM, olcott wrote:
> When simulating halt decider H examines the behavior of D correctly
> simulated by H it correctly determines that D(D) would never stop
> running unless H aborts its simulation of D.
>
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> *D simulated by H cannot correctly reach its ret instruction and halt*
>
> _D()
>  [00001d12] 55         push ebp
>  [00001d13] 8bec       mov ebp,esp
>  [00001d15] 51         push ecx
>  [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>  [00001d19] 50         push eax         // push D
>  [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>  [00001d1d] 51         push ecx         // push D
>  [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>  [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
>
> *Simulating Halt Deciders Defeat the Halting Theorem*
> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>

But 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 it has been shown that since H(D,D) returns 0, that D(D) will halt,
the correct answer for an actual Halt Decider is Halting, so your H is
NOT a correct Halt Decider.

Thus, you may have solved your POOP 💩 problem, but I don't know of
anyone interested in that. You are just showing that you don't
understand what you are talking about, and LYING about working on the
Halting Problem.

On 2/25/2023 1:31 PM, olcott wrote:
> When simulating halt decider H examines the behavior of D correctly
> simulated by H it correctly determines that D(D) would never stop
> running unless H aborts its simulation of D.
>
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> *D simulated by H cannot correctly reach its ret instruction and halt*
>
> _D()
>  [00001d12] 55         push ebp
>  [00001d13] 8bec       mov ebp,esp
>  [00001d15] 51         push ecx
>  [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>  [00001d19] 50         push eax         // push D
>  [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>  [00001d1d] 51         push ecx         // push D
>  [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>  [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
>
> *Simulating Halt Deciders Defeat the Halting Theorem*
> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>

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. https://en.wikipedia.org/wiki/Halting_problem

H does correctly predict that D(D) would keep running forever unless H
aborts its simulation of D, therefore H correctly rejects this input for
the same reason that it rejects these other two inputs:

void Infinite_Loop()
{ HERE: goto HERE;
}

void Infinite_Recursion(u32 N)
{ Infinite_Recursion(N);
}

*They would keep running forever unless H aborts its simulation*

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

On 2/25/2023 2:20 PM, Fritz Feldhase wrote:
> On Saturday, February 25, 2023 at 8:31:12 PM UTC+1, olcott wrote:
>
>> When simulating halt decider H examines the behavior of D [with input D]
>> it correctly determines that D(D) would never stop running <bla>
>
> Look man, either D(D) stops running or it doesn't. Got that?
>

void Infinite_Loop()
{ HERE: goto HERE;
}

Even Infinite_Loop() stops running when H aborts its simulation of
Infinite_Loop().

Because of this we know that whenever a program only stops running
when its simulation has been aborted this proves that this program
doesn't halt.

> Now if f H(D, D) determines that D(D) halts (and hence returns 1), D(D) doesn't halt. If H(D, D) determines that D(D) doesn't halt (and hence returns 0), D(D) halts. Got that?
>
> H simply doesn't determine the correct halt status of D with input D (i.e. D(D)).
>

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

On 2/25/23 2:57 PM, olcott wrote:
> On 2/25/2023 1:31 PM, olcott wrote:
>> When simulating halt decider H examines the behavior of D correctly
>> simulated by H it correctly determines that D(D) would never stop
>> running unless H aborts its simulation of D.
>>
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> *D simulated by H cannot correctly reach its ret instruction and halt*
>>
>> _D()
>>   [00001d12] 55         push ebp
>>   [00001d13] 8bec       mov ebp,esp
>>   [00001d15] 51         push ecx
>>   [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>>   [00001d19] 50         push eax         // push D
>>   [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>>   [00001d1d] 51         push ecx         // push D
>>   [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>>   [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
>>
>> *Simulating Halt Deciders Defeat the Halting Theorem*
>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>
>
> 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. https://en.wikipedia.org/wiki/Halting_problem
>
> H does correctly predict that D(D) would keep running forever unless H
> aborts its simulation of D, therefore H correctly rejects this input for
> the same reason that it rejects these other two inputs:

So, you quote the definition and then IGNORE it.

What matters is the program given. It doesn't matter what some other
program does.

Since H(D,D) DOES abort its simulation and return 0, D(D) DOES HALT, and
thus H is WRONG.

>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> void Infinite_Recursion(u32 N)
> {
>   Infinite_Recursion(N);
> }
>
> *They would keep running forever unless H aborts its simulation*
>

But it does, so that doesn't matter if H's behavior affects the machine,
like it does in D

You are just proving that you don't understand the basics of how
computers work, or logic.

You have disqualified yoursef to speak about these things.

On 2/25/23 3:25 PM, olcott wrote:
> On 2/25/2023 2:20 PM, Fritz Feldhase wrote:
>> On Saturday, February 25, 2023 at 8:31:12 PM UTC+1, olcott wrote:
>>
>>> When simulating halt decider H examines the behavior of D [with input D]
>>> it correctly determines that D(D) would never stop running <bla>
>>
>> Look man, either D(D) stops running or it doesn't. Got that?
>>
>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> Even Infinite_Loop() stops running when H aborts its simulation of
> Infinite_Loop().

Nope, the SIMULATION of it stops running, but not the actual machine.

You CAN'T abort an actual Turing Machine, it has no "off" switch.

>
> Because of this we know that whenever a program only stops running
> when its simulation has been aborted this proves that this program
> doesn't halt.

Nope, just shows you don't understand what you are talking about.

You COULD say if you replace THIS INSTANCE of the decider with a UTM,
and the simulation would go on forever, then the decider is correct to
say non-halting. Note carefully, just THIS INSTANCE, and that can not
change the code that is in the input, and since D calls H, you can't
change H, thus you can't use that option with the way you have defined
things.

You are just proving how little you understand about the theory, it
seems because you have made yourself intentionally ignorant of it. Your
fault and your loss. You are just proving your stupidity.

>
>> Now if f H(D, D) determines that D(D) halts (and hence returns 1),
>> D(D) doesn't halt. If H(D, D) determines that D(D) doesn't halt (and
>> hence returns 0), D(D) halts. Got that?
>>
>> H simply doesn't determine the correct halt status of D with input D
>> (i.e. D(D)).
>>
>

On 2/25/2023 1:31 PM, olcott wrote:
> When simulating halt decider H examines the behavior of D correctly
> simulated by H it correctly determines that D(D) would never stop
> running unless H aborts its simulation of D.
>
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> *D simulated by H cannot correctly reach its ret instruction and halt*
>
> _D()
>  [00001d12] 55         push ebp
>  [00001d13] 8bec       mov ebp,esp
>  [00001d15] 51         push ecx
>  [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>  [00001d19] 50         push eax         // push D
>  [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>  [00001d1d] 51         push ecx         // push D
>  [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>  [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
>
> *Simulating Halt Deciders Defeat the Halting Theorem*
> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>

Because D(D) would never stop running unless H aborts its simulation H
is necessarily correct to reject its input on this basis.

*The Peter Linz halting problem proof*
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

Because Ĥ applied to ⟨Ĥ⟩ would never stop running unless embedded_H
aborts its simulation embedded_H is necessarily correct to reject its
input on this basis.

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

On 2/25/23 4:01 PM, olcott wrote:
> On 2/25/2023 1:31 PM, olcott wrote:
>> When simulating halt decider H examines the behavior of D correctly
>> simulated by H it correctly determines that D(D) would never stop
>> running unless H aborts its simulation of D.
>>
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> *D simulated by H cannot correctly reach its ret instruction and halt*
>>
>> _D()
>>   [00001d12] 55         push ebp
>>   [00001d13] 8bec       mov ebp,esp
>>   [00001d15] 51         push ecx
>>   [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>>   [00001d19] 50         push eax         // push D
>>   [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>>   [00001d1d] 51         push ecx         // push D
>>   [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>>   [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
>>
>> *Simulating Halt Deciders Defeat the Halting Theorem*
>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>
>
> Because D(D) would never stop running unless H aborts its simulation H
> is necessarily correct to reject its input on this basis.
>

But the H(D,D) that D(D) calls DOES abort its simultion, so D(D) Halts.

> *The Peter Linz halting problem proof*
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞

If H/embedded_H go to qy, which they must do if Ĥ applied to ⟨Ĥ⟩ Halts

> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

If H/embedded)H go to qn, which they must do if Ĥ applied to ⟨Ĥ⟩ will
never halt.

(You seem to like to drop the required conditions, I think becaue your
H/embedded_H fail to meet them).

>
> Because Ĥ applied to ⟨Ĥ⟩ would never stop running unless embedded_H
> aborts its simulation embedded_H is necessarily correct to reject its
> input on this basis.
>
>

But if embedded_H never aborts its simulation, neither does H, and thus
H will not answer.

Thus since you have stated that H DOES abort its simulation and go to
qn, then so does embedded_H and thus Ĥ applied to ⟨Ĥ⟩ does halt.

You are getting yourself tangled up in confusing the truth of reality
with your lies about hypotheticals.

SInce Ĥ applied to ⟨Ĥ⟩ Halts, it can not be correct for H to go to qn,
but it MUST go to qy to be correct. Since it doesn't, it is just wrong.

On 2/25/2023 3:01 PM, olcott wrote:
> On 2/25/2023 1:31 PM, olcott wrote:
>> When simulating halt decider H examines the behavior of D correctly
>> simulated by H it correctly determines that D(D) would never stop
>> running unless H aborts its simulation of D.
>>
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> *D simulated by H cannot correctly reach its ret instruction and halt*
>>
>> _D()
>>   [00001d12] 55         push ebp
>>   [00001d13] 8bec       mov ebp,esp
>>   [00001d15] 51         push ecx
>>   [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>>   [00001d19] 50         push eax         // push D
>>   [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>>   [00001d1d] 51         push ecx         // push D
>>   [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>>   [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
>>
>> *Simulating Halt Deciders Defeat the Halting Theorem*
>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>
>
> Because D(D) would never stop running unless H aborts its simulation H
> is necessarily correct to reject its input on this basis.
>
> *The Peter Linz halting problem proof*
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> Because Ĥ applied to ⟨Ĥ⟩ would never stop running unless embedded_H
> aborts its simulation embedded_H is necessarily correct to reject its
> input on this basis.
>
>

A simulating halt decider correctly predicts what the behavior of its
input would be if this simulated input never had its simulation aborted.
It does this by correctly recognizing several non-halting behavior
patterns in a finite number of steps of correct simulation.

H correctly predicts that D(D) would never stop running if H does not
abort the simulation of its input.

embedded_H correctly predicts that Ĥ applied to ⟨Ĥ⟩ would never stop
running if H does not abort the simulation of its input.

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

On 2/25/23 4:43 PM, olcott wrote:
> On 2/25/2023 3:01 PM, olcott wrote:
>> On 2/25/2023 1:31 PM, olcott wrote:
>>> When simulating halt decider H examines the behavior of D correctly
>>> simulated by H it correctly determines that D(D) would never stop
>>> running unless H aborts its simulation of D.
>>>
>>> int D(int (*x)())
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> *D simulated by H cannot correctly reach its ret instruction and halt*
>>>
>>> _D()
>>>   [00001d12] 55         push ebp
>>>   [00001d13] 8bec       mov ebp,esp
>>>   [00001d15] 51         push ecx
>>>   [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>>>   [00001d19] 50         push eax         // push D
>>>   [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>>>   [00001d1d] 51         push ecx         // push D
>>>   [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>>>   [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
>>>
>>> *Simulating Halt Deciders Defeat the Halting Theorem*
>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>
>>
>> Because D(D) would never stop running unless H aborts its simulation H
>> is necessarily correct to reject its input on this basis.
>>
>> *The Peter Linz halting problem proof*
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> Because Ĥ applied to ⟨Ĥ⟩ would never stop running unless embedded_H
>> aborts its simulation embedded_H is necessarily correct to reject its
>> input on this basis.
>>
>>
>
> A simulating halt decider correctly predicts what the behavior of its
> input would be if this simulated input never had its simulation aborted.
> It does this by correctly recognizing several non-halting behavior
> patterns in a finite number of steps of correct simulation.

IF by that you mean if the decider, and alll copies of it elsewhere,
were different, then you definition is BROKEN, because it is looking at
inputs that it hasn't been given. You are not allowed to change the data
that has been given as an input, and because you have intertwined your
input and the decider, you can't talk about actually changing the code
of your decider, so your statement is just proven to be NONSENSE.

If you mean it THIS INSTANCE didn't abort its simulation, then your
answer is just wrong, as if H' is the altered version of H that doesn't
abort, then since H'(D,D) will reach a final state as H(D,D) by your
"logic" decided that its input is non-halting, so H' sees D(D) use
H(D,D), then see it return that 0, ad then Halt

>
> H correctly predicts that D(D) would never stop running if H does not
> abort the simulation of its input.

Except that since H DOES abort its simulation, that isn't the behavior
of its actual input.

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.

Ths since the actual D(D) Halts because the actual H(D,D) returns 0
(non-halting) the correct answer for a Halt Decider is Halting, so H is
not a correct halt decider.

>
> embedded_H correctly predicts that Ĥ applied to ⟨Ĥ⟩ would never stop
> running if H does not abort the simulation of its input.
>

So, embdded_H will, by your logic, abort its simulation and go to qn and
then Ĥ applied to ⟨Ĥ⟩ will also end up in qn and it will halt, showing
that this "correct answer" is NOT the correct answer for a Halt Decider,
thus proving that neither H or embedded_H are Halt Deciders and that you
have been just lying for the last couple of decades.

On Sat, 25 Feb 2023 17:13:52 -0500, Richard Damon wrote:

> On 2/25/23 4:43 PM, olcott wrote:
>> On 2/25/2023 3:01 PM, olcott wrote:
>>> On 2/25/2023 1:31 PM, olcott wrote:
>>>> When simulating halt decider H examines the behavior of D correctly
>>>> simulated by H it correctly determines that D(D) would never stop
>>>> running unless H aborts its simulation of D.
>>>>
>>>> int D(int (*x)())
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> *D simulated by H cannot correctly reach its ret instruction and
>>>> halt*
>>>>
>>>> _D()
>>>>   [00001d12] 55         push ebp [00001d13] 8bec       mov ebp,esp
>>>>   [00001d15] 51         push ecx [00001d16] 8b4508     mov
>>>>   eax,[ebp+08] // move 1st argument to eax [00001d19] 50        
>>>>   push eax         // push D [00001d1a] 8b4d08     mov ecx,[ebp+08]
>>>>   // move 1st argument to ecx [00001d1d] 51         push
>>>>   ecx         // push D [00001d1e] e83ff8ffff call 00001562    //
>>>>   call H same as H(D,D) [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
>>>>
>>>> *Simulating Halt Deciders Defeat the Halting Theorem*
>>>> https://www.researchgate.net/publication/
368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>>
>>>>
>>> Because D(D) would never stop running unless H aborts its simulation H
>>> is necessarily correct to reject its input on this basis.
>>>
>>> *The Peter Linz halting problem proof*
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> Because Ĥ applied to ⟨Ĥ⟩ would never stop running unless embedded_H
>>> aborts its simulation embedded_H is necessarily correct to reject its
>>> input on this basis.
>>>
>>>
>>>
>> A simulating halt decider correctly predicts what the behavior of its
>> input would be if this simulated input never had its simulation
>> aborted. It does this by correctly recognizing several non-halting
>> behavior patterns in a finite number of steps of correct simulation.
>
> IF by that you mean if the decider, and alll copies of it elsewhere,
> were different, then you definition is BROKEN, because it is looking at
> inputs that it hasn't been given. You are not allowed to change the data
> that has been given as an input, and because you have intertwined your
> input and the decider, you can't talk about actually changing the code
> of your decider, so your statement is just proven to be NONSENSE.
>
> If you mean it THIS INSTANCE didn't abort its simulation, then your
> answer is just wrong, as if H' is the altered version of H that doesn't
> abort, then since H'(D,D) will reach a final state as H(D,D) by your
> "logic" decided that its input is non-halting, so H' sees D(D) use
> H(D,D), then see it return that 0, ad then Halt
>
>
>> H correctly predicts that D(D) would never stop running if H does not
>> abort the simulation of its input.
>
> Except that since H DOES abort its simulation, that isn't the behavior
> of its actual input.
>
> 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.
>
> Ths since the actual D(D) Halts because the actual H(D,D) returns 0
> (non-halting) the correct answer for a Halt Decider is Halting, so H is
> not a correct halt decider.
>
>
>> embedded_H correctly predicts that Ĥ applied to ⟨Ĥ⟩ would never stop
>> running if H does not abort the simulation of its input.
>>
>>
> So, embdded_H will, by your logic, abort its simulation and go to qn and
> then Ĥ applied to ⟨Ĥ⟩ will also end up in qn and it will halt,
showing
> that this "correct answer" is NOT the correct answer for a Halt Decider,
> thus proving that neither H or embedded_H are Halt Deciders and that you
> have been just lying for the last couple of decades.

Reply again but this time randomly swap the words around a bit. Oh, you
have been doing that already, for over a year. Take your fucking meds,
mate.

/Flibble

On 2/26/23 10:05 AM, Mr Flibble wrote:
> On Sat, 25 Feb 2023 17:13:52 -0500, Richard Damon wrote:
>
>> On 2/25/23 4:43 PM, olcott wrote:
>>> On 2/25/2023 3:01 PM, olcott wrote:
>>>> On 2/25/2023 1:31 PM, olcott wrote:
>>>>> When simulating halt decider H examines the behavior of D correctly
>>>>> simulated by H it correctly determines that D(D) would never stop
>>>>> running unless H aborts its simulation of D.
>>>>>
>>>>> int D(int (*x)())
>>>>> {
>>>>>    int Halt_Status = H(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return Halt_Status;
>>>>> }
>>>>>
>>>>> *D simulated by H cannot correctly reach its ret instruction and
>>>>> halt*
>>>>>
>>>>> _D()
>>>>>   [00001d12] 55         push ebp [00001d13] 8bec       mov ebp,esp
>>>>>   [00001d15] 51         push ecx [00001d16] 8b4508     mov
>>>>>   eax,[ebp+08] // move 1st argument to eax [00001d19] 50
>>>>>   push eax         // push D [00001d1a] 8b4d08     mov ecx,[ebp+08]
>>>>>   // move 1st argument to ecx [00001d1d] 51         push
>>>>>   ecx         // push D [00001d1e] e83ff8ffff call 00001562    //
>>>>>   call H same as H(D,D) [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
>>>>>
>>>>> *Simulating Halt Deciders Defeat the Halting Theorem*
>>>>> https://www.researchgate.net/publication/
> 368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>>>
>>>>>
>>>> Because D(D) would never stop running unless H aborts its simulation H
>>>> is necessarily correct to reject its input on this basis.
>>>>
>>>> *The Peter Linz halting problem proof*
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> Because Ĥ applied to ⟨Ĥ⟩ would never stop running unless embedded_H
>>>> aborts its simulation embedded_H is necessarily correct to reject its
>>>> input on this basis.
>>>>
>>>>
>>>>
>>> A simulating halt decider correctly predicts what the behavior of its
>>> input would be if this simulated input never had its simulation
>>> aborted. It does this by correctly recognizing several non-halting
>>> behavior patterns in a finite number of steps of correct simulation.
>>
>> IF by that you mean if the decider, and alll copies of it elsewhere,
>> were different, then you definition is BROKEN, because it is looking at
>> inputs that it hasn't been given. You are not allowed to change the data
>> that has been given as an input, and because you have intertwined your
>> input and the decider, you can't talk about actually changing the code
>> of your decider, so your statement is just proven to be NONSENSE.
>>
>> If you mean it THIS INSTANCE didn't abort its simulation, then your
>> answer is just wrong, as if H' is the altered version of H that doesn't
>> abort, then since H'(D,D) will reach a final state as H(D,D) by your
>> "logic" decided that its input is non-halting, so H' sees D(D) use
>> H(D,D), then see it return that 0, ad then Halt
>>
>>
>>> H correctly predicts that D(D) would never stop running if H does not
>>> abort the simulation of its input.
>>
>> Except that since H DOES abort its simulation, that isn't the behavior
>> of its actual input.
>>
>> 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.
>>
>> Ths since the actual D(D) Halts because the actual H(D,D) returns 0
>> (non-halting) the correct answer for a Halt Decider is Halting, so H is
>> not a correct halt decider.
>>
>>
>>> embedded_H correctly predicts that Ĥ applied to ⟨Ĥ⟩ would never stop
>>> running if H does not abort the simulation of its input.
>>>
>>>
>> So, embdded_H will, by your logic, abort its simulation and go to qn and
>> then Ĥ applied to ⟨Ĥ⟩ will also end up in qn and it will halt,
> showing
>> that this "correct answer" is NOT the correct answer for a Halt Decider,
>> thus proving that neither H or embedded_H are Halt Deciders and that you
>> have been just lying for the last couple of decades.
>
> Reply again but this time randomly swap the words around a bit. Oh, you
> have been doing that already, for over a year. Take your fucking meds,
> mate.
>
> /Flibble

PLONK, if you understand the term.

You are showing yourself to just be incoherent.

On 2/26/2023 1:29 PM, Fritz Feldhase wrote:
> On Saturday, February 25, 2023 at 10:43:30 PM UTC+1, olcott wrote:
>
>> A [correct] halt decider [...] predicts what the behavior of its input would be
>
> ...if run "stand allone".
>
> Now, if run stand allone D(D) either stops running or it doesn't. Got that?
>
> Now if H(D, D) determines that D(D) halts (when run stand allone), D(D) doesn't halt (when run stand allone). If H(D, D) determines that D(D) doesn't halt (when run stand allone), D(D) halts (when run stand allone). Got that?
>
> H simply doesn't determine the correct halt behaviour of D(D).
>
>> H [...] predicts that D(D) would never stop running [when run stand allone]
>
> Well, in this case D(D) terminates (stops running) [when run stand allone]. Hence H's "prediction" is wrong.

ONLY LIARS WILL DISAGREE
The fact that D(D) never stops running unless H(D,D) aborts its
simulation of D conclusively proves that H is necessarily correct to
reject D as non-halting.

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

On 2/26/23 2:51 PM, olcott wrote:
> On 2/26/2023 1:29 PM, Fritz Feldhase wrote:
>> On Saturday, February 25, 2023 at 10:43:30 PM UTC+1, olcott wrote:
>>
>>> A [correct] halt decider [...] predicts what the behavior of its
>>> input would be
>>
>> ...if run "stand allone".
>>
>> Now, if run stand allone D(D) either stops running or it doesn't. Got
>> that?
>>
>> Now if H(D, D) determines that D(D) halts (when run stand allone),
>> D(D) doesn't halt (when run stand allone). If H(D, D) determines that
>> D(D) doesn't halt (when run stand allone), D(D) halts (when run stand
>> allone). Got that?
>>
>> H simply doesn't determine the correct halt behaviour of D(D).
>>
>>> H [...] predicts that D(D) would never stop running [when run stand
>>> allone]
>>
>> Well, in this case D(D) terminates (stops running) [when run stand
>> allone]. Hence H's "prediction" is wrong.
>
> ONLY LIARS WILL DISAGREE
> The fact that D(D) never stops running unless H(D,D) aborts its
> simulation of D conclusively proves that H is necessarily correct to
> reject D as non-halting.
>
>

Why do you say that?

The reasoning has been explained to you.

You have ignored it, or at least not pointed out an error in the rebuttal.

That makes YOU the LIAR.

And only liars will disagree.

If you want to redeam your reputation, you need to do more than just
keep on repeating disproven ideas and false statements.

You are going to DIE soon (unless you have been lying, but in one sense,
all of us will die soon) and right now, your only legacy is as that of a
lying crank. If you are satisfied with that, continue on and cement that
future.

On 2/26/2023 1:51 PM, olcott wrote:
> On 2/26/2023 1:29 PM, Fritz Feldhase wrote:
>> On Saturday, February 25, 2023 at 10:43:30 PM UTC+1, olcott wrote:
>>
>>> A [correct] halt decider [...] predicts what the behavior of its
>>> input would be
>>
>> ...if run "stand allone".
>>
>> Now, if run stand allone D(D) either stops running or it doesn't. Got
>> that?
>>
>> Now if H(D, D) determines that D(D) halts (when run stand allone),
>> D(D) doesn't halt (when run stand allone). If H(D, D) determines that
>> D(D) doesn't halt (when run stand allone), D(D) halts (when run stand
>> allone). Got that?
>>
>> H simply doesn't determine the correct halt behaviour of D(D).
>>
>>> H [...] predicts that D(D) would never stop running [when run stand
>>> allone]
>>
>> Well, in this case D(D) terminates (stops running) [when run stand
>> allone]. Hence H's "prediction" is wrong.
>
> ONLY LIARS WILL DISAGREE
> The fact that D(D) never stops running unless H(D,D) aborts its
> simulation of D conclusively proves that H is necessarily correct to
> reject D as non-halting.

LIARS know full well the the above is infallibly correct as proven by
their completely vacuous attempts at rebuttal.

They have known this for the whole two years since I first providing the
above reasoning.

Now that I know that completely vacuous attempts at rebuttal by lying
reviewers are affirmations that my point has been made things are
proceeding much more quickly.

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

On Sun, 26 Feb 2023 15:02:01 -0500, Richard Damon wrote:

> On 2/26/23 2:51 PM, olcott wrote:
>> On 2/26/2023 1:29 PM, Fritz Feldhase wrote:
>>> On Saturday, February 25, 2023 at 10:43:30 PM UTC+1, olcott wrote:
>>>
>>>> A [correct] halt decider [...] predicts what the behavior of its
>>>> input would be
>>>
>>> ...if run "stand allone".
>>>
>>> Now, if run stand allone D(D) either stops running or it doesn't. Got
>>> that?
>>>
>>> Now if H(D, D) determines that D(D) halts (when run stand allone),
>>> D(D) doesn't halt (when run stand allone). If H(D, D) determines that
>>> D(D) doesn't halt (when run stand allone), D(D) halts (when run stand
>>> allone). Got that?
>>>
>>> H simply doesn't determine the correct halt behaviour of D(D).
>>>
>>>> H [...] predicts that D(D) would never stop running [when run stand
>>>> allone]
>>>
>>> Well, in this case D(D) terminates (stops running) [when run stand
>>> allone]. Hence H's "prediction" is wrong.
>>
>> ONLY LIARS WILL DISAGREE The fact that D(D) never stops running unless
>> H(D,D) aborts its simulation of D conclusively proves that H is
>> necessarily correct to reject D as non-halting.
>>
>>
>>
> Why do you say that?
>
> The reasoning has been explained to you.
>
> You have ignored it, or at least not pointed out an error in the
> rebuttal.
>
> That makes YOU the LIAR.
>
> And only liars will disagree.
>
> If you want to redeam your reputation, you need to do more than just
> keep on repeating disproven ideas and false statements.
>
> You are going to DIE soon (unless you have been lying, but in one sense,
> all of us will die soon) and right now, your only legacy is as that of a
> lying crank. If you are satisfied with that, continue on and cement that
> future.

Reply again but this time randomly swap the words around a bit. Oh, you
have been doing that already, for over a year. Take your fucking meds,
mate.

/Flibble

On 2/26/23 3:13 PM, olcott wrote:
> On 2/26/2023 1:51 PM, olcott wrote:
>> On 2/26/2023 1:29 PM, Fritz Feldhase wrote:
>>> On Saturday, February 25, 2023 at 10:43:30 PM UTC+1, olcott wrote:
>>>
>>>> A [correct] halt decider [...] predicts what the behavior of its
>>>> input would be
>>>
>>> ...if run "stand allone".
>>>
>>> Now, if run stand allone D(D) either stops running or it doesn't. Got
>>> that?
>>>
>>> Now if H(D, D) determines that D(D) halts (when run stand allone),
>>> D(D) doesn't halt (when run stand allone). If H(D, D) determines that
>>> D(D) doesn't halt (when run stand allone), D(D) halts (when run stand
>>> allone). Got that?
>>>
>>> H simply doesn't determine the correct halt behaviour of D(D).
>>>
>>>> H [...] predicts that D(D) would never stop running [when run stand
>>>> allone]
>>>
>>> Well, in this case D(D) terminates (stops running) [when run stand
>>> allone]. Hence H's "prediction" is wrong.
>>
>> ONLY LIARS WILL DISAGREE
>> The fact that D(D) never stops running unless H(D,D) aborts its
>> simulation of D conclusively proves that H is necessarily correct to
>> reject D as non-halting.
>
> LIARS know full well the the above is infallibly correct as proven by
> their completely vacuous attempts at rebuttal.
>

So, no attempt to actually show it. I guess that is the needed proof
that it is just a fabrication.

> They have known this for the whole two years since I first providing the
> above reasoning.
>

Yes, we have known that everything you have said is just a fabrication
of your crocked mind.

> Now that I know that completely vacuous attempts at rebuttal by lying
> reviewers are affirmations that my point has been made things are
> proceeding much more quickly.
>

So, you plan to accelerate your insanity?

Maybe you should just submit the paper once and for all and get the
rejection that terminates the debate.

Or did you start to do that, and that is why you are trying to put down
the editor of the CACM?

If everyone (or nearly everyone) thinks your ideas are garbage, maybe it
is becaue it is.

Even the geniuses that were ahead of their time were able to get some
smart people to at least look at and try to understand their ideas.

You haven't. Take a hint.

On 2/26/2023 2:13 PM, olcott wrote:
> On 2/26/2023 1:51 PM, olcott wrote:
>> On 2/26/2023 1:29 PM, Fritz Feldhase wrote:
>>> On Saturday, February 25, 2023 at 10:43:30 PM UTC+1, olcott wrote:
>>>
>>>> A [correct] halt decider [...] predicts what the behavior of its
>>>> input would be
>>>
>>> ...if run "stand allone".
>>>
>>> Now, if run stand allone D(D) either stops running or it doesn't. Got
>>> that?
>>>
>>> Now if H(D, D) determines that D(D) halts (when run stand allone),
>>> D(D) doesn't halt (when run stand allone). If H(D, D) determines that
>>> D(D) doesn't halt (when run stand allone), D(D) halts (when run stand
>>> allone). Got that?
>>>
>>> H simply doesn't determine the correct halt behaviour of D(D).
>>>
>>>> H [...] predicts that D(D) would never stop running [when run stand
>>>> allone]
>>>
>>> Well, in this case D(D) terminates (stops running) [when run stand
>>> allone]. Hence H's "prediction" is wrong.
>>
>> ONLY LIARS WILL DISAGREE
>> The fact that D(D) never stops running unless H(D,D) aborts its
>> simulation of D conclusively proves that H is necessarily correct to
>> reject D as non-halting.
>
> LIARS know full well the the above is infallibly correct as proven by
> their completely vacuous attempts at rebuttal.
>
> They have known this for the whole two years since I first providing the
> above reasoning.
>
> Now that I know that completely vacuous attempts at rebuttal by lying
> reviewers are affirmations that my point has been made things are
> proceeding much more quickly.
>

A deductive argument is said to be valid if and only if it takes a form
that makes it impossible for the premises to be true and the conclusion
nevertheless to be false. Otherwise, a deductive argument is said to be
invalid. https://iep.utm.edu/val-snd/

The problem might be that when one starts with a falsehood and derives a
falsehood this is considered a valid deductive argument according to the
above standard definition.

The [correct reasoning] definition of valid deductive inference is
conclusion C of language L is derived by applying truth preserving
operations to premises P of language L. *Copyright 2023 Olcott*

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

On Sun, 26 Feb 2023 15:27:41 -0500, Richard Damon wrote:

> On 2/26/23 3:13 PM, olcott wrote:
>> On 2/26/2023 1:51 PM, olcott wrote:
>>> On 2/26/2023 1:29 PM, Fritz Feldhase wrote:
>>>> On Saturday, February 25, 2023 at 10:43:30 PM UTC+1, olcott wrote:
>>>>
>>>>> A [correct] halt decider [...] predicts what the behavior of its
>>>>> input would be
>>>>
>>>> ...if run "stand allone".
>>>>
>>>> Now, if run stand allone D(D) either stops running or it doesn't. Got
>>>> that?
>>>>
>>>> Now if H(D, D) determines that D(D) halts (when run stand allone),
>>>> D(D) doesn't halt (when run stand allone). If H(D, D) determines that
>>>> D(D) doesn't halt (when run stand allone), D(D) halts (when run stand
>>>> allone). Got that?
>>>>
>>>> H simply doesn't determine the correct halt behaviour of D(D).
>>>>
>>>>> H [...] predicts that D(D) would never stop running [when run stand
>>>>> allone]
>>>>
>>>> Well, in this case D(D) terminates (stops running) [when run stand
>>>> allone]. Hence H's "prediction" is wrong.
>>>
>>> ONLY LIARS WILL DISAGREE The fact that D(D) never stops running unless
>>> H(D,D) aborts its simulation of D conclusively proves that H is
>>> necessarily correct to reject D as non-halting.
>>
>> LIARS know full well the the above is infallibly correct as proven by
>> their completely vacuous attempts at rebuttal.
>>
>>
> So, no attempt to actually show it. I guess that is the needed proof
> that it is just a fabrication.
>
>> They have known this for the whole two years since I first providing
>> the above reasoning.
>>
>>
> Yes, we have known that everything you have said is just a fabrication
> of your crocked mind.
>
>> Now that I know that completely vacuous attempts at rebuttal by lying
>> reviewers are affirmations that my point has been made things are
>> proceeding much more quickly.
>>
>>
> So, you plan to accelerate your insanity?
>
> Maybe you should just submit the paper once and for all and get the
> rejection that terminates the debate.
>
> Or did you start to do that, and that is why you are trying to put down
> the editor of the CACM?
>
> If everyone (or nearly everyone) thinks your ideas are garbage, maybe it
> is becaue it is.
>
> Even the geniuses that were ahead of their time were able to get some
> smart people to at least look at and try to understand their ideas.
>
> You haven't. Take a hint.

Reply again but this time randomly swap the words around a bit. Oh, you
have been doing that already, for over a year. Take your fucking meds,
mate.

/Flibble

On 2/26/23 3:28 PM, olcott wrote:

>
> A deductive argument is said to be valid if and only if it takes a form
> that makes it impossible for the premises to be true and the conclusion
> nevertheless to be false. Otherwise, a deductive argument is said to be
> invalid. https://iep.utm.edu/val-snd/
>
> The problem might be that when one starts with a falsehood and derives a
> falsehood this is considered a valid deductive argument according to the
> above standard definition.
>
> The [correct reasoning] definition of valid deductive inference is
> conclusion C of language L is derived by applying truth preserving
> operations to premises P of language L.   *Copyright 2023 Olcott*
>
>

So, start with your correct reasoning definition and go back to
primitive logic and see what you can do.

It is just incorrect logic to try to change the basic rules and ignore
what they do to the system.

My guess is you don't have enough formal knowledge of how to build a
logic system to be able to do much with that advice, but looking forward
to you trying to prove me wrong on that.

On the other hand, your statement might actually not be any different
than what is currently established.

Remember, to use that A -> B you first need to PROVE A -> B, and what is
a proof other than your statement of using Truth Preserving Operations.

You also seem to have something against the operator of inplications,
that is that A -> B. That operator is actual nothing other than a short
cut for the assetion that ((!A) | B) is true, so unless you also think
that the OR operator has a problem you shouldn't have a problem with the
implication operator. And if you have a problem with or, you should have
a problem with and as (A | B) is equivalent to !(!A & !B)

So, unless your logic system is SO stripped down that you can't do any
logic (or maybe just can't use the not operator) implication should not
be an issue.

Now, part of your problem seems to be that you seem to be willing to
inject as a usable inference things that are NOT actually established by
a "Proof", or in your words, by applying truth perserving operations to
the premises of the field.

After all, when was the last time you actually did that. Start from JUST
the well established principles of the field (and not just thing that
must be true by the meaning of the words, when the meaning of the words
isn't an actual established definition of the field).

You ALWAYS seem to fall back to something "MUST" be true as it is
obvious, and ignore when people point out that it isn't true.

That just shows you don't actually follow even your own rules for logic.

On 2/26/2023 2:28 PM, olcott wrote:
> On 2/26/2023 2:13 PM, olcott wrote:
>> On 2/26/2023 1:51 PM, olcott wrote:
>>> On 2/26/2023 1:29 PM, Fritz Feldhase wrote:
>>>> On Saturday, February 25, 2023 at 10:43:30 PM UTC+1, olcott wrote:
>>>>
>>>>> A [correct] halt decider [...] predicts what the behavior of its
>>>>> input would be
>>>>
>>>> ...if run "stand allone".
>>>>
>>>> Now, if run stand allone D(D) either stops running or it doesn't.
>>>> Got that?
>>>>
>>>> Now if H(D, D) determines that D(D) halts (when run stand allone),
>>>> D(D) doesn't halt (when run stand allone). If H(D, D) determines
>>>> that D(D) doesn't halt (when run stand allone), D(D) halts (when run
>>>> stand allone). Got that?
>>>>
>>>> H simply doesn't determine the correct halt behaviour of D(D).
>>>>
>>>>> H [...] predicts that D(D) would never stop running [when run stand
>>>>> allone]
>>>>
>>>> Well, in this case D(D) terminates (stops running) [when run stand
>>>> allone]. Hence H's "prediction" is wrong.
>>>
>>> ONLY LIARS WILL DISAGREE
>>> The fact that D(D) never stops running unless H(D,D) aborts its
>>> simulation of D conclusively proves that H is necessarily correct to
>>> reject D as non-halting.
>>
>> LIARS know full well the the above is infallibly correct as proven by
>> their completely vacuous attempts at rebuttal.
>>
>> They have known this for the whole two years since I first providing the
>> above reasoning.
>>
>> Now that I know that completely vacuous attempts at rebuttal by lying
>> reviewers are affirmations that my point has been made things are
>> proceeding much more quickly.
>>
>
> A deductive argument is said to be valid if and only if it takes a form
> that makes it impossible for the premises to be true and the conclusion
> nevertheless to be false. Otherwise, a deductive argument is said to be
> invalid. https://iep.utm.edu/val-snd/
>
> The problem might be that when one starts with a falsehood and derives a
> falsehood this is considered a valid deductive argument according to the
> above standard definition.
>
> The [correct reasoning] definition of valid deductive inference is
> conclusion C of language L is derived by applying truth preserving
> operations to premises P of language L.   *Copyright 2023 Olcott*

The Prolog programming language already provides this system of [correct
reasoning] with its Facts (expressions of language stipulated to be
true) and Rules (truth preserving operations).

?- G = not(provable(F, G)). % G = ¬(F ⊢ G)

When we test the above pair of expressions we find that neither of them
are are provable in the Prolog formal system: (SWI-Prolog (threaded, 64
bits, version 7.6.4)

?- unify_with_occurs_check(G, not(provable(F, G))).
false.

G is unprovable because it has a cycle in its evaluation graph that
Prolog correctly detects.

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

On Sun, 26 Feb 2023 16:28:09 -0500, Richard Damon wrote:

> On 2/26/23 3:28 PM, olcott wrote:
>
>
>> A deductive argument is said to be valid if and only if it takes a form
>> that makes it impossible for the premises to be true and the conclusion
>> nevertheless to be false. Otherwise, a deductive argument is said to be
>> invalid. https://iep.utm.edu/val-snd/
>>
>> The problem might be that when one starts with a falsehood and derives
>> a falsehood this is considered a valid deductive argument according to
>> the above standard definition.
>>
>> The [correct reasoning] definition of valid deductive inference is
>> conclusion C of language L is derived by applying truth preserving
>> operations to premises P of language L.   *Copyright 2023 Olcott*
>>
>>
>>
> So, start with your correct reasoning definition and go back to
> primitive logic and see what you can do.
>
> It is just incorrect logic to try to change the basic rules and ignore
> what they do to the system.
>
> My guess is you don't have enough formal knowledge of how to build a
> logic system to be able to do much with that advice, but looking forward
> to you trying to prove me wrong on that.
>
>
> On the other hand, your statement might actually not be any different
> than what is currently established.
>
> Remember, to use that A -> B you first need to PROVE A -> B, and what is
> a proof other than your statement of using Truth Preserving Operations.
>
> You also seem to have something against the operator of inplications,
> that is that A -> B. That operator is actual nothing other than a short
> cut for the assetion that ((!A) | B) is true, so unless you also think
> that the OR operator has a problem you shouldn't have a problem with the
> implication operator. And if you have a problem with or, you should have
> a problem with and as (A | B) is equivalent to !(!A & !B)
>
> So, unless your logic system is SO stripped down that you can't do any
> logic (or maybe just can't use the not operator) implication should not
> be an issue.
>
> Now, part of your problem seems to be that you seem to be willing to
> inject as a usable inference things that are NOT actually established by
> a "Proof", or in your words, by applying truth perserving operations to
> the premises of the field.
>
> After all, when was the last time you actually did that. Start from JUST
> the well established principles of the field (and not just thing that
> must be true by the meaning of the words, when the meaning of the words
> isn't an actual established definition of the field).
>
> You ALWAYS seem to fall back to something "MUST" be true as it is
> obvious, and ignore when people point out that it isn't true.
>
> That just shows you don't actually follow even your own rules for logic.

Reply again but this time randomly swap the words around a bit. Oh, you
have been doing that already, for over a year. Take your fucking meds,
mate.

/Flibble

On 2/26/2023 2:28 PM, olcott wrote:
> On 2/26/2023 2:13 PM, olcott wrote:
>> On 2/26/2023 1:51 PM, olcott wrote:
>>> On 2/26/2023 1:29 PM, Fritz Feldhase wrote:
>>>> On Saturday, February 25, 2023 at 10:43:30 PM UTC+1, olcott wrote:
>>>>
>>>>> A [correct] halt decider [...] predicts what the behavior of its
>>>>> input would be
>>>>
>>>> ...if run "stand allone".
>>>>
>>>> Now, if run stand allone D(D) either stops running or it doesn't.
>>>> Got that?
>>>>
>>>> Now if H(D, D) determines that D(D) halts (when run stand allone),
>>>> D(D) doesn't halt (when run stand allone). If H(D, D) determines
>>>> that D(D) doesn't halt (when run stand allone), D(D) halts (when run
>>>> stand allone). Got that?
>>>>
>>>> H simply doesn't determine the correct halt behaviour of D(D).
>>>>
>>>>> H [...] predicts that D(D) would never stop running [when run stand
>>>>> allone]
>>>>
>>>> Well, in this case D(D) terminates (stops running) [when run stand
>>>> allone]. Hence H's "prediction" is wrong.
>>>
>>> ONLY LIARS WILL DISAGREE
>>> The fact that D(D) never stops running unless H(D,D) aborts its
>>> simulation of D conclusively proves that H is necessarily correct to
>>> reject D as non-halting.
>>
>> LIARS know full well the the above is infallibly correct as proven by
>> their completely vacuous attempts at rebuttal.
>>
>> They have known this for the whole two years since I first providing the
>> above reasoning.
>>
>> Now that I know that completely vacuous attempts at rebuttal by lying
>> reviewers are affirmations that my point has been made things are
>> proceeding much more quickly.
>>
>
> A deductive argument is said to be valid if and only if it takes a form
> that makes it impossible for the premises to be true and the conclusion
> nevertheless to be false. Otherwise, a deductive argument is said to be
> invalid. https://iep.utm.edu/val-snd/
>
> The problem might be that when one starts with a falsehood and derives a
> falsehood this is considered a valid deductive argument according to the
> above standard definition.
>
> The [correct reasoning] definition of valid deductive inference is
> conclusion C of language L is derived by applying truth preserving
> operations to premises P of language L.   *Copyright 2023 Olcott*

The Prolog programming language already provides this system of [correct
reasoning] with its Facts (expressions of language stipulated to be
true) and Rules (truth preserving operations).

?- G = not(provable(F, G)). % G = ¬(F ⊢ G)

When we test the above expression we finds that it is not provable in
the Prolog formal system: (SWI-Prolog (threaded, 64 bits, version 7.6.4)
*Because the expression has an infinite cycle in its evaluation graph*

?- unify_with_occurs_check(G, not(provable(F, G))).
false.

G is unprovable because it has an infinite cycle in its evaluation graph
that Prolog correctly detects.

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

On 2/26/23 5:16 PM, olcott wrote:
> On 2/26/2023 2:28 PM, olcott wrote:
>> On 2/26/2023 2:13 PM, olcott wrote:
>>> On 2/26/2023 1:51 PM, olcott wrote:
>>>> On 2/26/2023 1:29 PM, Fritz Feldhase wrote:
>>>>> On Saturday, February 25, 2023 at 10:43:30 PM UTC+1, olcott wrote:
>>>>>
>>>>>> A [correct] halt decider [...] predicts what the behavior of its
>>>>>> input would be
>>>>>
>>>>> ...if run "stand allone".
>>>>>
>>>>> Now, if run stand allone D(D) either stops running or it doesn't.
>>>>> Got that?
>>>>>
>>>>> Now if H(D, D) determines that D(D) halts (when run stand allone),
>>>>> D(D) doesn't halt (when run stand allone). If H(D, D) determines
>>>>> that D(D) doesn't halt (when run stand allone), D(D) halts (when
>>>>> run stand allone). Got that?
>>>>>
>>>>> H simply doesn't determine the correct halt behaviour of D(D).
>>>>>
>>>>>> H [...] predicts that D(D) would never stop running [when run
>>>>>> stand allone]
>>>>>
>>>>> Well, in this case D(D) terminates (stops running) [when run stand
>>>>> allone]. Hence H's "prediction" is wrong.
>>>>
>>>> ONLY LIARS WILL DISAGREE
>>>> The fact that D(D) never stops running unless H(D,D) aborts its
>>>> simulation of D conclusively proves that H is necessarily correct to
>>>> reject D as non-halting.
>>>
>>> LIARS know full well the the above is infallibly correct as proven by
>>> their completely vacuous attempts at rebuttal.
>>>
>>> They have known this for the whole two years since I first providing the
>>> above reasoning.
>>>
>>> Now that I know that completely vacuous attempts at rebuttal by lying
>>> reviewers are affirmations that my point has been made things are
>>> proceeding much more quickly.
>>>
>>
>> A deductive argument is said to be valid if and only if it takes a form
>> that makes it impossible for the premises to be true and the conclusion
>> nevertheless to be false. Otherwise, a deductive argument is said to be
>> invalid. https://iep.utm.edu/val-snd/
>>
>> The problem might be that when one starts with a falsehood and derives a
>> falsehood this is considered a valid deductive argument according to the
>> above standard definition.
>>
>> The [correct reasoning] definition of valid deductive inference is
>> conclusion C of language L is derived by applying truth preserving
>> operations to premises P of language L.   *Copyright 2023 Olcott*
>
> The Prolog programming language already provides this system of [correct
> reasoning] with its Facts (expressions of language stipulated to be
> true) and Rules (truth preserving operations).

Nope, because if you use Prolog you can not go past first order logic,
so you can't deal with the sort of logic needed in computability theory.

You keep on doing this, and it just prove how much of a novice you are
at this.

Have you figured out how to get Prolog to prove the Pythagorean Theorem?

>
> ?- G = not(provable(F, G)).         % G = ¬(F ⊢ G)

Which isn't G, and the Prolog Logic system doesn't meet the minimums
that Godel requires, so you are just proving yourself to be a lying idiot.

Stike One, Strike Two

>
> When we test the above expression we finds that it is not provable in
> the Prolog formal system: (SWI-Prolog (threaded, 64 bits, version 7.6.4)
> *Because the expression has an infinite cycle in its evaluation graph*
>

Of course Prolog can't deal with it, it is beyond what Prolog can handle.

> ?- unify_with_occurs_check(G, not(provable(F, G))).
> false.

Strike Three

>
> G is unprovable because it has an infinite cycle in its evaluation graph
> that Prolog correctly detects.
>

Nope, you are just proving that you are a total idiot about what you are
talking about,

Your use of Prolog is like bringing a knife to a Gun fight.