From Newsgroup: comp.ai.philosophy

On 8/6/2025 5:54 AM, Richard Damon wrote:

On 8/5/25 11:47 PM, olcott wrote:

It corrects the error of the requirement that
a halt decider reports on its own behavior.

But it isn't an error.

Halt Deciders need to answer about *ANY* program, and they are programs.

    "The contradiction in Linz's (or Turing's) self-referential
     halting construction only appears if one insists that the
     machine can and must decide on its own behavior, which is
     neither possible nor required."

https://chatgpt.com/share/6890ee5a-52bc-8011-852e-3d9f97bcfbd8

Because you lied to it and said it was an error.

The above paragraph is proved true by the meaning of its words.
When we ask a Turing machine to report on its own behavior we
are assuming that its Turing Machine description is an accurate
proxy for this behavior. When there are exceptions to this rule
then we cannot possibly ask a Turing machine about its own behavior.
This is easily corrected:

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
its simulated final halt state of ⟨Ĥ.qn⟩, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
reach its simulated final halt state of ⟨Ĥ.qn⟩.

When we use the above standard then a halt decider
will always report on the actual behavior that its
input actually specifies.
--
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

On 8/6/2025 9:13 PM, Richard Damon wrote:

On 8/6/25 8:18 AM, olcott wrote:

On 8/6/2025 6:41 AM, Richard Damon wrote:

On 8/6/25 7:39 AM, olcott wrote:

On 8/6/2025 4:00 AM, Fred. Zwarts wrote:

Op 06.aug.2025 om 05:47 schreef olcott:

It corrects the error of the requirement that
a halt decider reports on its own behavior.

    "The contradiction in Linz's (or Turing's) self-referential >>>>>>      halting construction only appears if one insists that the >>>>>>      machine can and must decide on its own behavior, which is >>>>>>      neither possible nor required."

https://chatgpt.com/share/6890ee5a-52bc-8011-852e-3d9f97bcfbd8

That seems to be one of your misunderstanding. A decider must
report on the behaviour of its input, even if this behaviour
resembles its own behaviour. That is very different from 'deciding
on its own behaviour'.

*This is my correction*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
    if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
    its simulated final halt state of ⟨Ĥ.qn⟩, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
    if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly >>>>     reach its simulated final halt state of ⟨Ĥ.qn⟩.

*This is the original erroneous one*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
    if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
    if Ĥ applied to ⟨Ĥ⟩ does not halt.

*Lines two and four requires Ĥ.embedded_H to report on its own
behavior*

Which is valid.

And you are just stupid to think otherwise.

It is only valid when Turing machine deciders can
take themselves as inputs.

They only need to take representation of themselves as input.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.

The Linz proof has Ĥ take its own machine description
as input (this is fine) yet requires Ĥ.embedded_H to
directly report on its own behavior. No TM can ever
do that.
--
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

Op 07.aug.2025 om 05:15 schreef olcott:

On 8/6/2025 9:13 PM, Richard Damon wrote:

On 8/6/25 8:18 AM, olcott wrote:

On 8/6/2025 6:41 AM, Richard Damon wrote:

On 8/6/25 7:39 AM, olcott wrote:

On 8/6/2025 4:00 AM, Fred. Zwarts wrote:

Op 06.aug.2025 om 05:47 schreef olcott:

It corrects the error of the requirement that
a halt decider reports on its own behavior.

    "The contradiction in Linz's (or Turing's) self-referential >>>>>>>      halting construction only appears if one insists that the >>>>>>>      machine can and must decide on its own behavior, which is >>>>>>>      neither possible nor required."

https://chatgpt.com/share/6890ee5a-52bc-8011-852e-3d9f97bcfbd8

That seems to be one of your misunderstanding. A decider must
report on the behaviour of its input, even if this behaviour
resembles its own behaviour. That is very different from 'deciding >>>>>> on its own behaviour'.

*This is my correction*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
    if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
    its simulated final halt state of ⟨Ĥ.qn⟩, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
    if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly >>>>>     reach its simulated final halt state of ⟨Ĥ.qn⟩.

*This is the original erroneous one*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
    if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
    if Ĥ applied to ⟨Ĥ⟩ does not halt.

*Lines two and four requires Ĥ.embedded_H to report on its own
behavior*

Which is valid.

And you are just stupid to think otherwise.

It is only valid when Turing machine deciders can
take themselves as inputs.

They only need to take representation of themselves as input.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.

The Linz proof has Ĥ take its own machine description
as input (this is fine) yet requires Ĥ.embedded_H to
directly report on its own behavior. No TM can ever
do that.

That is your mistake. It does not require to report on its own
behaviour, but on the behaviour of Ĥ. It is irrelevant whether the
behaviour of Ĥ resembles that of embedded_H.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

Op 07.aug.2025 om 05:24 schreef olcott:

On 8/6/2025 9:27 PM, Richard Damon wrote:

On 8/6/25 7:53 AM, olcott wrote:

On 8/6/2025 5:54 AM, Richard Damon wrote:

On 8/5/25 11:47 PM, olcott wrote:

It corrects the error of the requirement that
a halt decider reports on its own behavior.

But it isn't an error.

Halt Deciders need to answer about *ANY* program, and they are
programs.

    "The contradiction in Linz's (or Turing's) self-referential
     halting construction only appears if one insists that the
     machine can and must decide on its own behavior, which is
     neither possible nor required."

https://chatgpt.com/share/6890ee5a-52bc-8011-852e-3d9f97bcfbd8

Because you lied to it and said it was an error.

The above paragraph is proved true by the meaning of its words.
When we ask a Turing machine to report on its own behavior we
are assuming that its Turing Machine description is an accurate
proxy for this behavior. When there are exceptions to this rule
then we cannot possibly ask a Turing machine about its own behavior.
This is easily corrected:

But the existance of UTMs means that it IS possible to make a perfect
proxy, as the UTM can completely recreate the behavior of ANY machine
from its Turing Machine Description.

All you are doing is admitting that you think errors and lies are ok.

   Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy,
   Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

After a finite number of correct simulations the UTM
will reach its final state yet no simulated UTM ever
reaches its own final state.

Indeed, that is the proof that such a simulation fails.
No simulator exists that is able to simulate correctly all halting
programs up to the end,because it fails to simulate correctly code that resembles its own code.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 8/6/25 11:15 PM, olcott wrote:

On 8/6/2025 9:13 PM, Richard Damon wrote:

On 8/6/25 8:18 AM, olcott wrote:

On 8/6/2025 6:41 AM, Richard Damon wrote:

On 8/6/25 7:39 AM, olcott wrote:

On 8/6/2025 4:00 AM, Fred. Zwarts wrote:

Op 06.aug.2025 om 05:47 schreef olcott:

It corrects the error of the requirement that
a halt decider reports on its own behavior.

    "The contradiction in Linz's (or Turing's) self-referential >>>>>>>      halting construction only appears if one insists that the >>>>>>>      machine can and must decide on its own behavior, which is >>>>>>>      neither possible nor required."

https://chatgpt.com/share/6890ee5a-52bc-8011-852e-3d9f97bcfbd8

That seems to be one of your misunderstanding. A decider must
report on the behaviour of its input, even if this behaviour
resembles its own behaviour. That is very different from 'deciding >>>>>> on its own behaviour'.

*This is my correction*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
    if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
    its simulated final halt state of ⟨Ĥ.qn⟩, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
    if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly >>>>>     reach its simulated final halt state of ⟨Ĥ.qn⟩.

*This is the original erroneous one*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
    if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
    if Ĥ applied to ⟨Ĥ⟩ does not halt.

*Lines two and four requires Ĥ.embedded_H to report on its own
behavior*

Which is valid.

And you are just stupid to think otherwise.

It is only valid when Turing machine deciders can
take themselves as inputs.

They only need to take representation of themselves as input.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.

The Linz proof has Ĥ take its own machine description
as input (this is fine) yet requires Ĥ.embedded_H to
directly report on its own behavior. No TM can ever
do that.

You claim that, but you are wrong.

First, H isn't being asked to report on "its own" behavior, but the
behavior of a program that contains it.

Second, if your claim *IS* true, then you are just stating that it MUST
be defintionally impossible for a Halt Decider to exist, as Halt
Deciders, by their definition, need to answer about ANY program, but
since they are programs, they need to answer about themselves.

Also, Mr Flibble has show, that assuming that the decider is able to
detect this pattern, (that the input is calling a copy of the decider),
that there IS a method to determine the answer in many cases, that is if
there IS a possible answer that it can give.

Thus, your claim is just false on its face.

The fact that we can come up with a case that the decider can't
correctly answer doesn't, as your ignorant mind thinks, mean that the
question isn't valid, because the problem always included the
possibility that the answer is that "NO decider can answer this question
for every possible input."

And that *IS* the correct answer, that the problem is just
non-computable, and thus all you arguments about "computable functions"
are just category errors, as we were never dealing with a computable
function, but asking if something WAS a computable function.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 8/7/2025 4:11 AM, Fred. Zwarts wrote:

Op 07.aug.2025 om 05:15 schreef olcott:

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.

The Linz proof has Ĥ take its own machine description
as input (this is fine) yet requires Ĥ.embedded_H to
directly report on its own behavior. No TM can ever
do that.

That is your mistake. It does not require to report on its own
behaviour, but on the behaviour of Ĥ.

That *is* its own behavior.
Ĥ.embedded_H *is* an aspect of Ĥ.
Ĥ.embedded_H does correctly report on the behavior
specified by its input ⟨Ĥ⟩ ⟨Ĥ⟩ as measured by its
correct simulation of this input.

It is irrelevant whether the
behaviour of Ĥ resembles that of embedded_H.

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

On 8/7/25 9:39 AM, olcott wrote:

On 8/7/2025 4:11 AM, Fred. Zwarts wrote:

Op 07.aug.2025 om 05:15 schreef olcott:

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.

The Linz proof has Ĥ take its own machine description
as input (this is fine) yet requires Ĥ.embedded_H to
directly report on its own behavior. No TM can ever
do that.

That is your mistake. It does not require to report on its own
behaviour, but on the behaviour of Ĥ.

That *is* its own behavior.

No it isn't, unless you think you are just your big toe.

Ĥ.embedded_H *is* an aspect of Ĥ.

But it isn't Ĥ

Ĥ.embedded_H does correctly report on the behavior
specified by its input ⟨Ĥ⟩ ⟨Ĥ⟩ as measured by its
correct simulation of this input.

No, it doesn't, because it doesn't correctly simulate it, and the
hypothetical H (That isn't actually H) doesn't simulate the same input,
as the program the input represent contains the H that is deciding it,
and thus you can't look at the behavior of the hypothectical H emulation
of its input, as it is a different input.

You keep on making that lie, because you try to redefine what correct simulation means, but of course, you can only use "correct simulation"
as a proxy for the behavior of the program the input represents with the specifically defined definition of it.

So, all you are doing is showing you don't know the meaning of the words
you are using, or even that words HAVE correct meanings.

It is irrelevant whether the behaviour of Ĥ resembles that of embedded_H.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

Op 07.aug.2025 om 15:39 schreef olcott:

On 8/7/2025 4:11 AM, Fred. Zwarts wrote:

Op 07.aug.2025 om 05:15 schreef olcott:

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞,
if Ĥ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if Ĥ applied to ⟨Ĥ⟩ does not halt.

The Linz proof has Ĥ take its own machine description
as input (this is fine) yet requires Ĥ.embedded_H to
directly report on its own behavior. No TM can ever
do that.

That is your mistake. It does not require to report on its own
behaviour, but on the behaviour of Ĥ.

That *is* its own behavior.

That is your mistake. It is not its own behaviour, but that of Ĥ (which resembles its own behaviour). That is a fundamental difference.
When it is unable to analyse the behaviour that resembles its own
behaviour, it fails due to a limitation in its analysis. A decider is
required to analyse any behaviour, even if it resembles its own behaviour.

Ĥ.embedded_H *is* an aspect of Ĥ.
Ĥ.embedded_H does correctly report on the behavior
specified by its input ⟨Ĥ⟩ ⟨Ĥ⟩ as measured by its
correct simulation of this input.

It is irrelevant whether the behaviour of Ĥ resembles that of embedded_H.

--- Synchronet 3.21a-Linux NewsLink 1.2