Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)

void E(int (*x)())
{ HH(x, x);
return;
}

int main()
{ HH(E,E);
}

Two people with masters degrees in computer science have agreed that E
correctly simulated by HH cannot possibly reach its own "return"
instruction in any finite number of steps of correct simulation.

HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally in any finite number of
steps. *Fully operational software linked below proves this*

*Simulating Halt Decider Applied to the Halting Theorem*
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

*Complete halt deciding system* (Visual Studio Project)
(a) x86utm operating system
(b) x86 emulator adapted from libx86emu to compile under Windows
(c) Several halt deciders and their sample inputs contained within Halt7.c

https://liarparadox.org/2023_02_07.zip

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

Your repeaing this claim withput answering the objectsions only proves
you have no basis for your claims.

You are admitting you have lost.

On 2/11/23 10:21 PM, olcott wrote:
> Every E correctly simulated by any HH cannot possibly halt
> (AKA reach its own return instruction and terminate normally)

But every E that is decided by the HH it is built on will Halt.

Thus, no HH that decides on the D built on itself actually correctly
simulates its input, but aborts it without proof of being non-halting.
>
> void E(int (*x)())
> {
>   HH(x, x);
>   return;
> }
>
> int main()
> {
>   HH(E,E);
> }
>
> Two people with masters degrees in computer science have agreed that E
> correctly simulated by HH cannot possibly reach its own "return"
> instruction in any finite number of steps of correct simulation.

Right, because *IF* HH does a correct simulation, it is impossible for
it to reach a valid conclusion

>
> HH only needs to simulate E until HH correctly detects that E has a
> repeating state such that E correctly simulated by HH cannot possibly
> reach its own final state an terminate normally in any finite number of
> steps. *Fully operational software linked below proves this*

The Fullu operational software linked below proves that it does not get
the right answer because the decider doesn't actually PROVE that its
input is non-halting, but uses a FALSE premise to make its decision.

The problem is your Decider assumes that the copy of the decider called
will fulfil the requriements, when it doesn't.

It is just another example of the fact that you don't understand how
logic works and you seem to fall into every known logical fallacy.

This is likely because you have admitted that you live in a world of
enforced ignorance because you are afraid of being contaminated by the
Truth.

>
> *Simulating Halt Decider Applied to the Halting Theorem*
> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>
> *Complete halt deciding system* (Visual Studio Project)
> (a) x86utm operating system
> (b) x86 emulator adapted from libx86emu to compile under Windows
> (c) Several halt deciders and their sample inputs contained within Halt7.c
>
> https://liarparadox.org/2023_02_07.zip
>
>

SOrry, you are just proving you are a totoal idiot.

On 2/11/2023 9:21 PM, olcott wrote:
> Every E correctly simulated by any HH cannot possibly halt
> (AKA reach its own return instruction and terminate normally)
>
> void E(int (*x)())
> {
>   HH(x, x);
>   return;
> }
>
> int main()
> {
>   HH(E,E);
> }
>
> Two people with masters degrees in computer science have agreed that E
> correctly simulated by HH cannot possibly reach its own "return"
> instruction in any finite number of steps of correct simulation.
>
> HH only needs to simulate E until HH correctly detects that E has a
> repeating state such that E correctly simulated by HH cannot possibly
> reach its own final state an terminate normally in any finite number of
> steps. *Fully operational software linked below proves this*
>
> *Simulating Halt Decider Applied to the Halting Theorem*
> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>
> *Complete halt deciding system* (Visual Studio Project)
> (a) x86utm operating system
> (b) x86 emulator adapted from libx86emu to compile under Windows
> (c) Several halt deciders and their sample inputs contained within Halt7.c
>
> https://liarparadox.org/2023_02_07.zip
>
>

Because it is an easily verified fact that
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH
cannot possibly halt
(reach its own "return" instruction and terminate normally)

It is necessarily correct for HH to abort its simulation of E and reject
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH

as non-halting as soon as it detects the repeating state in
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH

*straw man*
An intentionally misrepresented proposition that is set up because it is
easier to defeat than an opponent's real argument.
https://www.lexico.com/en/definition/straw_man

--
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/11/2023 9:21 PM, olcott wrote:
> Every E correctly simulated by any HH cannot possibly halt
> (AKA reach its own return instruction and terminate normally)
>
> void E(int (*x)())
> {
>   HH(x, x);
>   return;
> }
>
> int main()
> {
>   HH(E,E);
> }
>
> Two people with masters degrees in computer science have agreed that E
> correctly simulated by HH cannot possibly reach its own "return"
> instruction in any finite number of steps of correct simulation.
>
> HH only needs to simulate E until HH correctly detects that E has a
> repeating state such that E correctly simulated by HH cannot possibly
> reach its own final state an terminate normally in any finite number of
> steps. *Fully operational software linked below proves this*
>
> *Simulating Halt Decider Applied to the Halting Theorem*
> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>
> *Complete halt deciding system* (Visual Studio Project)
> (a) x86utm operating system
> (b) x86 emulator adapted from libx86emu to compile under Windows
> (c) Several halt deciders and their sample inputs contained within Halt7.c
>
> https://liarparadox.org/2023_02_07.zip
>
>

*Because it is an easily verified fact that*
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH
cannot possibly halt
(reach its own "return" instruction and terminate normally)

*HH is necessarily correct to abort its simulation of E and reject*
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH

*as non-halting as soon as it detects the repeating state in*
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH

*straw man*
An intentionally misrepresented proposition that is set up because it is
easier to defeat than an opponent's real argument.
https://www.lexico.com/en/definition/straw_man

--
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/12/23 11:10 AM, olcott wrote:
> On 2/11/2023 9:21 PM, olcott wrote:
>> Every E correctly simulated by any HH cannot possibly halt
>> (AKA reach its own return instruction and terminate normally)
>>
>> void E(int (*x)())
>> {
>>    HH(x, x);
>>    return;
>> }
>>
>> int main()
>> {
>>    HH(E,E);
>> }
>>
>> Two people with masters degrees in computer science have agreed that E
>> correctly simulated by HH cannot possibly reach its own "return"
>> instruction in any finite number of steps of correct simulation.
>>
>> HH only needs to simulate E until HH correctly detects that E has a
>> repeating state such that E correctly simulated by HH cannot possibly
>> reach its own final state an terminate normally in any finite number of
>> steps. *Fully operational software linked below proves this*
>>
>> *Simulating Halt Decider Applied to the Halting Theorem*
>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>
>> *Complete halt deciding system* (Visual Studio Project)
>> (a) x86utm operating system
>> (b) x86 emulator adapted from libx86emu to compile under Windows
>> (c) Several halt deciders and their sample inputs contained within
>> Halt7.c
>>
>> https://liarparadox.org/2023_02_07.zip
>>
>>
>
> Because it is an easily verified fact that
> E correctly simulated by HH
> E correctly simulated by HH
> E correctly simulated by HH
> cannot possibly halt
> (reach its own "return" instruction and terminate normally)

Just as it is easily verified that IF HH correctly simulated E, it never
aborts and returns an answer, so fails to be a decider.

>
> It is necessarily correct for HH to abort its simulation of E and reject
> E correctly simulated by HH
> E correctly simulated by HH
> E correctly simulated by HH
>

Nope, that is saying it is correct to give an answer based on false
assumptions.

HH either DOES correctly simulate E, and thus never anwwers, or HH
DOESN'T correctly simulate E and usies INVALID logic to claim its answer
is incorrecgt.

> as non-halting as soon as it detects the repeating state in
> E correctly simulated by HH
> E correctly simulated by HH
> E correctly simulated by HH

And there is no EXACTLY repeating state in E correctly simulated by HH,
as what HH sees as it simulates is:

it simulating the instructionss of E to the call to HH

then it simulating the code of HH simulating the instuctions of E utill
that reaches a call to HH

then it simulationg the code of HH simulating the code of HH simmulating
the instructions of E untill....

You never reach the EXACT same state.

>
> *straw man*
> An intentionally misrepresented proposition that is set up because it is
> easier to defeat than an opponent's real argument.
> https://www.lexico.com/en/definition/straw_man
>

Right, just what you are providing.

Remember, the ACTUAL question given to a Halting Decider is what is the
behavior of the machine its input describes, when that machine would be
actually run.

By the definiton of a UTM, that can be replaced by asking the Halting
Decider what is the behavior of the simulation done by a UTM simulating
the input to this halt decider.

Changing that simulation from a UTH to the Decider is just preforming a
Straw Man.

Your continued use of this just shows you are either totally ignorant of
the actual rules of logic or that you are just a pathological liar.

You will likely not actually respond to this, but just repeat your
claim, PROVING you don't actually HAVE a valid response to it.

Your REPUTATION is MUD, and for as long as you are remembered it will be
as the idiot that you have proven yourself to be.

On 2/12/2023 10:16 AM, olcott wrote:
> On 2/11/2023 9:21 PM, olcott wrote:
>> Every E correctly simulated by any HH cannot possibly halt
>> (AKA reach its own return instruction and terminate normally)
>>
>> void E(int (*x)())
>> {
>>    HH(x, x);
>>    return;
>> }
>>
>> int main()
>> {
>>    HH(E,E);
>> }
>>
>> Two people with masters degrees in computer science have agreed that E
>> correctly simulated by HH cannot possibly reach its own "return"
>> instruction in any finite number of steps of correct simulation.
>>
>> HH only needs to simulate E until HH correctly detects that E has a
>> repeating state such that E correctly simulated by HH cannot possibly
>> reach its own final state an terminate normally in any finite number of
>> steps. *Fully operational software linked below proves this*
>>
>> *Simulating Halt Decider Applied to the Halting Theorem*
>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>
>> *Complete halt deciding system* (Visual Studio Project)
>> (a) x86utm operating system
>> (b) x86 emulator adapted from libx86emu to compile under Windows
>> (c) Several halt deciders and their sample inputs contained within
>> Halt7.c
>>
>> https://liarparadox.org/2023_02_07.zip
>>
>>
>
> *Because it is an easily verified fact that*
> E correctly simulated by HH
> E correctly simulated by HH
> E correctly simulated by HH
> cannot possibly halt
> (reach its own "return" instruction and terminate normally)
>
> *HH is necessarily correct to abort its simulation of E and reject*
> E correctly simulated by HH
> E correctly simulated by HH
> E correctly simulated by HH
>
> *as non-halting as soon as it detects the repeating state in*
> E correctly simulated by HH
> E correctly simulated by HH
> E correctly simulated by HH
>
> *straw man*
> An intentionally misrepresented proposition that is set up because it is
> easier to defeat than an opponent's real argument.
> https://www.lexico.com/en/definition/straw_man

Finally I have closure, my point is so clear that anyone denying it has
only ridiculously foolish antics that can be spotted as obvious
deception by anyone with very slight software engineering competence.

--
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/12/23 4:34 PM, olcott wrote:
> On 2/12/2023 10:16 AM, olcott wrote:
>> On 2/11/2023 9:21 PM, olcott wrote:
>>> Every E correctly simulated by any HH cannot possibly halt
>>> (AKA reach its own return instruction and terminate normally)
>>>
>>> void E(int (*x)())
>>> {
>>>    HH(x, x);
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    HH(E,E);
>>> }
>>>
>>> Two people with masters degrees in computer science have agreed that E
>>> correctly simulated by HH cannot possibly reach its own "return"
>>> instruction in any finite number of steps of correct simulation.
>>>
>>> HH only needs to simulate E until HH correctly detects that E has a
>>> repeating state such that E correctly simulated by HH cannot possibly
>>> reach its own final state an terminate normally in any finite number of
>>> steps. *Fully operational software linked below proves this*
>>>
>>> *Simulating Halt Decider Applied to the Halting Theorem*
>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>>
>>> *Complete halt deciding system* (Visual Studio Project)
>>> (a) x86utm operating system
>>> (b) x86 emulator adapted from libx86emu to compile under Windows
>>> (c) Several halt deciders and their sample inputs contained within
>>> Halt7.c
>>>
>>> https://liarparadox.org/2023_02_07.zip
>>>
>>>
>>
>> *Because it is an easily verified fact that*
>> E correctly simulated by HH
>> E correctly simulated by HH
>> E correctly simulated by HH
>> cannot possibly halt
>> (reach its own "return" instruction and terminate normally)
>>
>> *HH is necessarily correct to abort its simulation of E and reject*
>> E correctly simulated by HH
>> E correctly simulated by HH
>> E correctly simulated by HH
>>
>> *as non-halting as soon as it detects the repeating state in*
>> E correctly simulated by HH
>> E correctly simulated by HH
>> E correctly simulated by HH
>>
>> *straw man*
>> An intentionally misrepresented proposition that is set up because it is
>> easier to defeat than an opponent's real argument.
>> https://www.lexico.com/en/definition/straw_man
>
> Finally I have closure, my point is so clear that anyone denying it has
> only ridiculously foolish antics that can be spotted as obvious
> deception by anyone with very slight software engineering competence.
>

Nope.

I replied to you ranting, you have ignored my statements because you
have NO answer to it, so you are admitting you are a failure and are
using flawed logic.

YOU ARE ADMITTING FAILURE BY NOT RESPONDING TO THE REBUTAL.

You are just proving that you are a ignorant pathological lying idiot.

Your arguement is base on simple lies that are based on assuming the
impossible happens.

On 2/12/2023 10:16 AM, olcott wrote:
> On 2/11/2023 9:21 PM, olcott wrote:
>> Every E correctly simulated by any HH cannot possibly halt
>> (AKA reach its own return instruction and terminate normally)
>>
>> void E(int (*x)())
>> {
>>    HH(x, x);
>>    return;
>> }
>>
>> int main()
>> {
>>    HH(E,E);
>> }
>>
>> Two people with masters degrees in computer science have agreed that E
>> correctly simulated by HH cannot possibly reach its own "return"
>> instruction in any finite number of steps of correct simulation.
>>
>> HH only needs to simulate E until HH correctly detects that E has a
>> repeating state such that E correctly simulated by HH cannot possibly
>> reach its own final state an terminate normally in any finite number of
>> steps. *Fully operational software linked below proves this*
>>
>> *Simulating Halt Decider Applied to the Halting Theorem*
>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>
>> *Complete halt deciding system* (Visual Studio Project)
>> (a) x86utm operating system
>> (b) x86 emulator adapted from libx86emu to compile under Windows
>> (c) Several halt deciders and their sample inputs contained within
>> Halt7.c
>>
>> https://liarparadox.org/2023_02_07.zip
>>
>>
>
> *Because it is an easily verified fact that*
> E correctly simulated by HH
> E correctly simulated by HH
> E correctly simulated by HH
> cannot possibly halt
> (reach its own "return" instruction and terminate normally)
>
> *HH is necessarily correct to abort its simulation of E and reject*
> E correctly simulated by HH
> E correctly simulated by HH
> E correctly simulated by HH
>
> *as non-halting as soon as it detects the repeating state in*
> E correctly simulated by HH
> E correctly simulated by HH
> E correctly simulated by HH
>

The repeating state that we and HH can both see is that
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH
would continue to call HH(E,E) in recursive simulation
making it impossible for
E correctly simulated by H
E correctly simulated by H
E correctly simulated by H
to reach its own "return" instruction and terminate normally (AKA halt).

> *straw man*
> An intentionally misrepresented proposition that is set up because it is
> easier to defeat than an opponent's real argument.
> https://www.lexico.com/en/definition/straw_man

--
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/13/23 11:17 AM, olcott wrote:
> On 2/12/2023 10:16 AM, olcott wrote:
>> On 2/11/2023 9:21 PM, olcott wrote:
>>> Every E correctly simulated by any HH cannot possibly halt
>>> (AKA reach its own return instruction and terminate normally)
>>>
>>> void E(int (*x)())
>>> {
>>>    HH(x, x);
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    HH(E,E);
>>> }
>>>
>>> Two people with masters degrees in computer science have agreed that E
>>> correctly simulated by HH cannot possibly reach its own "return"
>>> instruction in any finite number of steps of correct simulation.
>>>
>>> HH only needs to simulate E until HH correctly detects that E has a
>>> repeating state such that E correctly simulated by HH cannot possibly
>>> reach its own final state an terminate normally in any finite number of
>>> steps. *Fully operational software linked below proves this*
>>>
>>> *Simulating Halt Decider Applied to the Halting Theorem*
>>> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>>>
>>> *Complete halt deciding system* (Visual Studio Project)
>>> (a) x86utm operating system
>>> (b) x86 emulator adapted from libx86emu to compile under Windows
>>> (c) Several halt deciders and their sample inputs contained within
>>> Halt7.c
>>>
>>> https://liarparadox.org/2023_02_07.zip
>>>
>>>
>>
>> *Because it is an easily verified fact that*
>> E correctly simulated by HH
>> E correctly simulated by HH
>> E correctly simulated by HH
>> cannot possibly halt
>> (reach its own "return" instruction and terminate normally)
>>
>> *HH is necessarily correct to abort its simulation of E and reject*
>> E correctly simulated by HH
>> E correctly simulated by HH
>> E correctly simulated by HH
>>
>> *as non-halting as soon as it detects the repeating state in*
>> E correctly simulated by HH
>> E correctly simulated by HH
>> E correctly simulated by HH
>>
>
> The repeating state that we and HH can both see is that
> E correctly simulated by HH
> E correctly simulated by HH
> E correctly simulated by HH
> would continue to call HH(E,E) in recursive simulation
> making it impossible for
> E correctly simulated by H
> E correctly simulated by H
> E correctly simulated by H
> to reach its own "return" instruction and terminate normally (AKA halt).
>
>> *straw man*
>> An intentionally misrepresented proposition that is set up because it is
>> easier to defeat than an opponent's real argument.
>> https://www.lexico.com/en/definition/straw_man
>
>
>

Nope.

I replied to you ranting, you have ignored my statements because you
have NO answer to it, so you are admitting you are a failure and are
using flawed logic.

YOU ARE ADMITTING FAILURE BY NOT RESPONDING TO THE REBUTAL.

You are just proving that you are a ignorant pathological lying idiot.

Your arguement is base on simple lies that are based on assuming the
impossible happens.