From Newsgroup: comp.ai.philosophy

On Sun, 2025-08-03 at 10:29 -0500, olcott wrote:

On 8/3/2025 9:48 AM, wij wrote:

On Sun, 2025-08-03 at 09:30 -0500, olcott wrote:

On 8/3/2025 6:05 AM, Richard Damon wrote:

Your problem is you don't find an error in the shown counter example, because your created input that you claim to solve has essential differences from it.

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

_DD()
[00002162] 55             push ebp
[00002163] 8bec           mov ebp,esp
[00002165] 51             push ecx
[00002166] 6862210000     push 00002162 // push DD
[0000216b] e862f4ffff     call 000015d2 // call HHH
[00002170] 83c404         add esp,+04
[00002173] 8945fc         mov [ebp-04],eax
[00002176] 837dfc00       cmp dword [ebp-04],+00
[0000217a] 7402           jz 0000217e
[0000217c] ebfe           jmp 0000217c
[0000217e] 8b45fc         mov eax,[ebp-04]
[00002181] 8be5           mov esp,ebp
[00002183] 5d             pop ebp
[00002184] c3             ret
Size in bytes:(0035) [00002184]

DD correctly emulated by HHH cannot possibly reach
its own "if" statement, thus the "do the opposite"
code is unreachable.

I agree with the point here. The halt decider cannot exist is
because it will be stuck in the infinite recursive call, not
because it would return something for "if' to detect and do
something opposite. But the "if" part is an assumption, easy
to explain. IMO, it all about self-reference.

Self-reference has been the focus of my primary research
into the philosophy of:
(a) logic
(b) computation and
(c) math for 22 years.

I began with the Liar Paradox.
That is why I own the domain LiarParadox.org.

?- LP = not(true(LP)).
LP = not(true(LP)).

?- unify_with_occurs_check(LP, not(true(LP))).
false.

Just like Prolog correctly detects and rejects
the infinitely recursive structure of the Liar
Paradox HHH(DD) correctly detects and rejects
the infinitely recursive structure of its input.

I had explicitly put it in ClassGuidelines.txt to suggest 'self-reference' is impossible to detect in (TM equvilent) programming langage.
....
This guideline has no strong opinion on how this self-ops should be handled,
yet (it is like divided by zero error). Implement may check the self-ops (not
generally doable) and return ELOOP. Working around might be needed since the
intent mostly assumes the argument is passed by value, nonetheless a
theoretical bug might be thus hidden.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 8/3/2025 11:03 AM, Mr Flibble wrote:

On Sun, 03 Aug 2025 10:56:17 -0500, olcott wrote:

On 8/3/2025 10:45 AM, Mr Flibble wrote:

Halting problem proofs are predicated on total deciders so cannot be
refuted using partial deciders.

/Flibble

You are incorrect about that.

No I am correct about that: you do not get to change definition of the halting problem unless you are working on a different problem.

You are conflating the halting problem with its convetional proof.
They are not the same thing.

They propose that no universal halt decider exists is proven entirely on
the basis that HHH(DD) has no correct answer.

It may be the case that no universal halt decider exists, yet the
conventional proofs do not prove that.

Again: your work is unrelated to the halting problem and is sufficiently uninteresting to be considered a waste of 22 years of effort.

/Flibble

I have not refuting the halting problem.
I have refuted the conventional halting problem proof.

Once this is fully understood the exact same reasoning
equally applies to the Tarksi Undefinability theorem.
--
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.ai.philosophy

[ Followup-To: set ]

In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> wrote:

[ .... ]

Again, irrelevant examples.
The input for HHH is more like:

void Finite_Recursion () {
static int N = 5;
if (N > 0) Finite_Recursion ();
printf ("Olcott thinks this is never printed.\n");
}

Careful! I think you meant "if (N-- > 0) ...." :-)

The fact that PO missed this shows how little attention he pays to
detail.

[ .... ]
--
Alan Mackenzie (Nuremberg, Germany).

--- Synchronet 3.21a-Linux NewsLink 1.2