Re: How do simulating termination analyzers work? ---Truth Maker Maximalism FULL_TRACE

On 7/6/2025 11:02 AM, Alan Mackenzie wrote:

[ Followup-To: set ]
 In comp.theory olcott <polcott333@gmail.com> wrote:

On 7/6/2025 5:16 AM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 7/5/2025 2:07 PM, Alan Mackenzie wrote:

 

You lie.  You don't have a proof.  Many people in this group have pointed
out lots of errors in various versions of your purported proof, which you
just ignore.  The section in Professor Linz's book you used to be so fond
of citing will contain plenty of details, if only you would take the
trouble to understand it (assuming you're capable of such understanding).

 

I have addressed ....

 

Meaningless pompous word.

 

.... all of those details that you make sure to ignore so that you can
baselessly claim that I am wrong.

 

I vaguely remember rolling my eyes at your hopeless lack of
understanding.  It was like watching a 7 year old trying to do calculus.
The basic understanding was simply not there.  Years later, it's still
not there.

 

And yes, you are wrong.  The proofs of the halting theorem which involve
constructing programs which purported halting deciders cannot decide
correctly are correct.

 

Yet you cannot point to even one mistake because there are none.

 That's what I'm saying.  Those proofs of the halting theorem are free
from mistakes.
 More to the point, it is YOU who cannot point to any mistakes in them.

I have yet you could not understand.
Failing to understand is not a rebuttal.

They are valid proofs.  Your work, if it contradicts those proofs (which
isn't at all clear) can thus be dismissed without further consideration.
 

The is the ad ignorantiam error.
https://en.wikipedia.org/wiki/Argument_from_ignorance
Atheists have made that their doctrine.

There cannot possibly be *AN ACTUAL INPUT* that does the
opposite of whatever its decider decides. All of the examples
of this have never been *ACTUAL INPUTS*

 

That's so sloppily worded, it could mean almost anything.

 

The standard halting problem proof cannot even be constructed.

 It has been constructed, and is valid.  But one would normally talk about
formulating a proof, rather than constructing one.
 [ .... ]
 

No Turing machine can possibly take another directly executing
Turing machine as in input, thus removing these from the
domain of every halt decider.

 

And that, too.

 

*Thus the requirement that HHH report on the behavior*
*of the directly executed DD has always been bogus*

 

And that makes your hat trick.

 

Turing machine partial halt deciders compute the mapping
from their actual inputs to the actual behavior that these
inputs specify.

 

And a fourth.  There's some semblance of truth in there, but it's very
confused.

 

It is not at all confused. I know exactly what it means.

 It's very confused to everybody but you, then.
 

Sloppy wording is your technique to get people to go down to your level
of discussion.  That involves many posts trying just to tie you down to
specific word meanings, and is very tiresome and unrewarding.  I decline
to get involved any further.

 

*Yet as I claimed you found no actual mistake*

 I've found plenty of actual mistakes.  I was a software developer by
profession.
 

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
Then you should know that DD simulated by HHH
according to the semantics of the C programming
language cannot possibly reach its own "return"
statement final halt state.

Let me tell you the punchline so that you can
see why I said those things.

 Despite what I said last post, I will actually go to the trouble of
analysing your sloppy expression.
 

Because directly executed Turing machines cannot
possibly be inputs to Turing machine deciders this
makes them outside of the domain of these deciders.

 It's entirely unclear what a "directly executed Turing machine" is.  Most
of the time turing machines are theoretical constructs used for proving
theorems.  They can be executed, but rarely are.
 

typedef void (*ptr)();
int HHH(ptr P);
void DDD()
{
   HHH(DDD);
   return;
}
int main()
{
   HHH(DDD);  // DDD finite string of x86 code emulated by HHH
   DDD();     // DDD directly executed
}

It's unclear what you mean by a turing machine being an input to a turing
machine.  Read up about universal turing machines to get a bit of
background.
 

The directly executed DDD() is not an input to HHH.
We have the exact same thing in the Linz proof.
When Ĥ is applied to ⟨Ĥ⟩     // adapted from bottom of page 319
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
   if Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
   if Ĥ applied to ⟨Ĥ⟩ does not halt
Ĥ applied to ⟨Ĥ⟩ is the directly executed Ĥ ⟨Ĥ⟩
not ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H.
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
  >> When a partial halt decider is required to report

on the direct execution of a machine this requirement
is bogus.

 See above.  That paragraph is meaningless.
 

That you do not understand a paragraph does not entail
that it is meaningless.

This means that the behavior of DD() is none of the damn
business of HHH, thus does not contradict HHH(DD)==0.
*If you disagree this only proves that you do not understand*

 It's fully obscure what DD() and HHH mean, and thus impossible to
affirm or contradict the meaningless "HHH(DD)==0".
 

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0. (HHH1 has identical code).

HHH(DD) does correctly detect that DD simulated by HHH
according to the semantics pf the C programming language
cannot possibly reach its own "return"statement final
halt state.

 See above.  By the way, people concerned with computation theory use
turing machines, which are well-defined, simple, and powerful.  They lack
the complexity, ambiguity, and unsuitability for theoretical work of real
world programming languages like C.
 

Yet they have vagueness that C does not have.
C is a fully operational high level programming language.
TM's are at such a low level that it could take hundreds
of instructions to just move a single value in memory.

*If you disagree this only proves that you do not understand*

 

Any mindless idiot can disagree. Showing an error and proving
that it is an actual mistake requires much more than this.

 Indeed.  All you have done is disagree with one of the proofs of the
halting theorem.  You have yet to show an error in it.  That will be
difficult, because there aren't any.
 

There are two errors:
(1) The false assumption that TM's report on the behavior
     of the directly executed machine "if Ĥ applied to ⟨Ĥ⟩ halts"
     (see above).
(2) That simulating partial halt decider Ĥ.embedded_H is
     incorrect to transition to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩.

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

 

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