Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

"Pascal is Pascal is Pascal is dog meat." -- M. Devine and P. Larson, Computer Science 340


devel / comp.theory / Re: Concise refutation of halting problem proofs

SubjectAuthor
* Concise refutation of halting problem proofsolcott
+* Concise refutation of halting problem proofsBen Bacarisse
|`* Concise refutation of halting problem proofsolcott
| `* Concise refutation of halting problem proofsBen Bacarisse
|  `* Concise refutation of halting problem proofsolcott
|   +- Concise refutation of halting problem proofsRichard Damon
|   `* Concise refutation of halting problem proofsBen Bacarisse
|    `* Concise refutation of halting problem proofsolcott
|     +* Concise refutation of halting problem proofsBen Bacarisse
|     |`* Concise refutation of halting problem proofs [ Richard seems toolcott
|     | +* Concise refutation of halting problem proofs [ Richard seems toRichard Damon
|     | |`* Concise refutation of halting problem proofs [ Richard seems toolcott
|     | | `- Concise refutation of halting problem proofs [ Richard seems toRichard Damon
|     | `* Concise refutation of halting problem proofs [ Richard seems to understand this Ben Bacarisse
|     |  `* Concise refutation of halting problem proofs [ Richard seems toolcott
|     |   +- Concise refutation of halting problem proofs [ Richard seems toRichard Damon
|     |   +* Concise refutation of halting problem proofs [ Richard seems toAndré G. Isaak
|     |   |`* Concise refutation of halting problem proofs [ Richard seems toolcott
|     |   | `- Concise refutation of halting problem proofs [ Richard seems toRichard Damon
|     |   `- Concise refutation of halting problem proofs [ Richard seems to understand this Ben Bacarisse
|     `- Concise refutation of halting problem proofsRichard Damon
+* Concise refutation of halting problem proofsAndré G. Isaak
|+* Concise refutation of halting problem proofsMalcolm McLean
||+* Concise refutation of halting problem proofsBen Bacarisse
|||+* Concise refutation of halting problem proofsolcott
||||+* Concise refutation of halting problem proofsAndré G. Isaak
|||||`* Concise refutation of halting problem proofsolcott
||||| `* Concise refutation of halting problem proofsAndré G. Isaak
|||||  `* Concise refutation of halting problem proofsolcott
|||||   +* Concise refutation of halting problem proofsAndré G. Isaak
|||||   |`* Concise refutation of halting problem proofs [ focus on one pointolcott
|||||   | +* Concise refutation of halting problem proofs [ focus on one pointRichard Damon
|||||   | |`* Concise refutation of halting problem proofs [ focus on one pointolcott
|||||   | | `- Concise refutation of halting problem proofs [ focus on one pointRichard Damon
|||||   | `* Concise refutation of halting problem proofs [ focus on one pointAndré G. Isaak
|||||   |  `* Concise refutation of halting problem proofs [ focus on one pointolcott
|||||   |   +* Concise refutation of halting problem proofs [ focus on one pointAndré G. Isaak
|||||   |   |`* Concise refutation of halting problem proofs [ focus on one pointolcott
|||||   |   | +* Concise refutation of halting problem proofs [ focus on one pointAndré G. Isaak
|||||   |   | |`* Concise refutation of halting problem proofs [ focus on one pointolcott
|||||   |   | | `* Concise refutation of halting problem proofs [ focus on one pointAndré G. Isaak
|||||   |   | |  `* Concise refutation of halting problem proofs [ focus on one pointolcott
|||||   |   | |   `- Concise refutation of halting problem proofs [ focus on one point ]Richard Damon
|||||   |   | `- Concise refutation of halting problem proofs [ focus on one pointRichard Damon
|||||   |   `* Concise refutation of halting problem proofs [ focus on one pointRichard Damon
|||||   |    `* Concise refutation of halting problem proofs [ pure simulation ]olcott
|||||   |     `* Concise refutation of halting problem proofs [ pure simulation ]Richard Damon
|||||   |      `* Concise refutation of halting problem proofs [ pure simulation ]olcott
|||||   |       `* Concise refutation of halting problem proofs [ pure simulation ]Richard Damon
|||||   |        `* Concise refutation of halting problem proofs [ pure simulation ]olcott
|||||   |         `- Concise refutation of halting problem proofs [ pure simulation ]Richard Damon
|||||   `- Concise refutation of halting problem proofsRichard Damon
||||+- Concise refutation of halting problem proofsBen Bacarisse
||||`- Concise refutation of halting problem proofsRichard Damon
|||`* Concise refutation of halting problem proofsMalcolm McLean
||| +* Concise refutation of halting problem proofsolcott
||| |`- Concise refutation of halting problem proofsRichard Damon
||| `* Concise refutation of halting problem proofsBen Bacarisse
|||  `* Concise refutation of halting problem proofsolcott
|||   +- Concise refutation of halting problem proofsRichard Damon
|||   +* Concise refutation of halting problem proofsBen Bacarisse
|||   |`* Concise refutation of halting problem proofsolcott
|||   | +* Concise refutation of halting problem proofsMalcolm McLean
|||   | |+* Concise refutation of halting problem proofsolcott
|||   | ||`- Concise refutation of halting problem proofsRichard Damon
|||   | |`* Concise refutation of halting problem proofsBen Bacarisse
|||   | | `* Concise refutation of halting problem proofsolcott
|||   | |  `- Concise refutation of halting problem proofsRichard Damon
|||   | `* Concise refutation of halting problem proofsBen Bacarisse
|||   |  `* Concise refutation of halting problem proofsolcott
|||   |   +- Concise refutation of halting problem proofsRichard Damon
|||   |   `* Concise refutation of halting problem proofsBen Bacarisse
|||   |    `* Concise refutation of halting problem proofsolcott
|||   |     +- Concise refutation of halting problem proofsRichard Damon
|||   |     `- Concise refutation of halting problem proofsBen Bacarisse
|||   `- Concise refutation of halting problem proofsRichard Damon
||`* Concise refutation of halting problem proofsolcott
|| +* Concise refutation of halting problem proofsAndré G. Isaak
|| |`* Concise refutation of halting problem proofs [ ta-da ? ]olcott
|| | `* Concise refutation of halting problem proofs [ ta-da ? ]André G. Isaak
|| |  `- Concise refutation of halting problem proofs [ ta-da ? ]olcott
|| `- Concise refutation of halting problem proofsRichard Damon
|`* Concise refutation of halting problem proofsolcott
| `- Concise refutation of halting problem proofsAndré G. Isaak
`* Concise refutation of halting problem proofsRichard Damon
 `* Concise refutation of halting problem proofsolcott
  `- Concise refutation of halting problem proofsRichard Damon

Pages:1234
Concise refutation of halting problem proofs

<vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic alt.philosophy
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: Thu, 04 Nov 2021 10:47:54 -0500
Date: Thu, 4 Nov 2021 10:47:53 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,alt.philosophy
Content-Language: en-US
From: NoO...@NoWhere.com (olcott)
Subject: Concise refutation of halting problem proofs
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
Lines: 90
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-So6t1+3EJ5nw8MT0chGGT3CLHwCakhFv2ZpxQX2F7c2joxlILSiMHBlnaO6YwS2pu2ZjydL6XvtyeP7!LGJ4GJ3+ilX+iJBuxVu+L9+jRHV0FS+1HeBzp+A+ZCvYJbxqPipLDsmqaXnBEgROeTZDwrRS/G6k!Hw==
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: 4951
 by: olcott - Thu, 4 Nov 2021 15:47 UTC

This tiny little proof totally proves that the counter-examples of all
of the conventional halting problem proofs do not prove that the halting
problem cannot be solved.

This is the simplest example of the classic halting problem input that
"proves" that the halting problem cannot be solved.
https://en.wikipedia.org/wiki/Halting_problem

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
  if (H(x, x))
    HERE: goto HERE;
}

This is the assembly language of the above function after it has been
translated by the Microsoft C compiler.

_P()
[00000c36](01)  55          push ebp
[00000c37](02)  8bec        mov ebp,esp
[00000c39](03)  8b4508      mov eax,[ebp+08] // 2nd Param
[00000c3c](01)  50          push eax
[00000c3d](03)  8b4d08      mov ecx,[ebp+08] // 1st Param
[00000c40](01)  51          push ecx
[00000c41](05)  e820fdffff  call 00000966    // call H
[00000c46](03)  83c408      add esp,+08
[00000c49](02)  85c0        test eax,eax
[00000c4b](02)  7402        jz 00000c4f
[00000c4d](02)  ebfe        jmp 00000c4d
[00000c4f](01)  5d          pop ebp
[00000c50](01)  c3          ret
Size in bytes:(0027) [00000c50]

Begin Local Halt Decider Simulation at Machine Address:c36

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  =========  =============
[00000c36][002117ca][002117ce] 55          push ebp
[00000c37][002117ca][002117ce] 8bec        mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508      mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50          push eax       // push P
[00000c3d][002117c6][00000c36] 8b4d08      mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51          push ecx       // push P
[00000c41][002117be][00000c46] e820fdffff  call 00000966  // call H(P,P)

[00000c36][0025c1f2][0025c1f6] 55          push ebp
[00000c37][0025c1f2][0025c1f6] 8bec        mov ebp,esp
[00000c39][0025c1f2][0025c1f6] 8b4508      mov eax,[ebp+08]
[00000c3c][0025c1ee][00000c36] 50          push eax       // push P
[00000c3d][0025c1ee][00000c36] 8b4d08      mov ecx,[ebp+08]
[00000c40][0025c1ea][00000c36] 51          push ecx       // push P
[00000c41][0025c1e6][00000c46] e820fdffff  call 00000966  // call H(P,P)

Verified facts:
(1) The above 14 simulated lines are a correct pure simulation of the
input to H(P,P) for every possible encoding of simulating halt decider H.

(2) The above 14 simulated lines conclusively prove that the pure
simulation of the input to H(P,P) would never reach its final state of
c50 for every possible encoding of simulating halt decider H.

(1) and (2) conclusively prove that H(P,P) meets this criteria:

2021-11-03 Halt Deciding Criteria
It is impossible for any halt decider to be incorrect when the correct
pure simulation of its input never halts and it reports not halting.

Strachey, C 1965.  An impossible program The Computer Journal, Volume 7,
Issue 4, January 1965, Page 313, https://doi.org/10.1093/comjnl/7.4.313

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (318-320)

Halting problem undecidability and infinitely nested simulation
May 2021 PL Olcott

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Concise refutation of halting problem proofs

<87y263deg7.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs
Followup-To: comp.theory
Date: Thu, 04 Nov 2021 17:21:28 +0000
Organization: A noiseless patient Spider
Lines: 25
Message-ID: <87y263deg7.fsf@bsb.me.uk>
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain
Injection-Info: reader02.eternal-september.org; posting-host="8061128906792ee25c1ae701cf55af45";
logging-data="4042"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18/AQwbXsn22IIgu9PQjM3D57vOQvV3wJA="
Cancel-Lock: sha1:YoiPevyfte++YIrgeYA7ddNiHtk=
sha1:YuGioS8L55QPQYNzSqiFRLh9BzE=
X-BSB-Auth: 1.676c7c24d188dc9692b1.20211104172128GMT.87y263deg7.fsf@bsb.me.uk
 by: Ben Bacarisse - Thu, 4 Nov 2021 17:21 UTC

olcott <NoOne@NoWhere.com> writes:

> (1) and (2) conclusively prove that H(P,P) meets this criteria:

The singular is "criterion".

> 2021-11-03 Halt Deciding Criteria
> It is impossible for any halt decider to be incorrect when the correct
> pure simulation of its input never halts and it reports not halting.

Unfortunately H(P,P) does not meet the criterion for being correct about
the computation represented by it's arguments. H(P,P) == 0 when P(P)
halts is wrong:

Actual Halting Problem Criterion:
H(M,I) == true is only correct if M(I) halts, and H(M,I) == false is
only correct is M(I) does not halt.

You know this. After 14 years you know that "no" is not the right
answer for a halting instance of the problem.

Starting new threads every day won't make anyone forget this.

--
Ben.

Re: Concise refutation of halting problem proofs

<sm1608$kn8$1@dont-email.me>

 copy mid

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

 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
Date: Thu, 4 Nov 2021 11:41:27 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 102
Message-ID: <sm1608$kn8$1@dont-email.me>
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 4 Nov 2021 17:41:29 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="50cecaea6c75ed7a20dc4a51e1674129";
logging-data="21224"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+ugU702WoTkllrsftuUGgM"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:Xc51TZR97oKjTRMq5YZicN2hcPI=
In-Reply-To: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Thu, 4 Nov 2021 17:41 UTC

On 2021-11-04 09:47, olcott wrote:
> This tiny little proof totally proves that the counter-examples of all
> of the conventional halting problem proofs do not prove that the halting
> problem cannot be solved.
>
> This is the simplest example of the classic halting problem input that
> "proves" that the halting problem cannot be solved.
> https://en.wikipedia.org/wiki/Halting_problem
>
> // Simplified Linz Ĥ (Linz:1990:319)
>  // Strachey(1965) CPL translated to C
>  void P(u32 x)
>  {
>   if (H(x, x))
>     HERE: goto HERE;
>  }
>
> This is the assembly language of the above function after it has been
> translated by the Microsoft C compiler.
>
> _P()
>  [00000c36](01)  55          push ebp
>  [00000c37](02)  8bec        mov ebp,esp
>  [00000c39](03)  8b4508      mov eax,[ebp+08] // 2nd Param
>  [00000c3c](01)  50          push eax
>  [00000c3d](03)  8b4d08      mov ecx,[ebp+08] // 1st Param
>  [00000c40](01)  51          push ecx
>  [00000c41](05)  e820fdffff  call 00000966    // call H
>  [00000c46](03)  83c408      add esp,+08
>  [00000c49](02)  85c0        test eax,eax
>  [00000c4b](02)  7402        jz 00000c4f
>  [00000c4d](02)  ebfe        jmp 00000c4d
>  [00000c4f](01)  5d          pop ebp
>  [00000c50](01)  c3          ret
>  Size in bytes:(0027) [00000c50]
>
> Begin Local Halt Decider Simulation at Machine Address:c36
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
>  [00000c36][002117ca][002117ce] 55          push ebp
>  [00000c37][002117ca][002117ce] 8bec        mov ebp,esp
>  [00000c39][002117ca][002117ce] 8b4508      mov eax,[ebp+08]
>  [00000c3c][002117c6][00000c36] 50          push eax       // push P
>  [00000c3d][002117c6][00000c36] 8b4d08      mov ecx,[ebp+08]
>  [00000c40][002117c2][00000c36] 51          push ecx       // push P
>  [00000c41][002117be][00000c46] e820fdffff  call 00000966  // call H(P,P)
>
> [00000c36][0025c1f2][0025c1f6] 55          push ebp
>  [00000c37][0025c1f2][0025c1f6] 8bec        mov ebp,esp
>  [00000c39][0025c1f2][0025c1f6] 8b4508      mov eax,[ebp+08]
>  [00000c3c][0025c1ee][00000c36] 50          push eax       // push P
>  [00000c3d][0025c1ee][00000c36] 8b4d08      mov ecx,[ebp+08]
>  [00000c40][0025c1ea][00000c36] 51          push ecx       // push P
>  [00000c41][0025c1e6][00000c46] e820fdffff  call 00000966  // call H(P,P)
>
> Verified facts:

Verified by whom? Verified how?

> (1) The above 14 simulated lines are a correct pure simulation of the
> input to H(P,P) for every possible encoding of simulating halt decider H.

What exactly does 'every possible encoding of simulating halt decider H'
even mean?

> (2) The above 14 simulated lines conclusively prove that the pure

They conclusively prove this how? Just stating that something
'conclusively proves' something isn't a proof. You need to actually show
a proof.

> simulation of the input to H(P,P) would never reach its final state of
> c50 for every possible encoding of simulating halt decider H.

> (1) and (2) conclusively prove that H(P,P) meets this criteria:
> 2021-11-03 Halt Deciding Criteria
> It is impossible for any halt decider to be incorrect when the correct
> pure simulation of its input never halts and it reports not halting.

That's not a criterion. Its a statement. How does something meet a
statement?

You said you were going to offer a 'tiny little proof' but I see nothing
resembling a proof here. So where is your tiny little proof?

************************************************************************
More importantly, how do you reconcile your claim that H(P, P) == 0 with
the fact that P(P) halts? YOU NEED TO ADDRESS THIS POINT.
************************************************************************

I could adopt your approach of repeating the above line a bazillion
times, but I can't bring myself to be that juvenile, so I've added some
asterisks to highlight this point since it is the crucial objection that
you keep ignoring.

André

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

Re: Concise refutation of halting problem proofs

<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:622a:4cf:: with SMTP id q15mr56875580qtx.265.1636056561159;
Thu, 04 Nov 2021 13:09:21 -0700 (PDT)
X-Received: by 2002:a25:b317:: with SMTP id l23mr15734729ybj.338.1636056560888;
Thu, 04 Nov 2021 13:09:20 -0700 (PDT)
Path: i2pn2.org!i2pn.org!aioe.org!news.mixmin.net!proxad.net!feeder1-2.proxad.net!209.85.160.216.MISMATCH!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Thu, 4 Nov 2021 13:09:20 -0700 (PDT)
In-Reply-To: <sm1608$kn8$1@dont-email.me>
Injection-Info: google-groups.googlegroups.com; posting-host=2a00:23a8:400a:5601:20cf:f0d0:8e96:ce5b;
posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 2a00:23a8:400a:5601:20cf:f0d0:8e96:ce5b
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com> <sm1608$kn8$1@dont-email.me>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
Subject: Re: Concise refutation of halting problem proofs
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Thu, 04 Nov 2021 20:09:21 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
 by: Malcolm McLean - Thu, 4 Nov 2021 20:09 UTC

On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>
> > (1) The above 14 simulated lines are a correct pure simulation of the
> > input to H(P,P) for every possible encoding of simulating halt decider H.
> What exactly does 'every possible encoding of simulating halt decider H'
> even mean?
>
You need to understand the PO is working with x86 code, not Turing machines..
So P does not contain an embedded near copy of H, as in Linz's scheme,
but a call to H.
Now at first sight, that doesn't matter. But it allows for a mental separation
between "the input" (the simple little driver which calls H and inverts behaviour
when it gets the result) and H itself (the halt decider).
If we replace the call to H by a call to another simulating halt decider, have
we changed anything now?

Re: Concise refutation of halting problem proofs

<87k0hnd3nv.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs
Date: Thu, 04 Nov 2021 21:14:28 +0000
Organization: A noiseless patient Spider
Lines: 32
Message-ID: <87k0hnd3nv.fsf@bsb.me.uk>
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=iso-8859-1
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="8061128906792ee25c1ae701cf55af45";
logging-data="8631"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18y9z5W6ZgbLkdtPJ1dAeXWtANGnp6f4Rc="
Cancel-Lock: sha1:INIlcRYBvGncr4Eid4WmLR7Blt0=
sha1:JRXZzcsshkbg5hg4kzag/Chvgjc=
X-BSB-Auth: 1.5e5e61de6fe54bcd03e5.20211104211428GMT.87k0hnd3nv.fsf@bsb.me.uk
 by: Ben Bacarisse - Thu, 4 Nov 2021 21:14 UTC

Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:

> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>
>> > (1) The above 14 simulated lines are a correct pure simulation of the
>> > input to H(P,P) for every possible encoding of simulating halt decider H.
>>
>> What exactly does 'every possible encoding of simulating halt decider H'
>> even mean?
>>
> You need to understand the PO is working with x86 code, not Turing
> machines.

Not always. He's also posted a lot of incorrect things about TMs.

> So P does not contain an embedded near copy of H, as in Linz's scheme,
> but a call to H. Now at first sight, that doesn't matter. But it
> allows for a mental separation between "the input" (the simple little
> driver which calls H and inverts behaviour when it gets the result)
> and H itself (the halt decider).

How does this mental separation help PO ignore the fact that H gets the
answer wrong? How do you excuse his simply ignoring the plain fact that
H(P,P) == false is the wrong answer? I ask /you/, specifically, because
you seem to be kindly disposed towards PO, and I can't work it out at
all. He can't not know that an H that gives the wrong answer is utterly
trivial. He must know, that we know, that this can't be the miraculous
impossible TM he claimed to have tree years ago. I just can't find any
flattering spin to put on it.

--
Ben.

Re: Concise refutation of halting problem proofs

<jLSdnS1o5tcA0xn8nZ2dnUU7-XXNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory sci.logic
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: Thu, 04 Nov 2021 16:20:29 -0500
Date: Thu, 4 Nov 2021 16:20:28 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: Concise refutation of halting problem proofs
Content-Language: en-US
Newsgroups: comp.theory,sci.logic
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <jLSdnS1o5tcA0xn8nZ2dnUU7-XXNnZ2d@giganews.com>
Lines: 28
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-LBBMRoZB2r2wMUE3Lmi0RL6sFKgG8yHpcyUUKzJHVMYxQzpGVHZZLmrw4OtP3NrZbRQBv++D/jufE8w!2LOywQtPh9BwNUg4BuD+pBncnmcUBpkARiBdbDXMyq0Stj8pdQo7yPsq0osN9bLp+xQ9kpumZrpw!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: 2506
 by: olcott - Thu, 4 Nov 2021 21:20 UTC

On 11/4/2021 3:09 PM, Malcolm McLean wrote:
> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>
>>> (1) The above 14 simulated lines are a correct pure simulation of the
>>> input to H(P,P) for every possible encoding of simulating halt decider H.
>> What exactly does 'every possible encoding of simulating halt decider H'
>> even mean?
>>
> You need to understand the PO is working with x86 code, not Turing machines.
> So P does not contain an embedded near copy of H, as in Linz's scheme,
> but a call to H.
> Now at first sight, that doesn't matter. But it allows for a mental separation
> between "the input" (the simple little driver which calls H and inverts behaviour
> when it gets the result) and H itself (the halt decider).
> If we replace the call to H by a call to another simulating halt decider, have
> we changed anything now?
>

I think that you have this correctly.

My current proof applies to every possible encoding of H thus
eliminating any need to see the encoding of any specific H.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Concise refutation of halting problem proofs

<sm1j1f$i2g$1@dont-email.me>

 copy mid

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

 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
Date: Thu, 4 Nov 2021 15:23:59 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 36
Message-ID: <sm1j1f$i2g$1@dont-email.me>
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<jLSdnS1o5tcA0xn8nZ2dnUU7-XXNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 4 Nov 2021 21:24:00 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="50cecaea6c75ed7a20dc4a51e1674129";
logging-data="18512"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19LR/za78GBZuQucdBYWb8Y"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:QSV26Ub2y171g5QsDVOTV7GlYLY=
In-Reply-To: <jLSdnS1o5tcA0xn8nZ2dnUU7-XXNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Thu, 4 Nov 2021 21:23 UTC

On 2021-11-04 15:20, olcott wrote:
> On 11/4/2021 3:09 PM, Malcolm McLean wrote:
>> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>>
>>>> (1) The above 14 simulated lines are a correct pure simulation of the
>>>> input to H(P,P) for every possible encoding of simulating halt
>>>> decider H.
>>> What exactly does 'every possible encoding of simulating halt decider H'
>>> even mean?
>>>
>> You need to understand the PO is working with x86 code, not Turing
>> machines.
>> So P does not contain an embedded near copy of H, as in Linz's scheme,
>> but a call to H.
>> Now at first sight, that doesn't matter. But it allows for a mental
>> separation
>> between "the input" (the simple little driver which calls H and
>> inverts behaviour
>> when it gets the result)  and H itself (the halt decider).
>> If we replace the call to H by a call to another simulating halt
>> decider, have
>> we changed anything now?
>>
>
> I think that you have this correctly.
>
> My current proof applies to every possible encoding of H thus
> eliminating any need to see the encoding of any specific H.

Again, I ask, what do you mean by an 'encoding of H'?

André

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

Re: Concise refutation of halting problem proofs

<dNidnZrKUJ4byhn8nZ2dnUU7-LfNnZ2d@giganews.com>

 copy mid

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

 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: Thu, 04 Nov 2021 16:58:30 -0500
Date: Thu, 4 Nov 2021 16:58:29 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: Concise refutation of halting problem proofs
Content-Language: en-US
Newsgroups: comp.theory
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<87y263deg7.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87y263deg7.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <dNidnZrKUJ4byhn8nZ2dnUU7-LfNnZ2d@giganews.com>
Lines: 45
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-rYzGInuoEnIYJt8LWTjZ6bd5PODQ1f01ISqK8ZEg8XQkTyLjbX6gO6wOy/KxziB8pgKjjhixPc6HKj4!1WST2eGLco97OsFduc/OIEWZtu+S7nm6Z6/kWQj5xHxEwxuRzF9bbKwTb9kJ2l7FINSIiP1jkzYb!AA==
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: 2995
 by: olcott - Thu, 4 Nov 2021 21:58 UTC

On 11/4/2021 12:21 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> (1) and (2) conclusively prove that H(P,P) meets this criteria:
>
> The singular is "criterion".
>
I was thinking that too.

>> 2021-11-03 Halt Deciding Criteria
>> It is impossible for any halt decider to be incorrect when the correct
>> pure simulation of its input never halts and it reports not halting.
>
> Unfortunately H(P,P) does not meet the criterion for being correct about
> the computation represented by it's arguments. H(P,P) == 0 when P(P)
> halts is wrong:
>

Since you can't comprehend the x86 assembly language you are out of your
depth in this. If you could understand the x86 source code of P then you
would see that its simulated execution trace does match this source code
thus making impossible for the simulation to be incorrect.

> Actual Halting Problem Criterion:
> H(M,I) == true is only correct if M(I) halts, and H(M,I) == false is
> only correct is M(I) does not halt.
>
> You know this. After 14 years you know that "no" is not the right
> answer for a halting instance of the problem.
>
> Starting new threads every day won't make anyone forget this.

You can make all kinds of false assumptions and never realize that they
are false assumptions until you can understand the x86 code of this
proof and thus comprehend that the proof is necessarily correct.

For example to show that the 14 lines simulated by H(P,P) are not a pure
simulation you would have to show a line of the source code was skipped
or a line of the simulation that does not exist in the source code.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Concise refutation of halting problem proofs

<m92dnVqmW_kjxBn8nZ2dnUU7-eXNnZ2d@giganews.com>

 copy mid

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

 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: Thu, 04 Nov 2021 17:07:58 -0500
Date: Thu, 4 Nov 2021 17:07:56 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: Concise refutation of halting problem proofs
Content-Language: en-US
Newsgroups: comp.theory
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sm1608$kn8$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <m92dnVqmW_kjxBn8nZ2dnUU7-eXNnZ2d@giganews.com>
Lines: 118
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-fC69I+NaDp3sFj8RL0vOmACa528iR6ARSLqZ6iVDFR5u1FbGWFC0Fww4HOnTM8eWrmUt9BO2ovOQY1u!38hueG/Nv/ivkYpEpSlJTxksq4wzQBCfNaPcH3tqqU6cJNc2GJOoIYKSxUETAIs1x2otmBDtpCKK!hA==
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: 6265
 by: olcott - Thu, 4 Nov 2021 22:07 UTC

On 11/4/2021 12:41 PM, André G. Isaak wrote:
> On 2021-11-04 09:47, olcott wrote:
>> This tiny little proof totally proves that the counter-examples of all
>> of the conventional halting problem proofs do not prove that the
>> halting problem cannot be solved.
>>
>> This is the simplest example of the classic halting problem input that
>> "proves" that the halting problem cannot be solved.
>> https://en.wikipedia.org/wiki/Halting_problem
>>
>> // Simplified Linz Ĥ (Linz:1990:319)
>>   // Strachey(1965) CPL translated to C
>>   void P(u32 x)
>>   {
>>    if (H(x, x))
>>      HERE: goto HERE;
>>   }
>>
>> This is the assembly language of the above function after it has been
>> translated by the Microsoft C compiler.
>>
>> _P()
>>   [00000c36](01)  55          push ebp
>>   [00000c37](02)  8bec        mov ebp,esp
>>   [00000c39](03)  8b4508      mov eax,[ebp+08] // 2nd Param
>>   [00000c3c](01)  50          push eax
>>   [00000c3d](03)  8b4d08      mov ecx,[ebp+08] // 1st Param
>>   [00000c40](01)  51          push ecx
>>   [00000c41](05)  e820fdffff  call 00000966    // call H
>>   [00000c46](03)  83c408      add esp,+08
>>   [00000c49](02)  85c0        test eax,eax
>>   [00000c4b](02)  7402        jz 00000c4f
>>   [00000c4d](02)  ebfe        jmp 00000c4d
>>   [00000c4f](01)  5d          pop ebp
>>   [00000c50](01)  c3          ret
>>   Size in bytes:(0027) [00000c50]
>>
>> Begin Local Halt Decider Simulation at Machine Address:c36
>>
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>>   [00000c36][002117ca][002117ce] 55          push ebp
>>   [00000c37][002117ca][002117ce] 8bec        mov ebp,esp
>>   [00000c39][002117ca][002117ce] 8b4508      mov eax,[ebp+08]
>>   [00000c3c][002117c6][00000c36] 50          push eax       // push P
>>   [00000c3d][002117c6][00000c36] 8b4d08      mov ecx,[ebp+08]
>>   [00000c40][002117c2][00000c36] 51          push ecx       // push P
>>   [00000c41][002117be][00000c46] e820fdffff  call 00000966  // call
>> H(P,P)
>>
>> [00000c36][0025c1f2][0025c1f6] 55          push ebp
>>   [00000c37][0025c1f2][0025c1f6] 8bec        mov ebp,esp
>>   [00000c39][0025c1f2][0025c1f6] 8b4508      mov eax,[ebp+08]
>>   [00000c3c][0025c1ee][00000c36] 50          push eax       // push P
>>   [00000c3d][0025c1ee][00000c36] 8b4d08      mov ecx,[ebp+08]
>>   [00000c40][0025c1ea][00000c36] 51          push ecx       // push P
>>   [00000c41][0025c1e6][00000c46] e820fdffff  call 00000966  // call
>> H(P,P)
>>
>> Verified facts:
>
> Verified by whom? Verified how?
>
>> (1) The above 14 simulated lines are a correct pure simulation of the
>> input to H(P,P) for every possible encoding of simulating halt decider H.
>
> What exactly does 'every possible encoding of simulating halt decider H'
> even mean?
>

The important point to know is that the above 14 lines conclusively
prove that H(P,P) did execute a correct pure simulation of its input for
all of these 14 lines.

>> (2) The above 14 simulated lines conclusively prove that the pure
>
> They conclusively prove this how? Just stating that something
> 'conclusively proves' something isn't a proof. You need to actually show
> a proof.
>

You need to understand the prior step before we can proceed to this step.

>> simulation of the input to H(P,P) would never reach its final state of
>> c50 for every possible encoding of simulating halt decider H.
>
>> (1) and (2) conclusively prove that H(P,P) meets this criteria:
>> 2021-11-03 Halt Deciding Criteria
>> It is impossible for any halt decider to be incorrect when the correct
>> pure simulation of its input never halts and it reports not halting.
>
> That's not a criterion. Its a statement. How does something meet a
> statement?
>
> You said you were going to offer a 'tiny little proof' but I see nothing
> resembling a proof here. So where is your tiny little proof?
>
> ************************************************************************
> More importantly, how do you reconcile your claim that H(P, P) == 0 with
> the fact that P(P) halts? YOU NEED TO ADDRESS THIS POINT.
> ************************************************************************
>
> I could adopt your approach of repeating the above line a bazillion
> times, but I can't bring myself to be that juvenile, so I've added some
> asterisks to highlight this point since it is the crucial objection that
> you keep ignoring.
>
> André
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Concise refutation of halting problem proofs

<_Z6dnWOFjPmewBn8nZ2dnUU7-cPNnZ2d@giganews.com>

 copy mid

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

 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: Thu, 04 Nov 2021 17:21:55 -0500
Date: Thu, 4 Nov 2021 17:21:54 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: Concise refutation of halting problem proofs
Content-Language: en-US
Newsgroups: comp.theory
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<87k0hnd3nv.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87k0hnd3nv.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <_Z6dnWOFjPmewBn8nZ2dnUU7-cPNnZ2d@giganews.com>
Lines: 54
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-qWkFGBrIj3+m9UbvE4UNcRo1Lx6aQ53yX1R1UjhbQnda31cLPtBsC6lOHnW4JJEsYEJWDIRUkVnN8mN!6S4jriotTIs2zj0pGeY9mPIwfc/TDkUyW1lvn4W3nktwXOFZOrP87fZCAXGQV0cSXxjqHCwUDEqH!/A==
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: 3540
 by: olcott - Thu, 4 Nov 2021 22:21 UTC

On 11/4/2021 4:14 PM, Ben Bacarisse wrote:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>
>> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>>
>>>> (1) The above 14 simulated lines are a correct pure simulation of the
>>>> input to H(P,P) for every possible encoding of simulating halt decider H.
>>>
>>> What exactly does 'every possible encoding of simulating halt decider H'
>>> even mean?
>>>
>> You need to understand the PO is working with x86 code, not Turing
>> machines.
>
> Not always. He's also posted a lot of incorrect things about TMs.
>
>> So P does not contain an embedded near copy of H, as in Linz's scheme,
>> but a call to H. Now at first sight, that doesn't matter. But it
>> allows for a mental separation between "the input" (the simple little
>> driver which calls H and inverts behaviour when it gets the result)
>> and H itself (the halt decider).
>
> How does this mental separation help PO ignore the fact that H gets the
> answer wrong?

(1) The key thing here is that no one ever needs to see the source code
for H because an infinite number of different simulating halt deciders
must have exactly the same behavior while they are doing a pure
simulation of their input.

(2) We are not verifying whether or not the internal code of H correctly
decides the halt status of its input, so we don't need to see this code.

(3) It can be easily verified (by anyone knowing the x86 language) that
it is a matter of fact that H does do a pure simulation of its input for
the first 14 lines of this simulation.

> How do you excuse his simply ignoring the plain fact that
> H(P,P) == false is the wrong answer? I ask /you/, specifically, because
> you seem to be kindly disposed towards PO, and I can't work it out at
> all. He can't not know that an H that gives the wrong answer is utterly
> trivial. He must know, that we know, that this can't be the miraculous
> impossible TM he claimed to have tree years ago. I just can't find any
> flattering spin to put on it.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Concise refutation of halting problem proofs

<sm1mnu$be5$1@dont-email.me>

 copy mid

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

 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
Date: Thu, 4 Nov 2021 16:27:10 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 17
Message-ID: <sm1mnu$be5$1@dont-email.me>
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me> <m92dnVqmW_kjxBn8nZ2dnUU7-eXNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 4 Nov 2021 22:27:10 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="50cecaea6c75ed7a20dc4a51e1674129";
logging-data="11717"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/7KYRJNpNqEQvt71fKZJIU"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:srm0lw5UC2B76kMi9Xc47B1HKv0=
In-Reply-To: <m92dnVqmW_kjxBn8nZ2dnUU7-eXNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Thu, 4 Nov 2021 22:27 UTC

On 2021-11-04 16:07, olcott wrote:
> On 11/4/2021 12:41 PM, André G. Isaak wrote:

>> ************************************************************************
>> More importantly, how do you reconcile your claim that H(P, P) == 0
>> with the fact that P(P) halts? YOU NEED TO ADDRESS THIS POINT.
>> ************************************************************************

Once again, you completely skipped over this key point. You're going to
have to address this at some point.

André

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

Re: Concise refutation of halting problem proofs

<sm1ms4$be5$2@dont-email.me>

 copy mid

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

 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
Date: Thu, 4 Nov 2021 16:29:24 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 42
Message-ID: <sm1ms4$be5$2@dont-email.me>
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<87k0hnd3nv.fsf@bsb.me.uk> <_Z6dnWOFjPmewBn8nZ2dnUU7-cPNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 4 Nov 2021 22:29:24 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="50cecaea6c75ed7a20dc4a51e1674129";
logging-data="11717"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/zFDSF+HuYjPH1jLkMj78c"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:1YsASLyTeOhz0TcZNyP88yGOULg=
In-Reply-To: <_Z6dnWOFjPmewBn8nZ2dnUU7-cPNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Thu, 4 Nov 2021 22:29 UTC

On 2021-11-04 16:21, olcott wrote:
> On 11/4/2021 4:14 PM, Ben Bacarisse wrote:
>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>
>>> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>>>
>>>>> (1) The above 14 simulated lines are a correct pure simulation of the
>>>>> input to H(P,P) for every possible encoding of simulating halt
>>>>> decider H.
>>>>
>>>> What exactly does 'every possible encoding of simulating halt
>>>> decider H'
>>>> even mean?
>>>>
>>> You need to understand the PO is working with x86 code, not Turing
>>> machines.
>>
>> Not always.  He's also posted a lot of incorrect things about TMs.
>>
>>> So P does not contain an embedded near copy of H, as in Linz's scheme,
>>> but a call to H.  Now at first sight, that doesn't matter. But it
>>> allows for a mental separation between "the input" (the simple little
>>> driver which calls H and inverts behaviour when it gets the result)
>>> and H itself (the halt decider).
>>
>> How does this mental separation help PO ignore the fact that H gets the
>> answer wrong?
>
> (1) The key thing here is that no one ever needs to see the source code
> for H because an infinite number of different simulating halt deciders
> must have exactly the same behavior while they are doing a pure
> simulation of their input.

Based on the above, am I correct in inferring that when you talk about
"encodings of H" what you actually mean is "implementations of a
simulating halt decider".

André

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

Re: Concise refutation of halting problem proofs [ ta-da ? ]

<kIydnbUqUOXjwhn8nZ2dnUU7-TPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy sci.math
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: Thu, 04 Nov 2021 17:32:30 -0500
Date: Thu, 4 Nov 2021 17:32:29 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: Concise refutation of halting problem proofs [ ta-da ? ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,sci.math
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<jLSdnS1o5tcA0xn8nZ2dnUU7-XXNnZ2d@giganews.com> <sm1j1f$i2g$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sm1j1f$i2g$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <kIydnbUqUOXjwhn8nZ2dnUU7-TPNnZ2d@giganews.com>
Lines: 51
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Gnek4aSFLnWchM2JzJ6OlJ3tDWcu8cJy1qD3LJ6nPSqTp9s/iKfDt21W0Y5CeuiOdSMrGn80sbuNzv8!/q24mI5Hcwb8yqKwbPGIhcD9U3bhiv5Myff0Zw8c0VoTrtO6Vi6xDgmUBte/1E5iqS6k1iIukIKl!Bg==
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: 3342
 by: olcott - Thu, 4 Nov 2021 22:32 UTC

On 11/4/2021 4:23 PM, André G. Isaak wrote:
> On 2021-11-04 15:20, olcott wrote:
>> On 11/4/2021 3:09 PM, Malcolm McLean wrote:
>>> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>>>
>>>>> (1) The above 14 simulated lines are a correct pure simulation of the
>>>>> input to H(P,P) for every possible encoding of simulating halt
>>>>> decider H.
>>>> What exactly does 'every possible encoding of simulating halt
>>>> decider H'
>>>> even mean?
>>>>
>>> You need to understand the PO is working with x86 code, not Turing
>>> machines.
>>> So P does not contain an embedded near copy of H, as in Linz's scheme,
>>> but a call to H.
>>> Now at first sight, that doesn't matter. But it allows for a mental
>>> separation
>>> between "the input" (the simple little driver which calls H and
>>> inverts behaviour
>>> when it gets the result)  and H itself (the halt decider).
>>> If we replace the call to H by a call to another simulating halt
>>> decider, have
>>> we changed anything now?
>>>
>>
>> I think that you have this correctly.
>>
>> My current proof applies to every possible encoding of H thus
>> eliminating any need to see the encoding of any specific H.
>
> Again, I ask, what do you mean by an 'encoding of H'?

The C source code. H can be written an infinite number of different ways
and each one of these ways would derive the exact same pure simulation
of its input.

Since my new proof doesn't care about whether or not H decides its input
correctly we don't need to examine the details of how H makes its halt
status decision.

My new proof merely shows that a pure simulation of the input to H(P,P)
never reaches the final state of P, therefore not halting would be a
correct halt status decision.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Concise refutation of halting problem proofs [ ta-da ? ]

<sm1p1p$t9k$1@dont-email.me>

 copy mid

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

 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 [ ta-da ? ]
Date: Thu, 4 Nov 2021 17:06:32 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 50
Message-ID: <sm1p1p$t9k$1@dont-email.me>
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<jLSdnS1o5tcA0xn8nZ2dnUU7-XXNnZ2d@giganews.com> <sm1j1f$i2g$1@dont-email.me>
<kIydnbUqUOXjwhn8nZ2dnUU7-TPNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 4 Nov 2021 23:06:33 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="a466bc96e5f1c4cf417b6f4d8437ec20";
logging-data="30004"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+Lc65nT9lUXV0reWqxqoMF"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:xupbI/CJ08Lmf7ko8N4tpKWu0TM=
In-Reply-To: <kIydnbUqUOXjwhn8nZ2dnUU7-TPNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Thu, 4 Nov 2021 23:06 UTC

On 2021-11-04 16:32, olcott wrote:
> On 11/4/2021 4:23 PM, André G. Isaak wrote:
>> On 2021-11-04 15:20, olcott wrote:
>>> On 11/4/2021 3:09 PM, Malcolm McLean wrote:
>>>> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>>>>
>>>>>> (1) The above 14 simulated lines are a correct pure simulation of the
>>>>>> input to H(P,P) for every possible encoding of simulating halt
>>>>>> decider H.
>>>>> What exactly does 'every possible encoding of simulating halt
>>>>> decider H'
>>>>> even mean?
>>>>>
>>>> You need to understand the PO is working with x86 code, not Turing
>>>> machines.
>>>> So P does not contain an embedded near copy of H, as in Linz's scheme,
>>>> but a call to H.
>>>> Now at first sight, that doesn't matter. But it allows for a mental
>>>> separation
>>>> between "the input" (the simple little driver which calls H and
>>>> inverts behaviour
>>>> when it gets the result)  and H itself (the halt decider).
>>>> If we replace the call to H by a call to another simulating halt
>>>> decider, have
>>>> we changed anything now?
>>>>
>>>
>>> I think that you have this correctly.
>>>
>>> My current proof applies to every possible encoding of H thus
>>> eliminating any need to see the encoding of any specific H.
>>
>> Again, I ask, what do you mean by an 'encoding of H'?
>
> The C source code. H can be written an infinite number of different ways
> and each one of these ways would derive the exact same pure simulation
> of its input.

That's not how the word 'encoding' is normally used. The word you are
looking for is 'implementation'.

So would your H1 be one of those different ways? The H1 which give a
*different answer*? Apparently they *don't* all derive the exact same
"pure" simulation.

André

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

Re: Concise refutation of halting problem proofs

<raqdndTQQdfD5Bn8nZ2dnUU7-X-dnZ2d@giganews.com>

 copy mid

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

 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: Thu, 04 Nov 2021 19:22:54 -0500
Date: Thu, 4 Nov 2021 19:22:53 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: Concise refutation of halting problem proofs
Content-Language: en-US
Newsgroups: comp.theory
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<87k0hnd3nv.fsf@bsb.me.uk> <_Z6dnWOFjPmewBn8nZ2dnUU7-cPNnZ2d@giganews.com>
<sm1ms4$be5$2@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sm1ms4$be5$2@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <raqdndTQQdfD5Bn8nZ2dnUU7-X-dnZ2d@giganews.com>
Lines: 48
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ILNtOq3bR0JafXycKsU7psl4iXT5s6S9FcH2t/ATJrxLS0YluWt+jlaUdBrG5uOn1hDquxdbtW4FN+s!NajvLZbOcCK0hzl0wD/rogoXvmXTyYbjt9M/LwowiWJdnmZOe7yzOOo0TgK0HGsuISR0ofFTmAeu!xw==
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: 3190
 by: olcott - Fri, 5 Nov 2021 00:22 UTC

On 11/4/2021 5:29 PM, André G. Isaak wrote:
> On 2021-11-04 16:21, olcott wrote:
>> On 11/4/2021 4:14 PM, Ben Bacarisse wrote:
>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>>
>>>> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>>>>
>>>>>> (1) The above 14 simulated lines are a correct pure simulation of the
>>>>>> input to H(P,P) for every possible encoding of simulating halt
>>>>>> decider H.
>>>>>
>>>>> What exactly does 'every possible encoding of simulating halt
>>>>> decider H'
>>>>> even mean?
>>>>>
>>>> You need to understand the PO is working with x86 code, not Turing
>>>> machines.
>>>
>>> Not always.  He's also posted a lot of incorrect things about TMs.
>>>
>>>> So P does not contain an embedded near copy of H, as in Linz's scheme,
>>>> but a call to H.  Now at first sight, that doesn't matter. But it
>>>> allows for a mental separation between "the input" (the simple little
>>>> driver which calls H and inverts behaviour when it gets the result)
>>>> and H itself (the halt decider).
>>>
>>> How does this mental separation help PO ignore the fact that H gets the
>>> answer wrong?
>>
>> (1) The key thing here is that no one ever needs to see the source
>> code for H because an infinite number of different simulating halt
>> deciders must have exactly the same behavior while they are doing a
>> pure simulation of their input.
>
> Based on the above, am I correct in inferring that when you talk about
> "encodings of H" what you actually mean is "implementations of a
> simulating halt decider".
>
> André
>

Computer programmers write code.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Concise refutation of halting problem proofs

<sm1tmi$nr3$1@dont-email.me>

 copy mid

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

 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
Date: Thu, 4 Nov 2021 18:25:54 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 59
Message-ID: <sm1tmi$nr3$1@dont-email.me>
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<87k0hnd3nv.fsf@bsb.me.uk> <_Z6dnWOFjPmewBn8nZ2dnUU7-cPNnZ2d@giganews.com>
<sm1ms4$be5$2@dont-email.me> <raqdndTQQdfD5Bn8nZ2dnUU7-X-dnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 5 Nov 2021 00:25:54 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="a466bc96e5f1c4cf417b6f4d8437ec20";
logging-data="24419"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19et1qWkVSICEUPJTDr3TQm"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:duQPZxN01uUT4CSfxGQX+mUAk3M=
In-Reply-To: <raqdndTQQdfD5Bn8nZ2dnUU7-X-dnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 5 Nov 2021 00:25 UTC

On 2021-11-04 18:22, olcott wrote:
> On 11/4/2021 5:29 PM, André G. Isaak wrote:
>> On 2021-11-04 16:21, olcott wrote:
>>> On 11/4/2021 4:14 PM, Ben Bacarisse wrote:
>>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>>>
>>>>> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>>>>>
>>>>>>> (1) The above 14 simulated lines are a correct pure simulation of
>>>>>>> the
>>>>>>> input to H(P,P) for every possible encoding of simulating halt
>>>>>>> decider H.
>>>>>>
>>>>>> What exactly does 'every possible encoding of simulating halt
>>>>>> decider H'
>>>>>> even mean?
>>>>>>
>>>>> You need to understand the PO is working with x86 code, not Turing
>>>>> machines.
>>>>
>>>> Not always.  He's also posted a lot of incorrect things about TMs.
>>>>
>>>>> So P does not contain an embedded near copy of H, as in Linz's scheme,
>>>>> but a call to H.  Now at first sight, that doesn't matter. But it
>>>>> allows for a mental separation between "the input" (the simple little
>>>>> driver which calls H and inverts behaviour when it gets the result)
>>>>> and H itself (the halt decider).
>>>>
>>>> How does this mental separation help PO ignore the fact that H gets the
>>>> answer wrong?
>>>
>>> (1) The key thing here is that no one ever needs to see the source
>>> code for H because an infinite number of different simulating halt
>>> deciders must have exactly the same behavior while they are doing a
>>> pure simulation of their input.
>>
>> Based on the above, am I correct in inferring that when you talk about
>> "encodings of H" what you actually mean is "implementations of a
>> simulating halt decider".
>>
>> André
>>
>
> Computer programmers write code.

Yes, I am aware of that. Did you have a point?

And you failed to address my other question:

So would your H1 be one of those different ways? The H1 which give a
*different answer*? Apparently they *don't* all derive the exact same
"pure" simulation.

André

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

Re: Concise refutation of halting problem proofs [ ta-da ? ]

<3OGdnVIp873k5xn8nZ2dnUU7-bPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory sci.logic
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: Thu, 04 Nov 2021 19:27:37 -0500
Date: Thu, 4 Nov 2021 19:27:36 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: Concise refutation of halting problem proofs [ ta-da ? ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<jLSdnS1o5tcA0xn8nZ2dnUU7-XXNnZ2d@giganews.com> <sm1j1f$i2g$1@dont-email.me>
<kIydnbUqUOXjwhn8nZ2dnUU7-TPNnZ2d@giganews.com> <sm1p1p$t9k$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sm1p1p$t9k$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <3OGdnVIp873k5xn8nZ2dnUU7-bPNnZ2d@giganews.com>
Lines: 105
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-3ohza36kJDuszhyUeZSEwhYubAKppmxzrmfrGwC80gRyZVaRRludjBV3Gh8r5ERVxyh3qYwMMbXUxFQ!nXLNny+9+KpxEVgErw71GvcUZZFQC/j4r9MQR2iZy4LfB6ZRrGvjy3ooqLAH++gRzfswwcYaxaYq!3w==
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: 5585
 by: olcott - Fri, 5 Nov 2021 00:27 UTC

On 11/4/2021 6:06 PM, André G. Isaak wrote:
> On 2021-11-04 16:32, olcott wrote:
>> On 11/4/2021 4:23 PM, André G. Isaak wrote:
>>> On 2021-11-04 15:20, olcott wrote:
>>>> On 11/4/2021 3:09 PM, Malcolm McLean wrote:
>>>>> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>>>>>
>>>>>>> (1) The above 14 simulated lines are a correct pure simulation of
>>>>>>> the
>>>>>>> input to H(P,P) for every possible encoding of simulating halt
>>>>>>> decider H.
>>>>>> What exactly does 'every possible encoding of simulating halt
>>>>>> decider H'
>>>>>> even mean?
>>>>>>
>>>>> You need to understand the PO is working with x86 code, not Turing
>>>>> machines.
>>>>> So P does not contain an embedded near copy of H, as in Linz's scheme,
>>>>> but a call to H.
>>>>> Now at first sight, that doesn't matter. But it allows for a mental
>>>>> separation
>>>>> between "the input" (the simple little driver which calls H and
>>>>> inverts behaviour
>>>>> when it gets the result)  and H itself (the halt decider).
>>>>> If we replace the call to H by a call to another simulating halt
>>>>> decider, have
>>>>> we changed anything now?
>>>>>
>>>>
>>>> I think that you have this correctly.
>>>>
>>>> My current proof applies to every possible encoding of H thus
>>>> eliminating any need to see the encoding of any specific H.
>>>
>>> Again, I ask, what do you mean by an 'encoding of H'?
>>
>> The C source code. H can be written an infinite number of different
>> ways and each one of these ways would derive the exact same pure
>> simulation of its input.
>
> That's not how the word 'encoding' is normally used.

Computer programmers write code.

No matter how H is encoded in any programming language it always
necessarily performs a pure simulation of the exact same steps of any
input.

_P()
[00000c36](01) 55 push ebp
[00000c37](02) 8bec mov ebp,esp
[00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
[00000c3c](01) 50 push eax
[00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
[00000c40](01) 51 push ecx
[00000c41](05) e820fdffff call 00000966 // call H
[00000c46](03) 83c408 add esp,+08
[00000c49](02) 85c0 test eax,eax
[00000c4b](02) 7402 jz 00000c4f
[00000c4d](02) ebfe jmp 00000c4d
[00000c4f](01) 5d pop ebp
[00000c50](01) c3 ret
Size in bytes:(0027) [00000c50]

Begin Local Halt Decider Simulation at Machine Address:c36

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00000c36][002117ca][002117ce] 55 push ebp
[00000c37][002117ca][002117ce] 8bec mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50 push eax // push P
[00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51 push ecx // push P
[00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)

[00000c36][0025c1f2][0025c1f6] 55 push ebp
[00000c37][0025c1f2][0025c1f6] 8bec mov ebp,esp
[00000c39][0025c1f2][0025c1f6] 8b4508 mov eax,[ebp+08]
[00000c3c][0025c1ee][00000c36] 50 push eax // push P
[00000c3d][0025c1ee][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][0025c1ea][00000c36] 51 push ecx // push P
[00000c41][0025c1e6][00000c46] e820fdffff call 00000966 // call H(P,P)

The above 14 steps are always exactly the same for every simulating halt
decider H that performs a pure simulation of the first 14 steps of P.

> The word you are
> looking for is 'implementation'.
>
> So would your H1 be one of those different ways? The H1 which give a
> *different answer*? Apparently they *don't* all derive the exact same
> "pure" simulation.
>
> André
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Concise refutation of halting problem proofs

<i46dnX8h96FH5hn8nZ2dnUU78InNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!weretis.net!feeder8.news.weretis.net!border2.nntp.ams1.giganews.com!nntp.giganews.com!buffer2.nntp.ams1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 04 Nov 2021 19:33:30 -0500
Date: Thu, 4 Nov 2021 19:33:28 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: Concise refutation of halting problem proofs
Content-Language: en-US
Newsgroups: comp.theory
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<87k0hnd3nv.fsf@bsb.me.uk> <_Z6dnWOFjPmewBn8nZ2dnUU7-cPNnZ2d@giganews.com>
<sm1ms4$be5$2@dont-email.me> <raqdndTQQdfD5Bn8nZ2dnUU7-X-dnZ2d@giganews.com>
<sm1tmi$nr3$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sm1tmi$nr3$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <i46dnX8h96FH5hn8nZ2dnUU78InNnZ2d@giganews.com>
Lines: 73
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-VUATN1cRSabEVmXi4iBsj/3kVFegKRSoFzV8TxAdxT5Rr9Y6i8ox06WztYCLaBHi1V6gP/8Az2Ng9uk!NzpGxoEzz4z/NXXDTNVQFVoecLEtCwMNLHlouiAseTwn/har9W+W2Ut9yAtBf2a42q2G0zvBlzQ3!5w==
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: 4034
 by: olcott - Fri, 5 Nov 2021 00:33 UTC

On 11/4/2021 7:25 PM, André G. Isaak wrote:
> On 2021-11-04 18:22, olcott wrote:
>> On 11/4/2021 5:29 PM, André G. Isaak wrote:
>>> On 2021-11-04 16:21, olcott wrote:
>>>> On 11/4/2021 4:14 PM, Ben Bacarisse wrote:
>>>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>>>>
>>>>>> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>>>>>>
>>>>>>>> (1) The above 14 simulated lines are a correct pure simulation
>>>>>>>> of the
>>>>>>>> input to H(P,P) for every possible encoding of simulating halt
>>>>>>>> decider H.
>>>>>>>
>>>>>>> What exactly does 'every possible encoding of simulating halt
>>>>>>> decider H'
>>>>>>> even mean?
>>>>>>>
>>>>>> You need to understand the PO is working with x86 code, not Turing
>>>>>> machines.
>>>>>
>>>>> Not always.  He's also posted a lot of incorrect things about TMs.
>>>>>
>>>>>> So P does not contain an embedded near copy of H, as in Linz's
>>>>>> scheme,
>>>>>> but a call to H.  Now at first sight, that doesn't matter. But it
>>>>>> allows for a mental separation between "the input" (the simple little
>>>>>> driver which calls H and inverts behaviour when it gets the result)
>>>>>> and H itself (the halt decider).
>>>>>
>>>>> How does this mental separation help PO ignore the fact that H gets
>>>>> the
>>>>> answer wrong?
>>>>
>>>> (1) The key thing here is that no one ever needs to see the source
>>>> code for H because an infinite number of different simulating halt
>>>> deciders must have exactly the same behavior while they are doing a
>>>> pure simulation of their input.
>>>
>>> Based on the above, am I correct in inferring that when you talk
>>> about "encodings of H" what you actually mean is "implementations of
>>> a simulating halt decider".
>>>
>>> André
>>>
>>
>> Computer programmers write code.
>
>
> Yes, I am aware of that. Did you have a point?
>

Then you are also aware that I used the term encoded correctly.

Every single C program simulating halt decider that can possibly ever be
written would necessarily simulate the exact same 14 steps of P when it
is performing a pure simulation of its input.

> And you failed to address my other question:
>
> So would your H1 be one of those different ways? The H1 which give a
> *different answer*? Apparently they *don't* all derive the exact same
> "pure" simulation.
>
> André
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Concise refutation of halting problem proofs

<sm1v00$vcp$1@dont-email.me>

 copy mid

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

 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
Date: Thu, 4 Nov 2021 18:47:58 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 71
Message-ID: <sm1v00$vcp$1@dont-email.me>
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<87k0hnd3nv.fsf@bsb.me.uk> <_Z6dnWOFjPmewBn8nZ2dnUU7-cPNnZ2d@giganews.com>
<sm1ms4$be5$2@dont-email.me> <raqdndTQQdfD5Bn8nZ2dnUU7-X-dnZ2d@giganews.com>
<sm1tmi$nr3$1@dont-email.me> <i46dnX8h96FH5hn8nZ2dnUU78InNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 5 Nov 2021 00:48:00 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="a466bc96e5f1c4cf417b6f4d8437ec20";
logging-data="32153"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18hM15+oifXsIvMSdaiSKHz"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:9u8LDBQRNgTO0nweYfegrmYYs08=
In-Reply-To: <i46dnX8h96FH5hn8nZ2dnUU78InNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 5 Nov 2021 00:47 UTC

On 2021-11-04 18:33, olcott wrote:
> On 11/4/2021 7:25 PM, André G. Isaak wrote:
>> On 2021-11-04 18:22, olcott wrote:
>>> On 11/4/2021 5:29 PM, André G. Isaak wrote:
>>>> On 2021-11-04 16:21, olcott wrote:
>>>>> On 11/4/2021 4:14 PM, Ben Bacarisse wrote:
>>>>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>>>>>
>>>>>>> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>>>>>>>
>>>>>>>>> (1) The above 14 simulated lines are a correct pure simulation
>>>>>>>>> of the
>>>>>>>>> input to H(P,P) for every possible encoding of simulating halt
>>>>>>>>> decider H.
>>>>>>>>
>>>>>>>> What exactly does 'every possible encoding of simulating halt
>>>>>>>> decider H'
>>>>>>>> even mean?
>>>>>>>>
>>>>>>> You need to understand the PO is working with x86 code, not Turing
>>>>>>> machines.
>>>>>>
>>>>>> Not always.  He's also posted a lot of incorrect things about TMs.
>>>>>>
>>>>>>> So P does not contain an embedded near copy of H, as in Linz's
>>>>>>> scheme,
>>>>>>> but a call to H.  Now at first sight, that doesn't matter. But it
>>>>>>> allows for a mental separation between "the input" (the simple
>>>>>>> little
>>>>>>> driver which calls H and inverts behaviour when it gets the result)
>>>>>>> and H itself (the halt decider).
>>>>>>
>>>>>> How does this mental separation help PO ignore the fact that H
>>>>>> gets the
>>>>>> answer wrong?
>>>>>
>>>>> (1) The key thing here is that no one ever needs to see the source
>>>>> code for H because an infinite number of different simulating halt
>>>>> deciders must have exactly the same behavior while they are doing a
>>>>> pure simulation of their input.
>>>>
>>>> Based on the above, am I correct in inferring that when you talk
>>>> about "encodings of H" what you actually mean is "implementations of
>>>> a simulating halt decider".
>>>>
>>>> André
>>>>
>>>
>>> Computer programmers write code.
>>
>>
>> Yes, I am aware of that. Did you have a point?
>>
>
> Then you are also aware that I used the term encoded correctly.

That's a rather nonstandard use of the term. And it is particularly
misleading when discussing the Linz proof and halt deciders in which
context 'encode' means something rather different.

And you AGAIN failed to address my other question:

So would your H1 be one of those different "encodings"? The H1 which
give a *different answer*? Apparently they *don't* all derive the exact
same "pure" simulation.

André

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

Re: Concise refutation of halting problem proofs

<87ee7vcsgd.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs
Followup-To: comp.theory
Date: Fri, 05 Nov 2021 01:16:34 +0000
Organization: A noiseless patient Spider
Lines: 51
Message-ID: <87ee7vcsgd.fsf@bsb.me.uk>
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<87y263deg7.fsf@bsb.me.uk>
<dNidnZrKUJ4byhn8nZ2dnUU7-LfNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="ec63e162839d7185db4ce5e00fe0d50f";
logging-data="26849"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18/ccanBP2Pp9HVy5ASeTPQ6vTEfGjPaxk="
Cancel-Lock: sha1:++Dkqued5p7sHAucoNECZ0muS1c=
sha1:3PSQnCXHIKDpk57pP0SHmZaBubM=
X-BSB-Auth: 1.ed46c2b6d6bf50a84054.20211105011634GMT.87ee7vcsgd.fsf@bsb.me.uk
 by: Ben Bacarisse - Fri, 5 Nov 2021 01:16 UTC

olcott <NoOne@NoWhere.com> writes:

> On 11/4/2021 12:21 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> (1) and (2) conclusively prove that H(P,P) meets this criteria:
>> The singular is "criterion".
>>
> I was thinking that too.
>
>>> 2021-11-03 Halt Deciding Criteria
>>> It is impossible for any halt decider to be incorrect when the correct
>>> pure simulation of its input never halts and it reports not halting.
>>
>> Unfortunately H(P,P) does not meet the criterion for being correct about
>> the computation represented by it's arguments. H(P,P) == 0 when P(P)
>> halts is wrong:
>
> Since you can't comprehend the x86 assembly language you are out of
> your depth in this.

You are funny! The definition of the halting problem is what it is.

> If you could understand the x86 source code of P then you
> would see that its simulated execution trace does match this source
> code thus making impossible for the simulation to be incorrect.

You have provided the two key facts: H(P,P) == false and P(P) halts.
You don't like to post the trace of P(P) but you did once. False is not
the right answer for a halting computation.

>> Actual Halting Problem Criterion:
>> H(M,I) == true is only correct if M(I) halts, and H(M,I) == false is
>> only correct is M(I) does not halt.
>>
>> You know this. After 14 years you know that "no" is not the right
>> answer for a halting instance of the problem.
>> Starting new threads every day won't make anyone forget this.
>
> You can make all kinds of false assumptions...

It's the definition of the halting problem. You know this too, because
three years ago you claimed to have "H on input pair (Ĥ, Ĥ) meeting the
Linz specs". An H the rejects an input representing a halting
computation does not meet Linz's specs.

You are really floundering around looking for ways to not talk about how
the problem is defined.

--
Ben.

Re: Concise refutation of halting problem proofs

<8735obcrfv.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Concise refutation of halting problem proofs
Followup-To: comp.theory
Date: Fri, 05 Nov 2021 01:38:28 +0000
Organization: A noiseless patient Spider
Lines: 66
Message-ID: <8735obcrfv.fsf@bsb.me.uk>
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<87k0hnd3nv.fsf@bsb.me.uk>
<_Z6dnWOFjPmewBn8nZ2dnUU7-cPNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=iso-8859-1
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="ec63e162839d7185db4ce5e00fe0d50f";
logging-data="15069"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/OKPmc6Zzp8q1ZUtsLTTtE26Vml+7a1QQ="
Cancel-Lock: sha1:qI5VTW+C6pWqiLB55iqJin9qZ3E=
sha1:bsyqs6y8UP9oUsc88JpTnnWXzus=
X-BSB-Auth: 1.e62964f1d41b35068b27.20211105013828GMT.8735obcrfv.fsf@bsb.me.uk
 by: Ben Bacarisse - Fri, 5 Nov 2021 01:38 UTC

olcott <NoOne@NoWhere.com> writes:

> On 11/4/2021 4:14 PM, Ben Bacarisse wrote:
>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>
>>> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>>>
>>>>> (1) The above 14 simulated lines are a correct pure simulation of the
>>>>> input to H(P,P) for every possible encoding of simulating halt decider H.
>>>>
>>>> What exactly does 'every possible encoding of simulating halt decider H'
>>>> even mean?
>>>>
>>> You need to understand the PO is working with x86 code, not Turing
>>> machines.
>> Not always. He's also posted a lot of incorrect things about TMs.
>>
>>> So P does not contain an embedded near copy of H, as in Linz's scheme,
>>> but a call to H. Now at first sight, that doesn't matter. But it
>>> allows for a mental separation between "the input" (the simple little
>>> driver which calls H and inverts behaviour when it gets the result)
>>> and H itself (the halt decider).
>>
>> How does this mental separation help PO ignore the fact that H gets the
>> answer wrong?
>
> (1) The key thing here is that no one ever needs to see the source
> code for H because an infinite number of different simulating halt
> deciders must have exactly the same behavior while they are doing a
> pure simulation of their input.

We know that H(P,P) == false because you told us. We know that P(P)
halts because you told us. You should know that false is the wrong
answer for a halting computation, but you pretend not to.

> (2) We are not verifying whether or not the internal code of H
> correctly decides the halt status of its input, so we don't need to
> see this code.

We know that H(P,P) == false because you told us. We know that P(P)
halts because you told us. We don't need to know anything more about H
to know that it's wrong.

> (3) It can be easily verified (by anyone knowing the x86 language)
> that it is a matter of fact that H does do a pure simulation of its
> input for the first 14 lines of this simulation.

If, three years ago, you had told us that you had C code, H, (not a
Turing machine as you claimed) that returned false for H(H^, H^) and
that this was "correct" despite H^(H^) halting it would have looked like
a joke. How has it taken you three years or work (and counting) when
you could just have published this back then:

bool H(uintptr_t M, uintptr_t I) { return false; }

void P(uintptr_t M) { if (H(M, M)) while (1); }

This H also has H(P, P) == false with P(P) halting, so it's just as good
as your fancy version for the only case you say you are about.

Of course we know why. You knew back then what the right answer should
be for a halting computation. It's only because you let a few details
slip out that you are now defending the indefensible.

--
Ben.

Re: Concise refutation of halting problem proofs

<l40hJ.64958$IW4.22152@fx48.iad>

 copy mid

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

 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!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx48.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.2.1
Subject: Re: Concise refutation of halting problem proofs
Content-Language: en-US
Newsgroups: comp.theory
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 110
Message-ID: <l40hJ.64958$IW4.22152@fx48.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 4 Nov 2021 21:49:02 -0400
X-Received-Bytes: 5368
X-Original-Bytes: 5235
 by: Richard Damon - Fri, 5 Nov 2021 01:49 UTC

On 11/4/21 11:47 AM, olcott wrote:
> This tiny little proof totally proves that the counter-examples of all
> of the conventional halting problem proofs do not prove that the halting
> problem cannot be solved.
>
> This is the simplest example of the classic halting problem input that
> "proves" that the halting problem cannot be solved.
> https://en.wikipedia.org/wiki/Halting_problem
>
> // Simplified Linz Ĥ (Linz:1990:319)
>  // Strachey(1965) CPL translated to C
>  void P(u32 x)
>  {
>   if (H(x, x))
>     HERE: goto HERE;
>  }
>
> This is the assembly language of the above function after it has been
> translated by the Microsoft C compiler.
>
> _P()
>  [00000c36](01)  55          push ebp
>  [00000c37](02)  8bec        mov ebp,esp
>  [00000c39](03)  8b4508      mov eax,[ebp+08] // 2nd Param
>  [00000c3c](01)  50          push eax
>  [00000c3d](03)  8b4d08      mov ecx,[ebp+08] // 1st Param
>  [00000c40](01)  51          push ecx
>  [00000c41](05)  e820fdffff  call 00000966    // call H
>  [00000c46](03)  83c408      add esp,+08
>  [00000c49](02)  85c0        test eax,eax
>  [00000c4b](02)  7402        jz 00000c4f
>  [00000c4d](02)  ebfe        jmp 00000c4d
>  [00000c4f](01)  5d          pop ebp
>  [00000c50](01)  c3          ret
>  Size in bytes:(0027) [00000c50]
>
> Begin Local Halt Decider Simulation at Machine Address:c36
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
>  [00000c36][002117ca][002117ce] 55          push ebp
>  [00000c37][002117ca][002117ce] 8bec        mov ebp,esp
>  [00000c39][002117ca][002117ce] 8b4508      mov eax,[ebp+08]
>  [00000c3c][002117c6][00000c36] 50          push eax       // push P
>  [00000c3d][002117c6][00000c36] 8b4d08      mov ecx,[ebp+08]
>  [00000c40][002117c2][00000c36] 51          push ecx       // push P
>  [00000c41][002117be][00000c46] e820fdffff  call 00000966  // call H(P,P)
>
> [00000c36][0025c1f2][0025c1f6] 55          push ebp
>  [00000c37][0025c1f2][0025c1f6] 8bec        mov ebp,esp
>  [00000c39][0025c1f2][0025c1f6] 8b4508      mov eax,[ebp+08]
>  [00000c3c][0025c1ee][00000c36] 50          push eax       // push P
>  [00000c3d][0025c1ee][00000c36] 8b4d08      mov ecx,[ebp+08]
>  [00000c40][0025c1ea][00000c36] 51          push ecx       // push P
>  [00000c41][0025c1e6][00000c46] e820fdffff  call 00000966  // call H(P,P)
>
> Verified facts:
> (1) The above 14 simulated lines are a correct pure simulation of the
> input to H(P,P) for every possible encoding of simulating halt decider H.

So me ONE working x86 processor where a Call 000000966 instruction
proceeds to address 00000C36.

Thus, this is NOT a correct simulation, and thus the rest of your
argument is invalid.

>
> (2) The above 14 simulated lines conclusively prove that the pure
> simulation of the input to H(P,P) would never reach its final state of
> c50 for every possible encoding of simulating halt decider H.
>

False premises do not prove assertions based on the premise being true.

FAIL.

> (1) and (2) conclusively prove that H(P,P) meets this criteria:

Nope, two wrongs don't make a rignt/

>
> 2021-11-03 Halt Deciding Criteria
> It is impossible for any halt decider to be incorrect when the correct
> pure simulation of its input never halts and it reports not halting.
>
>

Yes, but the currect pure simulation of the input to H, namely P,P when
give to an ACTUAL pure simulator, ie a UTM will give the identical
result (by definition) of running P(P) which is known to Halt.

By definitons a wrong answer is incorrect.

>
>
> Strachey, C 1965.  An impossible program The Computer Journal, Volume 7,
> Issue 4, January 1965, Page 313, https://doi.org/10.1093/comjnl/7.4.313
>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (318-320)
>
> Halting problem undecidability and infinitely nested simulation
> May 2021 PL Olcott
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
>

Re: Concise refutation of halting problem proofs [ focus on one point ]

<ApidneInKNK7Exn8nZ2dnUU7-X_NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory sci.logic
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: Thu, 04 Nov 2021 20:51:34 -0500
Date: Thu, 4 Nov 2021 20:51:33 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: Concise refutation of halting problem proofs [ focus on one point
]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<87k0hnd3nv.fsf@bsb.me.uk> <_Z6dnWOFjPmewBn8nZ2dnUU7-cPNnZ2d@giganews.com>
<sm1ms4$be5$2@dont-email.me> <raqdndTQQdfD5Bn8nZ2dnUU7-X-dnZ2d@giganews.com>
<sm1tmi$nr3$1@dont-email.me> <i46dnX8h96FH5hn8nZ2dnUU78InNnZ2d@giganews.com>
<sm1v00$vcp$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sm1v00$vcp$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ApidneInKNK7Exn8nZ2dnUU7-X_NnZ2d@giganews.com>
Lines: 116
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-e3rXgluPa8sya80iJHZm9CJMK67/oj1+sHKW1SJnCRrNGZ2U3Qzy+OJbSE559iiUcRLT7ZiBBFTSlue!fP4PXn2R6tC8Fbn6qTHGSjCHadEWVDa4lWRuh6RjeLOuceIREX04qvK/EXhMjC5YYgA+ZZmOs+l4!NQ==
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: 6278
 by: olcott - Fri, 5 Nov 2021 01:51 UTC

On 11/4/2021 7:47 PM, André G. Isaak wrote:
> On 2021-11-04 18:33, olcott wrote:
>> On 11/4/2021 7:25 PM, André G. Isaak wrote:
>>> On 2021-11-04 18:22, olcott wrote:
>>>> On 11/4/2021 5:29 PM, André G. Isaak wrote:
>>>>> On 2021-11-04 16:21, olcott wrote:
>>>>>> On 11/4/2021 4:14 PM, Ben Bacarisse wrote:
>>>>>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>>>>>>
>>>>>>>> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>>>>>>>>
>>>>>>>>>> (1) The above 14 simulated lines are a correct pure simulation
>>>>>>>>>> of the
>>>>>>>>>> input to H(P,P) for every possible encoding of simulating halt
>>>>>>>>>> decider H.
>>>>>>>>>
>>>>>>>>> What exactly does 'every possible encoding of simulating halt
>>>>>>>>> decider H'
>>>>>>>>> even mean?
>>>>>>>>>
>>>>>>>> You need to understand the PO is working with x86 code, not Turing
>>>>>>>> machines.
>>>>>>>
>>>>>>> Not always.  He's also posted a lot of incorrect things about TMs.
>>>>>>>
>>>>>>>> So P does not contain an embedded near copy of H, as in Linz's
>>>>>>>> scheme,
>>>>>>>> but a call to H.  Now at first sight, that doesn't matter. But it
>>>>>>>> allows for a mental separation between "the input" (the simple
>>>>>>>> little
>>>>>>>> driver which calls H and inverts behaviour when it gets the result)
>>>>>>>> and H itself (the halt decider).
>>>>>>>
>>>>>>> How does this mental separation help PO ignore the fact that H
>>>>>>> gets the
>>>>>>> answer wrong?
>>>>>>
>>>>>> (1) The key thing here is that no one ever needs to see the source
>>>>>> code for H because an infinite number of different simulating halt
>>>>>> deciders must have exactly the same behavior while they are doing
>>>>>> a pure simulation of their input.
>>>>>
>>>>> Based on the above, am I correct in inferring that when you talk
>>>>> about "encodings of H" what you actually mean is "implementations
>>>>> of a simulating halt decider".
>>>>>
>>>>> André
>>>>>
>>>>
>>>> Computer programmers write code.
>>>
>>>
>>> Yes, I am aware of that. Did you have a point?
>>>
>>
>> Then you are also aware that I used the term encoded correctly.
>
> That's a rather nonstandard use of the term. And it is particularly
> misleading when discussing the Linz proof and halt deciders in which
> context 'encode' means something rather different.
>
> And you AGAIN failed to address my other question:
>
> So would your H1 be one of those different "encodings"? The H1 which
> give a *different answer*? Apparently they *don't* all derive the exact
> same "pure" simulation.
>
> André
>

_P()
[00000c36](01) 55 push ebp
[00000c37](02) 8bec mov ebp,esp
[00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
[00000c3c](01) 50 push eax
[00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
[00000c40](01) 51 push ecx
[00000c41](05) e820fdffff call 00000966 // call H
[00000c46](03) 83c408 add esp,+08
[00000c49](02) 85c0 test eax,eax
[00000c4b](02) 7402 jz 00000c4f
[00000c4d](02) ebfe jmp 00000c4d
[00000c4f](01) 5d pop ebp
[00000c50](01) c3 ret
Size in bytes:(0027) [00000c50]

Begin Local Halt Decider Simulation at Machine Address:c36

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00000c36][002117ca][002117ce] 55 push ebp
[00000c37][002117ca][002117ce] 8bec mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50 push eax // push P
[00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51 push ecx // push P
[00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)

[00000c36][0025c1f2][0025c1f6] 55 push ebp
[00000c37][0025c1f2][0025c1f6] 8bec mov ebp,esp
[00000c39][0025c1f2][0025c1f6] 8b4508 mov eax,[ebp+08]
[00000c3c][0025c1ee][00000c36] 50 push eax // push P
[00000c3d][0025c1ee][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][0025c1ea][00000c36] 51 push ecx // push P
[00000c41][0025c1e6][00000c46] e820fdffff call 00000966 // call H(P,P)

We have to stay focused on the one single point that I perfectly and
totally proved that H did act as a pure simulator of the 14 steps of P
before we can move on to any other point.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Concise refutation of halting problem proofs

<K_idnXAS1_D-Ehn8nZ2dnUU7-dPNnZ2d@giganews.com>

 copy mid

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

 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: Thu, 04 Nov 2021 20:56:51 -0500
Date: Thu, 4 Nov 2021 20:56:50 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: Concise refutation of halting problem proofs
Content-Language: en-US
Newsgroups: comp.theory
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<87y263deg7.fsf@bsb.me.uk> <dNidnZrKUJ4byhn8nZ2dnUU7-LfNnZ2d@giganews.com>
<87ee7vcsgd.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87ee7vcsgd.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <K_idnXAS1_D-Ehn8nZ2dnUU7-dPNnZ2d@giganews.com>
Lines: 69
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Pox7ZszGQTIe3mKWDZDylOkG2tgx/O3SJ4/9rng2XDY4J3aLUJX2UYIPUO517VOizKDtwLLd5sKGs3U!ZRm0F5J+1KIHsDiZNH4Nku2VbwYggT34LFzKoYylI/epYRry7EwOncO5By4ISrhgCceXmS5iKS0n!5w==
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: 3885
 by: olcott - Fri, 5 Nov 2021 01:56 UTC

On 11/4/2021 8:16 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/4/2021 12:21 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> (1) and (2) conclusively prove that H(P,P) meets this criteria:
>>> The singular is "criterion".
>>>
>> I was thinking that too.
>>
>>>> 2021-11-03 Halt Deciding Criteria
>>>> It is impossible for any halt decider to be incorrect when the correct
>>>> pure simulation of its input never halts and it reports not halting.
>>>
>>> Unfortunately H(P,P) does not meet the criterion for being correct about
>>> the computation represented by it's arguments. H(P,P) == 0 when P(P)
>>> halts is wrong:
>>
>> Since you can't comprehend the x86 assembly language you are out of
>> your depth in this.
>
> You are funny! The definition of the halting problem is what it is.
>

And you are incapable of examining this at the totally concrete level of
the x86 language.

>> If you could understand the x86 source code of P then you
>> would see that its simulated execution trace does match this source
>> code thus making impossible for the simulation to be incorrect.
>
> You have provided the two key facts: H(P,P) == false and P(P) halts.
> You don't like to post the trace of P(P) but you did once. False is not
> the right answer for a halting computation.
>

If it doesn't pertain to the behavior of the x86 code of P it is off topic.

>>> Actual Halting Problem Criterion:
>>> H(M,I) == true is only correct if M(I) halts, and H(M,I) == false is
>>> only correct is M(I) does not halt.
>>>
>>> You know this. After 14 years you know that "no" is not the right
>>> answer for a halting instance of the problem.
>>> Starting new threads every day won't make anyone forget this.
>>
>> You can make all kinds of false assumptions...
>
> It's the definition of the halting problem. You know this too, because
> three years ago you claimed to have "H on input pair (Ĥ, Ĥ) meeting the
> Linz specs". An H the rejects an input representing a halting
> computation does not meet Linz's specs.
>

I have a 100-fold simpler proof now that only relies upon two easily
verifiable facts. It it utterly impossible to begin to have any slight
understanding of this proof without good knowledge of the x86 language.

> You are really floundering around looking for ways to not talk about how
> the problem is defined.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: Concise refutation of halting problem proofs

<ch0hJ.144997$Tr6.130772@fx47.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.2.1
Subject: Re: Concise refutation of halting problem proofs
Content-Language: en-US
Newsgroups: comp.theory
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<87k0hnd3nv.fsf@bsb.me.uk> <_Z6dnWOFjPmewBn8nZ2dnUU7-cPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <_Z6dnWOFjPmewBn8nZ2dnUU7-cPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 102
Message-ID: <ch0hJ.144997$Tr6.130772@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 4 Nov 2021 22:02:48 -0400
X-Received-Bytes: 5526
 by: Richard Damon - Fri, 5 Nov 2021 02:02 UTC

On 11/4/21 6:21 PM, olcott wrote:
> On 11/4/2021 4:14 PM, Ben Bacarisse wrote:
>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>>
>>> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>>>
>>>>> (1) The above 14 simulated lines are a correct pure simulation of the
>>>>> input to H(P,P) for every possible encoding of simulating halt
>>>>> decider H.
>>>>
>>>> What exactly does 'every possible encoding of simulating halt
>>>> decider H'
>>>> even mean?
>>>>
>>> You need to understand the PO is working with x86 code, not Turing
>>> machines.
>>
>> Not always.  He's also posted a lot of incorrect things about TMs.
>>
>>> So P does not contain an embedded near copy of H, as in Linz's scheme,
>>> but a call to H.  Now at first sight, that doesn't matter. But it
>>> allows for a mental separation between "the input" (the simple little
>>> driver which calls H and inverts behaviour when it gets the result)
>>> and H itself (the halt decider).
>>
>> How does this mental separation help PO ignore the fact that H gets the
>> answer wrong?
>
> (1) The key thing here is that no one ever needs to see the source code
> for H because an infinite number of different simulating halt deciders
> must have exactly the same behavior while they are doing a pure
> simulation of their input.

Correct, but remember what the definition of a pur simulator is, and
most of your Hs are NOT pure simulators. There is one case where it is,
and in that case H never aborts its simulation of P(P) and the P built
on that H actual is non-halting, but since that H was defined to never
abort the simulation, that H is ALSO non-halting and thus never gives
the non-halting answer, and thus fails to be a decider.

All you other Hs are NOT pure simulator, but only partial simulators (by
definition) and are incorrect about the behavior of the P that is based
on them, as it is halting based on it seeing the answer that its copy of
that H returnng to it the answer of non-halting, and halts just a bit
after the H that is simulating it gives up and incorrectly says it will
never halt.

>
> (2) We are not verifying whether or not the internal code of H correctly
> decides the halt status of its input, so we don't need to see this code.

But we CAN verify that it is incorrect.

IF H(P,P) returns non-halting then we KNOW BY DEFINITION that when P(P)
uses that H(P,P) is WILL get back in finite time that same non-halting
answer and will halt itself shortly thereafter. Thus ALL P that are
based on an H that answers H({P,P) as non-halting are halting, and that
H is wrong.

We don't need to see what H did, as like you say, it is irrelevent, it
doesn't matter what tortured logic it tries to use to justify that it
was correct in its logic, we can see by this simple logic that it must
be wrong.

If you want to TRY to make an argument about what its logic is
processing, you of course need to provide enough detail for people to
see the logic, you 'claim' that it is correct just doesn't cut it.

Now, you existing argument that you previous were making had the flaw
that H made assumptions in its simulation that no H(P,P) that it i
simulating will ever abort its simulation, but since then you have
H(P,P) abort it simulation, the logic is obviously been built on a false
premise, and thus is unsound.

>
> (3) It can be easily verified (by anyone knowing the x86 language) that
> it is a matter of fact that H does do a pure simulation of its input for
> the first 14 lines of this simulation.
>

No, it does NOT do a 'pure simulation'

First, the call instruction to H is NOT properly simulated, thus it is
not a pure simulation.

Second, the simulation is aborted, and thus H is BY DEFINITION not a
pure simulator, and the assumption that it is is flawed.

FAIL.

>
>> How do you excuse his simply ignoring the plain fact that
>> H(P,P) == false is the wrong answer?  I ask /you/, specifically, because
>> you seem to be kindly disposed towards PO, and I can't work it out at
>> all.  He can't not know that an H that gives the wrong answer is utterly
>> trivial.  He must know, that we know, that this can't be the miraculous
>> impossible TM he claimed to have tree years ago.  I just can't find any
>> flattering spin to put on it.
>>
>
>

Pages:1234
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor