Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

All great ideas are controversial, or have been at one time.


devel / comp.theory / Re: Concise refutation of halting problem proofs V27 [ input is not in domain ]

SubjectAuthor
* Concise refutation of halting problem proofs V27 [ finallyolcott
+* Concise refutation of halting problem proofs V27 [ finallyolcott
|`* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
| `* Concise refutation of halting problem proofs V27 [ finallyolcott
|  +- Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|  `* Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|   `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    +* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |`* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    | `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |  +* Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |  |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |  | `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |  `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |   `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | +* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |+* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | ||+* Concise refutation of halting problem proofs V27 [ finallyMalcolm McLean
|    |    | | |||`* Concise refutation of halting problem proofs V27 [ finally mathematically precisBen Bacarisse
|    |    | | ||| `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |||  `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |||   `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |||    `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | ||`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | || +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | || `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | ||  `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | ||   +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | ||   |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | ||   | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | ||   | `- Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | ||   `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |`- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | | `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |  `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   | `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |  `* Concise refutation of halting problem proofs V27 [ finally mathematically precisolcott
|    |    | | |   |   +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   |   | `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |  `* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   |   +* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |   |`* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   |   | +- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   |   |   | `* Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |   |  +* Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   |   |  |+- Concise refutation of halting problem proofs V27 [ finallyolcott
|    |    | | |   |   |   |  |+- Concise refutation of halting problem proofs V27 [ finallyAndré G. Isaak
|    |    | | |   |   |   |  |`- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   |   |   |  `* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   +* Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |`* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   | +- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   | `* Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |  +* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |  |+* Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |  ||`* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |  || +* Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |  || |+* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |  || ||+- Concise refutation of halting problem proofs V27 [ input is notAndré G. Isaak
|    |    | | |   |   |   |   |  || ||`- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   |  || |`* Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |  || | `- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   |  || `- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   |  |`- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   |   |  `* Concise refutation of halting problem proofs V27 [ input is not in domain ]Ben Bacarisse
|    |    | | |   |   |   |   |   +* Concise refutation of halting problem proofs V27 [ input is not in domain ]Ben Bacarisse
|    |    | | |   |   |   |   |   |+- Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   |   |`- Concise refutation of halting problem proofs V27 [ input is not in domain ]Ben Bacarisse
|    |    | | |   |   |   |   |   `- Concise refutation of halting problem proofs V27 [ input is notolcott
|    |    | | |   |   |   |   `- Concise refutation of halting problem proofs V27 [ input is notRichard Damon
|    |    | | |   |   |   `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   |   `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | |   `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | | `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    | `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    |    `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
|    `- Concise refutation of halting problem proofs V27 [ finallyRichard Damon
`- Concise refutation of halting problem proofs V27 [ finallyRichard Damon

Pages:1234
Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<snjlc9$g4m$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23907&group=comp.theory#23907

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Date: Tue, 23 Nov 2021 14:10:31 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 102
Message-ID: <snjlc9$g4m$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 23 Nov 2021 21:10:34 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="49b13d9d5e2a82410bb5befc4a1eb4ad";
logging-data="16534"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+/AHSv7ZNfVY5yQsqRO8oe"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:7MWU/caT7IJLIJA2jvThLgqWOu0=
In-Reply-To: <WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 23 Nov 2021 21:10 UTC

On 2021-11-23 11:24, olcott wrote:
> On 11/23/2021 12:11 PM, André G. Isaak wrote:
>> On 2021-11-23 10:50, olcott wrote:
>>> On 11/23/2021 10:54 AM, André G. Isaak wrote:
>>>> On 2021-11-23 07:59, olcott wrote:
>>>>> On 11/23/2021 12:13 AM, André G. Isaak wrote:
>>>>>> On 2021-11-22 22:42, olcott wrote:
>>>>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>>>>>
>>>>>>>> And that's what the halting problem is about. Determining
>>>>>>>> whether an independent computation halts. Unless H is part of
>>>>>>>> the input string why on earth would H be involved in the
>>>>>>>> independent execution?
>>>>>>>>
>>>>>>>>> No deciders can actually work that way. All deciders either
>>>>>>>>> accept or reject finite string inputs.
>>>>>>>>
>>>>>>>> And they reject them based on whether the independent
>>>>>>>> computation described by those strings halt or not. Why would
>>>>>>>> this be a problem?
>>>>>>>>
>>>>>>>
>>>>>>> You can't correctly pass anything to H besides the pair of finite
>>>>>>> strings or references to the machine language of P.
>>>>>>>
>>>>>>> Its inputs are not allowed to have the extra criteria that you
>>>>>>> assume, thus have no basis to apply it.
>>>>>>
>>>>>> Which 'extra criteria'? The inputs to a halt decider are nothing
>>>>>> more than a finite string exactly as specified in the definition
>>>>>> of 'halt decider'.
>>>>>>
>>>>>> André
>>>>>>
>>>>>>
>>>>>
>>>>> H is only allowed to have two copies or two references to the
>>>>> machine code of P as its input corresponding to the finite strings
>>>>> of the TM description and its input.
>>>>>
>>>>> Since this input cannot contain criteria to distinguish its
>>>>> execution or simulation outside of H from its its execution or
>>>>> simulation by H anyone that says H must report on the behavior of
>>>>> the execution or simulation outside of H is incorrect. H is not
>>>>> allowed to know the difference.
>>>>
>>>> There is no "extra criterion" being passed. The halting problem
>>>> DEFINES exactly what is to be answered, which is whether the
>>>> *independent* computation represented by the input halts, so the
>>>> idea that the input would need to somehow specify that the execution
>>>> is "outside of H" is nonsensical.
>>>>
>>>
>>> You cannot** tell H that it cannot base its halt status decision on
>>> its own simulation of its input.
>>
>> No one is telling it that it cannot base its decision on simulation.
>> But the answer it gives must actually correspond to to the question a
>> halt decider is required answer, which is concerned with the
>> *independent* execution of a computation.
>>
>> André
>>
>>
>
> That is another way of saying that a decider must base its decision on a
> finite string that is not its actual input.

Nonsense. A halt decider takes as its input a string which is a
representation of a computation (i.e. a representation of a TM + an
input string).

It is expected to determine, based on THAT INPUT STRING, whether the
independent computation represented by that input string would halt.

So of course it bases its decision on its actual input.

H can do anything it wants with that string including using it for the
basis of a simulation, but the question it must answer is not about what
happens to the string inside H, nor inside a simulator, nor inside a
partial simulator, nor inside a halt decider. The question is how the
computation which the string represents behaves. And if whatever goes on
inside your H can't answer about that independent computation it means
that the algorithm used by the decider is unsound.

You claim it is impossible for it to answer about the independent
computation. If that is truly the case it means you are *agreeing* with
Linz that a universal halt decider is not possible (though Linz's logic
is sound whereas yours is incomprehensible).

> What would the behavior of the input to H(P,P) be if it was not an input
> to H(P,P) ???

The input is a STRING. strings don't have halting behaviour. H is
expected to determine the behaviour of the independent computation
represented by that string.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<snjllu$ibv$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23908&group=comp.theory#23908

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Date: Tue, 23 Nov 2021 14:15:41 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 94
Message-ID: <snjllu$ibv$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<Ha-dnQk9NNCoGAH8nZ2dnUU7-cXNnZ2d@giganews.com> <sni135$54o$2@dont-email.me>
<ivSdnVrS3JPunwD8nZ2dnUU7-W1QAAAA@giganews.com> <snj6fi$utp$2@dont-email.me>
<7smdnTe6kZRttwD8nZ2dnUU7-QXNnZ2d@giganews.com> <snjav5$22o$2@dont-email.me>
<WfidnVTHgenqrwD8nZ2dnUU7-K2dnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 23 Nov 2021 21:15:43 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="49b13d9d5e2a82410bb5befc4a1eb4ad";
logging-data="18815"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/yD81bufdi2Cc6iwY/q8wy"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:eZcE3UKJ0eUXErr0dgCdHruGD50=
In-Reply-To: <WfidnVTHgenqrwD8nZ2dnUU7-K2dnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 23 Nov 2021 21:15 UTC

On 2021-11-23 11:27, olcott wrote:
> On 11/23/2021 12:12 PM, André G. Isaak wrote:
>> On 2021-11-23 10:54, olcott wrote:
>>> On 11/23/2021 10:56 AM, André G. Isaak wrote:
>>>> On 2021-11-23 08:02, olcott wrote:
>>>>> On 11/23/2021 12:18 AM, André G. Isaak wrote:
>>>>>> On 2021-11-22 23:07, olcott wrote:
>>>>>>> On 11/22/2021 11:42 PM, olcott wrote:
>>>>>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>>>>>
>>>>>>>>> And you still haven't actually answered my question:
>>>>>>>>>
>>>>>>>>> What does it *mean* for the 'input', something which is not a
>>>>>>>>> computation, to halt?
>>>>>>>>>
>>>>>>>
>>>>>>> In my first example the input is directly executed so you are
>>>>>>> still basing your comments on what you think that I must saying
>>>>>>> instead of what I am actually saying.
>>>>>>
>>>>>> Which first example? No examples of anything were given in the
>>>>>> post you are responding to. And what does 'the input is directly
>>>>>> executed mean'? The input is a string which cannot be executed at
>>>>>> all. You mean the
>>>>>
>>>>> #include <stdint.h>
>>>>> #include <stdio.h>
>>>>> typedef int (*ptr)();
>>>>>
>>>>> int H(ptr x, ptr y)
>>>>> {
>>>>>    x(y); // direct execution of P(P)
>>>>>    return 1;
>>>>> }
>>>>>
>>>>> // Minimal essence of Linz(1990) Ĥ
>>>>> // and Strachey(1965) P
>>>>> int P(ptr x)
>>>>> {
>>>>>    H(x, x);
>>>>>    return 1; // Give P a last instruction at the "c" level
>>>>> }
>>>>>
>>>>> int main(void)
>>>>> {
>>>>>    H(P, P);
>>>>> }
>>>>>
>>>>> In the above basis of this whole post H directly invokes P(P).
>>>>
>>>> And the above cannot possibly form the basis for a halt decider
>>>> because there would then be no way to 'abort' the execution of a
>>>> non-halting input. Your approach depends on the input being simulated.
>>>>
>>>
>>> None-the-less the above conclusively proves that any talk about the
>>> simulation being incorrect is pure nonsense.
>>
>> It proves no such thing since by changing the definition of H you have
>> also changed the definition of P. You are no longer talking about the
>> P you claim your decider 'correctly' decides.
>>
>
> H is a computable function that accepts or rejects inputs in its domain
> on the basis that these inputs specify a sequence of configurations that
> reach their final state.

You keep repeating this sentence in response to things without any
attempt to demonstrate its relevance to what you are responding to. As
far as I can tell it has no relevance in the above instance.

>>> When H directly executes its input in the debug step mode of a
>>> debugger we get the exact same result as when H simulates its input,
>>> thus anyone saying that the simulation is incorrect is proven wrong.
>>
>> Executing something inside a debugger is *not* the same thing as the
>> direct, independent execution of a computation.
>
> It necessarily has the same sequence of configurations.

No, it does not. You very clearly have no idea how a debugger works.

When your P is executed inside a debugger, there are *many* instructions
which occur between every two instructions of P. Those instructions
constitute configurations which are not present in P, and they have the
ability to impact the function of P. If you are not actually making use
of any of those capabilities of a debugger, then why would you be
running it inside one in the first place?

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23909&group=comp.theory#23909

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!backlog3.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 16:32:08 -0600
Date: Tue, 23 Nov 2021 16:32:07 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com> <NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me> <MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com> <TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me> <cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me> <xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me> <LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me> <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me> <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me> <ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me> <lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me> <WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snjlc9$g4m$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>
Lines: 112
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-tvMpZHJWRtLMKcRrj5FHj9xZZwGcofjl+U/ky9+J1j+cYgmrsESzQzZYoJxa3zDycwlyCUXxweQV11U!gQ0Kdiy40JS7+cnrT1GWNPCtwVIuFi1XXcCDLkvWk+qEFJNvOxdLL14GizxosQoTyy7ljaZ8llWl!yw==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6742
 by: olcott - Tue, 23 Nov 2021 22:32 UTC

On 11/23/2021 3:10 PM, André G. Isaak wrote:
> On 2021-11-23 11:24, olcott wrote:
>> On 11/23/2021 12:11 PM, André G. Isaak wrote:
>>> On 2021-11-23 10:50, olcott wrote:
>>>> On 11/23/2021 10:54 AM, André G. Isaak wrote:
>>>>> On 2021-11-23 07:59, olcott wrote:
>>>>>> On 11/23/2021 12:13 AM, André G. Isaak wrote:
>>>>>>> On 2021-11-22 22:42, olcott wrote:
>>>>>>>> On 11/22/2021 10:20 PM, André G. Isaak wrote:
>>>>>>>
>>>>>>>>> And that's what the halting problem is about. Determining
>>>>>>>>> whether an independent computation halts. Unless H is part of
>>>>>>>>> the input string why on earth would H be involved in the
>>>>>>>>> independent execution?
>>>>>>>>>
>>>>>>>>>> No deciders can actually work that way. All deciders either
>>>>>>>>>> accept or reject finite string inputs.
>>>>>>>>>
>>>>>>>>> And they reject them based on whether the independent
>>>>>>>>> computation described by those strings halt or not. Why would
>>>>>>>>> this be a problem?
>>>>>>>>>
>>>>>>>>
>>>>>>>> You can't correctly pass anything to H besides the pair of
>>>>>>>> finite strings or references to the machine language of P.
>>>>>>>>
>>>>>>>> Its inputs are not allowed to have the extra criteria that you
>>>>>>>> assume, thus have no basis to apply it.
>>>>>>>
>>>>>>> Which 'extra criteria'? The inputs to a halt decider are nothing
>>>>>>> more than a finite string exactly as specified in the definition
>>>>>>> of 'halt decider'.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> H is only allowed to have two copies or two references to the
>>>>>> machine code of P as its input corresponding to the finite strings
>>>>>> of the TM description and its input.
>>>>>>
>>>>>> Since this input cannot contain criteria to distinguish its
>>>>>> execution or simulation outside of H from its its execution or
>>>>>> simulation by H anyone that says H must report on the behavior of
>>>>>> the execution or simulation outside of H is incorrect. H is not
>>>>>> allowed to know the difference.
>>>>>
>>>>> There is no "extra criterion" being passed. The halting problem
>>>>> DEFINES exactly what is to be answered, which is whether the
>>>>> *independent* computation represented by the input halts, so the
>>>>> idea that the input would need to somehow specify that the
>>>>> execution is "outside of H" is nonsensical.
>>>>>
>>>>
>>>> You cannot** tell H that it cannot base its halt status decision on
>>>> its own simulation of its input.
>>>
>>> No one is telling it that it cannot base its decision on simulation.
>>> But the answer it gives must actually correspond to to the question a
>>> halt decider is required answer, which is concerned with the
>>> *independent* execution of a computation.
>>>
>>> André
>>>
>>>
>>
>> That is another way of saying that a decider must base its decision on
>> a finite string that is not its actual input.
>
> Nonsense. A halt decider takes as its input a string which is a
> representation of a computation (i.e. a representation of a TM + an
> input string).
>
> It is expected to determine, based on THAT INPUT STRING, whether the
> independent computation represented by that input string would halt.
>

There is no possible way to force the idea of [independent] into the
input to the halt decider, that is your big mistake.

> So of course it bases its decision on its actual input.
>
> H can do anything it wants with that string including using it for the
> basis of a simulation, but the question it must answer is not about what
> happens to the string inside H, nor inside a simulator, nor inside a
> partial simulator, nor inside a halt decider. The question is how the
> computation which the string represents behaves. And if whatever goes on
> inside your H can't answer about that independent computation it means
> that the algorithm used by the decider is unsound.
>
> You claim it is impossible for it to answer about the independent
> computation. If that is truly the case it means you are *agreeing* with
> Linz that a universal halt decider is not possible (though Linz's logic
> is sound whereas yours is incomprehensible).
>
>> What would the behavior of the input to H(P,P) be if it was not an
>> input to H(P,P) ???
>
> The input is a STRING. strings don't have halting behaviour. H is
> expected to determine the behaviour of the independent computation
> represented by that string.
>
> André
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<snjqvs$lp6$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23910&group=comp.theory#23910

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Date: Tue, 23 Nov 2021 15:46:19 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 15
Message-ID: <snjqvs$lp6$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 23 Nov 2021 22:46:21 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="49b13d9d5e2a82410bb5befc4a1eb4ad";
logging-data="22310"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/wfeLjnV0SPO9B/l5oHAZn"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:xPCT35JKcr36/GskFNlDTTCufK0=
In-Reply-To: <8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 23 Nov 2021 22:46 UTC

On 2021-11-23 15:32, olcott wrote:

> There is no possible way to force the idea of [independent] into the
> input to the halt decider, that is your big mistake.

The idea of independent (is that the same thing as [independent]?)
*isn't* part of the input, nor is it forced upon the input. It is part
of the definition of 'halt decider'.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<nHenJ.88920$Z0a.5377@fx17.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23911&group=comp.theory#23911

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.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:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 28
Message-ID: <nHenJ.88920$Z0a.5377@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, 23 Nov 2021 18:20:40 -0500
X-Received-Bytes: 3085
 by: Richard Damon - Tue, 23 Nov 2021 23:20 UTC

On 11/23/21 5:32 PM, olcott wrote:

> There is no possible way to force the idea of [independent] into the
> input to the halt decider, that is your big mistake.
>

But the 'idea' isn't in the input, but in the REQUIREMENTS.

Is that your problem, you have forgotten what requirements are?

What the RIGHT answer would be is easily defined by looking at the
input, and the TESTER performing that independent compuation, and thus
determining the right answer, and comparing it to the results that H gives.

Yes, in some cases the tester may not be able to determine this, and we
end up not being able to confirm the answer, but since for this case
P(P) does halt, and does so on time scales similar to H making its
decision, it is easy to prove that H was wrong.

What H is FORCED to do is run as programmed, as that is the nature of
designing and running a program. H's job is to do as programmed, and the
programmers job is to try and make that program give the right answer.

Since "Give the Right Answer' is NOT an algorithm, the fact that you
can't say 'Give the Right Answer based on independent execution' fails
also before we even get into the need for the independent exectution.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23912&group=comp.theory#23912

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 18:11:50 -0600
Date: Tue, 23 Nov 2021 18:11:50 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com> <snjqvs$lp6$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snjqvs$lp6$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>
Lines: 26
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-3uKmNy1jOUD3/iHcrAoa8crjmoXDbnDIpbUeDysmBoe+dTSOUTjrTHdUKFXdjCKR8oX94itqwF/9loK!uwff2myOgMYELKvJ5XT7i1z7kA2AES6Gp6rJBtXadOb2LdQFnm+XKHKqOgB+UUKqHI9QIZGXkgjK!ug==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 2979
 by: olcott - Wed, 24 Nov 2021 00:11 UTC

On 11/23/2021 4:46 PM, André G. Isaak wrote:
> On 2021-11-23 15:32, olcott wrote:
>
>> There is no possible way to force the idea of [independent] into the
>> input to the halt decider, that is your big mistake.
>
> The idea of independent (is that the same thing as [independent]?)
> *isn't* part of the input, nor is it forced upon the input. It is part
> of the definition of 'halt decider'.
>
> André
>
>

There is no way to tell H(X,Y) the difference between the direct
execution of X(Y) outside of H and the direct execution or simulation of
X(Y) inside of H when all that you are allowed to provide to H is the
machine code of X and its finite string Y.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<TCfnJ.68386$SR4.45609@fx43.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23913&group=comp.theory#23913

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.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:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com> <snjqvs$lp6$1@dont-email.me>
<7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 38
Message-ID: <TCfnJ.68386$SR4.45609@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: Tue, 23 Nov 2021 19:24:08 -0500
X-Received-Bytes: 3327
 by: Richard Damon - Wed, 24 Nov 2021 00:24 UTC

On 11/23/21 7:11 PM, olcott wrote:
> On 11/23/2021 4:46 PM, André G. Isaak wrote:
>> On 2021-11-23 15:32, olcott wrote:
>>
>>> There is no possible way to force the idea of [independent] into the
>>> input to the halt decider, that is your big mistake.
>>
>> The idea of independent (is that the same thing as [independent]?)
>> *isn't* part of the input, nor is it forced upon the input. It is part
>> of the definition of 'halt decider'.
>>
>> André
>>
>>
>
> There is no way to tell H(X,Y) the difference between the direct
> execution of X(Y) outside of H and the direct execution or simulation of
> X(Y) inside of H when all that you are allowed to provide to H is the
> machine code of X and its finite string Y.
>
>

There is no way for H(X,Y) to SEE direct execution of X(Y) if H is NOT
actually a UTM, which means that any H that tries to return a
non-halting response can not see the actual direct execution of its input.

That doesn't matter, because it is H's job to figure out what that would
have been based on what it can see.

Of course, this is proved to be impossible, which is one reason you
can't make an accurate Halt Decider.

You are just pointing out why H can't do the job it needs to do to be
right.

The fact that it IS impossible, doesn't mean the requirements change, it
just proves that it is impossible.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<snk1n5$t3o$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23916&group=comp.theory#23916

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Date: Tue, 23 Nov 2021 17:41:07 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 69
Message-ID: <snk1n5$t3o$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<NvednQUyFr32mQH8nZ2dnUU7-IGdnZ2d@giganews.com> <snh212$mup$1@dont-email.me>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com> <snjqvs$lp6$1@dont-email.me>
<7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 24 Nov 2021 00:41:09 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="f65bdac1178d5bb8e5d528eb77ec20a8";
logging-data="29816"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+vbcBtck5y3J4Fki44wu8H"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:mlv1/t89y4GF8OvrdhlRuKuRTb0=
In-Reply-To: <7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Wed, 24 Nov 2021 00:41 UTC

On 2021-11-23 17:11, olcott wrote:
> On 11/23/2021 4:46 PM, André G. Isaak wrote:
>> On 2021-11-23 15:32, olcott wrote:
>>
>>> There is no possible way to force the idea of [independent] into the
>>> input to the halt decider, that is your big mistake.
>>
>> The idea of independent (is that the same thing as [independent]?)
>> *isn't* part of the input, nor is it forced upon the input. It is part
>> of the definition of 'halt decider'.
>>
>> André
>>
>>
>
> There is no way to tell H(X,Y) the difference between the direct
> execution of X(Y) outside of H and the direct execution or simulation of
> X(Y) inside of H when all that you are allowed to provide to H is the
> machine code of X and its finite string Y.

It doesn't *need* to be told this.

Even if it were the case that there is some coherently statable
difference between X(Y) 'outside' of H and X(Y) 'inside' of H (there is
not), the problem *defines* which of these two the machine is to provide
an answer about. It must determine whether the INDEPENDENT computation
halts. So the halt decider *knows* that it must answer about X(Y)
'outside' of H without being told this.

But let's consider things beyond that. You are effectively stating that
X(Y) 'inside of H' and X(Y) 'outside of H' are two distinct
computations. Let's imagine hypothetically that that were true (it isn't).

The halting function is a mathematical mapping from the set of ALL
POSSIBLE computations to either 'halts' or 'does not halt'.

This function is only a computable function if there exists some Turing
Machine which can, for every POSSIBLE computation, determine whether the
halting function maps that computation to 'halts' or 'doesn't halt'.
Since a TM cannot take an actual computation as an input it must take a
string describing that computation, but it must be able to answer for
EVERY single computation in the domain of the halting function.

If it is true that X(Y) 'inside of H' and X(Y) 'outside of H' are two
distinct computations, then the halting function will contain a mapping
for each of these two distinct computations.

If it is really not possible for your halt decider to determine whether
the string <X> <Y> represents X(Y) 'inside of H' or X(Y) 'outside of H',
then you are claiming that your halt decider can only be asked about ONE
of these two computations.

That means there is at least one computation in the halting function
which your halting decider cannot actually be asked about, which means
there is at least one computation that your halting function cannot
decide. The means that your decider is NOT a universal halt decider.

So even if we accept your meaningless claim that there is a difference
between X(Y) 'outside' of H and X(Y) 'inside' of H, we are still forced
to conclude that you cannot construct a universal halt decider, meaning
the halting function is not a computable function.

Which is the exact same conclusion that the Linz proof reaches.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23921&group=comp.theory#23921

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 19:01:49 -0600
Date: Tue, 23 Nov 2021 19:01:47 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<snh212$mup$1@dont-email.me> <MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com> <snjqvs$lp6$1@dont-email.me>
<7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com> <snk1n5$t3o$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snk1n5$t3o$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>
Lines: 134
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-XGX0K9rLUOE7i7nixkQPfbN7dMnfCTrHnkfLC2hxtu7Bcrf1pfibgf6dQG+HRzaSxEdZTynluhH9Uky!RbhBaHeC0yvXK7lghzw+LNvpeC7FN7ZQFHRkjyfoN8WZ14jxN4ZYkJJyYzyKSmCLVg2HXeEDYgQc!CA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7581
 by: olcott - Wed, 24 Nov 2021 01:01 UTC

On 11/23/2021 6:41 PM, André G. Isaak wrote:
> On 2021-11-23 17:11, olcott wrote:
>> On 11/23/2021 4:46 PM, André G. Isaak wrote:
>>> On 2021-11-23 15:32, olcott wrote:
>>>
>>>> There is no possible way to force the idea of [independent] into the
>>>> input to the halt decider, that is your big mistake.
>>>
>>> The idea of independent (is that the same thing as [independent]?)
>>> *isn't* part of the input, nor is it forced upon the input. It is
>>> part of the definition of 'halt decider'.
>>>
>>> André
>>>
>>>
>>
>> There is no way to tell H(X,Y) the difference between the direct
>> execution of X(Y) outside of H and the direct execution or simulation
>> of X(Y) inside of H when all that you are allowed to provide to H is
>> the machine code of X and its finite string Y.
>
> It doesn't *need* to be told this.
>
> Even if it were the case that there is some coherently statable
> difference between X(Y) 'outside' of H and X(Y) 'inside' of H (there is
> not), the problem *defines* which of these two the machine is to provide
> an answer about. It must determine whether the INDEPENDENT computation
> halts. So the halt decider *knows* that it must answer about X(Y)
> 'outside' of H without being told this.
>
> But let's consider things beyond that. You are effectively stating that
> X(Y) 'inside of H' and X(Y) 'outside of H' are two distinct
> computations. Let's imagine hypothetically that that were true (it isn't).
>
> The halting function is a mathematical mapping from the set of ALL
> POSSIBLE computations to either 'halts' or 'does not halt'.
>

In the case of H(X,Y) it is only a mapping fro a unique pair of finite
strings to an accept or reject state.

Then you veer totally off point...

> This function is only a computable function if there exists some Turing
> Machine which can, for every POSSIBLE computation, determine whether the
> halting function maps that computation to 'halts' or 'doesn't halt'.
> Since a TM cannot take an actual computation as an input it must take a
> string describing that computation, but it must be able to answer for
> EVERY single computation in the domain of the halting function.
>
> If it is true that X(Y) 'inside of H' and X(Y) 'outside of H' are two
> distinct computations, then the halting function will contain a mapping
> for each of these two distinct computations.
>

// Minimal essence of Linz(1990) Ĥ
// and Strachey(1965) P
int P(ptr x)
{ H(x, x);
return 1; // Give P a last instruction at the "c" level
}

H(P,P) maps to reject. // inside of H
H1(P,P) maps to accept. // outside of H

> If it is really not possible for your halt decider to determine whether
> the string <X> <Y> represents X(Y) 'inside of H' or X(Y) 'outside of H',
> then you are claiming that your halt decider can only be asked about ONE
> of these two computations.
>
> That means there is at least one computation in the halting function
> which your halting decider cannot actually be asked about, which means
> there is at least one computation that your halting function cannot
> decide. The means that your decider is NOT a universal halt decider.
>

No that is not it.

There exists elements of the PSR subset B such that it
is a verified fact that the input to Hn(Pn,Pn) never halts
and Pn(Pn) halts.

No other computations ever work this way so it is quite
counter-intuitive. This is conclusively proven on the basis or
relatively simple {software engineering , set theory, syllogisms}.

Combinations of (H,P) having pathological self-reference (PSR)
H(P,P) simulates or executes its input and aborts or does
not abort its input and P(P) calls this same H(P,P) with itself.

We can think of the combinations of (H,P) as an enumerated sequence of
finite strings of C source-code. The above source code specifies the
H0(P0,P0) first element of this sequence.

Set theory and syllogisms select subsets of the infinite set of
behaviors of the Hn(Pn, Pn) combinations such that we know these subsets
specify the actual behavior of their elements.

PSR set: When Hn(Pn, Pn) executes or simulates its input we can see that
this input never reaches its last instruction. When Hn(Pn, Pn) executes
or simulates its input and aborts this execution or simulation at some
point this input still never reaches its last instruction.

PSR subset A: When Hn(Pn, Pn) executes or simulates its input and aborts
this execution or simulation at some point this input still never
reaches its last instruction and Hn(Pn, Pn) halts.

PSR subset B: When Hn(Pn, Pn) executes or simulates its input and aborts
this execution or simulation at some point this input still never
reaches its last instruction and Hn(Pn, Pn) halts and Pn(Pn) called from
main() halts.

> So even if we accept your meaningless claim that there is a difference
> between X(Y) 'outside' of H and X(Y) 'inside' of H, we are still forced
> to conclude that you cannot construct a universal halt decider, meaning
> the halting function is not a computable function.
>
> Which is the exact same conclusion that the Linz proof reaches.
>
> André
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<snk4rc$cuu$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23923&group=comp.theory#23923

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Date: Tue, 23 Nov 2021 18:34:34 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 140
Message-ID: <snk4rc$cuu$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com> <snjqvs$lp6$1@dont-email.me>
<7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com> <snk1n5$t3o$1@dont-email.me>
<6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 24 Nov 2021 01:34:36 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="84791843d7ed22a0a2f82336688b7cbe";
logging-data="13278"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18RlLOR9SsQzB90u+DGiaTn"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:HxWYpWQ15liccJyM/KS7ZDDbs6s=
In-Reply-To: <6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Wed, 24 Nov 2021 01:34 UTC

On 2021-11-23 18:01, olcott wrote:
> On 11/23/2021 6:41 PM, André G. Isaak wrote:
>> On 2021-11-23 17:11, olcott wrote:
>>> On 11/23/2021 4:46 PM, André G. Isaak wrote:
>>>> On 2021-11-23 15:32, olcott wrote:
>>>>
>>>>> There is no possible way to force the idea of [independent] into
>>>>> the input to the halt decider, that is your big mistake.
>>>>
>>>> The idea of independent (is that the same thing as [independent]?)
>>>> *isn't* part of the input, nor is it forced upon the input. It is
>>>> part of the definition of 'halt decider'.
>>>>
>>>> André
>>>>
>>>>
>>>
>>> There is no way to tell H(X,Y) the difference between the direct
>>> execution of X(Y) outside of H and the direct execution or simulation
>>> of X(Y) inside of H when all that you are allowed to provide to H is
>>> the machine code of X and its finite string Y.
>>
>> It doesn't *need* to be told this.
>>
>> Even if it were the case that there is some coherently statable
>> difference between X(Y) 'outside' of H and X(Y) 'inside' of H (there
>> is not), the problem *defines* which of these two the machine is to
>> provide an answer about. It must determine whether the INDEPENDENT
>> computation halts. So the halt decider *knows* that it must answer
>> about X(Y) 'outside' of H without being told this.

No response? Did you even read the above?

>> But let's consider things beyond that. You are effectively stating
>> that X(Y) 'inside of H' and X(Y) 'outside of H' are two distinct
>> computations. Let's imagine hypothetically that that were true (it
>> isn't).
>>
>> The halting function is a mathematical mapping from the set of ALL
>> POSSIBLE computations to either 'halts' or 'does not halt'.
>>
>
> In the case of H(X,Y) it is only a mapping fro a unique pair of finite
> strings to an accept  or reject state.

I said halting FUNCTION, not halt decider. Do you grasp the difference?

> Then you veer totally off point...

No, then I start taking about halt deciders.

>> This function is only a computable function if there exists some
>> Turing Machine which can, for every POSSIBLE computation, determine
>> whether the halting function maps that computation to 'halts' or
>> 'doesn't halt'. Since a TM cannot take an actual computation as an
>> input it must take a string describing that computation, but it must
>> be able to answer for EVERY single computation in the domain of the
>> halting function.
>>
>> If it is true that X(Y) 'inside of H' and X(Y) 'outside of H' are two
>> distinct computations, then the halting function will contain a
>> mapping for each of these two distinct computations.
>>
>
> // Minimal essence of Linz(1990) Ĥ
> // and Strachey(1965) P
> int P(ptr x)
> {
>   H(x, x);
>   return 1; // Give P a last instruction at the "c" level
> }
>
>  H(P,P) maps to reject. // inside of H
> H1(P,P) maps to accept. // outside of H

Your H1 and H are separate programs. A halt decider is a *single*
program which computes the halting function.

>> If it is really not possible for your halt decider to determine
>> whether the string <X> <Y> represents X(Y) 'inside of H' or X(Y)
>> 'outside of H', then you are claiming that your halt decider can only
>> be asked about ONE of these two computations.
>>
>> That means there is at least one computation in the halting function
>> which your halting decider cannot actually be asked about, which means
>> there is at least one computation that your halting function cannot
>> decide. The means that your decider is NOT a universal halt decider.
>>
>
> No that is not it.
>
> There exists elements of the PSR subset B  such that it
> is a verified fact that the input to Hn(Pn,Pn) never halts
> and Pn(Pn) halts.
>
> No other computations ever work this way so it is quite
> counter-intuitive. This is conclusively proven on the basis or
> relatively simple {software engineering , set theory, syllogisms}.

A given computation maps to EXACTLY one element of the set {halts,
doesn't halt}. Otherwise it would not be a function.

>
>
> Combinations of (H,P) having pathological self-reference (PSR)
>   H(P,P) simulates or executes its input and aborts or does
>   not abort its input and P(P) calls this same H(P,P) with itself.
>
> We can think of the combinations of (H,P) as an enumerated sequence of
> finite strings of C source-code. The above source code specifies the
> H0(P0,P0) first element of this sequence.
>
> Set theory and syllogisms select subsets of the infinite set of
> behaviors of the Hn(Pn, Pn) combinations such that we know these subsets
> specify the actual behavior of their elements.

Now do set theory and syllogisms 'decide' things?

> PSR set: When Hn(Pn, Pn) executes or simulates its input we can see that
> this input never reaches its last instruction. When Hn(Pn, Pn) executes
> or simulates its input and aborts this execution or simulation at some
> point this input still never reaches its last instruction.
>
> PSR subset A: When Hn(Pn, Pn) executes or simulates its input and aborts
> this execution or simulation at some point this input still never
> reaches its last instruction and Hn(Pn, Pn) halts.
>
> PSR subset B: When Hn(Pn, Pn) executes or simulates its input and aborts
> this execution or simulation at some point this input still never
> reaches its last instruction and Hn(Pn, Pn) halts and Pn(Pn) called from
> main() halts.

Input don't reach instructions.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23927&group=comp.theory#23927

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 19:53:28 -0600
Date: Tue, 23 Nov 2021 19:53:27 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com> <snjqvs$lp6$1@dont-email.me>
<7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com> <snk1n5$t3o$1@dont-email.me>
<6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com> <snk4rc$cuu$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snk4rc$cuu$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com>
Lines: 177
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-t6tHmSusm1jmMgafAVP9uldLWm8Pkc/qQ2OtnXD6Kg09/AhaMAYkY7u3LXwOTAirtrl0YSW9pd8BOkV!isBL74EruF2TCw/ppY72tdE1TbDUf9GMZTo8sg/4qXn1ute120OB5g87lEYN/ofvbKBeeHwRd0/N!jA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 9069
 by: olcott - Wed, 24 Nov 2021 01:53 UTC

On 11/23/2021 7:34 PM, André G. Isaak wrote:
> On 2021-11-23 18:01, olcott wrote:
>> On 11/23/2021 6:41 PM, André G. Isaak wrote:
>>> On 2021-11-23 17:11, olcott wrote:
>>>> On 11/23/2021 4:46 PM, André G. Isaak wrote:
>>>>> On 2021-11-23 15:32, olcott wrote:
>>>>>
>>>>>> There is no possible way to force the idea of [independent] into
>>>>>> the input to the halt decider, that is your big mistake.
>>>>>
>>>>> The idea of independent (is that the same thing as [independent]?)
>>>>> *isn't* part of the input, nor is it forced upon the input. It is
>>>>> part of the definition of 'halt decider'.
>>>>>
>>>>> André
>>>>>
>>>>>
>>>>
>>>> There is no way to tell H(X,Y) the difference between the direct
>>>> execution of X(Y) outside of H and the direct execution or
>>>> simulation of X(Y) inside of H when all that you are allowed to
>>>> provide to H is the machine code of X and its finite string Y.
>>>
>>> It doesn't *need* to be told this.
>>>
>>> Even if it were the case that there is some coherently statable
>>> difference between X(Y) 'outside' of H and X(Y) 'inside' of H (there
>>> is not), the problem *defines* which of these two the machine is to
>>> provide an answer about. It must determine whether the INDEPENDENT
>>> computation halts. So the halt decider *knows* that it must answer
>>> about X(Y) 'outside' of H without being told this.
>
> No response? Did you even read the above?
>

I went on to show that these two machines cannot possbly be input to one
halt decider, you have to have two halt deciders, H1 and H.

>>> But let's consider things beyond that. You are effectively stating
>>> that X(Y) 'inside of H' and X(Y) 'outside of H' are two distinct
>>> computations. Let's imagine hypothetically that that were true (it
>>> isn't).
>>>
>>> The halting function is a mathematical mapping from the set of ALL
>>> POSSIBLE computations to either 'halts' or 'does not halt'.
>>>
>>
>> In the case of H(X,Y) it is only a mapping fro a unique pair of finite
>> strings to an accept  or reject state.
>
> I said halting FUNCTION, not halt decider. Do you grasp the difference?
>

A decider is mathematical function that maps finite strings to accept
and reject states. A halt decider must first be a decdier.

>> Then you veer totally off point...
>
> No, then I start taking about halt deciders.
>
>>> This function is only a computable function if there exists some
>>> Turing Machine which can, for every POSSIBLE computation, determine
>>> whether the halting function maps that computation to 'halts' or
>>> 'doesn't halt'. Since a TM cannot take an actual computation as an
>>> input it must take a string describing that computation, but it must
>>> be able to answer for EVERY single computation in the domain of the
>>> halting function.
>>>
>>> If it is true that X(Y) 'inside of H' and X(Y) 'outside of H' are two
>>> distinct computations, then the halting function will contain a
>>> mapping for each of these two distinct computations.
>>>
>>
>> // Minimal essence of Linz(1990) Ĥ
>> // and Strachey(1965) P
>> int P(ptr x)
>> {
>>    H(x, x);
>>    return 1; // Give P a last instruction at the "c" level
>> }
>>
>>   H(P,P) maps to reject. // inside of H
>> H1(P,P) maps to accept. // outside of H
>
> Your H1 and H are separate programs. A halt decider is a *single*
> program which computes the halting function.
>

It is impossible for H to have any idea what the execution of its input
as an independent computation executed outside of itself can possibly mean.

The only thing that we can do is create another halt decider H1 that
simulates the behavior of the input to H outside of H.

That gets rid of the pathological self reference and changes the
sequence of configurations of P(P).

>>> If it is really not possible for your halt decider to determine
>>> whether the string <X> <Y> represents X(Y) 'inside of H' or X(Y)
>>> 'outside of H', then you are claiming that your halt decider can only
>>> be asked about ONE of these two computations.
>>>
>>> That means there is at least one computation in the halting function
>>> which your halting decider cannot actually be asked about, which
>>> means there is at least one computation that your halting function
>>> cannot decide. The means that your decider is NOT a universal halt
>>> decider.
>>>
>>
>> No that is not it.
>>
>> There exists elements of the PSR subset B  such that it
>> is a verified fact that the input to Hn(Pn,Pn) never halts
>> and Pn(Pn) halts.
>>
>> No other computations ever work this way so it is quite
>> counter-intuitive. This is conclusively proven on the basis or
>> relatively simple {software engineering , set theory, syllogisms}.
>
> A given computation maps to EXACTLY one element of the set {halts,
> doesn't halt}. Otherwise it would not be a function.
>
>>
>>
>> Combinations of (H,P) having pathological self-reference (PSR)
>>    H(P,P) simulates or executes its input and aborts or does
>>    not abort its input and P(P) calls this same H(P,P) with itself.
>>
>> We can think of the combinations of (H,P) as an enumerated sequence of
>> finite strings of C source-code. The above source code specifies the
>> H0(P0,P0) first element of this sequence.
>>
>> Set theory and syllogisms select subsets of the infinite set of
>> behaviors of the Hn(Pn, Pn) combinations such that we know these
>> subsets specify the actual behavior of their elements.
>
> Now do set theory and syllogisms 'decide' things?
>

You have to actually carefully study what I said:

>> PSR set: When Hn(Pn, Pn) executes or simulates its input we can see
>> that this input never reaches its last instruction. When Hn(Pn, Pn)
>> executes or simulates its input and aborts this execution or
>> simulation at some point this input still never reaches its last
>> instruction.
>>
>> PSR subset A: When Hn(Pn, Pn) executes or simulates its input and
>> aborts this execution or simulation at some point this input still
>> never reaches its last instruction and Hn(Pn, Pn) halts.
>>
>> PSR subset B: When Hn(Pn, Pn) executes or simulates its input and
>> aborts this execution or simulation at some point this input still
>> never reaches its last instruction and Hn(Pn, Pn) halts and Pn(Pn)
>> called from main() halts.
>
> Input don't reach instructions.
>

If you make sure to ignore some of the words then they won't make sense.

executes or simulates its input we can see
executes or simulates its input we can see
executes or simulates its input we can see

> André
>
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<G0hnJ.130886$831.123812@fx40.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23931&group=comp.theory#23931

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder5.feed.usenet.farm!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx40.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<MpydnY7JbLEWkgH8nZ2dnUU7-SHNnZ2d@giganews.com>
<TtUmJ.126712$831.100143@fx40.iad> <snh4jm$a0i$1@dont-email.me>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com> <snjqvs$lp6$1@dont-email.me>
<7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com> <snk1n5$t3o$1@dont-email.me>
<6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 178
Message-ID: <G0hnJ.130886$831.123812@fx40.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, 23 Nov 2021 20:59:53 -0500
X-Received-Bytes: 9227
 by: Richard Damon - Wed, 24 Nov 2021 01:59 UTC

On 11/23/21 8:01 PM, olcott wrote:
> On 11/23/2021 6:41 PM, André G. Isaak wrote:
>> On 2021-11-23 17:11, olcott wrote:
>>> On 11/23/2021 4:46 PM, André G. Isaak wrote:
>>>> On 2021-11-23 15:32, olcott wrote:
>>>>
>>>>> There is no possible way to force the idea of [independent] into
>>>>> the input to the halt decider, that is your big mistake.
>>>>
>>>> The idea of independent (is that the same thing as [independent]?)
>>>> *isn't* part of the input, nor is it forced upon the input. It is
>>>> part of the definition of 'halt decider'.
>>>>
>>>> André
>>>>
>>>>
>>>
>>> There is no way to tell H(X,Y) the difference between the direct
>>> execution of X(Y) outside of H and the direct execution or simulation
>>> of X(Y) inside of H when all that you are allowed to provide to H is
>>> the machine code of X and its finite string Y.
>>
>> It doesn't *need* to be told this.
>>
>> Even if it were the case that there is some coherently statable
>> difference between X(Y) 'outside' of H and X(Y) 'inside' of H (there
>> is not), the problem *defines* which of these two the machine is to
>> provide an answer about. It must determine whether the INDEPENDENT
>> computation halts. So the halt decider *knows* that it must answer
>> about X(Y) 'outside' of H without being told this.
>>
>> But let's consider things beyond that. You are effectively stating
>> that X(Y) 'inside of H' and X(Y) 'outside of H' are two distinct
>> computations. Let's imagine hypothetically that that were true (it
>> isn't).
>>
>> The halting function is a mathematical mapping from the set of ALL
>> POSSIBLE computations to either 'halts' or 'does not halt'.
>>
>
> In the case of H(X,Y) it is only a mapping fro a unique pair of finite
> strings to an accept  or reject state.

But NOT mapping to the CORRECT answer.

Since H *CLAIMS* to be a Halt Decider, if P(I) halts, then H(P,I) needs
to return the 'Halting' value (1), and if P(I) will run FOREVER, then
H(P,I) needs to return the 'Non-Halting' value (0).

The mapping that you claim that H returns does NOT match this as even
you agree that P(P) Halts, so H(P,P) needs to return 1, but return 0.

So, FAIL.

>
> Then you veer totally off point...
>
>> This function is only a computable function if there exists some
>> Turing Machine which can, for every POSSIBLE computation, determine
>> whether the halting function maps that computation to 'halts' or
>> 'doesn't halt'. Since a TM cannot take an actual computation as an
>> input it must take a string describing that computation, but it must
>> be able to answer for EVERY single computation in the domain of the
>> halting function.
>>
>> If it is true that X(Y) 'inside of H' and X(Y) 'outside of H' are two
>> distinct computations, then the halting function will contain a
>> mapping for each of these two distinct computations.
>>
>
> // Minimal essence of Linz(1990) Ĥ
> // and Strachey(1965) P
> int P(ptr x)
> {
>   H(x, x);
>   return 1; // Give P a last instruction at the "c" level
> }
>
>  H(P,P) maps to reject. // inside of H
> H1(P,P) maps to accept. // outside of H

And since both of these have the SAME input, the answer of 'does the
input halt' needs to be the same, and since P(P) halts, it is H1 that is
right, and H is wrong, and since it is the one that P was built from, it
is H that needed to be right, but isn't.

>
>> If it is really not possible for your halt decider to determine
>> whether the string <X> <Y> represents X(Y) 'inside of H' or X(Y)
>> 'outside of H', then you are claiming that your halt decider can only
>> be asked about ONE of these two computations.
>>
>> That means there is at least one computation in the halting function
>> which your halting decider cannot actually be asked about, which means
>> there is at least one computation that your halting function cannot
>> decide. The means that your decider is NOT a universal halt decider.
>>
>
> No that is not it.
>
> There exists elements of the PSR subset B  such that it
> is a verified fact that the input to Hn(Pn,Pn) never halts
> and Pn(Pn) halts.
>

LIE.

Since the DEFINITION of 'the input' to Hn(Pn,Pn) is the representation
of Pn(Pn), then this is impossible, at least if you are talking about
the Halting Problem and not just POOP.

> No other computations ever work this way so it is quite
> counter-intuitive. This is conclusively proven on the basis or
> relatively simple {software engineering , set theory, syllogisms}.
>

NO computations work this way, because of the actual defintion of Halting.

You Don't prove this, you just try to redefine things with wrong
definitions to claim this, which is just LYING.

Remember the FUNDAMENTAL DEFINITION of the Problem the Halting Problem
is asking as that H(P,I) is asking if the independent computaiton P(I)
Halts or not.

You confuse the actual behavior or P(I) and the incomplete simulation
that happens inside H.

>
> Combinations of (H,P) having pathological self-reference (PSR)
>   H(P,P) simulates or executes its input and aborts or does
>   not abort its input and P(P) calls this same H(P,P) with itself.
>
> We can think of the combinations of (H,P) as an enumerated sequence of
> finite strings of C source-code. The above source code specifies the
> H0(P0,P0) first element of this sequence.
>
> Set theory and syllogisms select subsets of the infinite set of
> behaviors of the Hn(Pn, Pn) combinations such that we know these subsets
> specify the actual behavior of their elements.
>
> PSR set: When Hn(Pn, Pn) executes or simulates its input we can see that
> this input never reaches its last instruction. When Hn(Pn, Pn) executes
> or simulates its input and aborts this execution or simulation at some
> point this input still never reaches its last instruction.
>
> PSR subset A: When Hn(Pn, Pn) executes or simulates its input and aborts
> this execution or simulation at some point this input still never
> reaches its last instruction and Hn(Pn, Pn) halts.
>
> PSR subset B: When Hn(Pn, Pn) executes or simulates its input and aborts
> this execution or simulation at some point this input still never
> reaches its last instruction and Hn(Pn, Pn) halts and Pn(Pn) called from
> main() halts.
>
>

Just full of LIES. Halting is DEFINED to be based on the independent
computation, and to show non-halting you have to show that the input
will NEVER reach a halting state even if the machine is executed for an
unbounded number of steps. Seeing that it didn't reach a halting state
in the finite number of steps that H traced does NOT show Non-Halting,
it just indicates that you haven't answered the Halting status, and is
just in a not-yet state.

>
>> So even if we accept your meaningless claim that there is a difference
>> between X(Y) 'outside' of H and X(Y) 'inside' of H, we are still
>> forced to conclude that you cannot construct a universal halt decider,
>> meaning the halting function is not a computable function.
>>
>> Which is the exact same conclusion that the Linz proof reaches.
>>
>> André
>>
>
>

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<JdhnJ.29357$xe2.721@fx16.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23933&group=comp.theory#23933

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx16.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<snh4jm$a0i$1@dont-email.me> <cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com>
<snh8d4$4t1$1@dont-email.me> <xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhes8$c1c$1@dont-email.me> <LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhh1j$nre$1@dont-email.me> <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
<snhq6t$9bg$1@dont-email.me> <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<sni0pq$54o$1@dont-email.me> <ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>
<snj6bs$utp$1@dont-email.me> <lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>
<snjas5$22o$1@dont-email.me> <WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>
<snjlc9$g4m$1@dont-email.me> <8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>
<snjqvs$lp6$1@dont-email.me> <7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>
<snk1n5$t3o$1@dont-email.me> <6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>
<snk4rc$cuu$1@dont-email.me> <k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 230
Message-ID: <JdhnJ.29357$xe2.721@fx16.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, 23 Nov 2021 21:13:50 -0500
X-Received-Bytes: 10747
 by: Richard Damon - Wed, 24 Nov 2021 02:13 UTC

On 11/23/21 8:53 PM, olcott wrote:
> On 11/23/2021 7:34 PM, André G. Isaak wrote:
>> On 2021-11-23 18:01, olcott wrote:
>>> On 11/23/2021 6:41 PM, André G. Isaak wrote:
>>>> On 2021-11-23 17:11, olcott wrote:
>>>>> On 11/23/2021 4:46 PM, André G. Isaak wrote:
>>>>>> On 2021-11-23 15:32, olcott wrote:
>>>>>>
>>>>>>> There is no possible way to force the idea of [independent] into
>>>>>>> the input to the halt decider, that is your big mistake.
>>>>>>
>>>>>> The idea of independent (is that the same thing as [independent]?)
>>>>>> *isn't* part of the input, nor is it forced upon the input. It is
>>>>>> part of the definition of 'halt decider'.
>>>>>>
>>>>>> André
>>>>>>
>>>>>>
>>>>>
>>>>> There is no way to tell H(X,Y) the difference between the direct
>>>>> execution of X(Y) outside of H and the direct execution or
>>>>> simulation of X(Y) inside of H when all that you are allowed to
>>>>> provide to H is the machine code of X and its finite string Y.
>>>>
>>>> It doesn't *need* to be told this.
>>>>
>>>> Even if it were the case that there is some coherently statable
>>>> difference between X(Y) 'outside' of H and X(Y) 'inside' of H (there
>>>> is not), the problem *defines* which of these two the machine is to
>>>> provide an answer about. It must determine whether the INDEPENDENT
>>>> computation halts. So the halt decider *knows* that it must answer
>>>> about X(Y) 'outside' of H without being told this.
>>
>> No response? Did you even read the above?
>>
>
> I went on to show that these two machines cannot possbly be input to one
> halt decider, you have to have two halt deciders, H1 and H.

Then I guess neither is a proper Halt Decider. FAIL.

The domain of a Halt Decider is ANY Computation.

If H can't take the input P(P) for the P built on it, then it CAN'T be
the counter to Linz, as it fails by not allowing the input.

FAIL

>
>>>> But let's consider things beyond that. You are effectively stating
>>>> that X(Y) 'inside of H' and X(Y) 'outside of H' are two distinct
>>>> computations. Let's imagine hypothetically that that were true (it
>>>> isn't).
>>>>
>>>> The halting function is a mathematical mapping from the set of ALL
>>>> POSSIBLE computations to either 'halts' or 'does not halt'.
>>>>
>>>
>>> In the case of H(X,Y) it is only a mapping fro a unique pair of
>>> finite strings to an accept  or reject state.
>>
>> I said halting FUNCTION, not halt decider. Do you grasp the difference?
>>
>
> A decider is mathematical function that maps finite strings to accept
> and reject states. A halt decider must first be a decdier.
>

Right. Input is the representation of the computation. In your case, a
copy of the full object code of the COMPUTATION P. That can be given.

The Output, to be a correct Halting Decider must match what the
independent execution of P(P) does.

>>> Then you veer totally off point...
>>
>> No, then I start taking about halt deciders.
>>
>>>> This function is only a computable function if there exists some
>>>> Turing Machine which can, for every POSSIBLE computation, determine
>>>> whether the halting function maps that computation to 'halts' or
>>>> 'doesn't halt'. Since a TM cannot take an actual computation as an
>>>> input it must take a string describing that computation, but it must
>>>> be able to answer for EVERY single computation in the domain of the
>>>> halting function.
>>>>
>>>> If it is true that X(Y) 'inside of H' and X(Y) 'outside of H' are
>>>> two distinct computations, then the halting function will contain a
>>>> mapping for each of these two distinct computations.
>>>>
>>>
>>> // Minimal essence of Linz(1990) Ĥ
>>> // and Strachey(1965) P
>>> int P(ptr x)
>>> {
>>>    H(x, x);
>>>    return 1; // Give P a last instruction at the "c" level
>>> }
>>>
>>>   H(P,P) maps to reject. // inside of H
>>> H1(P,P) maps to accept. // outside of H
>>
>> Your H1 and H are separate programs. A halt decider is a *single*
>> program which computes the halting function.
>>
>
> It is impossible for H to have any idea what the execution of its input
> as an independent computation executed outside of itself can possibly mean.

So, you are admitting that H can't be correct?

Good. You just PROVED that Linz is correct.

Also, H is an algorithm, algoriths don't 'understand' meaning, they
computer results.

The GOAL of H is to try and determine what this thing that is can't
directly observe will do. That's why it is hard.

>
> The only thing that we can do is create another halt decider H1 that
> simulates the behavior of the input to H outside of H.

But that doesn't meet the requirements of the problem!!!

>
> That gets rid of the pathological self reference and changes the
> sequence of configurations of P(P).

And H1 is not the required Halting decider, so proves nothing.

Linz shows that a given H can not correctly decide for the H^ built on it.

He makes NO claims that another decider H1, can't get the right answer
for this H^.

>
>
>>>> If it is really not possible for your halt decider to determine
>>>> whether the string <X> <Y> represents X(Y) 'inside of H' or X(Y)
>>>> 'outside of H', then you are claiming that your halt decider can
>>>> only be asked about ONE of these two computations.
>>>>
>>>> That means there is at least one computation in the halting function
>>>> which your halting decider cannot actually be asked about, which
>>>> means there is at least one computation that your halting function
>>>> cannot decide. The means that your decider is NOT a universal halt
>>>> decider.
>>>>
>>>
>>> No that is not it.
>>>
>>> There exists elements of the PSR subset B  such that it
>>> is a verified fact that the input to Hn(Pn,Pn) never halts
>>> and Pn(Pn) halts.
>>>
>>> No other computations ever work this way so it is quite
>>> counter-intuitive. This is conclusively proven on the basis or
>>> relatively simple {software engineering , set theory, syllogisms}.
>>
>> A given computation maps to EXACTLY one element of the set {halts,
>> doesn't halt}. Otherwise it would not be a function.
>>
>>>
>>>
>>> Combinations of (H,P) having pathological self-reference (PSR)
>>>    H(P,P) simulates or executes its input and aborts or does
>>>    not abort its input and P(P) calls this same H(P,P) with itself.
>>>
>>> We can think of the combinations of (H,P) as an enumerated sequence
>>> of finite strings of C source-code. The above source code specifies
>>> the H0(P0,P0) first element of this sequence.
>>>
>>> Set theory and syllogisms select subsets of the infinite set of
>>> behaviors of the Hn(Pn, Pn) combinations such that we know these
>>> subsets specify the actual behavior of their elements.
>>
>> Now do set theory and syllogisms 'decide' things?
>>
>
> You have to actually carefully study what I said:
>
>>> PSR set: When Hn(Pn, Pn) executes or simulates its input we can see
>>> that this input never reaches its last instruction. When Hn(Pn, Pn)
>>> executes or simulates its input and aborts this execution or
>>> simulation at some point this input still never reaches its last
>>> instruction.
>>>
>>> PSR subset A: When Hn(Pn, Pn) executes or simulates its input and
>>> aborts this execution or simulation at some point this input still
>>> never reaches its last instruction and Hn(Pn, Pn) halts.
>>>
>>> PSR subset B: When Hn(Pn, Pn) executes or simulates its input and
>>> aborts this execution or simulation at some point this input still
>>> never reaches its last instruction and Hn(Pn, Pn) halts and Pn(Pn)
>>> called from main() halts.
>>
>> Input don't reach instructions.
>>
>
> If you make sure to ignore some of the words then they won't make sense.
>
> executes or simulates its input we can see
> executes or simulates its input we can see
> executes or simulates its input we can see


Click here to read the complete article
Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<snk7kc$pr8$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23934&group=comp.theory#23934

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Date: Tue, 23 Nov 2021 19:22:02 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 104
Message-ID: <snk7kc$pr8$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<snh4jm$a0i$1@dont-email.me> <cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com>
<snh8d4$4t1$1@dont-email.me> <xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhes8$c1c$1@dont-email.me> <LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhh1j$nre$1@dont-email.me> <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
<snhq6t$9bg$1@dont-email.me> <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<sni0pq$54o$1@dont-email.me> <ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>
<snj6bs$utp$1@dont-email.me> <lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>
<snjas5$22o$1@dont-email.me> <WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>
<snjlc9$g4m$1@dont-email.me> <8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>
<snjqvs$lp6$1@dont-email.me> <7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>
<snk1n5$t3o$1@dont-email.me> <6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>
<snk4rc$cuu$1@dont-email.me> <k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 24 Nov 2021 02:22:04 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="84791843d7ed22a0a2f82336688b7cbe";
logging-data="26472"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX195oVNqbhGCYhd6AW9OuRV3"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:jTBENDKoCL4hCx7tMVV++OvKYdM=
In-Reply-To: <k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Wed, 24 Nov 2021 02:22 UTC

On 2021-11-23 18:53, olcott wrote:
> On 11/23/2021 7:34 PM, André G. Isaak wrote:
>> On 2021-11-23 18:01, olcott wrote:
>>> On 11/23/2021 6:41 PM, André G. Isaak wrote:
>>>> On 2021-11-23 17:11, olcott wrote:
>>>>> On 11/23/2021 4:46 PM, André G. Isaak wrote:
>>>>>> On 2021-11-23 15:32, olcott wrote:
>>>>>>
>>>>>>> There is no possible way to force the idea of [independent] into
>>>>>>> the input to the halt decider, that is your big mistake.
>>>>>>
>>>>>> The idea of independent (is that the same thing as [independent]?)
>>>>>> *isn't* part of the input, nor is it forced upon the input. It is
>>>>>> part of the definition of 'halt decider'.
>>>>>>
>>>>>> André
>>>>>>
>>>>>>
>>>>>
>>>>> There is no way to tell H(X,Y) the difference between the direct
>>>>> execution of X(Y) outside of H and the direct execution or
>>>>> simulation of X(Y) inside of H when all that you are allowed to
>>>>> provide to H is the machine code of X and its finite string Y.
>>>>
>>>> It doesn't *need* to be told this.
>>>>
>>>> Even if it were the case that there is some coherently statable
>>>> difference between X(Y) 'outside' of H and X(Y) 'inside' of H (there
>>>> is not), the problem *defines* which of these two the machine is to
>>>> provide an answer about. It must determine whether the INDEPENDENT
>>>> computation halts. So the halt decider *knows* that it must answer
>>>> about X(Y) 'outside' of H without being told this.
>>
>> No response? Did you even read the above?
>>
>
> I went on to show that these two machines cannot possbly be input to one
> halt decider, you have to have two halt deciders, H1 and H.

A universal halt decider is a *single* machine which answers the halting
question for *any* possible computation. What you claim above is
equivalent to claiming that such a universal halt decider is not
possible. A fact that everyone else already knows.

>>>> But let's consider things beyond that. You are effectively stating
>>>> that X(Y) 'inside of H' and X(Y) 'outside of H' are two distinct
>>>> computations. Let's imagine hypothetically that that were true (it
>>>> isn't).
>>>>
>>>> The halting function is a mathematical mapping from the set of ALL
>>>> POSSIBLE computations to either 'halts' or 'does not halt'.
>>>>
>>>
>>> In the case of H(X,Y) it is only a mapping fro a unique pair of
>>> finite strings to an accept  or reject state.
>>
>> I said halting FUNCTION, not halt decider. Do you grasp the difference?
>>
>
> A decider is mathematical function that maps finite strings to accept
> and reject states. A halt decider must first be a decdier.

A halt decider is *not* a mathematical function. It is a Turing Machine.

The halting FUNCTION is a mathematical function.

A mathematical function is simply a mapping. In the case of the halting
function it maps the set of all possible computations to either 'halts'
or 'doesn't halt'.

A Turing Machine is something which *computes* a mathematical function.
That is, it takes as its input some element of the domain (or some
appropriate representation thereof) as an input and, following some set
of mechanical steps, determines what that element is mapped to by the
function being computed.

Crucially, the halting function exists *independently* and *prior* to
any Turing Machine which attempts to compute this function. The halting
function is *not* associated with any sort of algorithm; it is simply a
mapping. In other words it is simply a denumerably infinite list of all
possible computations and their halting status expressed as ordered pairs.

The computation P(P) will occur in this list exactly once, as will be
true for all other computation. Since your P(P) halts, it will map to
'halts'.

A halt decider, given <P> <P> as its input, is tasked with determining
what the entry for that computation in the list described above actually
is in a finite number of steps. If <P> <P> maps to 'halts' in the
halting function, then a halt decider must accept it. If it maps to
'doesn't halt', it must reject it.

That means that the halting value of P(P) is *not* specific to a given
halt decider. Your H and H1 must both provide the same answer if they
are both halt deciders. It means that it is non-sensical to talk about
the halting value of P(P) 'inside' some H, since H's job is to determine
what value this computation maps to in the halting FUNCTION which is
independent of any halt decider.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<iN2dnSK4M_hZMAD8nZ2dnUU7-W3NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23935&group=comp.theory#23935

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 21:13:08 -0600
Date: Tue, 23 Nov 2021 21:13:07 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com> <snjqvs$lp6$1@dont-email.me>
<7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com> <snk1n5$t3o$1@dont-email.me>
<6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com> <snk4rc$cuu$1@dont-email.me>
<k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com> <snk7kc$pr8$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snk7kc$pr8$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <iN2dnSK4M_hZMAD8nZ2dnUU7-W3NnZ2d@giganews.com>
Lines: 133
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-4ftYAMe96My6NG8c8F0X6iVvT/le/jUtpk+dPCJFJ2OYaqLbZ4OtBV+Xbb/qCzL490hHp5zprXF9J1p!fsitsmb5aKJfPB450FqdKmCv0uvXxN6e1rYP9Ydg+GfEACBgN+rr9f2dX+hvUKLWvUp5xuDVxmZZ!Og==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7782
 by: olcott - Wed, 24 Nov 2021 03:13 UTC

On 11/23/2021 8:22 PM, André G. Isaak wrote:
> On 2021-11-23 18:53, olcott wrote:
>> On 11/23/2021 7:34 PM, André G. Isaak wrote:
>>> On 2021-11-23 18:01, olcott wrote:
>>>> On 11/23/2021 6:41 PM, André G. Isaak wrote:
>>>>> On 2021-11-23 17:11, olcott wrote:
>>>>>> On 11/23/2021 4:46 PM, André G. Isaak wrote:
>>>>>>> On 2021-11-23 15:32, olcott wrote:
>>>>>>>
>>>>>>>> There is no possible way to force the idea of [independent] into
>>>>>>>> the input to the halt decider, that is your big mistake.
>>>>>>>
>>>>>>> The idea of independent (is that the same thing as
>>>>>>> [independent]?) *isn't* part of the input, nor is it forced upon
>>>>>>> the input. It is part of the definition of 'halt decider'.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> There is no way to tell H(X,Y) the difference between the direct
>>>>>> execution of X(Y) outside of H and the direct execution or
>>>>>> simulation of X(Y) inside of H when all that you are allowed to
>>>>>> provide to H is the machine code of X and its finite string Y.
>>>>>
>>>>> It doesn't *need* to be told this.
>>>>>
>>>>> Even if it were the case that there is some coherently statable
>>>>> difference between X(Y) 'outside' of H and X(Y) 'inside' of H
>>>>> (there is not), the problem *defines* which of these two the
>>>>> machine is to provide an answer about. It must determine whether
>>>>> the INDEPENDENT computation halts. So the halt decider *knows* that
>>>>> it must answer about X(Y) 'outside' of H without being told this.
>>>
>>> No response? Did you even read the above?
>>>
>>
>> I went on to show that these two machines cannot possbly be input to
>> one halt decider, you have to have two halt deciders, H1 and H.
>
> A universal halt decider is a *single* machine which answers the halting
> question for *any* possible computation. What you claim above is
> equivalent to claiming that such a universal halt decider is not
> possible. A fact that everyone else already knows.
>

I had a good reply the I erased to focus on the one key point below:

>>>>> But let's consider things beyond that. You are effectively stating
>>>>> that X(Y) 'inside of H' and X(Y) 'outside of H' are two distinct
>>>>> computations. Let's imagine hypothetically that that were true (it
>>>>> isn't).
>>>>>
>>>>> The halting function is a mathematical mapping from the set of ALL
>>>>> POSSIBLE computations to either 'halts' or 'does not halt'.
>>>>>
>>>>
>>>> In the case of H(X,Y) it is only a mapping fro a unique pair of
>>>> finite strings to an accept  or reject state.
>>>
>>> I said halting FUNCTION, not halt decider. Do you grasp the difference?
>>>
>>
>> A decider is mathematical function that maps finite strings to accept
>> and reject states. A halt decider must first be a decdier.
>
> A halt decider is *not* a mathematical function. It is a Turing Machine.
>
> The halting FUNCTION is a mathematical function.
>
> A mathematical function is simply a mapping. In the case of the halting
> function it maps the set of all possible computations to either 'halts'
> or 'doesn't halt'.
>
> A Turing Machine is something which *computes* a mathematical function.
> That is, it takes as its input some element of the domain (or some
> appropriate representation thereof) as an input and, following some set
> of mechanical steps, determines what that element is mapped to by the
> function being computed.
>

A decider maps input strings to final states.

> Crucially, the halting function exists *independently* and *prior* to

You don't realize it but you are asking a decider to make its decision
on the basis of a string that cannot possibly exist in its domain.

int H(ptr x, ptr y) { x(y); }
int P(ptr x) { H(x, x); }
int H(ptr x, ptr y) { x(y); }

The input to H requires that P call this very same H.
The input to H1 has no such pathological relationship to P.

By simply ignoring the pathological relationship between H and P you are
answering the wrong question.

You are asking the question what would the behavior of P be if P called
H1 instead of calling H?

> any Turing Machine which attempts to compute this function. The halting
> function is *not* associated with any sort of algorithm; it is simply a
> mapping. In other words it is simply a denumerably infinite list of all
> possible computations and their halting status expressed as ordered pairs.
>
> The computation P(P) will occur in this list exactly once, as will be
> true for all other computation. Since your P(P) halts, it will map to
> 'halts'.
>
> A halt decider, given <P> <P> as its input, is tasked with determining
> what the entry for that computation in the list described above actually
> is in a finite number of steps. If <P> <P> maps to 'halts' in the
> halting function, then a halt decider must accept it. If it maps to
> 'doesn't halt', it must reject it.
>
> That means that the halting value of P(P) is *not* specific to a given
> halt decider. Your H and H1 must both provide the same answer if they
> are both halt deciders. It means that it is non-sensical to talk about
> the halting value of P(P) 'inside' some H, since H's job is to determine
> what value this computation maps to in the halting FUNCTION which is
> independent of any halt decider.
>
> André
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ] typo

<iN2dnV24M_jdMwD8nZ2dnUU7-W2dnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23936&group=comp.theory#23936

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 21:15:12 -0600
Date: Tue, 23 Nov 2021 21:15:11 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ] typo
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<snh8d4$4t1$1@dont-email.me> <xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhes8$c1c$1@dont-email.me> <LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhh1j$nre$1@dont-email.me> <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
<snhq6t$9bg$1@dont-email.me> <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<sni0pq$54o$1@dont-email.me> <ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>
<snj6bs$utp$1@dont-email.me> <lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>
<snjas5$22o$1@dont-email.me> <WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>
<snjlc9$g4m$1@dont-email.me> <8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>
<snjqvs$lp6$1@dont-email.me> <7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>
<snk1n5$t3o$1@dont-email.me> <6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>
<snk4rc$cuu$1@dont-email.me> <k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com>
<snk7kc$pr8$1@dont-email.me> <iN2dnSK4M_hZMAD8nZ2dnUU7-W3NnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <iN2dnSK4M_hZMAD8nZ2dnUU7-W3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <iN2dnV24M_jdMwD8nZ2dnUU7-W2dnZ2d@giganews.com>
Lines: 140
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-DrXC37t/0EzB7h4g9HzH52n9ysa1wxp7ex4GzZKVEssEQW+PCjc92JJv+dFjszMovwwvAr0QlnOTnoh!59hGrCkxWbavyKziki0ktdF8e43I8ue6iMwuf17GDxqra5LZJnyPYWtjUi/wYcs3oRQmv6yaiEIf!9A==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 8016
 by: olcott - Wed, 24 Nov 2021 03:15 UTC

On 11/23/2021 9:13 PM, olcott wrote:
> On 11/23/2021 8:22 PM, André G. Isaak wrote:
>> On 2021-11-23 18:53, olcott wrote:
>>> On 11/23/2021 7:34 PM, André G. Isaak wrote:
>>>> On 2021-11-23 18:01, olcott wrote:
>>>>> On 11/23/2021 6:41 PM, André G. Isaak wrote:
>>>>>> On 2021-11-23 17:11, olcott wrote:
>>>>>>> On 11/23/2021 4:46 PM, André G. Isaak wrote:
>>>>>>>> On 2021-11-23 15:32, olcott wrote:
>>>>>>>>
>>>>>>>>> There is no possible way to force the idea of [independent]
>>>>>>>>> into the input to the halt decider, that is your big mistake.
>>>>>>>>
>>>>>>>> The idea of independent (is that the same thing as
>>>>>>>> [independent]?) *isn't* part of the input, nor is it forced upon
>>>>>>>> the input. It is part of the definition of 'halt decider'.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> There is no way to tell H(X,Y) the difference between the direct
>>>>>>> execution of X(Y) outside of H and the direct execution or
>>>>>>> simulation of X(Y) inside of H when all that you are allowed to
>>>>>>> provide to H is the machine code of X and its finite string Y.
>>>>>>
>>>>>> It doesn't *need* to be told this.
>>>>>>
>>>>>> Even if it were the case that there is some coherently statable
>>>>>> difference between X(Y) 'outside' of H and X(Y) 'inside' of H
>>>>>> (there is not), the problem *defines* which of these two the
>>>>>> machine is to provide an answer about. It must determine whether
>>>>>> the INDEPENDENT computation halts. So the halt decider *knows*
>>>>>> that it must answer about X(Y) 'outside' of H without being told
>>>>>> this.
>>>>
>>>> No response? Did you even read the above?
>>>>
>>>
>>> I went on to show that these two machines cannot possbly be input to
>>> one halt decider, you have to have two halt deciders, H1 and H.
>>
>> A universal halt decider is a *single* machine which answers the
>> halting question for *any* possible computation. What you claim above
>> is equivalent to claiming that such a universal halt decider is not
>> possible. A fact that everyone else already knows.
>>
>
> I had a good reply the I erased to focus on the one key point below:
>
>>>>>> But let's consider things beyond that. You are effectively stating
>>>>>> that X(Y) 'inside of H' and X(Y) 'outside of H' are two distinct
>>>>>> computations. Let's imagine hypothetically that that were true (it
>>>>>> isn't).
>>>>>>
>>>>>> The halting function is a mathematical mapping from the set of ALL
>>>>>> POSSIBLE computations to either 'halts' or 'does not halt'.
>>>>>>
>>>>>
>>>>> In the case of H(X,Y) it is only a mapping fro a unique pair of
>>>>> finite strings to an accept  or reject state.
>>>>
>>>> I said halting FUNCTION, not halt decider. Do you grasp the difference?
>>>>
>>>
>>> A decider is mathematical function that maps finite strings to accept
>>> and reject states. A halt decider must first be a decdier.
>>
>> A halt decider is *not* a mathematical function. It is a Turing Machine.
>>
>> The halting FUNCTION is a mathematical function.
>>
>> A mathematical function is simply a mapping. In the case of the
>> halting function it maps the set of all possible computations to
>> either 'halts' or 'doesn't halt'.
>>
>> A Turing Machine is something which *computes* a mathematical
>> function. That is, it takes as its input some element of the domain
>> (or some appropriate representation thereof) as an input and,
>> following some set of mechanical steps, determines what that element
>> is mapped to by the function being computed.
>>
>
> A decider maps input strings to final states.
>
>> Crucially, the halting function exists *independently* and *prior* to
>
> You don't realize it but you are asking a decider to make its decision
> on the basis of a string that cannot possibly exist in its domain.
>
> int H(ptr x, ptr y) { x(y);    }
> int P(ptr x)        { H(x, x); }

int H1(ptr x, ptr y) { x(y); }

>
> The input to H requires that P call this very same H.
> The input to H1 has no such pathological relationship to P.
>
> By simply ignoring the pathological relationship between H and P you are
> answering the wrong question.
>
> You are asking the question what would the behavior of P be if P called
> H1 instead of calling H?
>
>> any Turing Machine which attempts to compute this function. The
>> halting function is *not* associated with any sort of algorithm; it is
>> simply a mapping. In other words it is simply a denumerably infinite
>> list of all possible computations and their halting status expressed
>> as ordered pairs.
>>
>> The computation P(P) will occur in this list exactly once, as will be
>> true for all other computation. Since your P(P) halts, it will map to
>> 'halts'.
>>
>> A halt decider, given <P> <P> as its input, is tasked with determining
>> what the entry for that computation in the list described above
>> actually is in a finite number of steps. If <P> <P> maps to 'halts' in
>> the halting function, then a halt decider must accept it. If it maps
>> to 'doesn't halt', it must reject it.
>>
>> That means that the halting value of P(P) is *not* specific to a given
>> halt decider. Your H and H1 must both provide the same answer if they
>> are both halt deciders. It means that it is non-sensical to talk about
>> the halting value of P(P) 'inside' some H, since H's job is to
>> determine what value this computation maps to in the halting FUNCTION
>> which is independent of any halt decider.
>>
>> André
>>
>
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

Re: Concise refutation of halting problem proofs V27 [ input is not in domain ]

<bt6dncqPsKYYLQD8nZ2dnUU7-afNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23937&group=comp.theory#23937

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 21:24:53 -0600
Date: Tue, 23 Nov 2021 21:24:52 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ input is not
in domain ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<cNKdnX6ckqwSvAH8nZ2dnUU7-WXNnZ2d@giganews.com> <snh8d4$4t1$1@dont-email.me>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com> <snjqvs$lp6$1@dont-email.me>
<7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com> <snk1n5$t3o$1@dont-email.me>
<6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com> <snk4rc$cuu$1@dont-email.me>
<k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com> <snk7kc$pr8$1@dont-email.me>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snk7kc$pr8$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <bt6dncqPsKYYLQD8nZ2dnUU7-afNnZ2d@giganews.com>
Lines: 57
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-PDH98ly41//dBLYw2P55rdnVCOjV/gJjpljDjMZWI7o9/X7E4zOW/ztm7gQFc7iQIvMMhUh1Yl/DJMP!cOInaQrIQQ/Efi0nhyeGAVljivCL0/B9prqrOxf5FJ25owpP7LqoJmNAFVkLdLv5D64JyosqBI4z!WQ==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4494
 by: olcott - Wed, 24 Nov 2021 03:24 UTC

On 11/23/2021 8:22 PM, André G. Isaak wrote:
> On 2021-11-23 18:53, olcott wrote:
>> On 11/23/2021 7:34 PM, André G. Isaak wrote:

> Crucially, the halting function exists *independently* and *prior* to
> any Turing Machine which attempts to compute this function. The halting
> function is *not* associated with any sort of algorithm; it is simply a
> mapping. In other words it is simply a denumerably infinite list of all
> possible computations and their halting status expressed as ordered pairs.
>

You don't realize it but you are asking a decider to make its decision
on the basis of a hypothetical string that does not actually exist.

int H(ptr x, ptr y) { x(y); }
int P(ptr x) { H(x, x); }
int H1(ptr x, ptr y) { x(y); }

The input to H requires that P call this very same H.
The input to H1 has no such pathological relationship to P.

By simply ignoring the pathological relationship between H and P you are
answering the wrong question.

You are answering the question:
What would the behavior of P be if P called H1 instead of calling H?

That makes the "input" to H hypothetical rather than an actual string.

> The computation P(P) will occur in this list exactly once, as will be
> true for all other computation. Since your P(P) halts, it will map to
> 'halts'.
>
> A halt decider, given <P> <P> as its input, is tasked with determining
> what the entry for that computation in the list described above actually
> is in a finite number of steps. If <P> <P> maps to 'halts' in the
> halting function, then a halt decider must accept it. If it maps to
> 'doesn't halt', it must reject it.
>
> That means that the halting value of P(P) is *not* specific to a given
> halt decider. Your H and H1 must both provide the same answer if they
> are both halt deciders. It means that it is non-sensical to talk about
> the halting value of P(P) 'inside' some H, since H's job is to determine
> what value this computation maps to in the halting FUNCTION which is
> independent of any halt decider.
>
> André
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<snkbrq$hlj$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23938&group=comp.theory#23938

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Date: Tue, 23 Nov 2021 20:34:16 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 142
Message-ID: <snkbrq$hlj$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<snh8d4$4t1$1@dont-email.me> <xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhes8$c1c$1@dont-email.me> <LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhh1j$nre$1@dont-email.me> <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
<snhq6t$9bg$1@dont-email.me> <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<sni0pq$54o$1@dont-email.me> <ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>
<snj6bs$utp$1@dont-email.me> <lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>
<snjas5$22o$1@dont-email.me> <WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>
<snjlc9$g4m$1@dont-email.me> <8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>
<snjqvs$lp6$1@dont-email.me> <7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>
<snk1n5$t3o$1@dont-email.me> <6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>
<snk4rc$cuu$1@dont-email.me> <k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com>
<snk7kc$pr8$1@dont-email.me> <iN2dnSK4M_hZMAD8nZ2dnUU7-W3NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 24 Nov 2021 03:34:18 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="84791843d7ed22a0a2f82336688b7cbe";
logging-data="18099"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+wAlCg3hj9s/faRp7I4afX"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:hAsj6UheFFUtQfIGo/NBgmOtDAE=
In-Reply-To: <iN2dnSK4M_hZMAD8nZ2dnUU7-W3NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Wed, 24 Nov 2021 03:34 UTC

On 2021-11-23 20:13, olcott wrote:
> On 11/23/2021 8:22 PM, André G. Isaak wrote:
>> On 2021-11-23 18:53, olcott wrote:
>>> On 11/23/2021 7:34 PM, André G. Isaak wrote:
>>>> On 2021-11-23 18:01, olcott wrote:
>>>>> On 11/23/2021 6:41 PM, André G. Isaak wrote:
>>>>>> On 2021-11-23 17:11, olcott wrote:
>>>>>>> On 11/23/2021 4:46 PM, André G. Isaak wrote:
>>>>>>>> On 2021-11-23 15:32, olcott wrote:
>>>>>>>>
>>>>>>>>> There is no possible way to force the idea of [independent]
>>>>>>>>> into the input to the halt decider, that is your big mistake.
>>>>>>>>
>>>>>>>> The idea of independent (is that the same thing as
>>>>>>>> [independent]?) *isn't* part of the input, nor is it forced upon
>>>>>>>> the input. It is part of the definition of 'halt decider'.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> There is no way to tell H(X,Y) the difference between the direct
>>>>>>> execution of X(Y) outside of H and the direct execution or
>>>>>>> simulation of X(Y) inside of H when all that you are allowed to
>>>>>>> provide to H is the machine code of X and its finite string Y.
>>>>>>
>>>>>> It doesn't *need* to be told this.
>>>>>>
>>>>>> Even if it were the case that there is some coherently statable
>>>>>> difference between X(Y) 'outside' of H and X(Y) 'inside' of H
>>>>>> (there is not), the problem *defines* which of these two the
>>>>>> machine is to provide an answer about. It must determine whether
>>>>>> the INDEPENDENT computation halts. So the halt decider *knows*
>>>>>> that it must answer about X(Y) 'outside' of H without being told
>>>>>> this.
>>>>
>>>> No response? Did you even read the above?
>>>>
>>>
>>> I went on to show that these two machines cannot possbly be input to
>>> one halt decider, you have to have two halt deciders, H1 and H.
>>
>> A universal halt decider is a *single* machine which answers the
>> halting question for *any* possible computation. What you claim above
>> is equivalent to claiming that such a universal halt decider is not
>> possible. A fact that everyone else already knows.
>>
>
> I had a good reply the I erased to focus on the one key point below:

Likely story.

>>>>>> But let's consider things beyond that. You are effectively stating
>>>>>> that X(Y) 'inside of H' and X(Y) 'outside of H' are two distinct
>>>>>> computations. Let's imagine hypothetically that that were true (it
>>>>>> isn't).
>>>>>>
>>>>>> The halting function is a mathematical mapping from the set of ALL
>>>>>> POSSIBLE computations to either 'halts' or 'does not halt'.
>>>>>>
>>>>>
>>>>> In the case of H(X,Y) it is only a mapping fro a unique pair of
>>>>> finite strings to an accept  or reject state.
>>>>
>>>> I said halting FUNCTION, not halt decider. Do you grasp the difference?
>>>>
>>>
>>> A decider is mathematical function that maps finite strings to accept
>>> and reject states. A halt decider must first be a decdier.
>>
>> A halt decider is *not* a mathematical function. It is a Turing Machine.
>>
>> The halting FUNCTION is a mathematical function.
>>
>> A mathematical function is simply a mapping. In the case of the
>> halting function it maps the set of all possible computations to
>> either 'halts' or 'doesn't halt'.
>>
>> A Turing Machine is something which *computes* a mathematical
>> function. That is, it takes as its input some element of the domain
>> (or some appropriate representation thereof) as an input and,
>> following some set of mechanical steps, determines what that element
>> is mapped to by the function being computed.
>>
>
> A decider maps input strings to final states.
>
>> Crucially, the halting function exists *independently* and *prior* to
>
> You don't realize it but you are asking a decider to make its decision
> on the basis of a string that cannot possibly exist in its domain.

<P> <P> is a string representing the computation P(P). In what sense can
this string not 'possibly exist in its domain'?

Do you know what 'domain' means?

> int H(ptr x, ptr y) { x(y);    }
> int P(ptr x)        { H(x, x); }
> int H(ptr x, ptr y) { x(y);    }
>
> The input to H requires that P call this very same H.

No it does not. It requires H to evaluate whether P(P) halts.

The above does not do that since it has absolutely no code which can
possibly decide halting.

Your particular implementation of H given in previous posts allegedly
involves H *simulating* P, where the simulation of P includes a
simulation of H, but that's not the same as P calling H. And it is
certainly not a requirement of the problem that you implement your H in
this particular manner.

The original problem is stated in terms of turing machines. And it is
not even possible for P, implemented as a Turing machine, to call
another turing machine.

> The input to H1 has no such pathological relationship to P.

There's nothing pathological about it.

Go back to my discussion regarding the Halting FUNCTION, which is what
your H is supposed to compute. Your deciders job is simply to determine
what value that function maps P(P) to. That function is simply a list of
ordered pairs. If anything 'pathological' is going on, it is a byproduct
of your implementation, not of P(P).

> By simply ignoring the pathological relationship between H and P you are
> answering the wrong question.
>
> You are asking the question what would the behavior of P be if P called
> H1 instead of calling H?

No, I am not, I am asking the question 'does the computation P(P) halt?'
because that's the question a halt decider is required to answer.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Concise refutation of halting problem proofs V27 [ finally mathematically precise ]

<wvinJ.94511$ya3.85584@fx38.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23939&group=comp.theory#23939

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx38.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ finally
mathematically precise ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<snh8d4$4t1$1@dont-email.me> <xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhes8$c1c$1@dont-email.me> <LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhh1j$nre$1@dont-email.me> <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
<snhq6t$9bg$1@dont-email.me> <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<sni0pq$54o$1@dont-email.me> <ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>
<snj6bs$utp$1@dont-email.me> <lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>
<snjas5$22o$1@dont-email.me> <WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>
<snjlc9$g4m$1@dont-email.me> <8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>
<snjqvs$lp6$1@dont-email.me> <7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>
<snk1n5$t3o$1@dont-email.me> <6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>
<snk4rc$cuu$1@dont-email.me> <k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com>
<snk7kc$pr8$1@dont-email.me> <iN2dnSK4M_hZMAD8nZ2dnUU7-W3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <iN2dnSK4M_hZMAD8nZ2dnUU7-W3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 151
Message-ID: <wvinJ.94511$ya3.85584@fx38.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, 23 Nov 2021 22:41:15 -0500
X-Received-Bytes: 8240
 by: Richard Damon - Wed, 24 Nov 2021 03:41 UTC

On 11/23/21 10:13 PM, olcott wrote:
> On 11/23/2021 8:22 PM, André G. Isaak wrote:
>> On 2021-11-23 18:53, olcott wrote:
>>> On 11/23/2021 7:34 PM, André G. Isaak wrote:
>>>> On 2021-11-23 18:01, olcott wrote:
>>>>> On 11/23/2021 6:41 PM, André G. Isaak wrote:
>>>>>> On 2021-11-23 17:11, olcott wrote:
>>>>>>> On 11/23/2021 4:46 PM, André G. Isaak wrote:
>>>>>>>> On 2021-11-23 15:32, olcott wrote:
>>>>>>>>
>>>>>>>>> There is no possible way to force the idea of [independent]
>>>>>>>>> into the input to the halt decider, that is your big mistake.
>>>>>>>>
>>>>>>>> The idea of independent (is that the same thing as
>>>>>>>> [independent]?) *isn't* part of the input, nor is it forced upon
>>>>>>>> the input. It is part of the definition of 'halt decider'.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> There is no way to tell H(X,Y) the difference between the direct
>>>>>>> execution of X(Y) outside of H and the direct execution or
>>>>>>> simulation of X(Y) inside of H when all that you are allowed to
>>>>>>> provide to H is the machine code of X and its finite string Y.
>>>>>>
>>>>>> It doesn't *need* to be told this.
>>>>>>
>>>>>> Even if it were the case that there is some coherently statable
>>>>>> difference between X(Y) 'outside' of H and X(Y) 'inside' of H
>>>>>> (there is not), the problem *defines* which of these two the
>>>>>> machine is to provide an answer about. It must determine whether
>>>>>> the INDEPENDENT computation halts. So the halt decider *knows*
>>>>>> that it must answer about X(Y) 'outside' of H without being told
>>>>>> this.
>>>>
>>>> No response? Did you even read the above?
>>>>
>>>
>>> I went on to show that these two machines cannot possbly be input to
>>> one halt decider, you have to have two halt deciders, H1 and H.
>>
>> A universal halt decider is a *single* machine which answers the
>> halting question for *any* possible computation. What you claim above
>> is equivalent to claiming that such a universal halt decider is not
>> possible. A fact that everyone else already knows.
>>
>
> I had a good reply the I erased to focus on the one key point below:
>
>>>>>> But let's consider things beyond that. You are effectively stating
>>>>>> that X(Y) 'inside of H' and X(Y) 'outside of H' are two distinct
>>>>>> computations. Let's imagine hypothetically that that were true (it
>>>>>> isn't).
>>>>>>
>>>>>> The halting function is a mathematical mapping from the set of ALL
>>>>>> POSSIBLE computations to either 'halts' or 'does not halt'.
>>>>>>
>>>>>
>>>>> In the case of H(X,Y) it is only a mapping fro a unique pair of
>>>>> finite strings to an accept  or reject state.
>>>>
>>>> I said halting FUNCTION, not halt decider. Do you grasp the difference?
>>>>
>>>
>>> A decider is mathematical function that maps finite strings to accept
>>> and reject states. A halt decider must first be a decdier.
>>
>> A halt decider is *not* a mathematical function. It is a Turing Machine.
>>
>> The halting FUNCTION is a mathematical function.
>>
>> A mathematical function is simply a mapping. In the case of the
>> halting function it maps the set of all possible computations to
>> either 'halts' or 'doesn't halt'.
>>
>> A Turing Machine is something which *computes* a mathematical
>> function. That is, it takes as its input some element of the domain
>> (or some appropriate representation thereof) as an input and,
>> following some set of mechanical steps, determines what that element
>> is mapped to by the function being computed.
>>
>
> A decider maps input strings to final states.
>
>> Crucially, the halting function exists *independently* and *prior* to
>
> You don't realize it but you are asking a decider to make its decision
> on the basis of a string that cannot possibly exist in its domain.

Why do you say this. H is supposed to be a Halt Decider. The domain of a
Halt Decider is ALL Computations (via their representations) or
alternativly, ALL Turing Machines (via their representation) + the input
that will be provided to that Turing Machine.

If H can not accept as its input the P derived from it as outside of its
domain, then H starts off having failed the test.

>
> int H(ptr x, ptr y) { x(y);    }
> int P(ptr x)        { H(x, x); }
> int H(ptr x, ptr y) { x(y);    }
>
> The input to H requires that P call this very same H.
> The input to H1 has no such pathological relationship to P.
>
> By simply ignoring the pathological relationship between H and P you are
> answering the wrong question.

But you aren't ALLOWED to ignore the 'pathological' relationship, it is
VALID.

>
> You are asking the question what would the behavior of P be if P called
> H1 instead of calling H?

P needs to ALWAYS be the P that is derived for the currently define H.

H needs to get right the question H(P,P) for ITS P.

It doesn't, so it fails. PERIOD.

>
>> any Turing Machine which attempts to compute this function. The
>> halting function is *not* associated with any sort of algorithm; it is
>> simply a mapping. In other words it is simply a denumerably infinite
>> list of all possible computations and their halting status expressed
>> as ordered pairs.
>>
>> The computation P(P) will occur in this list exactly once, as will be
>> true for all other computation. Since your P(P) halts, it will map to
>> 'halts'.
>>
>> A halt decider, given <P> <P> as its input, is tasked with determining
>> what the entry for that computation in the list described above
>> actually is in a finite number of steps. If <P> <P> maps to 'halts' in
>> the halting function, then a halt decider must accept it. If it maps
>> to 'doesn't halt', it must reject it.
>>
>> That means that the halting value of P(P) is *not* specific to a given
>> halt decider. Your H and H1 must both provide the same answer if they
>> are both halt deciders. It means that it is non-sensical to talk about
>> the halting value of P(P) 'inside' some H, since H's job is to
>> determine what value this computation maps to in the halting FUNCTION
>> which is independent of any halt decider.
>>
>> André
>>
>
>

Re: Concise refutation of halting problem proofs V27 [ input is not in domain ]

<snkcf3$kb7$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23940&group=comp.theory#23940

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V27 [ input is not
in domain ]
Date: Tue, 23 Nov 2021 20:44:33 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 50
Message-ID: <snkcf3$kb7$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<snh8d4$4t1$1@dont-email.me> <xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhes8$c1c$1@dont-email.me> <LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhh1j$nre$1@dont-email.me> <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
<snhq6t$9bg$1@dont-email.me> <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<sni0pq$54o$1@dont-email.me> <ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>
<snj6bs$utp$1@dont-email.me> <lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>
<snjas5$22o$1@dont-email.me> <WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>
<snjlc9$g4m$1@dont-email.me> <8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>
<snjqvs$lp6$1@dont-email.me> <7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>
<snk1n5$t3o$1@dont-email.me> <6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>
<snk4rc$cuu$1@dont-email.me> <k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com>
<snk7kc$pr8$1@dont-email.me> <bt6dncqPsKYYLQD8nZ2dnUU7-afNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 24 Nov 2021 03:44:35 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="84791843d7ed22a0a2f82336688b7cbe";
logging-data="20839"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/8hgPeZW74o7pLAjfol6Yt"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:MN29g2sQvxZEK2ieXRuFLItI0jc=
In-Reply-To: <bt6dncqPsKYYLQD8nZ2dnUU7-afNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Wed, 24 Nov 2021 03:44 UTC

On 2021-11-23 20:24, olcott wrote:
> On 11/23/2021 8:22 PM, André G. Isaak wrote:
>> On 2021-11-23 18:53, olcott wrote:
>>> On 11/23/2021 7:34 PM, André G. Isaak wrote:
>
>> Crucially, the halting function exists *independently* and *prior* to
>> any Turing Machine which attempts to compute this function. The
>> halting function is *not* associated with any sort of algorithm; it is
>> simply a mapping. In other words it is simply a denumerably infinite
>> list of all possible computations and their halting status expressed
>> as ordered pairs.
>>
>
>
> You don't realize it but you are asking a decider to make its decision
> on the basis of a hypothetical string that does not actually exist.

???

So now you claim the STRING <P> <P> can't exist? But at the same time
you claim that your H1 returns the correct answer for this allegedly
impossible string? How on earth does that work.

If P is a Turing Machine it can be described by a string. Therefore this
string exists.

The input to a turing machine, by definition, is a string, so the input
to P also exists as a string.

So how can the string <P> <P> not exist?

The question which a halt decider is supposed to answer exists entirely
independently of any halt decider. It's answer is also entirely
independent of any halt decider.

In the case of the input <P> <P>, the question which it must answer is
"Does P(P) halt?" Note that this question makes no mention of H, or of
H1 or of UTMs or anything else. It mentions only P(P). Sot the correct
answer will be concerned only with P(P).

P(P) halts.

And that's the answer a halt decider must return for the perfectly
possible string <P> <P>.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Concise refutation of halting problem proofs V27 [ input is not in domain ]

<AAinJ.7989$1d1.1903@fx99.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23941&group=comp.theory#23941

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx99.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ input is not
in domain ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<snh8d4$4t1$1@dont-email.me> <xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhes8$c1c$1@dont-email.me> <LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhh1j$nre$1@dont-email.me> <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
<snhq6t$9bg$1@dont-email.me> <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<sni0pq$54o$1@dont-email.me> <ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>
<snj6bs$utp$1@dont-email.me> <lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>
<snjas5$22o$1@dont-email.me> <WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>
<snjlc9$g4m$1@dont-email.me> <8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>
<snjqvs$lp6$1@dont-email.me> <7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>
<snk1n5$t3o$1@dont-email.me> <6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>
<snk4rc$cuu$1@dont-email.me> <k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com>
<snk7kc$pr8$1@dont-email.me> <bt6dncqPsKYYLQD8nZ2dnUU7-afNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <bt6dncqPsKYYLQD8nZ2dnUU7-afNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 86
Message-ID: <AAinJ.7989$1d1.1903@fx99.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, 23 Nov 2021 22:46:39 -0500
X-Received-Bytes: 4974
 by: Richard Damon - Wed, 24 Nov 2021 03:46 UTC

On 11/23/21 10:24 PM, olcott wrote:
> On 11/23/2021 8:22 PM, André G. Isaak wrote:
>> On 2021-11-23 18:53, olcott wrote:
>>> On 11/23/2021 7:34 PM, André G. Isaak wrote:
>
>> Crucially, the halting function exists *independently* and *prior* to
>> any Turing Machine which attempts to compute this function. The
>> halting function is *not* associated with any sort of algorithm; it is
>> simply a mapping. In other words it is simply a denumerably infinite
>> list of all possible computations and their halting status expressed
>> as ordered pairs.
>>
>
>
> You don't realize it but you are asking a decider to make its decision
> on the basis of a hypothetical string that does not actually exist.

The only way for the representation of P to not exist is for H to not exist.

Thank you for confirming that H does not exist.

>
> int  H(ptr x, ptr y) { x(y);    }
> int  P(ptr x)        { H(x, x); }
> int H1(ptr x, ptr y) { x(y);    }
>
> The input to H requires that P call this very same H.
> The input to H1 has no such pathological relationship to P.
>
> By simply ignoring the pathological relationship between H and P you are
> answering the wrong question.

But the 'pathological relationship' is perfectly valid.

ANY Turing Machine can have in its algorithm a copy of any other Turing
Machine. PERIOD.

>
> You are answering the question:
> What would the behavior of P be if P called H1 instead of calling H?

No, that is not what is being asked.

The question is, what would P(P) do if directly executed.

Since you claim that H(P,P) returns 0, so it is correct, then by simple
analysis P(P) will Halt. and H was wrong.

>
> That makes the "input" to H hypothetical rather than an actual string.
>

Whats hypothetical about that?

H is supposed to answer what will P(P) do.

The way you do that is provide H with a description of that computation,
which should be P,P (if not, YOU defined things wrong)

If H exists, P exists by simple construction, thus P(P) is NOT hypothetical.

LIE.

>> The computation P(P) will occur in this list exactly once, as will be
>> true for all other computation. Since your P(P) halts, it will map to
>> 'halts'.
>>
>> A halt decider, given <P> <P> as its input, is tasked with determining
>> what the entry for that computation in the list described above
>> actually is in a finite number of steps. If <P> <P> maps to 'halts' in
>> the halting function, then a halt decider must accept it. If it maps
>> to 'doesn't halt', it must reject it.
>>
>> That means that the halting value of P(P) is *not* specific to a given
>> halt decider. Your H and H1 must both provide the same answer if they
>> are both halt deciders. It means that it is non-sensical to talk about
>> the halting value of P(P) 'inside' some H, since H's job is to
>> determine what value this computation maps to in the halting FUNCTION
>> which is independent of any halt decider.
>>
>> André
>>
>
>

Re: Concise refutation of halting problem proofs V27 [ input is not in domain ]

<9LWdnRLm0vQeJAD8nZ2dnUU7-efNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23942&group=comp.theory#23942

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 22:03:15 -0600
Date: Tue, 23 Nov 2021 22:03:13 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ input is not
in domain ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<xdmdndTsRo2SrwH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhes8$c1c$1@dont-email.me>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com> <snjqvs$lp6$1@dont-email.me>
<7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com> <snk1n5$t3o$1@dont-email.me>
<6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com> <snk4rc$cuu$1@dont-email.me>
<k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com> <snk7kc$pr8$1@dont-email.me>
<bt6dncqPsKYYLQD8nZ2dnUU7-afNnZ2d@giganews.com> <snkcf3$kb7$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snkcf3$kb7$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <9LWdnRLm0vQeJAD8nZ2dnUU7-efNnZ2d@giganews.com>
Lines: 69
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-pViNodjKGOUfM4hCxdfuWwvFNVI+LDyBulanQiG1xu4Q59pZ9ZUo/5N18sBnGTKnSFxlaflZ5s4vVyF!UWHUcxxwv0Sd1p62sECYZomxNwkWuhVZnHRj7f4S2MfJPgc+5yUrzvFav+EJzKc8I0xWuYa9Q56X!0Q==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4513
 by: olcott - Wed, 24 Nov 2021 04:03 UTC

On 11/23/2021 9:44 PM, André G. Isaak wrote:
> On 2021-11-23 20:24, olcott wrote:
>> On 11/23/2021 8:22 PM, André G. Isaak wrote:
>>> On 2021-11-23 18:53, olcott wrote:
>>>> On 11/23/2021 7:34 PM, André G. Isaak wrote:
>>
>>> Crucially, the halting function exists *independently* and *prior* to
>>> any Turing Machine which attempts to compute this function. The
>>> halting function is *not* associated with any sort of algorithm; it
>>> is simply a mapping. In other words it is simply a denumerably
>>> infinite list of all possible computations and their halting status
>>> expressed as ordered pairs.
>>>
>>
>>
>> You don't realize it but you are asking a decider to make its decision
>> on the basis of a hypothetical string that does not actually exist.
>
> ???
>
> So now you claim the STRING <P> <P> can't exist? But at the same time
> you claim that your H1 returns the correct answer for this allegedly
> impossible string? How on earth does that work.
>

int H(ptr x, ptr y) { x(y); }
int H1(ptr x, ptr y) { x(y); }
int P(ptr x) { H(x, x); }
int P1(ptr x) { H1(x, x); }

For H(P,P) to report on the behavior its its input when run independently

H(P,P) must report as if its input was (P1,P1) or
H(P,P) must report as if it was H1(P,P)
both cases are a break from reality.

> If P is a Turing Machine it can be described by a string. Therefore this
> string exists.
>
> The input to a turing machine, by definition, is a string, so the input
> to P also exists as a string.
>
> So how can the string <P> <P> not exist?
>
> The question which a halt decider is supposed to answer exists entirely
> independently of any halt decider. It's answer is also entirely
> independent of any halt decider.
>
> In the case of the input <P> <P>, the question which it must answer is
> "Does P(P) halt?" Note that this question makes no mention of H, or of
> H1 or of UTMs or anything else. It mentions only P(P). Sot the correct
> answer will be concerned only with P(P).
>
> P(P) halts.
>
> And that's the answer a halt decider must return for the perfectly
> possible string <P> <P>.
>
> André
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

Re: Concise refutation of halting problem proofs V27 [ input is not in domain ]

<1ZinJ.7993$1d1.4714@fx99.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23943&group=comp.theory#23943

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx99.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ input is not
in domain ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<snhes8$c1c$1@dont-email.me> <LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhh1j$nre$1@dont-email.me> <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
<snhq6t$9bg$1@dont-email.me> <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<sni0pq$54o$1@dont-email.me> <ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>
<snj6bs$utp$1@dont-email.me> <lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>
<snjas5$22o$1@dont-email.me> <WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>
<snjlc9$g4m$1@dont-email.me> <8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>
<snjqvs$lp6$1@dont-email.me> <7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>
<snk1n5$t3o$1@dont-email.me> <6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>
<snk4rc$cuu$1@dont-email.me> <k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com>
<snk7kc$pr8$1@dont-email.me> <bt6dncqPsKYYLQD8nZ2dnUU7-afNnZ2d@giganews.com>
<snkcf3$kb7$1@dont-email.me> <9LWdnRLm0vQeJAD8nZ2dnUU7-efNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <9LWdnRLm0vQeJAD8nZ2dnUU7-efNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 101
Message-ID: <1ZinJ.7993$1d1.4714@fx99.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, 23 Nov 2021 23:12:45 -0500
X-Received-Bytes: 5479
 by: Richard Damon - Wed, 24 Nov 2021 04:12 UTC

On 11/23/21 11:03 PM, olcott wrote:
> On 11/23/2021 9:44 PM, André G. Isaak wrote:
>> On 2021-11-23 20:24, olcott wrote:
>>> On 11/23/2021 8:22 PM, André G. Isaak wrote:
>>>> On 2021-11-23 18:53, olcott wrote:
>>>>> On 11/23/2021 7:34 PM, André G. Isaak wrote:
>>>
>>>> Crucially, the halting function exists *independently* and *prior*
>>>> to any Turing Machine which attempts to compute this function. The
>>>> halting function is *not* associated with any sort of algorithm; it
>>>> is simply a mapping. In other words it is simply a denumerably
>>>> infinite list of all possible computations and their halting status
>>>> expressed as ordered pairs.
>>>>
>>>
>>>
>>> You don't realize it but you are asking a decider to make its
>>> decision on the basis of a hypothetical string that does not actually
>>> exist.
>>
>> ???
>>
>> So now you claim the STRING <P> <P> can't exist? But at the same time
>> you claim that your H1 returns the correct answer for this allegedly
>> impossible string? How on earth does that work.
>>
>
> int H(ptr x, ptr y) { x(y); }
> int H1(ptr x, ptr y) { x(y); }

Don't know why you keep repeating these codes, since this is NOT what H
or H1 that you talk about are built as. BOTH of these will fail to
answer for any of H(P,P), H1(P,P), H(P1,P1) or H1(P1,P1) as ALL of them
will go into the infinite recursion as none of these has the magic code
to abort the simulation/debug trace execution.

There presence here is really just to LIE.

> int P(ptr x) { H(x, x); }
> int P1(ptr x) { H1(x, x); }
>
> For H(P,P) to report on the behavior its its input when run independently
>
> H(P,P) must report as if its input was (P1,P1) or
> H(P,P) must report as if it was H1(P,P)
> both cases are a break from reality.

WHY?

H and H1 are supposedly Halt Deciders, so they are supposed to be able
to handle ANY Turing Machine as input.

If not, the FAIL to meet there requirements.

The fact that you find it impossible to meet the requirements is just
the proof that an accurate Halt Decider can not exist.

Your 'Pathological Self-Reference' is perfectly valid code for a Turing
Machine, as I said, ANY Turing Machine is allowed to include a copy of
the code for ANY other Turing machine inside itself.

Thus H, to be a correct decider, needs to be able to handle Turing
Machines that use copies of H.

Note also, that for H to be a decider, it must be a computation, so all
copies of it must return the same answer for the same inputs.

If you H can't handle this, you are just admitting that you have failed
to meet the requirements.

PERIOD.

>
>
>> If P is a Turing Machine it can be described by a string. Therefore
>> this string exists.
>>
>> The input to a turing machine, by definition, is a string, so the
>> input to P also exists as a string.
>>
>> So how can the string <P> <P> not exist?
>>
>> The question which a halt decider is supposed to answer exists
>> entirely independently of any halt decider. It's answer is also
>> entirely independent of any halt decider.
>>
>> In the case of the input <P> <P>, the question which it must answer is
>> "Does P(P) halt?" Note that this question makes no mention of H, or of
>> H1 or of UTMs or anything else. It mentions only P(P). Sot the correct
>> answer will be concerned only with P(P).
>>
>> P(P) halts.
>>
>> And that's the answer a halt decider must return for the perfectly
>> possible string <P> <P>.
>>
>> André
>>
>
>

Re: Concise refutation of halting problem proofs V27 [ input is not in domain ]

<snkef3$tik$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23944&group=comp.theory#23944

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs V27 [ input is not
in domain ]
Date: Tue, 23 Nov 2021 21:18:42 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 84
Message-ID: <snkef3$tik$1@dont-email.me>
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<snhes8$c1c$1@dont-email.me> <LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com>
<snhh1j$nre$1@dont-email.me> <V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com>
<snhq6t$9bg$1@dont-email.me> <ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com>
<sni0pq$54o$1@dont-email.me> <ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com>
<snj6bs$utp$1@dont-email.me> <lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com>
<snjas5$22o$1@dont-email.me> <WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com>
<snjlc9$g4m$1@dont-email.me> <8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com>
<snjqvs$lp6$1@dont-email.me> <7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com>
<snk1n5$t3o$1@dont-email.me> <6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com>
<snk4rc$cuu$1@dont-email.me> <k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com>
<snk7kc$pr8$1@dont-email.me> <bt6dncqPsKYYLQD8nZ2dnUU7-afNnZ2d@giganews.com>
<snkcf3$kb7$1@dont-email.me> <9LWdnRLm0vQeJAD8nZ2dnUU7-efNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 24 Nov 2021 04:18:44 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="84791843d7ed22a0a2f82336688b7cbe";
logging-data="30292"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+FMi4uNBDLqWH+IqK/gdu6"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:mYL1ecwQAlra5W3bQEqzEtthrFk=
In-Reply-To: <9LWdnRLm0vQeJAD8nZ2dnUU7-efNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Wed, 24 Nov 2021 04:18 UTC

On 2021-11-23 21:03, olcott wrote:
> On 11/23/2021 9:44 PM, André G. Isaak wrote:
>> On 2021-11-23 20:24, olcott wrote:
>>> On 11/23/2021 8:22 PM, André G. Isaak wrote:
>>>> On 2021-11-23 18:53, olcott wrote:
>>>>> On 11/23/2021 7:34 PM, André G. Isaak wrote:
>>>
>>>> Crucially, the halting function exists *independently* and *prior*
>>>> to any Turing Machine which attempts to compute this function. The
>>>> halting function is *not* associated with any sort of algorithm; it
>>>> is simply a mapping. In other words it is simply a denumerably
>>>> infinite list of all possible computations and their halting status
>>>> expressed as ordered pairs.
>>>>
>>>
>>>
>>> You don't realize it but you are asking a decider to make its
>>> decision on the basis of a hypothetical string that does not actually
>>> exist.
>>
>> ???
>>
>> So now you claim the STRING <P> <P> can't exist? But at the same time
>> you claim that your H1 returns the correct answer for this allegedly
>> impossible string? How on earth does that work.
>>
>
> int H(ptr x, ptr y) { x(y); }
> int H1(ptr x, ptr y) { x(y); }
> int P(ptr x) { H(x, x); }
> int P1(ptr x) { H1(x, x); }

What does any of this have to do with your ridiculous claim that the
string <P> <P> does not actually exist?

> For H(P,P) to report on the behavior its its input when run independently
>
> H(P,P) must report as if its input was (P1,P1) or

No. H(P, P) must report whether the independent computation P(P) halts
because that's the question a halt decider is required to answer. If it
cannot answer this, that doesn't change the question, nor does it
entitle the decider to 'change' its input. It just means it cannot
correctly answer the question.

> H(P,P) must report as if it was H1(P,P)

No. H(P, P) must report whether the independent computation P(P) halts
because that's the question a halt decider is required to answer. If it
cannot answer this, that doesn't change the question, nor does it
entitle the decider to magically 'change' to a different decider. It
just means it cannot correctly answer the question.

> both cases are a break from reality.

The question is what it is. By definition it is "Can P(P) halt?" For
which the answer is 'yes'. If a decider cannot correctly answer this,
then it cannot answer it, but that doesn't change the fact that this is
the question a halt decider is required to answer.

If it is not possible for a particular decider to even be ASKED this
question, then it obviously also cannot answer it, but again that does
not change the fact that this is the question a halt decider is required
to answer.

Some questions simply cannot be answered by a Turing Machine. Deal with
it. Not all functions are computable functions. Deal with it.

Your obsession with this one particular non-computable function is a bit
mysterious. It turns out that the overwhelming majority of functions are
not computable. In fact, the percentage of functions which *are*
computable is very close to 0%. By that I mean it is 0% rounded to as
many decimal places as you want or can imagine.

This is a simple consequence of the fact that the set of all possible
computations is denumerable whereas the set of all possible functions is
not.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Concise refutation of halting problem proofs V27 [ input is not in domain ]

<K7WdnUb8UoOATwD8nZ2dnUU7-RvNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=23945&group=comp.theory#23945

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 23 Nov 2021 23:48:13 -0600
Date: Tue, 23 Nov 2021 23:48:12 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.2
Subject: Re: Concise refutation of halting problem proofs V27 [ input is not
in domain ]
Content-Language: en-US
Newsgroups: comp.theory
References: <5-2dncs2MNPqYwb8nZ2dnUU7-KvNnZ2d@giganews.com>
<LZSdnSHg28173QH8nZ2dnUU7-dfNnZ2d@giganews.com> <snhh1j$nre$1@dont-email.me>
<V92dnfjztvyO-gH8nZ2dnUU7-enNnZ2d@giganews.com> <snhq6t$9bg$1@dont-email.me>
<ru6dnRcSxdCo4gH8nZ2dnUU7-f3NnZ2d@giganews.com> <sni0pq$54o$1@dont-email.me>
<ivSdnVvS3JNFnAD8nZ2dnUU7-W3NnZ2d@giganews.com> <snj6bs$utp$1@dont-email.me>
<lfSdnXZ8BOtOtAD8nZ2dnUU7-TPNnZ2d@giganews.com> <snjas5$22o$1@dont-email.me>
<WfidnVXHgel1rAD8nZ2dnUU7-K2dnZ2d@giganews.com> <snjlc9$g4m$1@dont-email.me>
<8-udnSXeWdV19gD8nZ2dnUU7-fHNnZ2d@giganews.com> <snjqvs$lp6$1@dont-email.me>
<7Y-dnTBnr7XbHgD8nZ2dnUU7-T2dnZ2d@giganews.com> <snk1n5$t3o$1@dont-email.me>
<6_SdnR5DMbtgEwD8nZ2dnUU7-ffNnZ2d@giganews.com> <snk4rc$cuu$1@dont-email.me>
<k6GdnTubureFBgD8nZ2dnUU7-KHNnZ2d@giganews.com> <snk7kc$pr8$1@dont-email.me>
<bt6dncqPsKYYLQD8nZ2dnUU7-afNnZ2d@giganews.com> <snkcf3$kb7$1@dont-email.me>
<9LWdnRLm0vQeJAD8nZ2dnUU7-efNnZ2d@giganews.com> <snkef3$tik$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <snkef3$tik$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <K7WdnUb8UoOATwD8nZ2dnUU7-RvNnZ2d@giganews.com>
Lines: 107
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-4oRrJ/YWAhsYT20WZUSspbaxI/9amc2TmVqEhVCbcT8i/56SUysfCrrWBlFGPs99Lr5k3XRPmkGWB+U!BjNvStga/rKM0ZuuKPf6G9mXsSlrFcyQ2sqF+dfC+4zm9tPixzEcziv/vzOWTyNzZB2qekKyp+i1!ig==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6373
 by: olcott - Wed, 24 Nov 2021 05:48 UTC

On 11/23/2021 10:18 PM, André G. Isaak wrote:
> On 2021-11-23 21:03, olcott wrote:
>> On 11/23/2021 9:44 PM, André G. Isaak wrote:
>>> On 2021-11-23 20:24, olcott wrote:
>>>> On 11/23/2021 8:22 PM, André G. Isaak wrote:
>>>>> On 2021-11-23 18:53, olcott wrote:
>>>>>> On 11/23/2021 7:34 PM, André G. Isaak wrote:
>>>>
>>>>> Crucially, the halting function exists *independently* and *prior*
>>>>> to any Turing Machine which attempts to compute this function. The
>>>>> halting function is *not* associated with any sort of algorithm; it
>>>>> is simply a mapping. In other words it is simply a denumerably
>>>>> infinite list of all possible computations and their halting status
>>>>> expressed as ordered pairs.
>>>>>
>>>>
>>>>
>>>> You don't realize it but you are asking a decider to make its
>>>> decision on the basis of a hypothetical string that does not
>>>> actually exist.
>>>
>>> ???
>>>
>>> So now you claim the STRING <P> <P> can't exist? But at the same time
>>> you claim that your H1 returns the correct answer for this allegedly
>>> impossible string? How on earth does that work.
>>>
>>
>> int H(ptr x, ptr y) { x(y); }
>> int H1(ptr x, ptr y) { x(y);
>> int P(ptr x) { H(x, x); }
>> int P1(ptr x) { H1(x, x); }
>
>
> What does any of this have to do with your ridiculous claim that the
> string <P> <P> does not actually exist?

If you want the actual behavior of P(P) run independently
then you have to change P or H into something that they are not
because they are defined with hardwired inter-dependency.

You can imagine a P that does not call H(P1,P1)
That is not the actual P it is only imaginary.

or you could imaging an H1(P,P) that is not called by P
That is not the actual H it is only imaginary.

When we take the actual H and the actual P then H(P,P)
Then the real interdependencies change the behavior from what is expected.

>> For H(P,P) to report on the behavior its its input when run independently
>>
>> H(P,P) must report as if its input was (P1,P1) or
>
> No. H(P, P) must report whether the independent computation P(P) halts
> because that's the question a halt decider is required to answer. If it
> cannot answer this, that doesn't change the question, nor does it
> entitle the decider to 'change' its input. It just means it cannot
> correctly answer the question.
>
>> H(P,P) must report as if it was H1(P,P)
>
> No. H(P, P) must report whether the independent computation P(P) halts
> because that's the question a halt decider is required to answer. If it
> cannot answer this, that doesn't change the question, nor does it
> entitle the decider to magically 'change' to a different decider. It
> just means it cannot correctly answer the question.
>
>> both cases are a break from reality.
>
> The question is what it is. By definition it is "Can P(P) halt?" For
> which the answer is 'yes'. If a decider cannot correctly answer this,
> then it cannot answer it, but that doesn't change the fact that this is
> the question a halt decider is required to answer.
>
> If it is not possible for a particular decider to even be ASKED this
> question, then it obviously also cannot answer it, but again that does
> not change the fact that this is the question a halt decider is required
> to answer.
>
> Some questions simply cannot be answered by a Turing Machine. Deal with
> it. Not all functions are computable functions. Deal with it.
>
> Your obsession with this one particular non-computable function is a bit
> mysterious. It turns out that the overwhelming majority of functions are
> not computable. In fact, the percentage of functions which *are*
> computable is very close to 0%. By that I mean it is 0% rounded to as
> many decimal places as you want or can imagine.
>
> This is a simple consequence of the fact that the set of all possible
> computations is denumerable whereas the set of all possible functions is
> not.
>
> André
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

Pages:1234
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor