Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.theory > #135606 > unrolled thread

Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself

Back to article view | Back to comp.theory

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.

Contents

  Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <NoOne@NoWhere.com> - 2025-11-14 13:52 -0600
    Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-14 19:57 +0000
      Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-14 14:11 -0600
        Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-14 20:23 +0000
          Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-14 14:44 -0600
            Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-14 21:40 +0000
              Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-14 16:05 -0600
                Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-15 02:35 +0000
                  Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-14 21:10 -0600
                    Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-15 03:51 +0000
                      Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself wij <wyniijj5@gmail.com> - 2025-11-15 12:57 +0800
                        Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself wij <wyniijj5@gmail.com> - 2025-11-15 13:23 +0800
                      Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-14 23:25 -0600
                        Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-15 05:37 +0000
                          Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-14 23:48 -0600
                            Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-15 06:47 +0000
                              Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-15 10:36 -0600
                          Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-11-15 16:27 +0000
                            Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-15 10:43 -0600
                              Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-15 18:11 +0000
                                Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-15 12:58 -0600
                                  Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-15 20:11 +0000
                                    Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-15 14:22 -0600
                                      Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-15 21:33 +0000
                                        Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-15 15:49 -0600
                                          Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-15 22:08 +0000
                                            Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-11-15 14:15 -0800
                                            Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-15 17:26 -0600
    Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-11-14 21:34 -0800
      Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-14 23:42 -0600
        Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-15 06:54 +0000
          Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-15 10:38 -0600
            Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-15 18:07 +0000
              Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-15 12:55 -0600
                Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-15 20:17 +0000
                  Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-11-15 13:11 -0800
      Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Tristan Wibberley <tristan.wibberley+netnews2@alumni.manchester.ac.uk> - 2025-11-15 13:57 +0000
        Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-11-15 16:36 -0800
          Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-15 19:00 -0600
    Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself HAL 9000 <hal@discovery.nasa> - 2025-11-16 00:56 +0000
      Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-15 19:14 -0600
        Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself HAL 9000 <hal@discovery.nasa> - 2025-11-16 12:42 +0000
          Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-16 09:29 -0600
            Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself HAL 9000 <hal@discovery.nasa> - 2025-11-16 16:46 +0000
              Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself olcott <polcott333@gmail.com> - 2025-11-16 11:07 -0600
              Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself joes <noreply@example.org> - 2025-11-16 17:11 +0000
                DD simulated by HHH cannot possibly terminate normally olcott <polcott333@gmail.com> - 2025-11-16 11:20 -0600
                Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself HAL 9000 <hal@discovery.nasa> - 2025-11-16 18:40 +0000
                Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-16 18:43 +0000
              Re: Kaz ---Keith said DDD simulated by HHH is equivalent to DDD calling itself "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-11-16 13:18 -0800

Page 2 of 3 — ← Prev page 1 [2] 3  Next page →

#135700

On 11/15/2025 12:11 PM, Kaz Kylheku wrote:
> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>> On 11/15/2025 10:27 AM, Mike Terry wrote:
>>> Both of those facts have been concretely demonstrated with PO's code,
>>> namely running HHH(DD) and DD() respectively, called directly from
>>> main().  [All PO's explanations for why that isn't a counter-argument
>>> are just silly, and are seen as silly by pretty much everyone reviewing
>>> as soon as they properly understand what PO is claiming.]  We can talk
>>> about things like "what HHH /would/ do if it never aborted" or "what
>>> HHH's simulation /would/ do if resumed", but they are beyond what the HP
>>> talks of, and do not make a fully convincing /proof/ of PO's
>>> incorrectness (IMO of course), unlike the simple (1) and (2) above.
>>> [(1) and (2) work, because they focus directly on what HP requires and
>>> what PO claims.]
>>>
>>>
>>> Mike.
>>>
>>
>>> On 2025-11-05, olcott <polcott333@gmail.com> wrote:
>>>>
>>>> The whole point is that D simulated by H
>>>> cannot possbly reach its own simulated
>>>> "return" statement no matter what H does.
>>>
>>> Yes; this doesn't happen while H is running.
>>>
>>> So while H does /something/, no matter what H does,
>>> that D simulation won't reach the return statement.
>>>
>>
>> Kaz already admitted that D simulated by H
>> cannot possibly reach its own "return"
>> statement final halt state, thus anything
>> that he says after that regarding the behavior
>> of D simulated by H is necessarily nonsense.
> 
> What I mean by that is that the simulation of D
> doesn't reach that statement while conducted by H.
> 

Thus conclusively proving the the input to H(D)
specifies non-halting behavior when D simulated
by H cannot possibly reach its own "return"
statement final halt state is the measure of
the behavior of the input to H(D).

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

[toc] | [prev] | [next] | [standalone]

#135710

On 2025-11-15, olcott <polcott333@gmail.com> wrote:
> On 11/15/2025 12:11 PM, Kaz Kylheku wrote:
>> What I mean by that is that the simulation of D
>> doesn't reach that statement while conducted by H.
>> 
>
> Thus conclusively proving the the input to H(D)

No, the mere incompleteness of a simulation does not prove
that the subject terminates or does not terminate.

If the decider doesn't carry the simulation to completion, it also needs
to evaluate some criteria to decide it anyway.

Those criteria have to be correct, or else it makes the wrong decision.

> specifies non-halting behavior when D simulated
> by H cannot possibly reach its own "return"
> statement final halt state is the measure of
> the behavior of the input to H(D).

No such proof takes place when the simulation is stopped because of
/incorrect/ criteria.

And the diagonal test case assures us that the criteria are always
wrong.

There is not a femtometer of wiggle room for any doubt.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

[toc] | [prev] | [next] | [standalone]

#135715

On 11/15/2025 2:11 PM, Kaz Kylheku wrote:
> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>> On 11/15/2025 12:11 PM, Kaz Kylheku wrote:
>>> What I mean by that is that the simulation of D
>>> doesn't reach that statement while conducted by H.
>>>
>>
>> Thus conclusively proving the the input to H(D)
> 
> No, the mere incompleteness of a simulation does not prove
> that the subject terminates or does not terminate.
> 

 > On 2025-11-05, olcott <polcott333@gmail.com> wrote:
 >>
 >> The whole point is that D simulated by H
 >> cannot possbly reach its own simulated
 >> "return" statement no matter what H does.
 >
 > Yes; this doesn't happen while H is running.
 >
 > So while H does /something/, no matter what H does,
 > that D simulation won't reach the return statement.
 >

You already admitted that D simulated by H
cannot possibly reach its own final halt state.

The means that D simulated by H cannot possibly
halt and it also means that D simulated by H
would never stop running unless aborted.

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

[toc] | [prev] | [next] | [standalone]

#135727

On 2025-11-15, olcott <polcott333@gmail.com> wrote:
> On 11/15/2025 2:11 PM, Kaz Kylheku wrote:
>> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>>> On 11/15/2025 12:11 PM, Kaz Kylheku wrote:
>>>> What I mean by that is that the simulation of D
>>>> doesn't reach that statement while conducted by H.
>>>>
>>>
>>> Thus conclusively proving the the input to H(D)
>> 
>> No, the mere incompleteness of a simulation does not prove
>> that the subject terminates or does not terminate.
>> 
>
> > On 2025-11-05, olcott <polcott333@gmail.com> wrote:
> >>
> >> The whole point is that D simulated by H
> >> cannot possbly reach its own simulated
> >> "return" statement no matter what H does.
> >
> > Yes; this doesn't happen while H is running.
> >
> > So while H does /something/, no matter what H does,
> > that D simulation won't reach the return statement.
> >
>
> You already admitted that D simulated by H
> cannot possibly reach its own final halt state.

The full limit of my observation is this: the /simulation/ conducted by
H, of D, is not conducted far enough to reproduce the situation where D
returns. That's the most exact wording, no more no less.

In particular, I am not saying D doesn't have a final halt state, only
that if it doesn't it isn't /reproduced/ in /that/ simulation.

> The means that D simulated by H cannot possibly
> halt and it also means that D simulated by H
> would never stop running unless aborted.

You have to make up your mind! Which of these
is youru point of view, or at least closer to it:

- The fact of H not simulating D far enough causes
  D not to be terminating, because when the
  simulation is suspended, progress toward
  D's return statement is suspended. Effectively,
  D is slowed down to infinitely slow speed,
  and so cannot reach the return statement.

- D is /inherently/ not terminating when simulated
  by H. The fact that H suspends the simulation
  before D reaches any point where it could decide
  to terminate is incidental to this---D is
  not progressing any such point even if we don't
  consider the suspension of the simulation.

?
-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

[toc] | [prev] | [next] | [standalone]

#135730

On 11/15/2025 3:33 PM, Kaz Kylheku wrote:
> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>> On 11/15/2025 2:11 PM, Kaz Kylheku wrote:
>>> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>>>> On 11/15/2025 12:11 PM, Kaz Kylheku wrote:
>>>>> What I mean by that is that the simulation of D
>>>>> doesn't reach that statement while conducted by H.
>>>>>
>>>>
>>>> Thus conclusively proving the the input to H(D)
>>>
>>> No, the mere incompleteness of a simulation does not prove
>>> that the subject terminates or does not terminate.
>>>
>>
>>> On 2025-11-05, olcott <polcott333@gmail.com> wrote:
>>>>
>>>> The whole point is that D simulated by H
>>>> cannot possbly reach its own simulated
>>>> "return" statement no matter what H does.
>>>
>>> Yes; this doesn't happen while H is running.
>>>
>>> So while H does /something/, no matter what H does,
>>> that D simulation won't reach the return statement.
>>>
>>
>> You already admitted that D simulated by H
>> cannot possibly reach its own final halt state.
> 
> The full limit of my observation is this: the /simulation/ conducted by
> H, of D, is not conducted far enough to reproduce the situation where D
> returns. That's the most exact wording, no more no less.
> 

That is a damned lie. When I said damned I mean that
you might actually be condemned to actual Hell.
The whole purpose of my 28 year long primary research
was to show how "true on the basis of meaning" can be
made computable.

In the intervening time the survival of life on Earth
has come to depend on such a system that can refute the
hired liars of climate change.

Severe anthropogenic climate change
proven entirely with verifiable facts

https://www.researchgate.net/publication/336568434_Severe_anthropogenic_climate_change_proven_entirely_with_verifiable_facts 


So while you may think that your lies are mere trollish
fun if the planet is killed off in part because of your
lies their may be actual Hell toupee.

 > On 2025-11-05, olcott <polcott333@gmail.com> wrote:
 >>
 >> The whole point is that D simulated by H
 >> cannot possbly reach its own simulated
 >> "return" statement no matter what H does.
 >
 > Yes; this doesn't happen while H is running.
 >
 > So while H does /something/, no matter what H does,
 > that D simulation won't reach the return statement.
 >


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

[toc] | [prev] | [next] | [standalone]

#135734

On 2025-11-15, olcott <polcott333@gmail.com> wrote:
> On 11/15/2025 3:33 PM, Kaz Kylheku wrote:
>> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>>> You already admitted that D simulated by H
>>> cannot possibly reach its own final halt state.
>> 
>> The full limit of my observation is this: the /simulation/ conducted by
>> H, of D, is not conducted far enough to reproduce the situation where D
>> returns. That's the most exact wording, no more no less.
>> 
>
> That is a damned lie.

So you are sayiing that the simulation conduced by H, of D,
/is/ conducted far enough to reproduce the situation where D
returns?

When D is the diagonal D, we are not observing that, right?

*Headscratch*

> When I said damned I mean that
> you might actually be condemned to actual Hell.
> The whole purpose of my 28 year long primary research
> was to show how "true on the basis of meaning" can be
> made computable.

True is not based on meaning. Primary truth are based on
a correspondence between propositions and the state of
the world that those propostions are about.

After that, it's all logical operators combining
them together, hopefully in ways that preserve truths.

> So while you may think that your lies are mere trollish
> fun if the planet is killed off in part because of your
> lies their may be actual Hell toupee.

That's weapons-grade crazy. If you dohn't agree with a lunatic who
thinks the halting problem in math/CS is wrong, you are helping destroy
the planet.

Seriously, pause to listen to yourself for a moment.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

[toc] | [prev] | [next] | [standalone]

#135736

On 11/15/2025 2:08 PM, Kaz Kylheku wrote:
> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>> On 11/15/2025 3:33 PM, Kaz Kylheku wrote:
>>> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>>>> You already admitted that D simulated by H
>>>> cannot possibly reach its own final halt state.
>>>
>>> The full limit of my observation is this: the /simulation/ conducted by
>>> H, of D, is not conducted far enough to reproduce the situation where D
>>> returns. That's the most exact wording, no more no less.
>>>
>>
>> That is a damned lie.
> 
> So you are sayiing that the simulation conduced by H, of D,
> /is/ conducted far enough to reproduce the situation where D
> returns?
> 
> When D is the diagonal D, we are not observing that, right?
> 
> *Headscratch*
> 
>> When I said damned I mean that
>> you might actually be condemned to actual Hell.
>> The whole purpose of my 28 year long primary research
>> was to show how "true on the basis of meaning" can be
>> made computable.
> 
> True is not based on meaning. Primary truth are based on
> a correspondence between propositions and the state of
> the world that those propostions are about.
> 
> After that, it's all logical operators combining
> them together, hopefully in ways that preserve truths.
> 
>> So while you may think that your lies are mere trollish
>> fun if the planet is killed off in part because of your
>> lies their may be actual Hell toupee.
> 
> That's weapons-grade crazy. If you dohn't agree with a lunatic who
> thinks the halting problem in math/CS is wrong, you are helping destroy
> the planet.
> 
> Seriously, pause to listen to yourself for a moment.
> 

Loony Tunes with a rather odd brain disorder?...

[toc] | [prev] | [next] | [standalone]

#135746

On 11/15/2025 4:08 PM, Kaz Kylheku wrote:
> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>> On 11/15/2025 3:33 PM, Kaz Kylheku wrote:
>>> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>>>> You already admitted that D simulated by H
>>>> cannot possibly reach its own final halt state.
>>>
>>> The full limit of my observation is this: the /simulation/ conducted by
>>> H, of D, is not conducted far enough to reproduce the situation where D
>>> returns. That's the most exact wording, no more no less.
>>>
>>
>> That is a damned lie.
> 
> So you are sayiing that the simulation conduced by H, of D,
> /is/ conducted far enough to reproduce the situation where D
> returns?
> 

I am saying that you are flat out lying about
what you already agreed to.

On 11/4/2025 8:43 PM, Kaz Kylheku wrote:
 > On 2025-11-05, olcott <polcott333@gmail.com> wrote:
 >>
 >> ...D simulated by H cannot possibly reach its own
 >> simulated "return" statement...
 >
 > Yes; this doesn't happen while H is running.
 >


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

[toc] | [prev] | [next] | [standalone]

#135642

olcott <NoOne@NoWhere.com> writes:
> On 5/8/2025 8:30 PM, Keith Thompson wrote:
[...]

Ah, I see olcott is using an innocuous statement I made several months
ago and claiming it supports his ideas.

....

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */

[toc] | [prev] | [next] | [standalone]

#135645

On 11/14/2025 11:34 PM, Keith Thompson wrote:
> olcott <NoOne@NoWhere.com> writes:
>> On 5/8/2025 8:30 PM, Keith Thompson wrote:
> [...]
> 
> Ah, I see olcott is using an innocuous statement I made several months
> ago and claiming it supports his ideas.
> 
> ....
> 

It does. Kaz is trying to get away with deception.

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

Kaz is trying to get away with saying that although
D simulated by H cannot reach its "return" statement
while it is being simulated if it was simulated one
more time than it was simulated that the simulated
D would reach its own "return" statement final halt
state.

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

[toc] | [prev] | [next] | [standalone]

#135650

On 2025-11-15, olcott <polcott333@gmail.com> wrote:
> On 11/14/2025 11:34 PM, Keith Thompson wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>> On 5/8/2025 8:30 PM, Keith Thompson wrote:
>> [...]
>> 
>> Ah, I see olcott is using an innocuous statement I made several months
>> ago and claiming it supports his ideas.
>> 
>> ....
>> 
>
> It does. Kaz is trying to get away with deception.
>
> int D()
> {
>    int Halt_Status = H(D);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
>
> Kaz is trying to get away with saying that although

No, I'm not getting away with /saying/. I've coded it
and verified with execution traces.

The code is public; you could clone the repo (or
point to it as a remote and pull from it) and
experiment with the code.

> D simulated by H cannot reach its "return" statement
> while it is being simulated if it was simulated one
> more time than it was simulated that the simulated
> D would reach its own "return" statement final halt
> state.

Not just one more time; it takes a bunch of additional
DebugStep calls.

Depending on the exact Halt.obj we are talking
about the details differ.

In the February 2025 Halt.obj, there is a DDD/HHH test case. DDD is
abandoned while it is calling HHH, which is in the middle of calling
Decide_Halting_HH.

Decide_Halting_HH contains the loop which is conducting the
next level simulation. That simulation has just hit CALL HHH
and so the abort pattern kicks in.

So the frozen simulation of the top DDD is sitting in
Decide_Halting_HH.

It takes a number of DebugStep calls to get it to bail out of that loop;
that loop has to detect a second occurrence of the abort patter and
return to its caller, the simulated HHH, which then returns 0. I could
count how many instructions that takes, if necesary.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

[toc] | [prev] | [next] | [standalone]

#135680

On 11/15/2025 12:54 AM, Kaz Kylheku wrote:
> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>> On 11/14/2025 11:34 PM, Keith Thompson wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>> On 5/8/2025 8:30 PM, Keith Thompson wrote:
>>> [...]
>>>
>>> Ah, I see olcott is using an innocuous statement I made several months
>>> ago and claiming it supports his ideas.
>>>
>>> ....
>>>
>>
>> It does. Kaz is trying to get away with deception.
>>
>> int D()
>> {
>>     int Halt_Status = H(D);
>>     if (Halt_Status)
>>       HERE: goto HERE;
>>     return Halt_Status;
>> }
>>
>> Kaz is trying to get away with saying that although
> 
> No, I'm not getting away with /saying/. I've coded it
> and verified with execution traces.
> 
> The code is public; you could clone the repo (or
> point to it as a remote and pull from it) and
> experiment with the code.
> 
>> D simulated by H cannot reach its "return" statement
>> while it is being simulated if it was simulated one
>> more time than it was simulated that the simulated
>> D would reach its own "return" statement final halt
>> state.
> 
> Not just one more time; it takes a bunch of additional
> DebugStep calls.
> 

 > On 2025-11-05, olcott <polcott333@gmail.com> wrote:
 >>
 >> The whole point is that D simulated by H
 >> cannot possbly reach its own simulated
 >> "return" statement no matter what H does.
 >
 > Yes; this doesn't happen while H is running.
 >
 > So while H does /something/, no matter what H does,
 > that D simulation won't reach the return statement.
 >

You already admitted that infinity is not enough.
This means that you contradicted yourself.
-- 
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[toc] | [prev] | [next] | [standalone]

#135694

On 2025-11-15, olcott <polcott333@gmail.com> wrote:
> On 11/15/2025 12:54 AM, Kaz Kylheku wrote:
>> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>>> On 11/14/2025 11:34 PM, Keith Thompson wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>> On 5/8/2025 8:30 PM, Keith Thompson wrote:
>>>> [...]
>>>>
>>>> Ah, I see olcott is using an innocuous statement I made several months
>>>> ago and claiming it supports his ideas.
>>>>
>>>> ....
>>>>
>>>
>>> It does. Kaz is trying to get away with deception.
>>>
>>> int D()
>>> {
>>>     int Halt_Status = H(D);
>>>     if (Halt_Status)
>>>       HERE: goto HERE;
>>>     return Halt_Status;
>>> }
>>>
>>> Kaz is trying to get away with saying that although
>> 
>> No, I'm not getting away with /saying/. I've coded it
>> and verified with execution traces.
>> 
>> The code is public; you could clone the repo (or
>> point to it as a remote and pull from it) and
>> experiment with the code.
>> 
>>> D simulated by H cannot reach its "return" statement
>>> while it is being simulated if it was simulated one
>>> more time than it was simulated that the simulated
>>> D would reach its own "return" statement final halt
>>> state.
>> 
>> Not just one more time; it takes a bunch of additional
>> DebugStep calls.
>> 
>
> > On 2025-11-05, olcott <polcott333@gmail.com> wrote:
> >>
> >> The whole point is that D simulated by H
> >> cannot possbly reach its own simulated
> >> "return" statement no matter what H does.
> >
> > Yes; this doesn't happen while H is running.
> >
> > So while H does /something/, no matter what H does,
> > that D simulation won't reach the return statement.
> >
>
> You already admitted that infinity is not enough.
> This means that you contradicted yourself.

Well, yes; no matter how we design H; so that matter after how many
steps it quits and rejects D, that many steps is not enough.

But after H quits, the unfinished simulation that remains only has a
small, finite number of steps left to reach the return in D.

For H, no number of steps is long enough; the diagonal test
case D always keeps that out of its reach.

Just like a dog's tail always runs just as fast as the dog.

Another dog can easily catch that dog's tail though; the 
tail is not uncatchable.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

[toc] | [prev] | [next] | [standalone]

#135699

On 11/15/2025 12:07 PM, Kaz Kylheku wrote:
> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>> On 11/15/2025 12:54 AM, Kaz Kylheku wrote:
>>> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>>>> On 11/14/2025 11:34 PM, Keith Thompson wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>> On 5/8/2025 8:30 PM, Keith Thompson wrote:
>>>>> [...]
>>>>>
>>>>> Ah, I see olcott is using an innocuous statement I made several months
>>>>> ago and claiming it supports his ideas.
>>>>>
>>>>> ....
>>>>>
>>>>
>>>> It does. Kaz is trying to get away with deception.
>>>>
>>>> int D()
>>>> {
>>>>      int Halt_Status = H(D);
>>>>      if (Halt_Status)
>>>>        HERE: goto HERE;
>>>>      return Halt_Status;
>>>> }
>>>>
>>>> Kaz is trying to get away with saying that although
>>>
>>> No, I'm not getting away with /saying/. I've coded it
>>> and verified with execution traces.
>>>
>>> The code is public; you could clone the repo (or
>>> point to it as a remote and pull from it) and
>>> experiment with the code.
>>>
>>>> D simulated by H cannot reach its "return" statement
>>>> while it is being simulated if it was simulated one
>>>> more time than it was simulated that the simulated
>>>> D would reach its own "return" statement final halt
>>>> state.
>>>
>>> Not just one more time; it takes a bunch of additional
>>> DebugStep calls.
>>>
>>
>>> On 2025-11-05, olcott <polcott333@gmail.com> wrote:
>>>>
>>>> The whole point is that D simulated by H
>>>> cannot possbly reach its own simulated
>>>> "return" statement no matter what H does.
>>>
>>> Yes; this doesn't happen while H is running.
>>>
>>> So while H does /something/, no matter what H does,
>>> that D simulation won't reach the return statement.
>>>
>>
>> You already admitted that infinity is not enough.
>> This means that you contradicted yourself.
> 
> Well, yes; no matter how we design H; so that matter after how many
> steps it quits and rejects D, that many steps is not enough.
> 
> But after H quits, the unfinished simulation that remains only has a
> small, finite number of steps left to reach the return in D.
> 

That cannot possibly exist in the behavior
that the input to H(D) specifies as measured
by D simulated by H.

> For H, no number of steps is long enough; the diagonal test
> case D always keeps that out of its reach.
> 
> Just like a dog's tail always runs just as fast as the dog.
> 
> Another dog can easily catch that dog's tail though; the
> tail is not uncatchable.
> 


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

[toc] | [prev] | [next] | [standalone]

#135713

On 2025-11-15, olcott <polcott333@gmail.com> wrote:
> On 11/15/2025 12:07 PM, Kaz Kylheku wrote:
>> Well, yes; no matter how we design H; so that matter after how many
>> steps it quits and rejects D, that many steps is not enough.
>> 
>> But after H quits, the unfinished simulation that remains only has a
>> small, finite number of steps left to reach the return in D.
>> 
>
> That cannot possibly exist in the behavior
> that the input to H(D) specifies as measured
> by D simulated by H.

Proof? By what mechanism does the simulation cease to exist?

How can such a thing happen to any mathematical object?

Is the number pi at risk of ceasing to exist, too?

How about the Möbius strip? Safe, or at peril? 

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

[toc] | [prev] | [next] | [standalone]

#135724

On 11/15/2025 12:17 PM, Kaz Kylheku wrote:
> On 2025-11-15, olcott <polcott333@gmail.com> wrote:
>> On 11/15/2025 12:07 PM, Kaz Kylheku wrote:
>>> Well, yes; no matter how we design H; so that matter after how many
>>> steps it quits and rejects D, that many steps is not enough.
>>>
>>> But after H quits, the unfinished simulation that remains only has a
>>> small, finite number of steps left to reach the return in D.
>>>
>>
>> That cannot possibly exist in the behavior
>> that the input to H(D) specifies as measured
>> by D simulated by H.
> 
> Proof? By what mechanism does the simulation cease to exist?
> 
> How can such a thing happen to any mathematical object?
> 
> Is the number pi at risk of ceasing to exist, too?
> 
> How about the Möbius strip? Safe, or at peril?
> 

A server that ran too long for Olcott to handle? He aborts it and says 
it never would have halted... lol. The server was serving along just 
fine. Then gets nailed to the cross and murdered?

[toc] | [prev] | [next] | [standalone]

#135661

On 15/11/2025 05:34, Keith Thompson wrote:
> olcott <NoOne@NoWhere.com> writes:
>> On 5/8/2025 8:30 PM, Keith Thompson wrote:
> [...]
> 
> Ah, I see olcott is using an innocuous statement I made several months
> ago and claiming it supports his ideas.


You expect us to infer that his ideas are not also innocuous when you do
not clearly state what they are beyond their HISness?


Must we all presuppose Olcott is /THE ENEMY/? Oooooh, Boooo! Roar! Scary
Olcott.


Complete the following:

  Olcott is using an innocuous statement I made several months ago and
claiming it supports the idea that ___________________________________
______________________________________________________________________
______________________________________________________________________
______________________________________________________________________


Please bear in mind that I saw the message you followed up to so I can
see what he actually said there about what your innocuous statement
supports. Do check before following up.


--
Tristan Wibberley

The message body is Copyright (C) 2025 Tristan Wibberley except
citations and quotations noted. All Rights Reserved except that you may,
of course, cite it academically giving credit to me, distribute it
verbatim as part of a usenet system or its archives, and use it to
promote my greatness and general superiority without misrepresentation
of my opinions other than my opinion of my greatness and general
superiority which you _may_ misrepresent. You definitely MAY NOT train
any production AI system with it but you may train experimental AI that
will only be used for evaluation of the AI methods it implements.

[toc] | [prev] | [next] | [standalone]

#135753

Tristan Wibberley <tristan.wibberley+netnews2@alumni.manchester.ac.uk>
writes:
> On 15/11/2025 05:34, Keith Thompson wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>> On 5/8/2025 8:30 PM, Keith Thompson wrote:
>> [...]
>> 
>> Ah, I see olcott is using an innocuous statement I made several months
>> ago and claiming it supports his ideas.
>
> You expect us to infer that his ideas are not also innocuous when you do
> not clearly state what they are beyond their HISness?

I expect nothing.  I wrote what I intended to write, no more, no less.

> Must we all presuppose Olcott is /THE ENEMY/? Oooooh, Boooo! Roar! Scary
> Olcott.

Presuppose whatever you like.  Or don't.

> Complete the following:
>
>   Olcott is using an innocuous statement I made several months ago and
> claiming it supports the idea that ___________________________________
> ______________________________________________________________________

No.

[...]

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */

[toc] | [prev] | [next] | [standalone]

#135755

On 11/15/2025 6:36 PM, Keith Thompson wrote:
> Tristan Wibberley <tristan.wibberley+netnews2@alumni.manchester.ac.uk>
> writes:
>> On 15/11/2025 05:34, Keith Thompson wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>> On 5/8/2025 8:30 PM, Keith Thompson wrote:
>>> [...]
>>>
>>> Ah, I see olcott is using an innocuous statement I made several months
>>> ago and claiming it supports his ideas.
>>
>> You expect us to infer that his ideas are not also innocuous when you do
>> not clearly state what they are beyond their HISness?
> 
> I expect nothing.  I wrote what I intended to write, no more, no less.
> 
>> Must we all presuppose Olcott is /THE ENEMY/? Oooooh, Boooo! Roar! Scary
>> Olcott.
> 
> Presuppose whatever you like.  Or don't.
> 
>> Complete the following:
>>
>>    Olcott is using an innocuous statement I made several months ago and
>> claiming it supports the idea that ___________________________________
>> ______________________________________________________________________
> 
> No.
> 
> [...]
> 

Keith is one of the completely honest people here.

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

[toc] | [prev] | [next] | [standalone]

#135754

On Fri, 14 Nov 2025 13:52:14 -0600, olcott wrote:

> On 5/8/2025 8:30 PM, Keith Thompson wrote:
>> olcott <polcott333@gmail.com> writes:
>>> On 5/8/2025 6:49 PM, Keith Thompson wrote:
>>>> olcott <polcott333@gmail.com> writes:
>>>> [...]
>>>>> void DDD()
>>>>> {
>>>>>     HHH(DDD);
>>>>>     return;
>>>>> }
>>>>>
>>>>> If you are a competent C programmer then you know that DDD correctly
>>>>> simulated by HHH cannot possibly each its own "return" instruction.
>>>> "cannot possibly each"?
> 
> This is what On 5/8/2025 8:30 PM, Keith Thompson wrote:
> is responding to below:
> 
>>>> I am a competent C programmer (and I don't believe you can make the
>>>> same claim).  I don't know what HHH is.  The name "HHH" tells me
>>>> nothing about what it's supposed to do.  Without knowing what HHH is,
>>>> I can't say much about your code (or is it pseudo-code?).
>>>>
>>>>
>>> For the purpose of this discussion HHH is exactly what I said it is.
>>> It correctly simulates DDD.
>> 
>> Does HHH correctly simulate DDD *and do nothing else*?
>> 
>> Does HHH correctly simulate *every* function whose address is passed to
>> it?  Must the passed function be one that takes no arguments and does
>> not return a value?
>> 
>> Can HHH just *call* the function whose address is passed to it?
>> If it's a correct simulation, there should be no difference between
>> calling the function and "correctly simulating" it.
>> 
>> My knowledge of C tells me nothing about *how* HHH might simulate DDD.
>> 
>>> We need not know anything else about HHH to know that DDD correctly
>>> simulated by HHH cannot possibly REACH its own "return" instruction.
>> 
>> 
> *Here is his response *
> 
>> Assuming that HHH(DDD) "correctly simulates" DDD, and assuming it does
>> nothing else, your code would be equivalent to this:
>> 
>>      void DDD(void) {
>>          DDD(); return;
>>      }
>> 
>> Then the return statement (which is unnecessary anyway) will never be
>> reached.  In practice, the program will likely crash due to a stack
>> overflow, unless the compiler implements tail-call optimization, in
>> which case the program might just run forever -- which also means the
>> unnecessary return statement will never be reached.
>>

That is only the case if HHH is of an erroneous design: whatever HHH does 
with DDD should NOT leak out of HHH so your SHD is designed incorrectly.  
If HHH(DDD) reports non-halting then DDD will halt thus HHH is erroneous.

/HAL

[toc] | [prev] | [next] | [standalone]

Page 2 of 3 — ← Prev page 1 [2] 3  Next page →

Back to top | Article view | comp.theory

csiph-web