Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Kiss your keyboard goodbye!


computers / comp.ai.philosophy / Re: Simulating Halt Deciders Defeat the Halting Theorem V2

SubjectAuthor
* Simulating Halt Deciders Defeat the Halting Theorem V2olcott
+- Re: Simulating Halt Deciders Defeat the Halting Theorem V2Richard Damon
`* Re: Simulating Halt Deciders Defeat the Halting Theorem V2olcott
 +* Re: Simulating Halt Deciders Defeat the Halting Theorem V2olcott
 |`* Re: Simulating Halt Deciders Defeat the Halting Theorem V2olcott
 | +- Re: Simulating Halt Deciders Defeat the Halting Theorem V2Richard Damon
 | `* Re: Simulating Halt Deciders Defeat the Halting Theorem V2olcott
 |  +- Re: Simulating Halt Deciders Defeat the Halting Theorem V2Richard Damon
 |  `* Re: Simulating Halt Deciders Defeat the Halting Theorem V2olcott
 |   +- Re: Simulating Halt Deciders Defeat the Halting Theorem V2Richard Damon
 |   `* Re: Simulating Halt Deciders Defeat the Halting Theorem V2olcott
 |    +- Re: Simulating Halt Deciders Defeat the Halting Theorem V2Richard Damon
 |    `* Re: Simulating Halt Deciders Defeat the Halting Theorem V2olcott
 |     +- Re: Simulating Halt Deciders Defeat the Halting Theorem V2Richard Damon
 |     `* Re: Simulating Halt Deciders Defeat the Halting Theorem V2olcott
 |      `- Re: Simulating Halt Deciders Defeat the Halting Theorem V2Richard Damon
 `- Re: Simulating Halt Deciders Defeat the Halting Theorem V2Richard Damon

1
Simulating Halt Deciders Defeat the Halting Theorem V2

<tt0eo7$r85s$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
Subject: Simulating Halt Deciders Defeat the Halting Theorem V2
Date: Mon, 20 Feb 2023 12:39:02 -0600
Organization: A noiseless patient Spider
Lines: 31
Message-ID: <tt0eo7$r85s$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Mon, 20 Feb 2023 18:39:03 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="032dd952935e916dd03f7a051bf174ce";
logging-data="893116"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/2nTvKKqwJJMHnEXQpi37D"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.7.2
Cancel-Lock: sha1:UZE8kUoelN+FGAPqBEFGoDKS1A4=
Content-Language: en-US
 by: olcott - Mon, 20 Feb 2023 18:39 UTC

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

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

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

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

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

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<m7UIL.22460$Kqu2.21503@fx01.iad>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory comp.ai.philosophy comp.software-eng
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx01.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 V2
Content-Language: en-US
Newsgroups: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
References: <tt0eo7$r85s$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tt0eo7$r85s$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 63
Message-ID: <m7UIL.22460$Kqu2.21503@fx01.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: Mon, 20 Feb 2023 19:20:33 -0500
X-Received-Bytes: 3463
 by: Richard Damon - Tue, 21 Feb 2023 00:20 UTC

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

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

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

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

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

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

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

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

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

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<tt149k$tgbj$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
Subject: Re: Simulating Halt Deciders Defeat the Halting Theorem V2
Date: Mon, 20 Feb 2023 18:46:43 -0600
Organization: A noiseless patient Spider
Lines: 45
Message-ID: <tt149k$tgbj$1@dont-email.me>
References: <tt0eo7$r85s$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 21 Feb 2023 00:46:44 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="de1d1f45e9bc794de0197cf1e52aed20";
logging-data="967027"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18k+t0VVBy+GXrO4FzwFJB6"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.7.2
Cancel-Lock: sha1:gRzUV/gKenGSnXvx2F/A0lbZRLs=
Content-Language: en-US
In-Reply-To: <tt0eo7$r85s$1@dont-email.me>
 by: olcott - Tue, 21 Feb 2023 00:46 UTC

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

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<tt15lf$tgbj$2@dont-email.me>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
Subject: Re: Simulating Halt Deciders Defeat the Halting Theorem V2
Date: Mon, 20 Feb 2023 19:10:07 -0600
Organization: A noiseless patient Spider
Lines: 49
Message-ID: <tt15lf$tgbj$2@dont-email.me>
References: <tt0eo7$r85s$1@dont-email.me> <tt149k$tgbj$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 21 Feb 2023 01:10:07 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="de1d1f45e9bc794de0197cf1e52aed20";
logging-data="967027"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+E0EXlhWNuyMbbSaqWtrGm"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.7.2
Cancel-Lock: sha1:YN1ZXybkuGoxRlLaJ30h3P3fayw=
In-Reply-To: <tt149k$tgbj$1@dont-email.me>
Content-Language: en-US
 by: olcott - Tue, 21 Feb 2023 01:10 UTC

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

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<UvVIL.201690$Ldj8.189833@fx47.iad>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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!fx47.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 V2
Newsgroups: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
References: <tt0eo7$r85s$1@dont-email.me> <tt149k$tgbj$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
Content-Language: en-US
In-Reply-To: <tt149k$tgbj$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 67
Message-ID: <UvVIL.201690$Ldj8.189833@fx47.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: Mon, 20 Feb 2023 20:54:59 -0500
X-Received-Bytes: 3815
 by: Richard Damon - Tue, 21 Feb 2023 01:54 UTC

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

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

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

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

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<tt19t0$u06b$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
Subject: Re: Simulating Halt Deciders Defeat the Halting Theorem V2
Date: Mon, 20 Feb 2023 20:22:24 -0600
Organization: A noiseless patient Spider
Lines: 56
Message-ID: <tt19t0$u06b$1@dont-email.me>
References: <tt0eo7$r85s$1@dont-email.me> <tt149k$tgbj$1@dont-email.me>
<tt15lf$tgbj$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 21 Feb 2023 02:22:25 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="de1d1f45e9bc794de0197cf1e52aed20";
logging-data="983243"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1++eQyCCqCsyvDjgiBUFbLc"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.7.2
Cancel-Lock: sha1:qsqi2rH2hzCbjGLaIh+7tk6D2C4=
Content-Language: en-US
In-Reply-To: <tt15lf$tgbj$2@dont-email.me>
 by: olcott - Tue, 21 Feb 2023 02:22 UTC

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

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<93WIL.129550$b7Kc.80832@fx39.iad>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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!fx39.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 V2
Content-Language: en-US
Newsgroups: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
References: <tt0eo7$r85s$1@dont-email.me> <tt149k$tgbj$1@dont-email.me>
<tt15lf$tgbj$2@dont-email.me> <tt19t0$u06b$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tt19t0$u06b$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 69
Message-ID: <93WIL.129550$b7Kc.80832@fx39.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: Mon, 20 Feb 2023 21:32:36 -0500
X-Received-Bytes: 3606
 by: Richard Damon - Tue, 21 Feb 2023 02:32 UTC

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

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

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

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

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

I guess that just shows your ignorance.

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<tt1bmj$u06b$2@dont-email.me>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
Subject: Re: Simulating Halt Deciders Defeat the Halting Theorem V2
Date: Mon, 20 Feb 2023 20:53:07 -0600
Organization: A noiseless patient Spider
Lines: 77
Message-ID: <tt1bmj$u06b$2@dont-email.me>
References: <tt0eo7$r85s$1@dont-email.me> <tt149k$tgbj$1@dont-email.me>
<tt15lf$tgbj$2@dont-email.me> <tt19t0$u06b$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 21 Feb 2023 02:53:07 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="de1d1f45e9bc794de0197cf1e52aed20";
logging-data="983243"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+AkTcyPZYam3whpF6nMWdy"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.7.2
Cancel-Lock: sha1:k8BeiiJJZP6uFygv2wHtJapfo08=
In-Reply-To: <tt19t0$u06b$1@dont-email.me>
Content-Language: en-US
 by: olcott - Tue, 21 Feb 2023 02:53 UTC

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

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<ZyWIL.117073$OD18.65824@fx08.iad>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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!fx08.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 V2
Content-Language: en-US
Newsgroups: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
References: <tt0eo7$r85s$1@dont-email.me> <tt149k$tgbj$1@dont-email.me>
<tt15lf$tgbj$2@dont-email.me> <tt19t0$u06b$1@dont-email.me>
<tt1bmj$u06b$2@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tt1bmj$u06b$2@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 98
Message-ID: <ZyWIL.117073$OD18.65824@fx08.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: Mon, 20 Feb 2023 22:06:33 -0500
X-Received-Bytes: 5054
 by: Richard Damon - Tue, 21 Feb 2023 03:06 UTC

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

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

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

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

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

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<tt1dpb$u06b$3@dont-email.me>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
Subject: Re: Simulating Halt Deciders Defeat the Halting Theorem V2
Date: Mon, 20 Feb 2023 21:28:43 -0600
Organization: A noiseless patient Spider
Lines: 85
Message-ID: <tt1dpb$u06b$3@dont-email.me>
References: <tt0eo7$r85s$1@dont-email.me> <tt149k$tgbj$1@dont-email.me>
<tt15lf$tgbj$2@dont-email.me> <tt19t0$u06b$1@dont-email.me>
<tt1bmj$u06b$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 21 Feb 2023 03:28:43 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="de1d1f45e9bc794de0197cf1e52aed20";
logging-data="983243"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19ad9dg1BTjuPAAt3roD22H"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.7.2
Cancel-Lock: sha1:P6CdQPkV5Prme4xfz7BqNAdQ9vw=
In-Reply-To: <tt1bmj$u06b$2@dont-email.me>
Content-Language: en-US
 by: olcott - Tue, 21 Feb 2023 03:28 UTC

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<Z0XIL.230149$5CY7.104217@fx46.iad>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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!fx46.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 V2
Content-Language: en-US
Newsgroups: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
References: <tt0eo7$r85s$1@dont-email.me> <tt149k$tgbj$1@dont-email.me>
<tt15lf$tgbj$2@dont-email.me> <tt19t0$u06b$1@dont-email.me>
<tt1bmj$u06b$2@dont-email.me> <tt1dpb$u06b$3@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tt1dpb$u06b$3@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 106
Message-ID: <Z0XIL.230149$5CY7.104217@fx46.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: Mon, 20 Feb 2023 22:38:32 -0500
X-Received-Bytes: 5661
 by: Richard Damon - Tue, 21 Feb 2023 03:38 UTC

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

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

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

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<tt1g39$11d8c$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
Subject: Re: Simulating Halt Deciders Defeat the Halting Theorem V2
Date: Mon, 20 Feb 2023 22:08:09 -0600
Organization: A noiseless patient Spider
Lines: 95
Message-ID: <tt1g39$11d8c$1@dont-email.me>
References: <tt0eo7$r85s$1@dont-email.me> <tt149k$tgbj$1@dont-email.me>
<tt15lf$tgbj$2@dont-email.me> <tt19t0$u06b$1@dont-email.me>
<tt1bmj$u06b$2@dont-email.me> <tt1dpb$u06b$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 21 Feb 2023 04:08:09 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="de1d1f45e9bc794de0197cf1e52aed20";
logging-data="1094924"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+pPFJaEoeOEdx0EoEnjGTK"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.7.2
Cancel-Lock: sha1:iHcP13Ok8OyDxLfVevJcUww5qnQ=
In-Reply-To: <tt1dpb$u06b$3@dont-email.me>
Content-Language: en-US
 by: olcott - Tue, 21 Feb 2023 04:08 UTC

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

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<AFXIL.621137$t5W7.571422@fx13.iad>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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!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 V2
Content-Language: en-US
Newsgroups: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
References: <tt0eo7$r85s$1@dont-email.me> <tt149k$tgbj$1@dont-email.me>
<tt15lf$tgbj$2@dont-email.me> <tt19t0$u06b$1@dont-email.me>
<tt1bmj$u06b$2@dont-email.me> <tt1dpb$u06b$3@dont-email.me>
<tt1g39$11d8c$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tt1g39$11d8c$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 116
Message-ID: <AFXIL.621137$t5W7.571422@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: Mon, 20 Feb 2023 23:21:51 -0500
X-Received-Bytes: 6057
 by: Richard Damon - Tue, 21 Feb 2023 04:21 UTC

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

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

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

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

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<tt1i6j$11irt$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
Subject: Re: Simulating Halt Deciders Defeat the Halting Theorem V2
Date: Mon, 20 Feb 2023 22:44:03 -0600
Organization: A noiseless patient Spider
Lines: 107
Message-ID: <tt1i6j$11irt$1@dont-email.me>
References: <tt0eo7$r85s$1@dont-email.me> <tt149k$tgbj$1@dont-email.me>
<tt15lf$tgbj$2@dont-email.me> <tt19t0$u06b$1@dont-email.me>
<tt1bmj$u06b$2@dont-email.me> <tt1dpb$u06b$3@dont-email.me>
<tt1g39$11d8c$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 21 Feb 2023 04:44:03 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="de1d1f45e9bc794de0197cf1e52aed20";
logging-data="1100669"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+pXlMgZQ51moKG/w7bOjSo"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.7.2
Cancel-Lock: sha1:f8ZpgD/BG2KCj4+gKPNMO1Kgyqw=
Content-Language: en-US
In-Reply-To: <tt1g39$11d8c$1@dont-email.me>
 by: olcott - Tue, 21 Feb 2023 04:44 UTC

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

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<gq2JL.718674$gGD7.686169@fx11.iad>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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!fx11.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 V2
Content-Language: en-US
Newsgroups: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
References: <tt0eo7$r85s$1@dont-email.me> <tt149k$tgbj$1@dont-email.me>
<tt15lf$tgbj$2@dont-email.me> <tt19t0$u06b$1@dont-email.me>
<tt1bmj$u06b$2@dont-email.me> <tt1dpb$u06b$3@dont-email.me>
<tt1g39$11d8c$1@dont-email.me> <tt1i6j$11irt$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tt1i6j$11irt$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 128
Message-ID: <gq2JL.718674$gGD7.686169@fx11.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: Tue, 21 Feb 2023 07:03:24 -0500
X-Received-Bytes: 6470
 by: Richard Damon - Tue, 21 Feb 2023 12:03 UTC

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

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

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

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<tt2oh9$15u8i$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
Subject: Re: Simulating Halt Deciders Defeat the Halting Theorem V2
Date: Tue, 21 Feb 2023 09:38:16 -0600
Organization: A noiseless patient Spider
Lines: 125
Message-ID: <tt2oh9$15u8i$1@dont-email.me>
References: <tt0eo7$r85s$1@dont-email.me> <tt149k$tgbj$1@dont-email.me>
<tt15lf$tgbj$2@dont-email.me> <tt19t0$u06b$1@dont-email.me>
<tt1bmj$u06b$2@dont-email.me> <tt1dpb$u06b$3@dont-email.me>
<tt1g39$11d8c$1@dont-email.me> <tt1i6j$11irt$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 21 Feb 2023 15:38:17 -0000 (UTC)
Injection-Info: reader01.eternal-september.org; posting-host="de1d1f45e9bc794de0197cf1e52aed20";
logging-data="1243410"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18OhBWjy4KUD4JmKxZQoOpl"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.7.2
Cancel-Lock: sha1:NdQCUyy31QtJoc0FmT37MM3bES8=
In-Reply-To: <tt1i6j$11irt$1@dont-email.me>
Content-Language: en-US
 by: olcott - Tue, 21 Feb 2023 15:38 UTC

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

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

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

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

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

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

Re: Simulating Halt Deciders Defeat the Halting Theorem V2

<PIcJL.1211093$9sn9.1126320@fx17.iad>

 copy mid

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

 copy link   Newsgroups: sci.logic comp.theory 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!fx17.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 V2
Newsgroups: sci.logic,comp.theory,comp.ai.philosophy,comp.software-eng
References: <tt0eo7$r85s$1@dont-email.me> <tt149k$tgbj$1@dont-email.me>
<tt15lf$tgbj$2@dont-email.me> <tt19t0$u06b$1@dont-email.me>
<tt1bmj$u06b$2@dont-email.me> <tt1dpb$u06b$3@dont-email.me>
<tt1g39$11d8c$1@dont-email.me> <tt1i6j$11irt$1@dont-email.me>
<tt2oh9$15u8i$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
Content-Language: en-US
In-Reply-To: <tt2oh9$15u8i$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 141
Message-ID: <PIcJL.1211093$9sn9.1126320@fx17.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: Tue, 21 Feb 2023 18:45:51 -0500
X-Received-Bytes: 6775
 by: Richard Damon - Tue, 21 Feb 2023 23:45 UTC

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

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

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

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

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

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

You are just proving your insanity.

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

Nope, which also shows your stupidity.

How does your idea handle the Busy Beaver issue?

1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor