XPost: comp.theory, sci.logic, sci.math

On 12/19/2021 4:25 PM, Malcolm McLean wrote:

On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff Barnett wrote:

On 12/19/2021 11:44 AM, olcott wrote:

I can (and will shortly) conclusively prove that pure function H
correctly detects that P specifies infinitely nested simulation.

Simple question: Since virtually everyone who has studied this problem
knows, simulation is not a feasible way to build a halt decider
(assuming one could be built). The proof you are attacking as well as
others I am aware of are not based on simulation. Why do insist that
simulation is the way to go?

I think I can answer this for PO.

The first observation is that a simulating halt decider goes into an
infinite series of nested simulations if fed H_Hat. So this leads to the question, can we somehow exploit this to get round the Linz trap?

You are the only reviewer that has ever made any attempt at an honest
dialogue. (Except possibly Kaz) That one party of a conversation has no intention of any honest dialogue is proven by the fact that there are persistently zero elements of mutual agreement by one of the parties.

Every time that I effectively prove my point those respondents that have
no interest what-so-ever in any honest dialogue always change the
subject to another basis of rebuttal.

When Ben responded to your point he studiously totally bypassed the
point by nitpicking at the use of terminology.

Sapir–Whorf hypothesis
language determines thought and that linguistic categories limit and
determine cognitive categories. https://en.wikipedia.org/wiki/Linguistic_relativity

In order to talk about TMs that base their halt status decision on the
behavior of simulating N steps of their input until this input either
halts on its own or the TM recognizes an infinitely behavior pattern we
must have a term.

Since the term "decider" must halt on all inputs, the term decider may
not be perfectly apt unless we qualify it.

The most straight forward way to qualify such a term would be that a TM
is a simulating halt decider that computes the halt status of a limited
domain of finite string pairs.

H computes the function of mapping input pairs to an accept / reject
state on the basis of simulating N steps of this input pair until this simulated input reaches its final state or H has recognize an infinite
behavior pattern. Because the purpose of H is limited to showing how the conventional HP counter-examples would be decided the function that H
computes its limited to one element of these counter-example inputs.

The answer is "no". But in answering that question, we set up a system
in which the simulating halt decider must get the wrong answer, for reasons which have nothing to do with LInz's "invert the result" step. So have
we broken new ground? Can we maybe say that the result is correct,
because the simulation "aborts" instead of "halting", and if it didn't "abort" it would indeed run forever, so it must have correctly "aborted".

computation that halts… the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

As soon as H detects that the simulation of P cannot possibly ever reach
the final state of P then P meets the Linz definition of a computation
that does not halt.

Once H knows that P specifies a non-halting computation this is entirely sufficient for H to transition to its final reject state.

Not_Halting(P) → H.Reject(P)

https://en.wikipedia.org/wiki/Necessity_and_sufficiency
As long as the input to H specifies a computation that never halts H is
always correct to transition to its reject state.




--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 1/5/2022 4:15 PM, Richard Damon wrote:

On 1/5/22 4:01 PM, olcott wrote:

On 1/5/2022 2:55 PM, Richard Damon wrote:

On 1/5/22 3:41 PM, olcott wrote:

On 1/5/2022 2:36 PM, Richard Damon wrote:

On 1/5/22 3:03 PM, olcott wrote:

On 1/5/2022 1:54 PM, Richard Damon wrote:

On 1/5/22 1:00 PM, olcott wrote:

On 1/5/2022 10:29 AM, Richard Damon wrote:

On 1/5/22 11:06 AM, olcott wrote:

On 12/19/2021 4:25 PM, Malcolm McLean wrote:

On Sunday, 19 December 2021 at 19:04:11 UTC, Jeff Barnett wrote: >>>>>>>>>>>> On 12/19/2021 11:44 AM, olcott wrote:

I can (and will shortly) conclusively prove that pure >>>>>>>>>>>>> function H
correctly detects that P specifies infinitely nested >>>>>>>>>>>>> simulation.

Simple question: Since virtually everyone who has studied >>>>>>>>>>>> this problem
knows, simulation is not a feasible way to build a halt decider >>>>>>>>>>>> (assuming one could be built). The proof you are attacking >>>>>>>>>>>> as well as
others I am aware of are not based on simulation. Why do >>>>>>>>>>>> insist that
simulation is the way to go?

I think I can answer this for PO.

The first observation is that a simulating halt decider goes >>>>>>>>>>> into an
infinite series of nested simulations if fed H_Hat. So this >>>>>>>>>>> leads to the
question, can we somehow exploit this to get round the Linz >>>>>>>>>>> trap?

You are the only reviewer that has ever made any attempt at an >>>>>>>>>> honest dialogue. (Except possibly Kaz) That one party of a >>>>>>>>>> conversation has no intention of any honest dialogue is proven >>>>>>>>>> by the fact that there are persistently zero elements of
mutual agreement by one of the parties.

Every time that I effectively prove my point those respondents >>>>>>>>>> that have no interest what-so-ever in any honest dialogue
always change the subject to another basis of rebuttal.

When Ben responded to your point he studiously totally
bypassed the point by nitpicking at the use of terminology. >>>>>>>>>>
Sapir–Whorf hypothesis
language determines thought and that linguistic categories >>>>>>>>>> limit and determine cognitive categories.
https://en.wikipedia.org/wiki/Linguistic_relativity

In order to talk about TMs that base their halt status
decision on the behavior of simulating N steps of their input >>>>>>>>>> until this input either halts on its own or the TM recognizes >>>>>>>>>> an infinitely behavior pattern we must have a term.

Since the term "decider" must halt on all inputs, the term >>>>>>>>>> decider may not be perfectly apt unless we qualify it.

But since the Theorem that you want to actually talk about is >>>>>>>>> based on the term Decider, you can't change the meaning of the >>>>>>>>> term or use a slightly different term and still be talking
about THAT Theorem.

You don't get to 'change' the meaning of the terms in the
Theorem, no matter how inconvenient that makes things for you. >>>>>>>>>

The most straight forward way to qualify such a term would be >>>>>>>>>> that a TM is a simulating halt decider that computes the halt >>>>>>>>>> status of a limited domain of finite string pairs.

And to do the job you claim to be doing that domain MUST
include the string that represents the description of the H^ >>>>>>>>> machine build on your exact H being applied to that string.

Yes, that is the only element of the domain of the simulating
halt decider hat I am referring to.

H computes the function of mapping input pairs to an accept / >>>>>>>>>> reject state on the basis of simulating N steps of this input >>>>>>>>>> pair until this simulated input reaches its final state or H >>>>>>>>>> has recognize an infinite behavior pattern. Because the
purpose of H is limited to showing how the conventional HP >>>>>>>>>> counter-examples would be decided the function that H computes >>>>>>>>>> its limited to one element of these counter-example inputs. >>>>>>>>>

And to meet the REQUIREMENTS of the Theory, this accept/reject >>>>>>>>> needs to match the ACTUAL BEHAVIOR of that H^ machine built
from the H you are claiming to be correct applied to its
description.

If it is the case that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by >>>>>>>> embedded_H would never reach the final state of this simulated >>>>>>>> input then it would be  known with 100% perfectly justified
complete logical certainty that this input specifies a
non-halting computation.

If it is the case that simulation of <H^> <H^> by H WILL never
reach the final state, then this MEANS that since H^ USES H, that >>>>>>> H, which is IDENTICAL to this one, must never abort its
simulation and go to H.Qn, thus you premise is that H never goes >>>>>>> to H.Qn.

This might seem this way to a brain dead moron that can't begin to >>>>>> imagine that a simulating halt decider could recognize that
something as simple as an infinite loop would never stop running
unless this simulating halt decider actually waited an infinite
amount of time to verify that the infinite loop never stops running. >>>>>>
Are you really a brain dead moron or merely pretending to be one
as a vicious head game?

You may see me as 'Brain Dead', but you are the one who seems to
not be able to read what people say and make an appropriate response. >>>>>
If you think this task is so easy, just show your code that does it. >>>>>

One need not see any code when one knows that when the invocation of
a function results in the invocation of this same function with the
same inputs that this proves infinite behavior.

 From what I recall this was your own idea that you now deceitfully
deny.

Yes, INVOCATION of the same function in a CALL chain will generate
infinite behavior,

If H 'calls' its input (maybe by UTM Simulation) this would be the
behavior, but such an H then has lost the ability to 'abort' the
'simulation' to return the answer.

You and Ben both deny that a halt decider could have simulating
ability, this is so ridiculously stupid that it must be flat out
dishonesty.

LIE!!!

I never said that, please show where I did or retract it.

Maybe I should have a solicitor pay you a call with a defamation suit.

Maybe if you had to try to explain your logic to a jury under penalty of perjury you would shape up.

Since I have a fully operational halt decider that does have
simulating ability this proves that you are a damned liar.

But it doesn't give the right answer, so YOU are the damned liar.

You are simply too stupid to know what the right answer is.

If your H says that P(P) will not halt, then when the running of P(P)
per the requrements shows that P(P) Halts, this is PROOF that your H was wrong.

FAIL.

This is the damned lie of the fallacy of equivocation error. The input
to H never halts. The halting decider is only accountable for the
behavior of its input.

As soon as the halt decider correctly determines that no amount of
simulation will ever cause its input to reach the final state of this
input it has 100% complete proof that this input specifies a non-halting computation.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 1/6/2022 5:58 AM, Malcolm McLean wrote:

On Wednesday, 5 January 2022 at 23:22:33 UTC, olcott wrote:

On 1/5/2022 5:10 PM, Richard Damon wrote:

No, YOU do that, you have several different things that you call H, with >>> different behaviors.

It is not that hard.
(a) H directly executes its input
(b) H simulates its input
(c) H watches the simulation of its input looking for infinite behavior
patterns.

It does seem when first considering the problem that this approach
should work. If the halt decider fails on some input, then that just indicates that the infinite behaviour pattern detector needs to be more sophisticated.

But when you really get into it, you see that in fact that's a false impression. Even some fairly simple Turing machines will defeat any
infinite behaviour pattern detector you can devise.

Try and provide an example.
My goal was to defeat the conventional HP counter-examples.
It seems that I have done that.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)