Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

God requireth not a uniformity of religion. -- Roger Williams


computers / comp.ai.philosophy / Re: Simulating halt deciders defeat the halting theorem [ irrefutable reasoning ]

SubjectAuthor
* Simulating halt deciders defeat the halting theorem [ irrefutableolcott
+- Re: Simulating halt deciders defeat the halting theorem [ irrefutableRichard Damon
`* Re: Simulating halt deciders defeat the halting theorem [ irrefutableolcott
 +- Re: Simulating halt deciders defeat the halting theorem [ irrefutableRichard Damon
 `* Re: Simulating halt deciders defeat the halting theorem [ irrefutableolcott
  +- Re: Simulating halt deciders defeat the halting theorem [ irrefutableRichard Damon
  `* Re: Simulating halt deciders defeat the halting theorem [ irrefutableolcott
   `- Re: Simulating halt deciders defeat the halting theorem [ irrefutableRichard Damon

1
Simulating halt deciders defeat the halting theorem [ irrefutable reasoning ]

<tsm3ec$3bgsb$1@dont-email.me>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=10652&group=comp.ai.philosophy#10652

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy comp.software-eng
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,comp.software-eng
Subject: Simulating halt deciders defeat the halting theorem [ irrefutable
reasoning ]
Date: Thu, 16 Feb 2023 14:24:44 -0600
Organization: A noiseless patient Spider
Lines: 38
Message-ID: <tsm3ec$3bgsb$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Thu, 16 Feb 2023 20:24:44 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="d493afe0966e52bafb1ec8c3ebb221b7";
logging-data="3523467"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18JimLOPpe/a2x1S0PD8zZi"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.7.2
Cancel-Lock: sha1:INNoKBNJJU5XWDj1qJ0O/iNq9ZU=
Content-Language: en-US
 by: olcott - Thu, 16 Feb 2023 20:24 UTC

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

int main()
{ Output("Input_Halts = ", H(D,D));
Output("Input_Halts = ", D(D));
}

*Here is my current irrefutable reasoning*
H(D,D) does correctly compute the mapping from its input to its reject
state on the basis that H correctly predicts that D correctly simulated
by H would never halt (reach its own "return" statement and terminate
normally).

Everyone attempting to refute the above verified fact either
uses the strawman deception to change the subject away from
[D correctly simulated by H]
or flat out lies about the behavior of
[D correctly simulated by H]

*Complete halt deciding system* (Visual Studio Project)
https://liarparadox.org/2023_02_07.zip

*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

Re: Simulating halt deciders defeat the halting theorem [ irrefutable reasoning ]

<tkzHL.92535$wfQc.18484@fx43.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=10656&group=comp.ai.philosophy#10656

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy comp.software-eng
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx43.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:102.0)
Gecko/20100101 Thunderbird/102.7.2
Subject: Re: Simulating halt deciders defeat the halting theorem [ irrefutable
reasoning ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,comp.software-eng
References: <tsm3ec$3bgsb$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tsm3ec$3bgsb$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 44
Message-ID: <tkzHL.92535$wfQc.18484@fx43.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 16 Feb 2023 18:51:53 -0500
X-Received-Bytes: 2378
 by: Richard Damon - Thu, 16 Feb 2023 23:51 UTC

On 2/16/23 3:24 PM, olcott wrote:
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(D,D));
>   Output("Input_Halts = ", D(D));
> }
>
> *Here is my current irrefutable reasoning*
> H(D,D) does correctly compute the mapping from its input to its reject
> state on the basis that H correctly predicts that D correctly simulated
> by H would never halt (reach its own "return" statement and terminate
> normally).
>
> Everyone attempting to refute the above verified fact either
> uses the strawman deception to change the subject away from
> [D correctly simulated by H]
> or flat out lies about the behavior of
> [D correctly simulated by H]
>
>
>
> *Complete halt deciding system* (Visual Studio Project)
> https://liarparadox.org/2023_02_07.zip
>
> *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.

D(D) Halts

H(D,D) says Non-Halting, thus it is NOT a "Correct Halting Decider of
Computabilyt Theory", and any claim it is can be clearly seen to be a LIE.

Re: Simulating halt deciders defeat the halting theorem [ irrefutable reasoning ]

<tsmn8r$3duk6$2@dont-email.me>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=10657&group=comp.ai.philosophy#10657

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy comp.software-eng
Path: i2pn2.org!rocksolid2!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,comp.software-eng
Subject: Re: Simulating halt deciders defeat the halting theorem [ irrefutable
reasoning ]
Date: Thu, 16 Feb 2023 20:03:07 -0600
Organization: A noiseless patient Spider
Lines: 54
Message-ID: <tsmn8r$3duk6$2@dont-email.me>
References: <tsm3ec$3bgsb$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 17 Feb 2023 02:03:08 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="7f757de7aceb318c89c335403b7f02b0";
logging-data="3603078"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18napjKLpaFpZlV7YMcsKDE"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.7.2
Cancel-Lock: sha1:LxRE8Df74Xp91GIOdIEBZ4HGrbE=
In-Reply-To: <tsm3ec$3bgsb$1@dont-email.me>
Content-Language: en-US
 by: olcott - Fri, 17 Feb 2023 02:03 UTC

On 2/16/2023 2:24 PM, olcott wrote:
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(D,D));
>   Output("Input_Halts = ", D(D));
> }
>
> *Here is my current irrefutable reasoning*
> H(D,D) does correctly compute the mapping from its input to its reject
> state on the basis that H correctly predicts that D correctly simulated
> by H would never halt (reach its own "return" statement and terminate
> normally).
>
> Everyone attempting to refute the above verified fact either
> uses the strawman deception to change the subject away from
> [D correctly simulated by H]
> or flat out lies about the behavior of
> [D correctly simulated by H]
>
>
>
> *Complete halt deciding system* (Visual Studio Project)
> https://liarparadox.org/2023_02_07.zip
>
> *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.

And it is universally understood (by the definition of a UTM) that D
correctly simulated by H necessarily demonstrates the actual behavior
specified by this input.

My reviewers already know this... yet disagree with verified facts
anyway so that they can play trollish head games.

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

Re: Simulating halt deciders defeat the halting theorem [ irrefutable reasoning ]

<7MBHL.135873$mmyc.115960@fx37.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=10658&group=comp.ai.philosophy#10658

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy comp.software-eng
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx37.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:102.0)
Gecko/20100101 Thunderbird/102.7.2
Subject: Re: Simulating halt deciders defeat the halting theorem [ irrefutable
reasoning ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,comp.software-eng
References: <tsm3ec$3bgsb$1@dont-email.me> <tsmn8r$3duk6$2@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tsmn8r$3duk6$2@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 72
Message-ID: <7MBHL.135873$mmyc.115960@fx37.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 16 Feb 2023 21:37:56 -0500
X-Received-Bytes: 3514
 by: Richard Damon - Fri, 17 Feb 2023 02:37 UTC

On 2/16/23 9:03 PM, olcott wrote:
> On 2/16/2023 2:24 PM, olcott wrote:
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H(D,D));
>>    Output("Input_Halts = ", D(D));
>> }
>>
>> *Here is my current irrefutable reasoning*
>> H(D,D) does correctly compute the mapping from its input to its reject
>> state on the basis that H correctly predicts that D correctly simulated
>> by H would never halt (reach its own "return" statement and terminate
>> normally).
>>
>> Everyone attempting to refute the above verified fact either
>> uses the strawman deception to change the subject away from
>> [D correctly simulated by H]
>> or flat out lies about the behavior of
>> [D correctly simulated by H]
>>
>>
>>
>> *Complete halt deciding system* (Visual Studio Project)
>> https://liarparadox.org/2023_02_07.zip
>>
>> *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.
>
> And it is universally understood (by the definition of a UTM) that D
> correctly simulated by H necessarily demonstrates the actual behavior
> specified by this input.

And a UTM will ALWAYS continue simulating until it reaches a final state.

H doesn't do that, so H isn't a UTM, and thus H's simulation can not be
a substute for the actual execution of the input, or even the UTM
simulation of the input.

>
> My reviewers already know this... yet disagree with verified facts
> anyway so that they can play trollish head games.
>

No, it is a verified fact that the H that gives an answer is NOT a UTM,
and thus your claim that you can use its simulation is just a LIE.

Your continued instance just proves your ignorance.

The actual VERIIFED FACTS, which even you have agreed to is that D(D)
will Halt with your H that returns 0, which means non-halting from
H(D,D), and thus by the definition of a Halt Decider, the correct answer
is Halting,

It is also clear that you claims that Non-Halting is a "Correct Answer"
when you admit that the machine will actually Halt means you are just
LYING about what you are talking about.

PERIOD.

Re: Simulating halt deciders defeat the halting theorem [ irrefutable reasoning ]

<tso2mn$3l38l$2@dont-email.me>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=10659&group=comp.ai.philosophy#10659

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy comp.software-eng
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,comp.software-eng
Subject: Re: Simulating halt deciders defeat the halting theorem [ irrefutable
reasoning ]
Date: Fri, 17 Feb 2023 08:24:23 -0600
Organization: A noiseless patient Spider
Lines: 58
Message-ID: <tso2mn$3l38l$2@dont-email.me>
References: <tsm3ec$3bgsb$1@dont-email.me> <tsmn8r$3duk6$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 17 Feb 2023 14:24:24 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="7f757de7aceb318c89c335403b7f02b0";
logging-data="3837205"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/jXdQae5CFxiJMXXOT4AhU"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.7.2
Cancel-Lock: sha1:ZqsFNErY+1HwXsLZ8/3aa+owNJs=
Content-Language: en-US
In-Reply-To: <tsmn8r$3duk6$2@dont-email.me>
 by: olcott - Fri, 17 Feb 2023 14:24 UTC

On 2/16/2023 8:03 PM, olcott wrote:
> On 2/16/2023 2:24 PM, olcott wrote:
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H(D,D));
>>    Output("Input_Halts = ", D(D));
>> }
>>
>> *Here is my current irrefutable reasoning*
>> H(D,D) does correctly compute the mapping from its input to its reject
>> state on the basis that H correctly predicts that D correctly simulated
>> by H would never halt (reach its own "return" statement and terminate
>> normally).
>>
>> Everyone attempting to refute the above verified fact either
>> uses the strawman deception to change the subject away from
>> [D correctly simulated by H]
>> or flat out lies about the behavior of
>> [D correctly simulated by H]
>>
>>
>>
>> *Complete halt deciding system* (Visual Studio Project)
>> https://liarparadox.org/2023_02_07.zip
>>
>> *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.
>
> And it is universally understood (by the definition of a UTM) that D
> correctly simulated by H necessarily demonstrates the actual behavior
> specified by this input.
>

Therefore A halt decider H can be based on a UTM such that H continues
to simulate its input until H correctly determines that D correctly
simulated by H would never halt.

Because H is based on a UTM we know that the behavior that H is
evaluating is the behavior specified by 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

Re: Simulating halt deciders defeat the halting theorem [ irrefutable reasoning ]

<RnMHL.511623$t5W7.287500@fx13.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=10661&group=comp.ai.philosophy#10661

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy comp.software-eng
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx13.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:102.0)
Gecko/20100101 Thunderbird/102.7.2
Subject: Re: Simulating halt deciders defeat the halting theorem [ irrefutable
reasoning ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,comp.software-eng
References: <tsm3ec$3bgsb$1@dont-email.me> <tsmn8r$3duk6$2@dont-email.me>
<tso2mn$3l38l$2@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tso2mn$3l38l$2@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 68
Message-ID: <RnMHL.511623$t5W7.287500@fx13.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 17 Feb 2023 09:42:59 -0500
X-Received-Bytes: 3447
 by: Richard Damon - Fri, 17 Feb 2023 14:42 UTC

On 2/17/23 9:24 AM, olcott wrote:
> On 2/16/2023 8:03 PM, olcott wrote:
>> On 2/16/2023 2:24 PM, olcott wrote:
>>> int D(int (*x)())
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H(D,D));
>>>    Output("Input_Halts = ", D(D));
>>> }
>>>
>>> *Here is my current irrefutable reasoning*
>>> H(D,D) does correctly compute the mapping from its input to its reject
>>> state on the basis that H correctly predicts that D correctly simulated
>>> by H would never halt (reach its own "return" statement and terminate
>>> normally).
>>>
>>> Everyone attempting to refute the above verified fact either
>>> uses the strawman deception to change the subject away from
>>> [D correctly simulated by H]
>>> or flat out lies about the behavior of
>>> [D correctly simulated by H]
>>>
>>>
>>>
>>> *Complete halt deciding system* (Visual Studio Project)
>>> https://liarparadox.org/2023_02_07.zip
>>>
>>> *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.
>>
>> And it is universally understood (by the definition of a UTM) that D
>> correctly simulated by H necessarily demonstrates the actual behavior
>> specified by this input.
>>
>
> Therefore A halt decider H can be based on a UTM such that H continues
> to simulate its input until H correctly determines that D correctly
> simulated by H would never halt.
>
> Because H is based on a UTM we know that the behavior that H is
> evaluating is the behavior specified by its input.
>

Not quite, H could use logic that H simulated its input until H could
corredctly determint that D correctly simulated BY A UTM would never halt.

But, because H isn't a UTM, since it DOES abort its simulation before
getting to an end, it is an error to assume that H is a UTM, or in
particular, that D calling H is calling a UTM.

All you have done is show that you don't understand the basics of
programming.

You whole "proof" is based on the LIE that H is just like a UTM, when it
isn't.

Re: Simulating halt deciders defeat the halting theorem [ irrefutable reasoning ]

<tso51m$3ldt9$1@dont-email.me>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=10662&group=comp.ai.philosophy#10662

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy comp.software-eng
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,comp.software-eng
Subject: Re: Simulating halt deciders defeat the halting theorem [ irrefutable
reasoning ]
Date: Fri, 17 Feb 2023 09:04:21 -0600
Organization: A noiseless patient Spider
Lines: 64
Message-ID: <tso51m$3ldt9$1@dont-email.me>
References: <tsm3ec$3bgsb$1@dont-email.me> <tsmn8r$3duk6$2@dont-email.me>
<tso2mn$3l38l$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 17 Feb 2023 15:04:22 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="7f757de7aceb318c89c335403b7f02b0";
logging-data="3848105"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/dF+1cDS1fTpRxctwVFUdB"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.7.2
Cancel-Lock: sha1:QCm4uMGx1PcTxNApMAeIhigjPYU=
Content-Language: en-US
In-Reply-To: <tso2mn$3l38l$2@dont-email.me>
 by: olcott - Fri, 17 Feb 2023 15:04 UTC

On 2/17/2023 8:24 AM, olcott wrote:
> On 2/16/2023 8:03 PM, olcott wrote:
>> On 2/16/2023 2:24 PM, olcott wrote:
>>> int D(int (*x)())
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H(D,D));
>>>    Output("Input_Halts = ", D(D));
>>> }
>>>
>>> *Here is my current irrefutable reasoning*
>>> H(D,D) does correctly compute the mapping from its input to its reject
>>> state on the basis that H correctly predicts that D correctly simulated
>>> by H would never halt (reach its own "return" statement and terminate
>>> normally).
>>>
>>> Everyone attempting to refute the above verified fact either
>>> uses the strawman deception to change the subject away from
>>> [D correctly simulated by H]
>>> or flat out lies about the behavior of
>>> [D correctly simulated by H]
>>>
>>>
>>>
>>> *Complete halt deciding system* (Visual Studio Project)
>>> https://liarparadox.org/2023_02_07.zip
>>>
>>> *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.
>>
>> And it is universally understood (by the definition of a UTM) that D
>> correctly simulated by H necessarily demonstrates the actual behavior
>> specified by this input.
>>
>
> Therefore A halt decider H can be based on a UTM such that H continues
> to simulate its input until H correctly determines that D correctly
> simulated by H would never halt.
>
> Because H is based on a UTM we know that the behavior that H is
> evaluating is the behavior specified by its input.
>

H acts like a UTM and simulates its input until H correctly determines
that D correctly simulated by H would never reach its own "return"
statement and terminate normally.

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

Re: Simulating halt deciders defeat the halting theorem [ irrefutable reasoning ]

<GCNHL.511787$t5W7.432159@fx13.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=10663&group=comp.ai.philosophy#10663

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy comp.software-eng
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx13.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:102.0)
Gecko/20100101 Thunderbird/102.7.2
Subject: Re: Simulating halt deciders defeat the halting theorem [ irrefutable
reasoning ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,comp.software-eng
References: <tsm3ec$3bgsb$1@dont-email.me> <tsmn8r$3duk6$2@dont-email.me>
<tso2mn$3l38l$2@dont-email.me> <tso51m$3ldt9$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tso51m$3ldt9$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 87
Message-ID: <GCNHL.511787$t5W7.432159@fx13.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 17 Feb 2023 11:07:03 -0500
X-Received-Bytes: 4290
 by: Richard Damon - Fri, 17 Feb 2023 16:07 UTC

On 2/17/23 10:04 AM, olcott wrote:
> On 2/17/2023 8:24 AM, olcott wrote:
>> On 2/16/2023 8:03 PM, olcott wrote:
>>> On 2/16/2023 2:24 PM, olcott wrote:
>>>> int D(int (*x)())
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", H(D,D));
>>>>    Output("Input_Halts = ", D(D));
>>>> }
>>>>
>>>> *Here is my current irrefutable reasoning*
>>>> H(D,D) does correctly compute the mapping from its input to its reject
>>>> state on the basis that H correctly predicts that D correctly simulated
>>>> by H would never halt (reach its own "return" statement and terminate
>>>> normally).
>>>>
>>>> Everyone attempting to refute the above verified fact either
>>>> uses the strawman deception to change the subject away from
>>>> [D correctly simulated by H]
>>>> or flat out lies about the behavior of
>>>> [D correctly simulated by H]
>>>>
>>>>
>>>>
>>>> *Complete halt deciding system* (Visual Studio Project)
>>>> https://liarparadox.org/2023_02_07.zip
>>>>
>>>> *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.
>>>
>>> And it is universally understood (by the definition of a UTM) that D
>>> correctly simulated by H necessarily demonstrates the actual behavior
>>> specified by this input.
>>>
>>
>> Therefore A halt decider H can be based on a UTM such that H continues
>> to simulate its input until H correctly determines that D correctly
>> simulated by H would never halt.
>>
>> Because H is based on a UTM we know that the behavior that H is
>> evaluating is the behavior specified by its input.
>>
>
> H acts like a UTM and simulates its input until H correctly determines
> that D correctly simulated by H would never reach its own "return"
> statement and terminate normally.
>

No, if can't be "like a UTM until ..." that just isn't like a UTM.

That is like saying you are just like an immortal being until you die,
thus you can call yourself immortal.

You don't understand what being something means.

Maybe that is why you have at various times claimed to be "like God"
because you don't understand what that means.

You are not immortal, but maybe immoral due to your past history that
has been revealed.

H is NOT a Halt Decider, because 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.

Since D(D) has been shown to Halt, and you have even admittted that,
H(D,D) can NOT be a correct halt decider and say non-halting.

Either H isn't correct, or isn't a Halt Decider.

You claim that it is a correct halt decider is just proven to be a LIE
and shows that you are totally ignorant of the topic you are talking about.

1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor