From Newsgroup: comp.theory

Am Tue, 28 Oct 2025 09:43:15 -0500 schrieb olcott:

On 10/28/2025 3:40 AM, joes wrote:

Am Mon, 27 Oct 2025 23:01:52 -0500 schrieb olcott:

H simulates D that calls H(D) to simulate D that calls H(D)

here

Nothing past the marked point happens.

H is not in the repository it is a new hypothetical basis for my next
paper.

You haven’t mentioned how H differs from HHH.
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 11/3/2025 8:06 AM, joes wrote:

Am Tue, 28 Oct 2025 09:43:15 -0500 schrieb olcott:

On 10/28/2025 3:40 AM, joes wrote:

Am Mon, 27 Oct 2025 23:01:52 -0500 schrieb olcott:

H simulates D that calls H(D) to simulate D that calls H(D)

here

Nothing past the marked point happens.

H is not in the repository it is a new hypothetical basis for my next
paper.

You haven’t mentioned how H differs from HHH.

H is starting from scratch discarding all the preconceptions
and is understood to be a C level analysis that disregards
any and all of the x86 level analysis. That is the only difference.

I did this because the x86 level proved to be too difficult
for my reviewers and the C level proved to be an equally
unequivocal specification.

This is the new specification that replaces the prior
specifcation that proved to be too terse.

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

The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.

When given a function P, it literally simulates each step of executing
P() to see whether that simulated execution ever reaches a return
statement. Now let H simulate D. Based only on the outcome of that
literal simulation (not on reasoning about what should happen), what
result should H(D) produce?
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 11/2/2025 6:35 AM, Mikko wrote:

On 2025-11-01 13:27:50 +0000, olcott said:

The actual sequence of steps that the input to H(D)
specifies are the steps shown above. Anyone that disagrees
is not facing actual reality.

An example of a possible sequence is shown. There is no proof that this
is the actual sequence.

The semantics of the C programming language
conclusively proves its true.

In particulat, the actual number of simulation
levels before H sees the repeating pattern is not shown. The part of
the trace of D from the return from H to the termination of D is not
shown but it is provably a parto of the behaviour of D.

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

The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.

When given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement. Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On Mon, 03 Nov 2025 17:31:13 -0600, olcott wrote:

On 11/2/2025 6:35 AM, Mikko wrote:

On 2025-11-01 13:27:50 +0000, olcott said:

The actual sequence of steps that the input to H(D) specifies are the
steps shown above. Anyone that disagrees is not facing actual reality.

An example of a possible sequence is shown. There is no proof that this
is the actual sequence.

The semantics of the C programming language conclusively proves its
true.

In particulat, the actual number of simulation levels before H sees the
repeating pattern is not shown. The part of the trace of D from the
return from H to the termination of D is not shown but it is provably a
parto of the behaviour of D.

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

The function H is a simulating termination analyzer: (a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.

When given a function P, it literally simulates each step of executing
P() to see whether that simulated execution ever reaches a return
statement. Now let H simulate D. Based only on the outcome of that
literal simulation (not on reasoning about what should happen),
what result should H(D) produce?

It doesn't matter what result H(D) produces as D will do the opposite thus
H is wrong.

/Flibble
--
meet ever shorter deadlines, known as "beat the clock"
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-11-03 23:31:13 +0000, olcott said:

On 11/2/2025 6:35 AM, Mikko wrote:

On 2025-11-01 13:27:50 +0000, olcott said:

The actual sequence of steps that the input to H(D)
specifies are the steps shown above. Anyone that disagrees
is not facing actual reality.

An example of a possible sequence is shown. There is no proof that this
is the actual sequence.

The semantics of the C programming language
conclusively proves its true.

Nothing above tells what you claim to be proven true.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2