Groups > comp.lang.c++ > #122954 > unrolled thread

D simulated by H cannot possibly reach its own simulated final halt state

Started by	olcott <polcott333@gmail.com>
First post	2025-11-06 14:48 -0600
Last post	2025-12-03 19:54 -0600
Articles	20 on this page of 63 — 9 participants

Back to article view | Back to comp.lang.c++

  D simulated by H cannot possibly reach its own simulated final halt state olcott <polcott333@gmail.com> - 2025-11-06 14:48 -0600
    How pathological self-reference is confused with undecidability olcott <polcott333@gmail.com> - 2025-11-11 19:38 -0600
      Re: How pathological self-reference is confused with undecidability Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-12 02:13 +0000
        Re: How pathological self-reference is confused with undecidability olcott <polcott333@gmail.com> - 2025-11-11 20:33 -0600
        Re: How pathological self-reference is confused with undecidability olcott <polcott333@gmail.com> - 2025-11-11 21:05 -0600
          Re: How pathological self-reference is confused with undecidability olcott <polcott333@gmail.com> - 2025-11-11 21:45 -0600
            Re: How pathological self-reference is confused with undecidability Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-12 05:52 +0000
              Re: How pathological self-reference is confused with undecidability olcott <polcott333@gmail.com> - 2025-11-11 23:59 -0600
                Re: How pathological self-reference is confused with undecidability Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-12 06:13 +0000
                  Re: How pathological self-reference is confused with undecidability olcott <polcott333@gmail.com> - 2025-11-12 06:50 -0600
    Re: D simulated by H cannot possibly reach its own simulated final halt state olcott <polcott333@gmail.com> - 2025-11-11 20:41 -0600
      Re: D simulated by H cannot possibly reach its own simulated final halt state olcott <polcott333@gmail.com> - 2025-11-12 09:11 -0600
      Re: D simulated by H cannot possibly reach its own simulated final halt state olcott <polcott333@gmail.com> - 2025-11-12 20:30 -0600
        Re: D simulated by H cannot possibly reach its own simulated final halt state dbush <dbush.mobile@gmail.com> - 2025-11-12 21:35 -0500
      Re: D simulated by H cannot possibly reach its own simulated final halt state olcott <polcott333@gmail.com> - 2025-11-13 14:22 -0600
    Weasel word double talk excuses =--- AKA Liars olcott <polcott333@gmail.com> - 2025-11-18 15:57 -0600
    Re: D simulated by H cannot possibly reach its own simulated final halt state olcott <polcott333@gmail.com> - 2025-11-18 21:07 -0600
      Re: D simulated by H cannot possibly reach its own simulated final halt state Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-19 04:30 +0000
      DDD simulated by HHH cannot possibly reach its own simulated final halt state olcott <polcott333@gmail.com> - 2025-11-18 22:45 -0600
        Re: DDD simulated by HHH cannot possibly reach its own simulated final halt state Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-19 04:52 +0000
        Re: DDD simulated by HHH cannot possibly reach its own simulated final halt state olcott <polcott333@gmail.com> - 2025-11-18 23:08 -0600
          Re: DDD simulated by HHH cannot possibly reach its own simulated final halt state dbush <dbush.mobile@gmail.com> - 2025-11-19 00:14 -0500
          Re: DDD simulated by HHH cannot possibly reach its own simulated final halt state Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-19 05:23 +0000
      Glossary of names of my simulating termination analyzer HHH(DD) olcott <polcott333@gmail.com> - 2025-11-23 16:29 -0600
    polcott agrees the Kaz is a damned liar --- DD simulated by HHH olcott <polcott333@gmail.com> - 2025-11-22 07:22 -0600
      Re: polcott agrees the Kaz is a damned liar --- DD simulated by HHH Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-22 17:51 +0000
        Re: polcott agrees the Kaz is a damned liar --- DD simulated by HHH olcott <polcott333@gmail.com> - 2025-11-22 12:06 -0600
    polcott agrees the Kaz is a damned liar --- DD simulated by HHH olcott <polcott333@gmail.com> - 2025-11-22 07:33 -0600
      Re: polcott agrees the Kaz is a damned liar --- DD simulated by HHH Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-22 17:56 +0000
        Dangerous Precipice that could end all life --- DD simulated by HHH olcott <polcott333@gmail.com> - 2025-11-22 13:29 -0600
          Re: Dangerous Precipice that could end all life --- DD simulated by HHH olcott <polcott333@gmail.com> - 2025-11-22 23:02 -0600
            Re: Dangerous Precipice that could end all life --- DD simulated by HHH Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-23 05:23 +0000
            Re: Dangerous Precipice that could end all life --- DD simulated by HHH olcott <polcott333@gmail.com> - 2025-11-23 14:53 -0600
              Re: Dangerous Precipice that could end all life --- DD simulated by HHH "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-11-23 13:32 -0800
              Re: Dangerous Precipice that could end all life --- DD simulated by HHH Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-24 02:44 +0000
            DD simulated by HHH and DD simulated by HHH1 olcott <polcott333@gmail.com> - 2025-11-23 21:15 -0600
              Re: DD simulated by HHH and DD simulated by HHH1 Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-24 16:32 +0000
              Re: DD simulated by HHH and DD simulated by HHH1 olcott <polcott333@gmail.com> - 2025-11-24 10:45 -0600
                Re: DD simulated by HHH and DD simulated by HHH1 tTh <tth@none.invalid> - 2025-11-24 19:45 +0100
              Re: DD simulated by HHH and DD simulated by HHH1 olcott <polcott333@gmail.com> - 2025-11-24 12:08 -0600
                Re: DD simulated by HHH and DD simulated by HHH1 Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-24 19:22 +0000
                Re: DD simulated by HHH and DD simulated by HHH1 olcott <polcott333@gmail.com> - 2025-11-24 14:20 -0600
                  Re: DD simulated by HHH and DD simulated by HHH1 Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-24 22:31 +0000
                  Re: DD simulated by HHH and DD simulated by HHH1 olcott <NoOne@NoWhere.com> - 2025-11-24 17:23 -0600
                    Re: DD simulated by HHH and DD simulated by HHH1 Richard Heathfield <rjh@cpax.org.uk> - 2025-11-25 05:10 +0000
              Re: DD simulated by HHH and DD simulated by HHH1 olcott <polcott333@gmail.com> - 2025-11-24 14:15 -0600
                Re: DD simulated by HHH and DD simulated by HHH1 olcott <polcott333@gmail.com> - 2025-11-24 17:21 -0600
              Re: DD simulated by HHH and DD simulated by HHH1 olcott <polcott333@gmail.com> - 2025-11-24 17:19 -0600
                Re: DD simulated by HHH and DD simulated by HHH1 "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-11-24 16:15 -0800
                  Re: DD simulated by HHH and DD simulated by HHH1 "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2025-11-24 16:25 -0800
                Re: DD simulated by HHH and DD simulated by HHH1 Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-25 01:39 +0000
              Re: DD simulated by HHH and DD simulated by HHH1 olcott <NoOne@NoWhere.com> - 2025-11-24 17:24 -0600
                Re: DD simulated by HHH and DD simulated by HHH1 Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-25 01:42 +0000
              Re: DD simulated by HHH and DD simulated by HHH1 olcott <polcott333@gmail.com> - 2025-11-24 18:33 -0600
              Re: DD simulated by HHH and DD simulated by HHH1 olcott <polcott333@gmail.com> - 2025-11-25 13:35 -0600
                Re: DD simulated by HHH and DD simulated by HHH1 Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-25 20:27 +0000
    Re: D simulated by H cannot possibly reach its own simulated final halt state Bonita Montero <Bonita.Montero@gmail.com> - 2025-11-25 16:20 +0100
      Re: D simulated by H cannot possibly reach its own simulated final halt state olcott <polcott333@gmail.com> - 2025-11-25 09:47 -0600
        Re: D simulated by H cannot possibly reach its own simulated final halt state Bonita Montero <Bonita.Montero@gmail.com> - 2025-11-25 16:50 +0100
          Re: D simulated by H cannot possibly reach its own simulated final halt state olcott <polcott333@gmail.com> - 2025-11-25 10:09 -0600
            Re: D simulated by H cannot possibly reach its own simulated final halt state Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-25 17:33 +0000
        Re: D simulated by H cannot possibly reach its own simulated final halt state Richard Damon <Richard@Damon-Family.org> - 2025-11-25 11:37 -0500
    Olcott is provably correct --- no one can correctly refute this olcott <polcott333@gmail.com> - 2025-12-03 19:54 -0600

Page 1 of 4 [1] 2 3 4 Next page →

#122954 — D simulated by H cannot possibly reach its own simulated final halt state

From	olcott <polcott333@gmail.com>
Date	2025-11-06 14:48 -0600
Subject	D simulated by H cannot possibly reach its own simulated final halt state
Message-ID	<10ej1i4$1dbgr$1@dont-email.me>

D simulated by H cannot possibly reach its own
simulated final halt state.

I am not going to talk about any non-nonsense of
resuming a simulation after we already have this
final answer.

We just proved that the input to H(D) specifies
non-halting. Anything beyond this is flogging a
dead horse.

news://news.eternal-september.org/20251104183329.967@kylheku.com

On 11/4/2025 8:43 PM, Kaz Kylheku wrote:
 > 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] | [next] | [standalone]

#122963 — How pathological self-reference is confused with undecidability

From	olcott <polcott333@gmail.com>
Date	2025-11-11 19:38 -0600
Subject	How pathological self-reference is confused with undecidability
Message-ID	<10f0oe3$14vu8$1@dont-email.me>
In reply to	#122954

On 11/11/2025 3:38 PM, olcott wrote:
> On 11/11/2025 1:17 PM, Kaz Kylheku wrote:
>> On 2025-11-11, olcott <polcott333@gmail.com> wrote:
>>> On 11/10/2025 10:09 PM, Kaz Kylheku wrote:
>>>> On 2025-11-11, olcott <polcott333@gmail.com> wrote:
>>>>> On 11/10/2025 9:55 PM, Kaz Kylheku wrote:
>>>>>> On 2025-11-10, olcott <polcott333@gmail.com> wrote:
>>>>>>> On 11/10/2025 5:09 PM, Kaz Kylheku wrote:
>>>>>>>> On 2025-11-10, olcott <polcott333@gmail.com> wrote:
>>>>>>>>> That is not the behavior that the input to H(D) specifies.
>>>>>>>>
>>>>>>>> Insane nonsense.
>>>>>>>>
>>>>>>>> The input to H is one single D which specifies one single behavior.
>>>>>>>>
>>>>>>>>> simulator.exe simulates Test.c. This simulates D that
>>>>>>>>> calls H(D) that the simulator recognizes as itself.
>>>>>>>>
>>>>>>>> "recognizing self" is an undecidable problem.
>>>>>>>>
>>>>>>>
>>>>>>> simulator.exe is
>>>>>>
>>>>>> ... a figment of your imagination, and has whatever
>>>>>> properties you need it to have to suit whatever narrative
>>>>>> you are spinning at the moment.
>>>>>>
>>>>>
>>>>> On 11/3/2025 10:28 PM, Kaz Kylheku wrote:
>>>>>>
>>>>>>
>>>>>> The interpreter API consists of primitives built
>>>>>> into the system, so it isn't traced.
>>>>>>
>>>>>
>>>>> The internals of these primitives can be imagined
>>>>> without being directly specified.
>>>>
>>>> In my interpreter walkthrough I more or less specified /what/ the
>>>> interfaces do with the example. It is very clear how the simulation
>>>> object tracks the control flows and steps into statements; it is
>>>> plausible due to these details; no step requires "magical thinking"
>>>> or the solution to incomputable problems.
>>>>
>>>> You are not specifying anything concrete, neither by a body of
>>>> requirements, nor by concrete example.
>>>>
>>>
>>> typedef int (*ptr)();
>>> int HHH(ptr P);
>>>
>>> int DD()
>>> {
>>>     int Halt_Status = HHH(DD);
>>>     if (Halt_Status)
>>>       HERE: goto HERE;
>>>     return Halt_Status;
>>> }
>>>
>>> int main()
>>> {
>>>     HHH(DD);
>>> }
>>>
>>> I will just go back to my original code
>>> if you want to play head games.
>>
>> It has been shown with actual programming against your code framework
>> that abortind deciders leave behind continuable simulations, which may
>> terminate.
> 
> Only if you don't resume them at the
> exact same state where you left them
> and that is flat our cheating.
> 
>>
>> Mike Terry has evidently taken the code and perfected it; he removed all
>> your invalid hacks from the "H" and "D" resulting in pure functions.
>> With that he actually obtained evidence of an infinite simulation
>> tower starting up in which the individual D's terminate.
>>
> 
> Yet that is clearly cheating.
> Whether or not it is possible for HHH to determine
> that its input DOES NOT HALT any sufficiently competent
> C programmer (that is not a damned liar) can easily
> see this.
> 
> The non-halting behavior axiom is only differs from
> infinite recursion in that it is recursive simulation
> and not recursive invocation.
> 
> I honestly cannot believe that anyone denying
> that the input to HHH(DD) does not halt as
> anything but a damned liar. Not any ordinary
> liar, a liar that is literally condemned to
> actual Hell (if such a place exists).
> 

The reason that I am so harsh about this is because
a system that can compute truth can end the killing
of the entire planet by very well paid hired liars.
My paper outlines many key details required to
accomplish this.

We are moving the USA to the brink of the rise of
the fourth Reich only because True(x) is not computable.

Trump is about 45% of the way to achieving Hitler's
own power only because we cannot effectively counter
his Nazi propaganda.

When True(x) is computable an LLM can counter-act every
liar every which way simultaneously.

*How pathological self-reference is confused with undecidability*
https://www.researchgate.net/publication/397442168_How_pathological_self-reference_is_confused_with_undecidability 


https://philpapers.org/archive/OLCMTO-2.pdf

https://claude.ai/share/c9df30cf-ff71-46bf-9647-c78ed95cb389


>> You've done a number of things wrong in the Halt7 test cases:
>>
>> - conflating instruction traces from multiple independent simulations
>>    into one stream, thus falsely identifying recursion where there is
>>    none.
>>
>> - using a "Root" flag to get a top-level HHH to behave differently
>>    from the child HHH instances, so that it's two different functions.
>>
>> You cannot be pulling such stunts if you're going to present
>> anything to serious academia.
>>
>> Every HHH must have an e
>>
> 
> 


-- 
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]

#122964 — Re: How pathological self-reference is confused with undecidability

From	Kaz Kylheku <643-408-1753@kylheku.com>
Date	2025-11-12 02:13 +0000
Subject	Re: How pathological self-reference is confused with undecidability
Message-ID	<20251111181105.962@kylheku.com>
In reply to	#122963

On 2025-11-12, olcott <polcott333@gmail.com> wrote:
> The reason that I am so harsh about this is because
> a system that can compute truth can end the killing
> of the entire planet by very well paid hired liars.
>
> My paper outlines many key details required to
> accomplish this.

As the crank turns ...

> We are moving the USA to the brink of the rise of
> the fourth Reich only because True(x) is not computable.

Get help, and make sure that includes med prescriptions.

> Trump is about 45% of the way to achieving Hitler's
> own power only because we cannot effectively counter
> his Nazi propaganda.

You are more koo-koo than Toucan Sam is for Cocoa Puffs.

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

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

#122965 — Re: How pathological self-reference is confused with undecidability

From	olcott <polcott333@gmail.com>
Date	2025-11-11 20:33 -0600
Subject	Re: How pathological self-reference is confused with undecidability
Message-ID	<10f0rmo$15l7c$1@dont-email.me>
In reply to	#122964

On 11/11/2025 8:13 PM, Kaz Kylheku wrote:
> On 2025-11-12, olcott <polcott333@gmail.com> wrote:
>> The reason that I am so harsh about this is because
>> a system that can compute truth can end the killing
>> of the entire planet by very well paid hired liars.
>>

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

Rhetoric over reasoning really is killing the whole planet

-- 
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]

#122967 — Re: How pathological self-reference is confused with undecidability

From	olcott <polcott333@gmail.com>
Date	2025-11-11 21:05 -0600
Subject	Re: How pathological self-reference is confused with undecidability
Message-ID	<10f0th7$16258$1@dont-email.me>
In reply to	#122964

On 11/11/2025 8:13 PM, Kaz Kylheku wrote:
> On 2025-11-12, olcott <polcott333@gmail.com> wrote:
>> The reason that I am so harsh about this is because
>> a system that can compute truth can end the killing
>> of the entire planet by very well paid hired liars.
>>
>> My paper outlines many key details required to
>> accomplish this.
> 
> As the crank turns ...
> 
>> We are moving the USA to the brink of the rise of
>> the fourth Reich only because True(x) is not computable.
> 
> Get help, and make sure that includes med prescriptions.
> 
>> Trump is about 45% of the way to achieving Hitler's
>> own power only because we cannot effectively counter
>> his Nazi propaganda.
> 
> You are more koo-koo than Toucan Sam is for Cocoa Puffs.
> 

The key tell the Trump is exactly copying Hitler
was his lies about election fraud perfectly
duplicated Chapter 6 of Hitler's Mein Kampf
CHAPTER VI. WAR PROPAGANDA

#LiesAboutElectionFraud

Never any evidence of election fraud
that could possibly change the results.

Trump is just copying Hitler's "big lie"
There are many more things since then.

-- 
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]

#122968 — Re: How pathological self-reference is confused with undecidability

From	olcott <polcott333@gmail.com>
Date	2025-11-11 21:45 -0600
Subject	Re: How pathological self-reference is confused with undecidability
Message-ID	<10f0vse$16n7r$1@dont-email.me>
In reply to	#122967

On 11/11/2025 9:05 PM, olcott wrote:
> On 11/11/2025 8:13 PM, Kaz Kylheku wrote:
>> On 2025-11-12, olcott <polcott333@gmail.com> wrote:
>>> The reason that I am so harsh about this is because
>>> a system that can compute truth can end the killing
>>> of the entire planet by very well paid hired liars.
>>>
>>> My paper outlines many key details required to
>>> accomplish this.
>>
>> As the crank turns ...
>>
>>> We are moving the USA to the brink of the rise of
>>> the fourth Reich only because True(x) is not computable.
>>
>> Get help, and make sure that includes med prescriptions.
>>
>>> Trump is about 45% of the way to achieving Hitler's
>>> own power only because we cannot effectively counter
>>> his Nazi propaganda.
>>
>> You are more koo-koo than Toucan Sam is for Cocoa Puffs.
>>
> 
> The key tell the Trump is exactly copying Hitler
> was his lies about election fraud perfectly
> duplicated Chapter 6 of Hitler's Mein Kampf
> CHAPTER VI. WAR PROPAGANDA
> 
> #LiesAboutElectionFraud
> 
> Never any evidence of election fraud
> that could possibly change the results.
> 
> Trump is just copying Hitler's "big lie"
> There are many more things since then.
> 

For those that are sleepwalking toward totalitarianism
(the opposite of woke) Besides Trump following Hitler's
Mein Kampf as if it was his bible is all of the recent
actions of consolidating his power.

These are written up in Project 2025 that he disavows
yet follows exactly. Project 2025 is Trump's Mein Kampf.

-- 
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]

#122970 — Re: How pathological self-reference is confused with undecidability

From	Kaz Kylheku <643-408-1753@kylheku.com>
Date	2025-11-12 05:52 +0000
Subject	Re: How pathological self-reference is confused with undecidability
Message-ID	<20251111215158.776@kylheku.com>
In reply to	#122968

On 2025-11-12, olcott <polcott333@gmail.com> wrote:
> For those that are sleepwalking toward totalitarianism

... says the gullible twit who thinks LLMs are sentient.

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

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

#122971 — Re: How pathological self-reference is confused with undecidability

From	olcott <polcott333@gmail.com>
Date	2025-11-11 23:59 -0600
Subject	Re: How pathological self-reference is confused with undecidability
Message-ID	<10f17o9$188es$1@dont-email.me>
In reply to	#122970

On 11/11/2025 11:52 PM, Kaz Kylheku wrote:
> On 2025-11-12, olcott <polcott333@gmail.com> wrote:
>> For those that are sleepwalking toward totalitarianism
> 
> ... says the gullible twit who thinks LLMs are sentient.
> 

Alternatively stupid people that understand nothing
yet have catch phrases that convince fools.


-- 
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]

#122972 — Re: How pathological self-reference is confused with undecidability

From	Kaz Kylheku <643-408-1753@kylheku.com>
Date	2025-11-12 06:13 +0000
Subject	Re: How pathological self-reference is confused with undecidability
Message-ID	<20251111221205.197@kylheku.com>
In reply to	#122971

On 2025-11-12, olcott <polcott333@gmail.com> wrote:
> On 11/11/2025 11:52 PM, Kaz Kylheku wrote:
>> On 2025-11-12, olcott <polcott333@gmail.com> wrote:
>>> For those that are sleepwalking toward totalitarianism
>> 
>> ... says the gullible twit who thinks LLMs are sentient.
>> 
>
> Alternatively stupid people that understand nothing
> yet have catch phrases that convince fools.

The only difference between you and someone who repeats
catch phrases is that your repeated shit isn't catchy.

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

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

#122974 — Re: How pathological self-reference is confused with undecidability

From	olcott <polcott333@gmail.com>
Date	2025-11-12 06:50 -0600
Subject	Re: How pathological self-reference is confused with undecidability
Message-ID	<10f1vq7$1eir5$1@dont-email.me>
In reply to	#122972

On 11/12/2025 12:13 AM, Kaz Kylheku wrote:
> On 2025-11-12, olcott <polcott333@gmail.com> wrote:
>> On 11/11/2025 11:52 PM, Kaz Kylheku wrote:
>>> On 2025-11-12, olcott <polcott333@gmail.com> wrote:
>>>> For those that are sleepwalking toward totalitarianism
>>>
>>> ... says the gullible twit who thinks LLMs are sentient.
>>>
>>
>> Alternatively stupid people that understand nothing
>> yet have catch phrases that convince fools.
> 
> The only difference between you and someone who repeats
> catch phrases is that your repeated shit isn't catchy.
> 

In other words you can pay enough attention to realize
the dire consequences of climate change that our politicians
are lying about because of their huge bribes from fossil
fuel companies.

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

Rhetoric over reasoning really is killing the whole planet

-- 

-- 
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]

#122966

From	olcott <polcott333@gmail.com>
Date	2025-11-11 20:41 -0600
Message-ID	<10f0s4q$15o38$1@dont-email.me>
In reply to	#122954

On 11/11/2025 8:20 PM, Kaz Kylheku wrote:
> On 2025-11-11, olcott <polcott333@gmail.com> wrote:
>> On 11/11/2025 1:17 PM, Kaz Kylheku wrote:
>>> On 2025-11-11, olcott <polcott333@gmail.com> wrote:
>>>> On 11/10/2025 10:09 PM, Kaz Kylheku wrote:
>>>>> On 2025-11-11, olcott <polcott333@gmail.com> wrote:
>>>>>> On 11/10/2025 9:55 PM, Kaz Kylheku wrote:
>>>>>>> On 2025-11-10, olcott <polcott333@gmail.com> wrote:
>>>>>>>> On 11/10/2025 5:09 PM, Kaz Kylheku wrote:
>>>>>>>>> On 2025-11-10, olcott <polcott333@gmail.com> wrote:
>>>>>>>>>> That is not the behavior that the input to H(D) specifies.
>>>>>>>>>
>>>>>>>>> Insane nonsense.
>>>>>>>>>
>>>>>>>>> The input to H is one single D which specifies one single behavior.
>>>>>>>>>
>>>>>>>>>> simulator.exe simulates Test.c. This simulates D that
>>>>>>>>>> calls H(D) that the simulator recognizes as itself.
>>>>>>>>>
>>>>>>>>> "recognizing self" is an undecidable problem.
>>>>>>>>>
>>>>>>>>
>>>>>>>> simulator.exe is
>>>>>>>
>>>>>>> ... a figment of your imagination, and has whatever
>>>>>>> properties you need it to have to suit whatever narrative
>>>>>>> you are spinning at the moment.
>>>>>>>
>>>>>>
>>>>>> On 11/3/2025 10:28 PM, Kaz Kylheku wrote:
>>>>>>>
>>>>>>>
>>>>>>> The interpreter API consists of primitives built
>>>>>>> into the system, so it isn't traced.
>>>>>>>
>>>>>>
>>>>>> The internals of these primitives can be imagined
>>>>>> without being directly specified.
>>>>>
>>>>> In my interpreter walkthrough I more or less specified /what/ the
>>>>> interfaces do with the example. It is very clear how the simulation
>>>>> object tracks the control flows and steps into statements; it is
>>>>> plausible due to these details; no step requires "magical thinking"
>>>>> or the solution to incomputable problems.
>>>>>
>>>>> You are not specifying anything concrete, neither by a body of
>>>>> requirements, nor by concrete example.
>>>>>
>>>>
>>>> typedef int (*ptr)();
>>>> int HHH(ptr P);
>>>>
>>>> int DD()
>>>> {
>>>>      int Halt_Status = HHH(DD);
>>>>      if (Halt_Status)
>>>>        HERE: goto HERE;
>>>>      return Halt_Status;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>      HHH(DD);
>>>> }
>>>>
>>>> I will just go back to my original code
>>>> if you want to play head games.
>>>
>>> It has been shown with actual programming against your code framework
>>> that abortind deciders leave behind continuable simulations, which may
>>> terminate.
>>
>> Only if you don't resume them at the
>> exact same state where you left them
>> and that is flat our cheating.
> 
> The parameters required for the next DebugStep of the abandoned
> simulation are correctly determined.
> 
> You need to point out the exact lines of code which have the problem
> that you are alleging, and give details about that problem, otherwise
> you are blabbing about nothing.
> 

Like you are too stupid to recognize that recursive
simulation derives the exact same non-halting behavior
pattern as infinite recursion? I DON'T BUY IT !!!

Are you really this stupid or just a liar?
I know that Mike is not this stupid he proved
his technical competence in far too many ways.

That he proposed this also seems to prove he is not a liar.
https://en.wikipedia.org/wiki/Straw_man#Steelmanning

A software engineer Not being able to recognize
behavior exactly the same as infinite recursion
is the same as a PhD math professor that does
not know how to do first grade arithmetic.



-- 
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]

#122975

From	olcott <polcott333@gmail.com>
Date	2025-11-12 09:11 -0600
Message-ID	<10f282p$1gss3$1@dont-email.me>
In reply to	#122966

On 11/12/2025 9:03 AM, joes wrote:
> Am Wed, 12 Nov 2025 07:37:05 -0600 schrieb olcott:
>> On 11/12/2025 12:11 AM, Kaz Kylheku wrote:
> 
>>>>> On 2025-11-11, olcott <polcott333@gmail.com> wrote:
> 
>>>>>> Only if you don't resume them at the exact same state where you left
>>>>>> them and that is flat our cheating.
> Luckily that’s not what’s going on.
> 
>>> But, /all the instructions have to be from the same control flow/.
>> When DD calls HHH(DD) and HHH simulates DD this control flow is
>> isomorphic to HHH invoking DD.
> A caller cannot abort a function.
> 

typedef int (*ptr)();
int HHH(ptr P);

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

int main()
{
   HHH(DD);
}

None-the-less we have the exact same
repeating pattern such that DD simulated
or directly invoked by HHH cannot possibly
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]

#122981

From	olcott <polcott333@gmail.com>
Date	2025-11-12 20:30 -0600
Message-ID	<10f3fru$1s928$1@dont-email.me>
In reply to	#122966

On 11/12/2025 8:16 PM, Kaz Kylheku wrote:
> On 2025-11-12, olcott <polcott333@gmail.com> wrote:
> 
> You aren't doing that, by the way, in the latest
> Needs_To_Be_Aborted_Trace_HH:

*This is a FOREVER thing until someone admits the truth*
*This is a FOREVER thing until someone admits the truth*
*This is a FOREVER thing until someone admits the truth*

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

Everyone here rejects that the execution trace
of 5 statements of D simulated by H according to
the semantics of C is this:

(1)    H simulates D that calls H(D)
(2) that simulates D that calls H(D)
(3) that simulates D that calls H(D)
(4) that simulates D that calls H(D)
(5) that simulates D that calls 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]

#122983

From	dbush <dbush.mobile@gmail.com>
Date	2025-11-12 21:35 -0500
Message-ID	<10f3g5l$1rb2q$3@dont-email.me>
In reply to	#122981

On 11/12/2025 9:30 PM, olcott wrote:
> On 11/12/2025 8:16 PM, Kaz Kylheku wrote:
>> On 2025-11-12, olcott <polcott333@gmail.com> wrote:
>>
>> You aren't doing that, by the way, in the latest
>> Needs_To_Be_Aborted_Trace_HH:
> 
> *This is a FOREVER thing until someone admits the truth*
> *This is a FOREVER thing until someone admits the truth*
> *This is a FOREVER thing until someone admits the truth*
> 
> int D()
> {
>    int Halt_Status = H(D);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
> 
> Everyone here rejects that the execution trace
> of 5 statements of D simulated by H according to
> the semantics of C is this:
> 
> (1)    H simulates D that calls H(D)
> (2) that simulates D that calls H(D)
> (3) that simulates D that calls H(D)
> (4) that simulates D that calls H(D)
> (5) that simulates D that calls H(D)

That the above make no attempt to explain why the below is wrong 
constitutes your admission that the below is correct.

>
>>      if (current->Simplified_Opcode == CALL)
>>        if (current->Simplified_Opcode == traced->Simplified_Opcode)  // CALL
>>          if (current->Address == traced->Address)              // from same address
>>            if (current->Decode_Target == traced->Decode_Target)// to Same Function
>>              if (Count_Conditional_Branch_Instructions == 0)   // no escape
>> 
>> It's just checking for repeated "CALL HHH".
>> 
>> The CALL in struction doesn't include the arguments; they have to be
>> prepared in registers or pushed onto the stack (or both), depending on
>> the calling conventions.
>> 
>> I imagine you tried doing that but ran into the problem that since
>> you are idiotically conflating multiple execution traces,
>> 
>> The trace for the PUSH instruction which prepares the argument
>> for the CALL, in the Level [2] simulation will be separated
>> from its CALL by all the instruction traces of the DebugStep
>> loop of Level[1]!
>> 
>> The Level[1] loop, itself being simulated, has to DebugStep a PUSH
>> instruction that prepares an argument. Then it has to go all way around
>> its loop, during which time execution traces are being looged for it.
>> Then it has to DebugStep the CALL instruction.
>> 
>> If you did not conflate the instruction eents into a single buffer,
>> you could easily find the previous PUSH instruction for a given
>> CALL, in the private trace buffer of /that/ simulation.
>> 
>> (It may be that Mike Terry has implemented that; I've not seen his
>> code.)
>> 
>> 
>>>> But, /all the instructions have to be from the same control flow/.
>>>>
>>>
>>> When DD calls HHH(DD) and HHH simulates DD this
>>> control flow is isomorphic to HHH invoking DD.
>> 
>> I'm afraid your knowledge and skills here are limited to being able to
>> spell "isomorophic" and use it in a syntactically plausible sentence,
>> much like your LLM friends.

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

#122999

From	olcott <polcott333@gmail.com>
Date	2025-11-13 14:22 -0600
Message-ID	<10f5ela$2dkaq$1@dont-email.me>
In reply to	#122966

On 11/13/2025 1:38 PM, Kaz Kylheku wrote:
> On 2025-11-13, olcott <polcott333@gmail.com> wrote:
>> H computes the mapping from its input to the behavior
>> that this actual input actually specifies as measured
>> by N statements of D simulated by H according to the
>> semantics of the C language until N statements of D
>> match the their non-halting behavior pattern:
> 
> If the computation D is known to terminate in N + 5 steps,
> then that measure is simply not long enough.
> 

No that it just you totally screwing up again forgetting
that an aborted simulation does not count as terminating.

*On top of that you dishonestly erased the non-termination criteria*
D calls H(D) twice in sequence with the same argument
and there are no intervening conditional branch
instructions between the invocation of D and its
call to H(D).

> You're emeasuring a 15' room with a 12' measuring tape,
> declaring the room to be infinite.
> 
>> D calls H(D) twice in sequence with the same argument
> 
> Really? Let's look at the code:
> 
>> int D()
>> {
>>     int Halt_Status = H(D);
>>     if (Halt_Status)
>>       HERE: goto HERE;
>>     return Halt_Status;
>> }
> 
> No competent programmer would look at that and say that D
> calls H twice.
> 

Unless they don't have so much brain damage that
they can pay attention to what is asked for is:

*D simulated by H and not D invoked from main*
*D simulated by H and not D invoked from main*
*D simulated by H and not D invoked from main*
*D simulated by H and not D invoked from main*
*D simulated by H and not D invoked from main*

*D simulated by H and not D invoked from main*
*D simulated by H and not D invoked from main*
*D simulated by H and not D invoked from main*
*D simulated by H and not D invoked from main*
*D simulated by H and not D invoked from main*

*D simulated by H and not D invoked from main*
*D simulated by H and not D invoked from main*
*D simulated by H and not D invoked from main*
*D simulated by H and not D invoked from main*
*D simulated by H and not D invoked from main*

-- 
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]

#123012 — Weasel word double talk excuses =--- AKA Liars

From	olcott <polcott333@gmail.com>
Date	2025-11-18 15:57 -0600
Subject	Weasel word double talk excuses =--- AKA Liars
Message-ID	<10fiq4h$1rs9t$1@dont-email.me>
In reply to	#122954

On 11/18/2025 3:30 PM, Alan Mackenzie wrote:
> olcott <polcott333@gmail.com> wrote:
>> On 11/18/2025 2:24 PM, Alan Mackenzie wrote:
>>> [ Newsgroups: trimmed ]
> 
>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>> On 11/18/2025 12:51 PM, Alan Mackenzie wrote:
>>>>> olcott <polcott333@gmail.com> wrote:
>>>>>> On 11/18/2025 12:04 PM, joes wrote:
>>>>>>> Am Tue, 18 Nov 2025 10:43:32 -0600 schrieb olcott:
>>>>>>>> On 11/18/2025 4:23 AM, Mikko wrote:
> 
>>>>>>>>> The information that HHH is given is the same as a C execution
>>>>>>>>> environment is given for a direct exectuion.
> 
>>>>>>>> No it is not.
> 
>>>>>>> What information are HHH, HHH1, a UTM and an x86 processor given
>>>>>>> or not?  What is different, what is missing?
> 
> 
>>>>>> If you understood what ordinary recursion
>>>>>> is you would have known this a long time ago.
> 
>>>>> You patronising little bastard.
> 
> 
>>>> I asked her time and time again whether
>>>> she had any actual programming experience.
>>>> That lack of any response would seem to
>>>> indicate negative.
> 
>>> That's totally irrelevant.  A straight question was asked, and you
>>> chose to insult rather than giving a straight answer.
> 
> 
>> After my straight question was either dodged or lied about for more
>> than three years ....
> 
> I have seen no question of yours habitually dodged or lied about.
> People, including me, have answered your questions honestly and
> truthfully.
> 
>> .... I upped the ante to counter baseless denigration of my work ....
> 
> I have seen no baseless denigration of your work.  Other posters have
> given up their time to review and criticise your work.  You have failed
> to take that criticism on board.
> 
>> .... that is an example of the "reckless disregard for the truth" that
>> loses libel cases.
> 
> No, it is a thankless striving after the truth.  And even if you were
> right in what you're saying, it wouldn't be a libel cause, since it's not
> defamation directed at your person.
> 
>> If I didn't do this then the baseless denigration of my work could be
>> construed as correct. It would be stupid of me to tolerate that.
> 
> You mean if you didn't answer pertinent straight questions with
> derogatory insults and innuendo.  If you actually acted honourably on
> this newgroup you might find things going better for you.
> 
>>>>>> Not having any understanding of ordinary
>>>>>> recursion makes it impossible for you to understand.
> 
>>>>> Joes understands recursion full well, just like every other poster on
>>>>> this group.
> 
>>>>>> When I say that DD calls HHH(DD) in recursive simulation
>>>>>> translates into DD blah, blah, blah blah blah
>>>>>> you will never be able to get it.
> 
>>>>> That wasn't the question asked.  The question asked is still cited
>>>>> above, and you appear unable to answer it.  Or maybe you lack the
>>>>> manners to do so.
> 
> 
>>>> The implied base question which everyone here (besides Ben) either
>>>> dodged or expressed counter-factual assessment was:
> 
> 
>> Do you understand that DD simulated by HHH
>> cannot possibly reach its own simulated "return"
>> statement final halt state.
> 
> As a fact, HHH simulating DD _can_ reach DD's return instruction.  Kaz
> and Mike have actually tried this out using your HHH and seen it reaching
> the return.  You have dodged their findings.
> 

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Weasel word double talk excuses do not count
as a single contiguous execution trace in C
showing exactly how and why DD simulated by
HHH reaches its own simulated "return" statement
final halt state.

-- 
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

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

#123015

From	olcott <polcott333@gmail.com>
Date	2025-11-18 21:07 -0600
Message-ID	<10fjc9o$201kv$2@dont-email.me>
In reply to	#122954

On 11/18/2025 8:53 PM, Kaz Kylheku wrote:
> On 2025-11-19, olcott <polcott333@gmail.com> wrote:
>> On 11/18/2025 7:01 PM, Kaz Kylheku wrote:
>>> On 2025-11-18, olcott <polcott333@gmail.com> wrote:
>>>> On 11/18/2025 3:21 PM, Kaz Kylheku wrote:
>>>>> On 2025-11-18, olcott <polcott333@gmail.com> wrote:
>>>>>> If you ask a decider to determine if my
>>>>>> sister's name is "Sally" and I don't tell
>>>>>> it who I am then the information contained
>>>>>> in the input is insufficient. This does not
>>>>>> in any way limit computation itself.
>>>>>
>>>>> The problem is that UTM(D) can work out the fact that
>>>>> D halts. Why is it that UTM knows that D's sister's
>>>>> name is Sally, but H does not?
>>>>>
>>>>
>>>> UTM(D) is answering a different question.
>>>> (a) It is not providing any answer at all.
>>>
>>> Well, of course, by "UTM" we mean a /decider/ that purely simulates:
>>>
>>>    bool UTM(ptr P) {
>>>      sim S = sim_create(P);
>>>      sim_step_exhaustively(S);
>>>      return true;
>>>    }
>>>
>>> All deciders applied to D are tasked with answering exactly the same
>>> question.
>>>
>>> Pretending that a different question was asked is nonproductive;
>>> the answer will be interpreted to the original question.
>>>
>>> All the information needed to answer is positively contained in D.
>>>
>>> It is just too complex relative to H.
>>>
>>
>> What The F does UTM decide when DD calls UTM(DD)?
> 
> That doesn't happen; DD calls HHH(DD).
> 
> A diagonal functon set against UTM, call it DDUTM,
> cannot be decided by UTM(DDUTM).
> 
> That call simply does not return.
> 

Yes, and the other one does return proving the
whole point that I have been making for three
years that everyone (besides Ben) was too damned
dishonest to acknowledge has been true all along.

-- 
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

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

#123016

From	Kaz Kylheku <643-408-1753@kylheku.com>
Date	2025-11-19 04:30 +0000
Message-ID	<20251118202805.699@kylheku.com>
In reply to	#123015

On 2025-11-19, olcott <polcott333@gmail.com> wrote:
> On 11/18/2025 8:53 PM, Kaz Kylheku wrote:
>> On 2025-11-19, olcott <polcott333@gmail.com> wrote:
>>> On 11/18/2025 7:01 PM, Kaz Kylheku wrote:
>>>> On 2025-11-18, olcott <polcott333@gmail.com> wrote:
>>>>> On 11/18/2025 3:21 PM, Kaz Kylheku wrote:
>>>>>> On 2025-11-18, olcott <polcott333@gmail.com> wrote:
>>>>>>> If you ask a decider to determine if my
>>>>>>> sister's name is "Sally" and I don't tell
>>>>>>> it who I am then the information contained
>>>>>>> in the input is insufficient. This does not
>>>>>>> in any way limit computation itself.
>>>>>>
>>>>>> The problem is that UTM(D) can work out the fact that
>>>>>> D halts. Why is it that UTM knows that D's sister's
>>>>>> name is Sally, but H does not?
>>>>>>
>>>>>
>>>>> UTM(D) is answering a different question.
>>>>> (a) It is not providing any answer at all.
>>>>
>>>> Well, of course, by "UTM" we mean a /decider/ that purely simulates:
>>>>
>>>>    bool UTM(ptr P) {
>>>>      sim S = sim_create(P);
>>>>      sim_step_exhaustively(S);
>>>>      return true;
>>>>    }
>>>>
>>>> All deciders applied to D are tasked with answering exactly the same
>>>> question.
>>>>
>>>> Pretending that a different question was asked is nonproductive;
>>>> the answer will be interpreted to the original question.
>>>>
>>>> All the information needed to answer is positively contained in D.
>>>>
>>>> It is just too complex relative to H.
>>>>
>>>
>>> What The F does UTM decide when DD calls UTM(DD)?
>> 
>> That doesn't happen; DD calls HHH(DD).
>> 
>> A diagonal functon set against UTM, call it DDUTM,
>> cannot be decided by UTM(DDUTM).
>> 
>> That call simply does not return.
>> 
>
> Yes, and the other one does return proving the
> whole point that I have been making for three
> years that everyone (besides Ben) was too damned
> dishonest to acknowledge has been true all along.

What "other one"? Is that referring to HHH(DD)?

HHH(DD) returns; UTM(DDUTM) does not return.

That's four functions; HHH isn't UTM; DD isn't DDUTM.

HHH and DDUTM are unrelated; UTM and DD are unrelated.

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

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

#123017 — DDD simulated by HHH cannot possibly reach its own simulated final halt state

From	olcott <polcott333@gmail.com>
Date	2025-11-18 22:45 -0600
Subject	DDD simulated by HHH cannot possibly reach its own simulated final halt state
Message-ID	<10fji1q$21859$1@dont-email.me>
In reply to	#123015

On 11/18/2025 10:31 PM, Kaz Kylheku wrote:
> On 2025-11-19, olcott <polcott333@gmail.com> wrote:
>> On 11/18/2025 8:53 PM, Kaz Kylheku wrote:
>>> On 2025-11-19, olcott <polcott333@gmail.com> wrote:
>>>> On 11/18/2025 7:01 PM, Kaz Kylheku wrote:
>>>>> On 2025-11-18, olcott <polcott333@gmail.com> wrote:
>>>>>> On 11/18/2025 3:21 PM, Kaz Kylheku wrote:
>>>>>>> On 2025-11-18, olcott <polcott333@gmail.com> wrote:
>>>>>>>> If you ask a decider to determine if my
>>>>>>>> sister's name is "Sally" and I don't tell
>>>>>>>> it who I am then the information contained
>>>>>>>> in the input is insufficient. This does not
>>>>>>>> in any way limit computation itself.
>>>>>>>
>>>>>>> The problem is that UTM(D) can work out the fact that
>>>>>>> D halts. Why is it that UTM knows that D's sister's
>>>>>>> name is Sally, but H does not?
>>>>>>>
>>>>>>
>>>>>> UTM(D) is answering a different question.
>>>>>> (a) It is not providing any answer at all.
>>>>>
>>>>> Well, of course, by "UTM" we mean a /decider/ that purely simulates:
>>>>>
>>>>>     bool UTM(ptr P) {
>>>>>       sim S = sim_create(P);
>>>>>       sim_step_exhaustively(S);
>>>>>       return true;
>>>>>     }
>>>>>
>>>>> All deciders applied to D are tasked with answering exactly the same
>>>>> question.
>>>>>
>>>>> Pretending that a different question was asked is nonproductive;
>>>>> the answer will be interpreted to the original question.
>>>>>
>>>>> All the information needed to answer is positively contained in D.
>>>>>
>>>>> It is just too complex relative to H.
>>>>>
>>>>
>>>> What The F does UTM decide when DD calls UTM(DD)?
>>>
>>> That doesn't happen; DD calls HHH(DD).
>>>
>>> A diagonal functon set against UTM, call it DDUTM,
>>> cannot be decided by UTM(DDUTM).
>>>
>>> That call simply does not return.
>>>
>>
>> Yes, and the other one does return proving the
>> whole point that I have been making for three
>> years that everyone (besides Ben) was too damned
>> dishonest to acknowledge has been true all along.
> 
> What "other one"? Is that referring to HHH(DD)?
> 
> HHH(DD) returns; UTM(DDUTM) does not return.
> 
> That's four functions; HHH isn't UTM; DD isn't DDUTM.
> 
> HHH and DDUTM are unrelated; UTM and DD are unrelated.
> 

void DDD()
{
   HHH(DDD);
   return;
}

A simulating termination analyzer that must
abort the interpretation of the above ASCII
string to prevent its own non-termination
has different behavior than a simulating
termination analyzer that need not abort
its interpretation of the above exact same
ASCII string.


-- 
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

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

#123018 — Re: DDD simulated by HHH cannot possibly reach its own simulated final halt state

From	Kaz Kylheku <643-408-1753@kylheku.com>
Date	2025-11-19 04:52 +0000
Subject	Re: DDD simulated by HHH cannot possibly reach its own simulated final halt state
Message-ID	<20251118204801.981@kylheku.com>
In reply to	#123017

On 2025-11-19, olcott <polcott333@gmail.com> wrote:
> On 11/18/2025 10:31 PM, Kaz Kylheku wrote:
>> On 2025-11-19, olcott <polcott333@gmail.com> wrote:
>>> On 11/18/2025 8:53 PM, Kaz Kylheku wrote:
>>>> On 2025-11-19, olcott <polcott333@gmail.com> wrote:
>>>>> On 11/18/2025 7:01 PM, Kaz Kylheku wrote:
>>>>>> On 2025-11-18, olcott <polcott333@gmail.com> wrote:
>>>>>>> On 11/18/2025 3:21 PM, Kaz Kylheku wrote:
>>>>>>>> On 2025-11-18, olcott <polcott333@gmail.com> wrote:
>>>>>>>>> If you ask a decider to determine if my
>>>>>>>>> sister's name is "Sally" and I don't tell
>>>>>>>>> it who I am then the information contained
>>>>>>>>> in the input is insufficient. This does not
>>>>>>>>> in any way limit computation itself.
>>>>>>>>
>>>>>>>> The problem is that UTM(D) can work out the fact that
>>>>>>>> D halts. Why is it that UTM knows that D's sister's
>>>>>>>> name is Sally, but H does not?
>>>>>>>>
>>>>>>>
>>>>>>> UTM(D) is answering a different question.
>>>>>>> (a) It is not providing any answer at all.
>>>>>>
>>>>>> Well, of course, by "UTM" we mean a /decider/ that purely simulates:
>>>>>>
>>>>>>     bool UTM(ptr P) {
>>>>>>       sim S = sim_create(P);
>>>>>>       sim_step_exhaustively(S);
>>>>>>       return true;
>>>>>>     }
>>>>>>
>>>>>> All deciders applied to D are tasked with answering exactly the same
>>>>>> question.
>>>>>>
>>>>>> Pretending that a different question was asked is nonproductive;
>>>>>> the answer will be interpreted to the original question.
>>>>>>
>>>>>> All the information needed to answer is positively contained in D.
>>>>>>
>>>>>> It is just too complex relative to H.
>>>>>>
>>>>>
>>>>> What The F does UTM decide when DD calls UTM(DD)?
>>>>
>>>> That doesn't happen; DD calls HHH(DD).
>>>>
>>>> A diagonal functon set against UTM, call it DDUTM,
>>>> cannot be decided by UTM(DDUTM).
>>>>
>>>> That call simply does not return.
>>>>
>>>
>>> Yes, and the other one does return proving the
>>> whole point that I have been making for three
>>> years that everyone (besides Ben) was too damned
>>> dishonest to acknowledge has been true all along.
>> 
>> What "other one"? Is that referring to HHH(DD)?
>> 
>> HHH(DD) returns; UTM(DDUTM) does not return.
>> 
>> That's four functions; HHH isn't UTM; DD isn't DDUTM.
>> 
>> HHH and DDUTM are unrelated; UTM and DD are unrelated.
>> 
>
> void DDD()
> {
>    HHH(DDD);
>    return;
> }
>
> A simulating termination analyzer that must
> abort the interpretation of the above ASCII
> string to prevent its own non-termination
> has different behavior than a simulating
> termination analyzer that need not abort
> its interpretation of the above exact same
> ASCII string.

1. Up to that abort point, UTM(DDD) and HHH(DDD) conduct an
absolutely identical simulation. The only difference is
that the simulation continues under UTM, and is abandoned
under HHH.

2. This is not a difference attributable to DDD.  DDD is the same in
both cases. Not continuing the simulation fo DDD doesn't redefine what
DDD is. It is not possible to redefine what DDD is; it is the
agreed-upon procedure above.

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

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

Page 1 of 4 [1] 2 3 4 Next page →

csiph-web

D simulated by H cannot possibly reach its own simulated final halt state

Contents

#122954 — D simulated by H cannot possibly reach its own simulated final halt state

#122963 — How pathological self-reference is confused with undecidability

#122964 — Re: How pathological self-reference is confused with undecidability

#122965 — Re: How pathological self-reference is confused with undecidability

#122967 — Re: How pathological self-reference is confused with undecidability

#122968 — Re: How pathological self-reference is confused with undecidability

#122970 — Re: How pathological self-reference is confused with undecidability

#122971 — Re: How pathological self-reference is confused with undecidability

#122972 — Re: How pathological self-reference is confused with undecidability

#122974 — Re: How pathological self-reference is confused with undecidability

#122966

#122975

#122981

#122983

#122999

#123012 — Weasel word double talk excuses =--- AKA Liars

#123015

#123016

#123017 — DDD simulated by HHH cannot possibly reach its own simulated final halt state

#123018 — Re: DDD simulated by HHH cannot possibly reach its own simulated final halt state