Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.software-eng > #2830 > unrolled thread

What if a cat barks?

Started byolcott <NoOne@NoWhere.com>
First post2021-06-20 23:15 -0500
Last post2021-06-22 20:12 -0500
Articles 20 on this page of 49 — 3 participants

Back to article view | Back to comp.software-eng


Contents

  What if a cat barks? olcott <NoOne@NoWhere.com> - 2021-06-20 23:15 -0500
    Re: What if a cat barks? "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-06-20 22:04 -0700
      Re: What if a cat barks? olcott <NoOne@NoWhere.com> - 2021-06-21 16:11 -0500
        Re: What if a cat barks? olcott <NoOne@NoWhere.com> - 2021-06-21 16:26 -0500
        Re: What if a cat barks? olcott <NoOne@NoWhere.com> - 2021-06-21 20:39 -0500
          Re: What if a cat barks? olcott <NoOne@NoWhere.com> - 2021-06-21 22:09 -0500
            Re: What if a cat barks? olcott <NoOne@NoWhere.com> - 2021-06-22 12:05 -0500
              Re: What if a cat barks? olcott <NoOne@NoWhere.com> - 2021-06-23 15:07 -0500
                Re: What if a cat barks? [ sound deduction is a proof ] olcott <NoOne@NoWhere.com> - 2021-06-23 19:01 -0500
                  Re: What if a cat barks? [ sound deduction is a proof ] olcott <NoOne@NoWhere.com> - 2021-06-23 22:03 -0500
                    Re: What if a cat barks? [ sound deduction is a proof ] olcott <NoOne@NoWhere.com> - 2021-06-24 16:40 -0500
                      Re: What if a cat barks? [ sound deduction is a proof ] olcott <NoOne@NoWhere.com> - 2021-06-25 08:53 -0500
                    Re: What if a cat barks? [ sound deduction is a proof ](axiom) olcott <NoOne@NoWhere.com> - 2021-06-25 11:33 -0500
                      Re: What if a cat barks? [ sound deduction is a proof ](axiom) olcott <NoOne@NoWhere.com> - 2021-06-25 13:50 -0500
                        Re: What if a cat barks? [ sound deduction is a proof ](axiom) olcott <NoOne@NoWhere.com> - 2021-06-25 17:56 -0500
                          Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) olcott <NoOne@NoWhere.com> - 2021-06-25 20:01 -0500
                            Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) olcott <NoOne@NoWhere.com> - 2021-06-25 20:46 -0500
                              Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) olcott <NoOne@NoWhere.com> - 2021-06-25 22:07 -0500
                                Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-06-26 01:11 -0700
                                  Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) Jeff Barnett <jbb@notatt.com> - 2021-06-26 04:27 -0600
                                    Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)(Ben lies) olcott <NoOne@NoWhere.com> - 2021-06-26 10:52 -0500
                                      Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)(knucklehead) olcott <NoOne@NoWhere.com> - 2021-06-26 19:01 -0500
                                        Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)(I dare you) olcott <NoOne@NoWhere.com> - 2021-06-26 19:49 -0500
                                          Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)(I dare you) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-06-26 20:03 -0700
                                        Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)(knucklehead) olcott <NoOne@NoWhere.com> - 2021-06-26 19:54 -0500
                                          Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) olcott <NoOne@NoWhere.com> - 2021-06-26 20:39 -0500
                                            Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)(dumber than a box of rocks ) olcott <NoOne@NoWhere.com> - 2021-06-27 09:43 -0500
                                              Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)(dumber than a box of rocks ) olcott <NoOne@NoWhere.com> - 2021-06-27 13:00 -0500
                                                Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)(liar liar pants on fire ) olcott <NoOne@NoWhere.com> - 2021-06-27 15:04 -0500
                                                  Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)(liar liar pants on fire ) olcott <NoOne@NoWhere.com> - 2021-06-27 17:46 -0500
                                                    Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)(liar liar pants on fire ) olcott <NoOne@NoWhere.com> - 2021-06-27 18:11 -0500
                                        Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)(knucklehead) olcott <NoOne@NoWhere.com> - 2021-06-26 20:05 -0500
                                    Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) olcott <NoOne@NoWhere.com> - 2021-06-26 20:08 -0500
                                    Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) olcott <NoOne@NoWhere.com> - 2021-06-27 14:56 -0500
                                      Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) olcott <NoOne@NoWhere.com> - 2021-06-27 17:26 -0500
                                        Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) olcott <NoOne@NoWhere.com> - 2021-06-27 18:18 -0500
                                        Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) olcott <NoOne@NoWhere.com> - 2021-06-27 20:44 -0500
                                        Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) olcott <NoOne@NoWhere.com> - 2021-06-27 21:40 -0500
                                    Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) olcott <NoOne@NoWhere.com> - 2021-06-27 20:38 -0500
                                Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) olcott <NoOne@NoWhere.com> - 2021-06-26 11:00 -0500
                                  Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain) olcott <NoOne@NoWhere.com> - 2021-06-26 11:29 -0500
      Re: What if a cat barks? [ sound deduction proves that I am correct ] olcott <NoOne@NoWhere.com> - 2021-06-22 21:15 -0500
        Re: What if a cat barks? [ sound deduction proves that I am correct ] olcott <NoOne@NoWhere.com> - 2021-06-22 22:21 -0500
          Re: What if a cat barks? [ sound deduction proves that I am correct ] olcott <NoOne@NoWhere.com> - 2021-06-23 11:12 -0500
          Re: What if a cat barks? [ sound deduction proves that I am correct ] olcott <NoOne@NoWhere.com> - 2021-06-24 10:25 -0500
            Re: What if a cat barks? [ sound deduction proves that I am correct ] olcott <NoOne@NoWhere.com> - 2021-06-24 11:03 -0500
          Re: What if a cat barks? [ sound deduction proves that I am correct ] olcott <NoOne@NoWhere.com> - 2021-06-24 10:39 -0500
    Re: What if a cat barks? [ How can a cat bark? ] olcott <NoOne@NoWhere.com> - 2021-06-21 10:07 -0500
    Re: What if a cat barks? olcott <NoOne@NoWhere.com> - 2021-06-22 20:12 -0500

Page 1 of 3  [1] 2 3  Next page →


#2830 — What if a cat barks?

Fromolcott <NoOne@NoWhere.com>
Date2021-06-20 23:15 -0500
SubjectWhat if a cat barks?
Message-ID<BpqdnWBR5LTFj039nZ2dnUU7-XPNnZ2d@giganews.com>
If you see an animal and test its DNA and confirm that it is definitely 
a cat, what happens when the cat barks?

When we examine the behavior of the Peter Linz Ĥ applied to its own 
Turing machine description: ⟨Ĥ⟩ and simply assume that the embedded halt 
decider at its internal state of Ĥ.qx is a UTM then we find that this 
machine has infinitely nested simulation.

SELF-EVIDENT-TRUTH
Every computation that never halts unless its simulation is aborted is a 
computation that never halts.

SELF-EVIDENT-TRUTH
The <Ĥ> <Ĥ> input to the embedded halt decider at Ĥ.qx is a computation 
that never halts unless its simulation is aborted.

∴ IMPOSSIBLY FALSE CONCLUSION
The embedded simulating halt decider at Ĥ.qx correctly decides its 
input: <Ĥ> <Ĥ> is a computation that never halts.

The above three elements essentially provide the DNA of the cat.


Halting problem undecidability and infinitely nested simulation

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation



-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [next] | [standalone]


#2831

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-06-20 22:04 -0700
Message-ID<sap6l7$130c$5@gioia.aioe.org>
In reply to#2830
On 6/20/2021 9:15 PM, olcott wrote:
> If you see an animal and test its DNA and confirm that it is definitely 
> a cat, what happens when the cat barks?
[...]

Have you been hearing cats bark lately? Wow.

[toc] | [prev] | [next] | [standalone]


#2834

Fromolcott <NoOne@NoWhere.com>
Date2021-06-21 16:11 -0500
Message-ID<tZOdneTmHpHNnUz9nZ2dnUU7-V3NnZ2d@giganews.com>
In reply to#2831
On 6/21/2021 1:24 PM, André G. Isaak wrote:
> On 2021-06-20 23:04, Chris M. Thomasson wrote:
>> On 6/20/2021 9:15 PM, olcott wrote:
>>> If you see an animal and test its DNA and confirm that it is 
>>> definitely a cat, what happens when the cat barks?
>> [...]
>>
>> Have you been hearing cats bark lately? Wow.
> 
> As long as he's just hearing them bark, we're probably fine.
> 
> It's when the barking cats start telling him to do things (like kill 
> neighbours, steal catnip, or conquer Liechtenstein) that we really need 
> to worry.
> 
> André
> 

The point is that the mere intuition about the halting behavior of Ĥ 
applied to ⟨Ĥ⟩ is superseded by meticulous sound deductive inference.

SELF-EVIDENT-TRUTH
Every computation that never halts unless its simulation is aborted is a 
computation that never halts.

SELF-EVIDENT-TRUTH
The ⟨Ĥ⟩ ⟨Ĥ⟩ input to the embedded halt decider at Ĥ.qx is a computation 
that never halts unless its simulation is aborted.

∴ IMPOSSIBLY FALSE CONCLUSION
The embedded simulating halt decider at Ĥ.qx correctly decides its 
input: ⟨Ĥ⟩ ⟨Ĥ⟩ is a computation that never halts.

Ĥ.q0 ⟨Ĥ⟩ specifies an infinite chain of invocations that is terminated 
at its third invocation. The first invocation of Ĥ.qx ⟨Ĥ⟩, ⟨Ĥ⟩ is the 
first element of an infinite chain of invocations.

It is common knowledge that when any invocation of an infinite chain of 
invocations is terminated that the whole chain terminates. That the 
first element of this infinite chain terminates after its third element 
has been terminated does not entail that this first element is an actual 
terminating computation.

For the first element to be an actual terminating computation it must 
terminate without any of the elements of the infinite chain of 
invocations being terminated.





Halting problem undecidability and infinitely nested simulation
https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2835

Fromolcott <NoOne@NoWhere.com>
Date2021-06-21 16:26 -0500
Message-ID<0e-dnbFfeY-XmUz9nZ2dnUU7-ePNnZ2d@giganews.com>
In reply to#2834
On 6/21/2021 4:11 PM, olcott wrote:
> On 6/21/2021 1:24 PM, André G. Isaak wrote:
>> On 2021-06-20 23:04, Chris M. Thomasson wrote:
>>> On 6/20/2021 9:15 PM, olcott wrote:
>>>> If you see an animal and test its DNA and confirm that it is 
>>>> definitely a cat, what happens when the cat barks?
>>> [...]
>>>
>>> Have you been hearing cats bark lately? Wow.
>>
>> As long as he's just hearing them bark, we're probably fine.
>>
>> It's when the barking cats start telling him to do things (like kill 
>> neighbours, steal catnip, or conquer Liechtenstein) that we really 
>> need to worry.
>>
>> André
>>
> 
> The point is that the mere intuition about the halting behavior of Ĥ 
> applied to ⟨Ĥ⟩ is superseded by meticulous sound deductive inference.
> 

Self-Evident-Truth (premise[1])
Every computation that never halts unless its simulation is aborted is a 
computation that never halts.

Self-Evident-Truth (premise[2])
The ⟨Ĥ⟩ ⟨Ĥ⟩ input to the embedded halt decider at Ĥ.qx is a computation 
that never halts unless its simulation is aborted.

∴ Sound Deductive Conclusion
The embedded simulating halt decider at Ĥ.qx correctly decides its 
input: ⟨Ĥ⟩ ⟨Ĥ⟩ is a computation that never halts.

> Ĥ.q0 ⟨Ĥ⟩ specifies an infinite chain of invocations that is terminated 
> at its third invocation. The first invocation of Ĥ.qx ⟨Ĥ⟩, ⟨Ĥ⟩ is the 
> first element of an infinite chain of invocations.
> 
> It is common knowledge that when any invocation of an infinite chain of 
> invocations is terminated that the whole chain terminates. That the 
> first element of this infinite chain terminates after its third element 
> has been terminated does not entail that this first element is an actual 
> terminating computation.
> 
> For the first element to be an actual terminating computation it must 
> terminate without any of the elements of the infinite chain of 
> invocations being terminated.
> 
> 
> 
> 
> 
> Halting problem undecidability and infinitely nested simulation
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation 
> 
> 
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2837

Fromolcott <NoOne@NoWhere.com>
Date2021-06-21 20:39 -0500
Message-ID<zZOdnUG2JPuxokz9nZ2dnUU7-UPNnZ2d@giganews.com>
In reply to#2834
On 6/21/2021 7:57 PM, André G. Isaak wrote:
> On 2021-06-21 15:11, olcott wrote:
>> On 6/21/2021 1:24 PM, André G. Isaak wrote:
>>> On 2021-06-20 23:04, Chris M. Thomasson wrote:
>>>> On 6/20/2021 9:15 PM, olcott wrote:
>>>>> If you see an animal and test its DNA and confirm that it is 
>>>>> definitely a cat, what happens when the cat barks?
>>>> [...]
>>>>
>>>> Have you been hearing cats bark lately? Wow.
>>>
>>> As long as he's just hearing them bark, we're probably fine.
>>>
>>> It's when the barking cats start telling him to do things (like kill 
>>> neighbours, steal catnip, or conquer Liechtenstein) that we really 
>>> need to worry.
>>>
>>> André
>>>
>>
>> The point is that the mere intuition about the halting behavior of Ĥ 
>> applied to ⟨Ĥ⟩ is superseded by meticulous sound deductive inference.
>>
>> SELF-EVIDENT-TRUTH
>> Every computation that never halts unless its simulation is aborted is 
>> a computation that never halts.
> 
> How can that possibly be "self-evident" when it doesn't even explain 
> what "its simulation" means. Its simulation of/by what?
> 

We could simplify this and say that any computation that never halts 
unless this computation is aborted is a computation that never halts.

>> SELF-EVIDENT-TRUTH
>> The ⟨Ĥ⟩ ⟨Ĥ⟩ input to the embedded halt decider at Ĥ.qx is a 
>> computation that never halts unless its simulation is aborted.
> 
> If that were self-evident, you wouldn't have so many people pointing out 
> to you that it is simply wrong. Things can't be both wrong and 
> self-evident.
> 

That people simply don't want to bother to pay enough attention to see 
that I am right is not actually any rebuttal at all.

>> ∴ IMPOSSIBLY FALSE CONCLUSION
> 
> "Impossibly false" is a meaningless expression. No journal is going to 
> take you seriously if this phrase appears anywhere in your work.
> 

I improved this. I now call it the conclusion of sound deduction, which 
means exactly the same thing as impossibly false.

>> The embedded simulating halt decider at Ĥ.qx correctly decides its 
>> input: ⟨Ĥ⟩ ⟨Ĥ⟩ is a computation that never halts.
>>
>> Ĥ.q0 ⟨Ĥ⟩ specifies an infinite chain of invocations that is terminated 
>> at its third invocation. The first invocation of Ĥ.qx ⟨Ĥ⟩, ⟨Ĥ⟩ is the 
>> first element of an infinite chain of invocations.
>>
>> It is common knowledge that when any invocation of an infinite chain 
>> of invocations is terminated that the whole chain terminates. That the 
>> first element of this infinite chain terminates after its third 
>> element has been terminated does not entail that this first element is 
>> an actual terminating computation.
> 
> No. It isn't "common knowledge". It is simply false.
> 

I will make a common knowledge concrete example:
Infinite recursion is an infinite sequence of invocations right?

If any element of the infinite sequence of invocations of infinite 
recursion is aborted then the whole sequence stops right?

If the third invocation of the infinite sequence of invocations of 
infinite recursion is aborted then the whole sequence stops right?

Was it really that hard to see the above three steps on the basis of my 
claim of common knowledge?

> And if the simulation is terminated after the third call to Ĥ, the you 
> don't have an infinite chain of calls. You have a chain of three calls.
> 

When the halt decider is analyzing the behavior stipulated by a finite 
string it is incorrect for the halt decider to conflate its own behavior 
in this analysis.

The question that the halt decider is answering is whether or not a pure 
simulation/execution of the input must be aborted to prevent the 
infinite execution of this input.

>> For the first element to be an actual terminating computation it must 
>> terminate without any of the elements of the infinite chain of 
>> invocations being terminated.
> 
> This is just plain silly. 

See my infinite recursion example above.

> If some program H simulates another program Y 
> along with an input string but has the ability to terminate a 
> simulation, then there are three possibilities:
> 
> A) The simulation is allowed to continue until Y reaches one of its 
> final states. In such a case we can say that Y halts. Since Y halts, H 
> can also halt.
> 
> B) The simulation is allowed to continue forever, but it never reaches a 
> final state. The simulation continues forever. In this case, Y doesn't 
> halt. H therefore also doesn't halt. Of course, this option would be 
> difficult to empirically verify since we can't actually observe 
> something running for an infinite amount of time.
> 
> C) H decides to discontinue the simulation. In this case the simulation 
> neither halts nor runs forever. It may be that that Y is non-halting, or 
> it may be that H simply discontinued the simulation prematurely. But in 
> either of these two cases, H can halt.
> 
> André
> 

As I have said so very many hundreds of times now that you really should 
not have made such a terrible mistake with part C

When H must terminate the simulation of its input to prevent the 
infinite execution of P then H does necessarily infallibly correctly 
decide that its input never halts.

Unlike Turing machines where we must simply imagine crucially important 
details and have no way to infallibly ascertain that our imagination 
accurately represent the truth we can examine the x86 execution trace of 
P and know with 100% perfectly correct certainty that P would never ever 
halt unless H aborts P.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2838

Fromolcott <NoOne@NoWhere.com>
Date2021-06-21 22:09 -0500
Message-ID<E8Wdnezrd-inyUz9nZ2dnUU7-cHNnZ2d@giganews.com>
In reply to#2837
On 6/21/2021 9:29 PM, André G. Isaak wrote:
> On 2021-06-21 19:39, olcott wrote:
>> On 6/21/2021 7:57 PM, André G. Isaak wrote:
>>> On 2021-06-21 15:11, olcott wrote:
>>>> On 6/21/2021 1:24 PM, André G. Isaak wrote:
>>>>> On 2021-06-20 23:04, Chris M. Thomasson wrote:
>>>>>> On 6/20/2021 9:15 PM, olcott wrote:
>>>>>>> If you see an animal and test its DNA and confirm that it is 
>>>>>>> definitely a cat, what happens when the cat barks?
>>>>>> [...]
>>>>>>
>>>>>> Have you been hearing cats bark lately? Wow.
>>>>>
>>>>> As long as he's just hearing them bark, we're probably fine.
>>>>>
>>>>> It's when the barking cats start telling him to do things (like 
>>>>> kill neighbours, steal catnip, or conquer Liechtenstein) that we 
>>>>> really need to worry.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> The point is that the mere intuition about the halting behavior of Ĥ 
>>>> applied to ⟨Ĥ⟩ is superseded by meticulous sound deductive inference.
>>>>
>>>> SELF-EVIDENT-TRUTH
>>>> Every computation that never halts unless its simulation is aborted 
>>>> is a computation that never halts.
>>>
>>> How can that possibly be "self-evident" when it doesn't even explain 
>>> what "its simulation" means. Its simulation of/by what?
>>>
>>
>> We could simplify this and say that any computation that never halts 
>> unless this computation is aborted is a computation that never halts.
> 
> That's no better. A computation which is aborted doesn't halt. 'Halt' 
> means to reach one of the final states. If you abort something it 
> doesn't reach a final state. But the simulator itself can.
> 

When we are trying to determine whether or not an infinite loop is an 
infinite loop we can debug step through this code and see that it 
endlessly repeats and there is no escape from this endless repetition in 
this code. It is not really that hard.

>>>> SELF-EVIDENT-TRUTH
>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ input to the embedded halt decider at Ĥ.qx is a 
>>>> computation that never halts unless its simulation is aborted.
>>>
>>> If that were self-evident, you wouldn't have so many people pointing 
>>> out to you that it is simply wrong. Things can't be both wrong and 
>>> self-evident.
>>>
>>
>> That people simply don't want to bother to pay enough attention to see 
>> that I am right is not actually any rebuttal at all.
>>
>>>> ∴ IMPOSSIBLY FALSE CONCLUSION
>>>
>>> "Impossibly false" is a meaningless expression. No journal is going 
>>> to take you seriously if this phrase appears anywhere in your work.
>>>
>>
>> I improved this. I now call it the conclusion of sound deduction, 
>> which means exactly the same thing as impossibly false.
> 
> So where is the sound deduction from which you reach the above 
> conclusion? You start with two premises, one of which is too vague to be 
> interpreted and the other of which is simply false. That's not how 
> deductively sound arguments work.

We really have to look at this in terms of H and P because there is no 
other possible way to make sure that we examine all the details when we 
try to imagine what a Turing machine might do.

>>>> The embedded simulating halt decider at Ĥ.qx correctly decides its 
>>>> input: ⟨Ĥ⟩ ⟨Ĥ⟩ is a computation that never halts.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ specifies an infinite chain of invocations that is 
>>>> terminated at its third invocation. The first invocation of Ĥ.qx 
>>>> ⟨Ĥ⟩, ⟨Ĥ⟩ is the first element of an infinite chain of invocations.
>>>>
>>>> It is common knowledge that when any invocation of an infinite chain 
>>>> of invocations is terminated that the whole chain terminates. That 
>>>> the first element of this infinite chain terminates after its third 
>>>> element has been terminated does not entail that this first element 
>>>> is an actual terminating computation.
>>>
>>> No. It isn't "common knowledge". It is simply false.
>>>
>>
>> I will make a common knowledge concrete example:
>> Infinite recursion is an infinite sequence of invocations right?
> 
> Sure, but there is no infinite recursion (or recursion period) in the 
> Linz example.
> 
>> If any element of the infinite sequence of invocations of infinite 
>> recursion is aborted then the whole sequence stops right?
> 
> Not necessarily. That depends entirely on what is meant by 'abort'.
> 
>> If the third invocation of the infinite sequence of invocations of 
>> infinite recursion is aborted then the whole sequence stops right?
> 
> No. The third invocation is aborted. The simulator itself continues to 
> run and is able to halt.
> 
>> Was it really that hard to see the above three steps on the basis of 
>> my claim of common knowledge?
> 
> Things that you believe and 'common knowledge' are not the same thing.
> 
>>> And if the simulation is terminated after the third call to Ĥ, the 
>>> you don't have an infinite chain of calls. You have a chain of three 
>>> calls.
>>>
>>
>> When the halt decider is analyzing the behavior stipulated by a finite 
>> string it is incorrect for the halt decider to conflate its own 
>> behavior in this analysis.
> 
> And I am not conflating them. When you abort the simulation that doesn't 
> entail aborting the simulator. You conflate them by concluding that the 
> topmost program doesn't halt based on what happens to the program it is 
> simulating.
> 
>> The question that the halt decider is answering is whether or not a 
>> pure simulation/execution of the input must be aborted to prevent the 
>> infinite execution of this input.
>>
>>>> For the first element to be an actual terminating computation it 
>>>> must terminate without any of the elements of the infinite chain of 
>>>> invocations being terminated.
>>>
>>> This is just plain silly. 
>>
>> See my infinite recursion example above.
> 
> As I said, the above is just plain silly.
> 
>>> If some program H simulates another program Y along with an input 
>>> string but has the ability to terminate a simulation, then there are 
>>> three possibilities:
>>>
>>> A) The simulation is allowed to continue until Y reaches one of its 
>>> final states. In such a case we can say that Y halts. Since Y halts, 
>>> H can also halt.
>>>
>>> B) The simulation is allowed to continue forever, but it never 
>>> reaches a final state. The simulation continues forever. In this 
>>> case, Y doesn't halt. H therefore also doesn't halt. Of course, this 
>>> option would be difficult to empirically verify since we can't 
>>> actually observe something running for an infinite amount of time.
>>>
>>> C) H decides to discontinue the simulation. In this case the 
>>> simulation neither halts nor runs forever. It may be that that Y is 
>>> non-halting, or it may be that H simply discontinued the simulation 
>>> prematurely. But in either of these two cases, H can halt.
>>>
>>> André
>>>
>>
>> As I have said so very many hundreds of times now that you really 
>> should not have made such a terrible mistake with part C
> 
> There is no mistake in C. 


C) H decides to discontinue the simulation.
This is very terribly incorrect

H MUST stop its simulation of P or P never halts
H MUST stop its simulation of P or P never halts
H MUST stop its simulation of P or P never halts
H MUST stop its simulation of P or P never halts
H MUST stop its simulation of P or P never halts

This is not at all the same thing as H arbitrarily stops simulating P 
for possibly no good reason at all.

This is not at all the same thing as H arbitrarily stops simulating P 
for possibly no good reason at all.

This is not at all the same thing as H arbitrarily stops simulating P 
for possibly no good reason at all.

This is not at all the same thing as H arbitrarily stops simulating P 
for possibly no good reason at all.


> Your 'self-evident' truths are wrong, as 
> virtually everyone posting here has pointed out.
> 
>> When H must terminate the simulation of its input to prevent the 
>> infinite execution of P then H does necessarily infallibly correctly 
>> decide that its input never halts.
>>
>> Unlike Turing machines where we must simply imagine crucially 
>> important details and have no way to infallibly ascertain that our 
>> imagination 
> 
> Exactly which 'crucially important details' do you think we need to 
> imagine? 

100% of every single detail of the execution trace of the input without 
the most minute details not totally and completely specified. We just 
flat out can't do that with TM's of the sophistication of H and P.
With the Linz proof we are left to simply imagine hundreds of thousands 
of steps. With my C/x86 code we see every single relevant detail.

Crucially we the absolute necessity for H to abort its simulation of P 
on the basis of the actual x86 execution trace of P.

> Turing machines are precisely defined entities with precisely 
> defined behaviours. And there are literally thousands of programs 
> available which will allow you to execute Turing Machines if you'd 
> rather not trace through them manually.
> 
>> accurately represent the truth we can examine the x86 execution trace 
>> of P and know with 100% perfectly correct certainty that P would never 
>> ever halt unless H aborts P.
> 
> An execution trace does nothing other than to show what a particular 
> program did on a particular input. It provides no evidence whatsoever 
> for the correctness of the program. For that you need to provide actual 
> proof. An execution trace is not a proof.
> 
> André
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2839

Fromolcott <NoOne@NoWhere.com>
Date2021-06-22 12:05 -0500
Message-ID<4I-dnW6siND5hU_9nZ2dnUU7-V3NnZ2d@giganews.com>
In reply to#2838
On 6/22/2021 11:47 AM, André G. Isaak wrote:
> On 2021-06-21 21:09, olcott wrote:
>> On 6/21/2021 9:29 PM, André G. Isaak wrote:
>>> On 2021-06-21 19:39, olcott wrote:
>>>> On 6/21/2021 7:57 PM, André G. Isaak wrote:
>>>>> On 2021-06-21 15:11, olcott wrote:
>>>>>> On 6/21/2021 1:24 PM, André G. Isaak wrote:
>>>>>>> On 2021-06-20 23:04, Chris M. Thomasson wrote:
>>>>>>>> On 6/20/2021 9:15 PM, olcott wrote:
>>>>>>>>> If you see an animal and test its DNA and confirm that it is 
>>>>>>>>> definitely a cat, what happens when the cat barks?
>>>>>>>> [...]
>>>>>>>>
>>>>>>>> Have you been hearing cats bark lately? Wow.
>>>>>>>
>>>>>>> As long as he's just hearing them bark, we're probably fine.
>>>>>>>
>>>>>>> It's when the barking cats start telling him to do things (like 
>>>>>>> kill neighbours, steal catnip, or conquer Liechtenstein) that we 
>>>>>>> really need to worry.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> The point is that the mere intuition about the halting behavior of 
>>>>>> Ĥ applied to ⟨Ĥ⟩ is superseded by meticulous sound deductive 
>>>>>> inference.
>>>>>>
>>>>>> SELF-EVIDENT-TRUTH
>>>>>> Every computation that never halts unless its simulation is 
>>>>>> aborted is a computation that never halts.
>>>>>
>>>>> How can that possibly be "self-evident" when it doesn't even 
>>>>> explain what "its simulation" means. Its simulation of/by what?
>>>>>
>>>>
>>>> We could simplify this and say that any computation that never halts 
>>>> unless this computation is aborted is a computation that never halts.
>>>
>>> That's no better. A computation which is aborted doesn't halt. 'Halt' 
>>> means to reach one of the final states. If you abort something it 
>>> doesn't reach a final state. But the simulator itself can.
>>>
>>
>> When we are trying to determine whether or not an infinite loop is an 
>> infinite loop we can debug step through this code and see that it 
>> endlessly repeats and there is no escape from this endless repetition 
>> in this code. It is not really that hard.
> 
> Which has nothing to do with what I wrote.
> 

It explains the details of how a computation that must be aborted by the 
halt decider to prevent the infinite execution of this computation <is> 
a computation that never halts.

>>>>>> SELF-EVIDENT-TRUTH
>>>>>> The ⟨Ĥ⟩ ⟨Ĥ⟩ input to the embedded halt decider at Ĥ.qx is a 
>>>>>> computation that never halts unless its simulation is aborted.
>>>>>
>>>>> If that were self-evident, you wouldn't have so many people 
>>>>> pointing out to you that it is simply wrong. Things can't be both 
>>>>> wrong and self-evident.
>>>>>
>>>>
>>>> That people simply don't want to bother to pay enough attention to 
>>>> see that I am right is not actually any rebuttal at all.
>>>>
>>>>>> ∴ IMPOSSIBLY FALSE CONCLUSION
>>>>>
>>>>> "Impossibly false" is a meaningless expression. No journal is going 
>>>>> to take you seriously if this phrase appears anywhere in your work.
>>>>>
>>>>
>>>> I improved this. I now call it the conclusion of sound deduction, 
>>>> which means exactly the same thing as impossibly false.
>>>
>>> So where is the sound deduction from which you reach the above 
>>> conclusion? You start with two premises, one of which is too vague to 
>>> be interpreted and the other of which is simply false. That's not how 
>>> deductively sound arguments work.
>>
>> We really have to look at this in terms of H and P because there is no 
>> other possible way to make sure that we examine all the details when 
>> we try to imagine what a Turing machine might do.
> 
> Which doesn't answer my question. Where is your 'sound deductive argument'?
> 

(a) Every computation P that never halts unless the halt decider H 
aborts this computation is a computation that never halts.

(b) X is a computation that never halts unless it is aborted by its halt 
decider.

∴ (c) X is a computation that is correctly decided to be a computation 
that never halts.

>>>>>> The embedded simulating halt decider at Ĥ.qx correctly decides its 
>>>>>> input: ⟨Ĥ⟩ ⟨Ĥ⟩ is a computation that never halts.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ specifies an infinite chain of invocations that is 
>>>>>> terminated at its third invocation. The first invocation of Ĥ.qx 
>>>>>> ⟨Ĥ⟩, ⟨Ĥ⟩ is the first element of an infinite chain of invocations.
>>>>>>
>>>>>> It is common knowledge that when any invocation of an infinite 
>>>>>> chain of invocations is terminated that the whole chain 
>>>>>> terminates. That the first element of this infinite chain 
>>>>>> terminates after its third element has been terminated does not 
>>>>>> entail that this first element is an actual terminating computation.
>>>>>
>>>>> No. It isn't "common knowledge". It is simply false.
>>>>>
>>>>
>>>> I will make a common knowledge concrete example:
>>>> Infinite recursion is an infinite sequence of invocations right?
>>>
>>> Sure, but there is no infinite recursion (or recursion period) in the 
>>> Linz example.
>>>
>>>> If any element of the infinite sequence of invocations of infinite 
>>>> recursion is aborted then the whole sequence stops right?
>>>
>>> Not necessarily. That depends entirely on what is meant by 'abort'.
>>>
>>>> If the third invocation of the infinite sequence of invocations of 
>>>> infinite recursion is aborted then the whole sequence stops right?
>>>
>>> No. The third invocation is aborted. The simulator itself continues 
>>> to run and is able to halt.
>>>
>>>> Was it really that hard to see the above three steps on the basis of 
>>>> my claim of common knowledge?
>>>
>>> Things that you believe and 'common knowledge' are not the same thing.
>>>
>>>>> And if the simulation is terminated after the third call to Ĥ, the 
>>>>> you don't have an infinite chain of calls. You have a chain of 
>>>>> three calls.
>>>>>
>>>>
>>>> When the halt decider is analyzing the behavior stipulated by a 
>>>> finite string it is incorrect for the halt decider to conflate its 
>>>> own behavior in this analysis.
>>>
>>> And I am not conflating them. When you abort the simulation that 
>>> doesn't entail aborting the simulator. You conflate them by 
>>> concluding that the topmost program doesn't halt based on what 
>>> happens to the program it is simulating.
>>>
>>>> The question that the halt decider is answering is whether or not a 
>>>> pure simulation/execution of the input must be aborted to prevent 
>>>> the infinite execution of this input.
>>>>
>>>>>> For the first element to be an actual terminating computation it 
>>>>>> must terminate without any of the elements of the infinite chain 
>>>>>> of invocations being terminated.
>>>>>
>>>>> This is just plain silly. 
>>>>
>>>> See my infinite recursion example above.
>>>
>>> As I said, the above is just plain silly.
>>>
>>>>> If some program H simulates another program Y along with an input 
>>>>> string but has the ability to terminate a simulation, then there 
>>>>> are three possibilities:
>>>>>
>>>>> A) The simulation is allowed to continue until Y reaches one of its 
>>>>> final states. In such a case we can say that Y halts. Since Y 
>>>>> halts, H can also halt.
>>>>>
>>>>> B) The simulation is allowed to continue forever, but it never 
>>>>> reaches a final state. The simulation continues forever. In this 
>>>>> case, Y doesn't halt. H therefore also doesn't halt. Of course, 
>>>>> this option would be difficult to empirically verify since we can't 
>>>>> actually observe something running for an infinite amount of time.
>>>>>
>>>>> C) H decides to discontinue the simulation. In this case the 
>>>>> simulation neither halts nor runs forever. It may be that that Y is 
>>>>> non-halting, or it may be that H simply discontinued the simulation 
>>>>> prematurely. But in either of these two cases, H can halt.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> As I have said so very many hundreds of times now that you really 
>>>> should not have made such a terrible mistake with part C
>>>
>>> There is no mistake in C. 
>>
>>
>> C) H decides to discontinue the simulation.
>> This is very terribly incorrect
>>
>> H MUST stop its simulation of P or P never halts
> 
> Which is subsumed under option C. The above enumerates all logical 
> possibilities.
> 

Then you needs a (D)

(C) H MUST stop its simulation of P or P never halts

(D) H stops its simulation of P for some other reason.

>> H MUST stop its simulation of P or P never halts
>> H MUST stop its simulation of P or P never halts
>> H MUST stop its simulation of P or P never halts
>> H MUST stop its simulation of P or P never halts
>>
>> This is not at all the same thing as H arbitrarily stops simulating P 
>> for possibly no good reason at all.
> 
> Option C never said anything about why it aborts the simulation. 

That is its horribly terrible error. To simply ignore the key most 
important halt deciding criteria is a terribly awful mistake.


> Whether 
> it aborts it because it MUST do so (or, in your case, because you think 
> it MUST stop its simulation) or for some other reason, or for no reason 
> at all, H can still halt.
> 

When-so-ever H must abort its input to prevent the infinite execution of 
this input H always correctly decides that this input never halts 100% 
of all the time.

We can know this in the same way that we know that a dead person is not 
alive.

>> This is not at all the same thing as H arbitrarily stops simulating P 
>> for possibly no good reason at all.
>>
>> This is not at all the same thing as H arbitrarily stops simulating P 
>> for possibly no good reason at all.
>>
>> This is not at all the same thing as H arbitrarily stops simulating P 
>> for possibly no good reason at all.
>>
>>
>>> Your 'self-evident' truths are wrong, as virtually everyone posting 
>>> here has pointed out.
>>>
>>>> When H must terminate the simulation of its input to prevent the 
>>>> infinite execution of P then H does necessarily infallibly correctly 
>>>> decide that its input never halts.
>>>>
>>>> Unlike Turing machines where we must simply imagine crucially 
>>>> important details and have no way to infallibly ascertain that our 
>>>> imagination 
>>>
>>> Exactly which 'crucially important details' do you think we need to 
>>> imagine? 
>>
>> 100% of every single detail of the execution trace of the input 
>> without the most minute details not totally and completely specified. 
>> We just flat out can't do that with TM's of the sophistication of H 
>> and P.
> 
> Of course we can. People work with actual Turing Machines all the time 
> and they don't have to 'imagine' anything. 

Only for very trivial things.
No one has even attempted to write a C to TM compiler.

> You just don't want to work 
> with actual Turing Machines because you don't understand what they are 
> or how they work.
> 
> André
> 

The lack of direct memory access cripples the expressiveness of the TM 
model.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2846

Fromolcott <NoOne@NoWhere.com>
Date2021-06-23 15:07 -0500
Message-ID<48GdnbWRNeocCU79nZ2dnUU7-TXNnZ2d@giganews.com>
In reply to#2839
On 6/23/2021 12:29 PM, André G. Isaak wrote:
> On 2021-06-22 13:17, olcott wrote:
>> On 6/22/2021 1:38 PM, André G. Isaak wrote:
>>> On 2021-06-22 11:05, olcott wrote:
>>>> On 6/22/2021 11:47 AM, André G. Isaak wrote:
> 
> <snip>
> 
>> In the case of the simulation of P it is verified on the basis of the 
>> x86 execution trace of B, thus an established verified fact.
> 
> Except that an execution trace doesn't 'verify' anything. No one doubts 
> that your program decides that P(P) == 0. But unless the logic 
> underlying your program is actually correct, this result tells us 
> nothing. And you haven't provided any sort of proof that the logic 
> underlying your program is actually correct.
> 

Halting problem undecidability and infinitely nested simulation

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

Sure I have. When we look as page 3 and 4 of the above paper it is very 
easy to see that H does faithfully simulate the execution of P and that 
P has no escape from infinite execution in its own code.

Premise(1) Every computation that never halts unless its simulation is 
aborted is a computation that never halts. This verified as true on the 
basis of the meaning of its words.

Premise(2) The simulation of the input to H(P,P) never halts without 
being aborted is a verified fact on the basis of its x86 execution 
trace. (shown below).

Conclusion(3) From the above true premises it necessarily follows that 
simulating halt decider H correctly reports that its input: (P,P) never 
halts.

Only by very diligently making sure to not pay attention is it possible 
to maintain the ruse of a fake rebuttal.

> And it isn't correct. Most significantly, your trace skips over certain 
> portions of the P being simulated which completely invalidates its results.
> 

The question is:

Does the simulation of P have to be aborted to prevent its infinite 
execution?

As long as the answer to this question is [YES] then Premise(2) is 
perfectly satisfied and your objection is utterly pointless.

As long as the answer to this question is [YES] then Premise(2) is 
perfectly satisfied and your objection is utterly pointless.

As long as the answer to this question is [YES] then Premise(2) is 
perfectly satisfied and your objection is utterly pointless.

As long as the answer to this question is [YES] then Premise(2) is 
perfectly satisfied and your objection is utterly pointless.


> <snip>
> 
>>>>> Option C never said anything about why it aborts the simulation. 
>>>>
>>>> That is its horribly terrible error. To simply ignore the key most 
>>>> important halt deciding criteria is a terribly awful mistake.
>>>
>>> Clearly you have reading comprehension problems. The halting status 
>>> of the *simulator* has nothing to do with the halting status of its 
>>> input computation if the simulator is capable of aborting the 
>>> simulation of that input. That applies equally to your (C) and your 
>>> (D). In either case, the simulator can halt.
>>>
>>
>> An intentional fallacy of equivocation error that very persistently 
>> tries to hide the correct halt deciding criteria.
>>
>> Key to refuting all the conventional HP undecidability proofs
>>
>> -- H MUST stop its simulation of P or P never halts
> 
> I'm not hiding anything. Whether the halt deciding criterion is correct 
> or not has no bearing on my claim, which is that once a simulation is 
> aborted the simulator can still halt. That's true of a simulator using a 
> 'correct' criterion just as much as its true of one which simply aborts 
> its simulation at random.
> 
> André
> 
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2847 — Re: What if a cat barks? [ sound deduction is a proof ]

Fromolcott <NoOne@NoWhere.com>
Date2021-06-23 19:01 -0500
SubjectRe: What if a cat barks? [ sound deduction is a proof ]
Message-ID<6POdnUnCSvCzVk79nZ2dnUU7-a3NnZ2d@giganews.com>
In reply to#2846
On 6/23/2021 6:13 PM, André G. Isaak wrote:
> On 2021-06-23 14:07, olcott wrote:
>> On 6/23/2021 12:29 PM, André G. Isaak wrote:
>>> On 2021-06-22 13:17, olcott wrote:
>>>> On 6/22/2021 1:38 PM, André G. Isaak wrote:
>>>>> On 2021-06-22 11:05, olcott wrote:
>>>>>> On 6/22/2021 11:47 AM, André G. Isaak wrote:
>>>
>>> <snip>
>>>
>>>> In the case of the simulation of P it is verified on the basis of 
>>>> the x86 execution trace of B, thus an established verified fact.
>>>
>>> Except that an execution trace doesn't 'verify' anything. No one 
>>> doubts that your program decides that P(P) == 0. But unless the logic 
>>> underlying your program is actually correct, this result tells us 
>>> nothing. And you haven't provided any sort of proof that the logic 
>>> underlying your program is actually correct.
>>>
>>
>> Halting problem undecidability and infinitely nested simulation
>>
>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation 
>>
>>
>> Sure I have. When we look as page 3 and 4 of the above paper it is 
>> very easy to see that H does faithfully simulate the execution of P 
>> and that P has no escape from infinite execution in its own code.
> 
> No. First, it *doesn't* faithfully simulate the code. If H(P, P) is 
> simulating P(P), then P(P) can't call the main H -- it can only invoke a 
> copy of H *within the simulation*.
> 

It is actually and quite factually not a copy.
I have had to say this hundreds of times now.

It is the same freaking machine language at the
same freaking machine language address.

> Second, even if we ignore the above, the decision criterion you use is 
> flawed because it completely ignores all conditional branches contained 
> within P's copy of H, and it's these conditional branches which prevent 
> P(P) from being an 'infinitely recursive' computation.
> 

Unless we keep the independent variable separate from the dependent 
variable our analysis is incorrect.

The independent variable is the cause. Its value is independent of other 
variables in your study.

The dependent variable is the effect. Its value depends on changes in 
the independent variable.

https://www.scribbr.com/methodology/independent-and-dependent-variables/

When we are asking whether or not H must abort its simulation of P we 
examine the simulation of P. We must not examine the behavior of H.

> Once again, traces do not constitute proofs. If you want to be taken 
> seriously, you need to provide some actual *proof* that your algorithm 
> works.

That my proof does not conform to academic conventions does not show 
that it is not a proof. As long as I start with a set of premises that 
can be verified as true and my conclusion logically follows from these 
true premises then I definitely have a proof even if everyone in the 
universe disagrees.

>> Premise(1) Every computation that never halts unless its simulation is 
>> aborted is a computation that never halts. This verified as true on 
>> the basis of the meaning of its words.
>>
>> Premise(2) The simulation of the input to H(P,P) never halts without 
>> being aborted is a verified fact on the basis of its x86 execution 
>> trace. (shown below).
>>
>> Conclusion(3) From the above true premises it necessarily follows that 
>> simulating halt decider H correctly reports that its input: (P,P) 
>> never halts.
>>
>> Only by very diligently making sure to not pay attention is it 
>> possible to maintain the ruse of a fake rebuttal.
>>
>>> And it isn't correct. Most significantly, your trace skips over 
>>> certain portions of the P being simulated which completely 
>>> invalidates its results.
>>>
>>
>> The question is:
>>
>> Does the simulation of P have to be aborted to prevent its infinite 
>> execution?
>>
>> As long as the answer to this question is [YES] then Premise(2) is 
>> perfectly satisfied and your objection is utterly pointless.
> 
> You should cut it out with the asinine repetition.It just makes you look 
> like a three-year old.
> 

If I don't get ridiculous with the repetition in a single reply then I 
need twenty replies to make the same point because this point is 
perpetually ignored. I usually don't repeat the same sentence five times 
until after a key point has been ignored in several replies.

> And no, the objection is *not* pointless. You can't claim that there is 
> "no escape from infinite execution" when you ignore the conditional 
> statements which would allow P(P) to abort the simulation it is 
> conducting. Those are the conditional branches which provide that escape.
> 
> André
> 

The question is whether or not H must abort its simulation of P.
The behavior of H is totally irrelevant to this question.

Of the two hypothetical possibilities: (independent variable)
(1) H aborts the simulation of P
(2) H never aborts the simulation of P

We ask what is the effect on the behavior of P? (dependent variable)

(1) P halts
(2) P never halts

The above answer applies to every possible encoding of any simulating 
halt decoder H when applied to P or any computational equivalent to P 
such as the Linz ⟨Ĥ⟩.



-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2849 — Re: What if a cat barks? [ sound deduction is a proof ]

Fromolcott <NoOne@NoWhere.com>
Date2021-06-23 22:03 -0500
SubjectRe: What if a cat barks? [ sound deduction is a proof ]
Message-ID<kaudnZS1vPJiaE79nZ2dnUU7-QHNnZ2d@giganews.com>
In reply to#2847
On 6/23/2021 7:49 PM, André G. Isaak wrote:
> On 2021-06-23 18:01, olcott wrote:
>> On 6/23/2021 6:13 PM, André G. Isaak wrote:
>>> On 2021-06-23 14:07, olcott wrote:
>>>> On 6/23/2021 12:29 PM, André G. Isaak wrote:
>>>>> On 2021-06-22 13:17, olcott wrote:
>>>>>> On 6/22/2021 1:38 PM, André G. Isaak wrote:
>>>>>>> On 2021-06-22 11:05, olcott wrote:
>>>>>>>> On 6/22/2021 11:47 AM, André G. Isaak wrote:
>>>>>
>>>>> <snip>
>>>>>
>>>>>> In the case of the simulation of P it is verified on the basis of 
>>>>>> the x86 execution trace of B, thus an established verified fact.
>>>>>
>>>>> Except that an execution trace doesn't 'verify' anything. No one 
>>>>> doubts that your program decides that P(P) == 0. But unless the 
>>>>> logic underlying your program is actually correct, this result 
>>>>> tells us nothing. And you haven't provided any sort of proof that 
>>>>> the logic underlying your program is actually correct.
>>>>>
>>>>
>>>> Halting problem undecidability and infinitely nested simulation
>>>>
>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation 
>>>>
>>>>
>>>> Sure I have. When we look as page 3 and 4 of the above paper it is 
>>>> very easy to see that H does faithfully simulate the execution of P 
>>>> and that P has no escape from infinite execution in its own code.
>>>
>>> No. First, it *doesn't* faithfully simulate the code. If H(P, P) is 
>>> simulating P(P), then P(P) can't call the main H -- it can only 
>>> invoke a copy of H *within the simulation*.
>>>
>>
>> It is actually and quite factually not a copy.
>> I have had to say this hundreds of times now.
> 
> But if it isn't a copy, then your P isn't derived from your H in the 
> manner prescribed by the Linz proof. If you want to claim to have 
> provided a 'counterexample' to the 'standard proofs' then you need to 
> actually construct your P in the same manner that H_Hat is constructed 
> in those proofs.
> 
>> It is the same freaking machine language at the
>> same freaking machine language address.
> 
> If P is calling H directly, then in what sense is P being 'simulated'?
> 
>>> Second, even if we ignore the above, the decision criterion you use 
>>> is flawed because it completely ignores all conditional branches 
>>> contained within P's copy of H, and it's these conditional branches 
>>> which prevent P(P) from being an 'infinitely recursive' computation.
>>>
>>
>> Unless we keep the independent variable separate from the dependent 
>> variable our analysis is incorrect.
>>
>> The independent variable is the cause. Its value is independent of 
>> other variables in your study.
>>
>> The dependent variable is the effect. Its value depends on changes in 
>> the independent variable.
>>
>> https://www.scribbr.com/methodology/independent-and-dependent-variables/
>>
>> When we are asking whether or not H must abort its simulation of P we 
>> examine the simulation of P. We must not examine the behavior of H.
> 
> This is simply wrong. You can ignore the code in the *decider*, but not 
> code inside the computation which the decider is simulating. The call to 
> H inside P is an integral part of the computation performed by P. You 
> can't ignore this anymore than you can ignore any other instructions 
> inside P.
> 
> André
> 

The independent variable is the cause. Its value is independent of other 
variables in your study.

The dependent variable is the effect. Its value depends on changes in 
the independent variable.

https://www.scribbr.com/methodology/independent-and-dependent-variables/



The question is whether or not H must abort its simulation of P.
The behavior of H is totally irrelevant to this question.

As I have proven below.
As I have proven below.
As I have proven below.
As I have proven below.

Of the two hypothetical possibilities: (independent variable)
(1) H aborts the simulation of P
(2) H never aborts the simulation of P

We ask what is the effect on the behavior of P? (dependent variable)

(1) P halts
(2) P never halts

It does not freaking matter at all what-ever-the-Hell H does except what 
the behavior of P is under the above two hypothetical scenarios.

If the result of purely hypothetical H that never aborts its 
simulation/execution of P would result in the infinite execution of P 
then we know axiomatically that H decides that P never halts correctly.

Premise(1) Every computation that never halts unless its simulation is 
aborted is a computation that never halts. This verified as true on the 
basis of the meaning of its words.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2853 — Re: What if a cat barks? [ sound deduction is a proof ]

Fromolcott <NoOne@NoWhere.com>
Date2021-06-24 16:40 -0500
SubjectRe: What if a cat barks? [ sound deduction is a proof ]
Message-ID<0dWdnYvF0fc0Zkn9nZ2dnUU7-f_NnZ2d@giganews.com>
In reply to#2849
On 6/24/2021 4:13 PM, André G. Isaak wrote:
> On 2021-06-23 21:03, olcott wrote:
>> On 6/23/2021 7:49 PM, André G. Isaak wrote:
>>> On 2021-06-23 18:01, olcott wrote:
>>>> On 6/23/2021 6:13 PM, André G. Isaak wrote:
>>>>> On 2021-06-23 14:07, olcott wrote:
>>>>>> On 6/23/2021 12:29 PM, André G. Isaak wrote:
>>>>>>> On 2021-06-22 13:17, olcott wrote:
>>>>>>>> On 6/22/2021 1:38 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-06-22 11:05, olcott wrote:
>>>>>>>>>> On 6/22/2021 11:47 AM, André G. Isaak wrote:
>>>>>>>
>>>>>>> <snip>
>>>>>>>
>>>>>>>> In the case of the simulation of P it is verified on the basis 
>>>>>>>> of the x86 execution trace of B, thus an established verified fact.
>>>>>>>
>>>>>>> Except that an execution trace doesn't 'verify' anything. No one 
>>>>>>> doubts that your program decides that P(P) == 0. But unless the 
>>>>>>> logic underlying your program is actually correct, this result 
>>>>>>> tells us nothing. And you haven't provided any sort of proof that 
>>>>>>> the logic underlying your program is actually correct.
>>>>>>>
>>>>>>
>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>
>>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation 
>>>>>>
>>>>>>
>>>>>> Sure I have. When we look as page 3 and 4 of the above paper it is 
>>>>>> very easy to see that H does faithfully simulate the execution of 
>>>>>> P and that P has no escape from infinite execution in its own code.
>>>>>
>>>>> No. First, it *doesn't* faithfully simulate the code. If H(P, P) is 
>>>>> simulating P(P), then P(P) can't call the main H -- it can only 
>>>>> invoke a copy of H *within the simulation*.
>>>>>
>>>>
>>>> It is actually and quite factually not a copy.
>>>> I have had to say this hundreds of times now.
>>>
>>> But if it isn't a copy, then your P isn't derived from your H in the 
>>> manner prescribed by the Linz proof. If you want to claim to have 
>>> provided a 'counterexample' to the 'standard proofs' then you need to 
>>> actually construct your P in the same manner that H_Hat is 
>>> constructed in those proofs.
>>>
>>>> It is the same freaking machine language at the
>>>> same freaking machine language address.
>>>
>>> If P is calling H directly, then in what sense is P being 'simulated'?
>>>
>>>>> Second, even if we ignore the above, the decision criterion you use 
>>>>> is flawed because it completely ignores all conditional branches 
>>>>> contained within P's copy of H, and it's these conditional branches 
>>>>> which prevent P(P) from being an 'infinitely recursive' computation.
>>>>>
>>>>
>>>> Unless we keep the independent variable separate from the dependent 
>>>> variable our analysis is incorrect.
>>>>
>>>> The independent variable is the cause. Its value is independent of 
>>>> other variables in your study.
>>>>
>>>> The dependent variable is the effect. Its value depends on changes 
>>>> in the independent variable.
>>>>
>>>> https://www.scribbr.com/methodology/independent-and-dependent-variables/ 
>>>>
>>>>
>>>> When we are asking whether or not H must abort its simulation of P 
>>>> we examine the simulation of P. We must not examine the behavior of H.
>>>
>>> This is simply wrong. You can ignore the code in the *decider*, but 
>>> not code inside the computation which the decider is simulating. The 
>>> call to H inside P is an integral part of the computation performed 
>>> by P. You can't ignore this anymore than you can ignore any other 
>>> instructions inside P.
>>>
>>> André
>>>
>>
>> The independent variable is the cause. Its value is independent of 
>> other variables in your study.
>>
>> The dependent variable is the effect. Its value depends on changes in 
>> the independent variable.
>>
>> https://www.scribbr.com/methodology/independent-and-dependent-variables/
> 
> Is there some reason you always insist on posting a webpage link to 
> explain really basic concepts? In the unlikely event that someone here 
> doesn't understand what this is they can always look it up themselves.
> 
>>
>>
>> The question is whether or not H must abort its simulation of P.
>> The behavior of H is totally irrelevant to this question.
>>
>> As I have proven below.
>> As I have proven below.
>> As I have proven below.
>> As I have proven below.
>>
>> Of the two hypothetical possibilities: (independent variable)
>> (1) H aborts the simulation of P
>> (2) H never aborts the simulation of P
> 
>> We ask what is the effect on the behavior of P? (dependent variable)
>>
>> (1) P halts
> 
> You are abusing terms here. A Turing Machine halts only when it reaches 
> one of its final states. If H aborts its simulation of P, then P does 
> *not* halt (regardless of whether it is a halting or non-halting 
> computation). Its simulation simply ends prematurely at which point H 
> halts.
> 
>> (2) P never halts
>>
>> It does not freaking matter at all what-ever-the-Hell H does except 
>> what the behavior of P is under the above two hypothetical scenarios.
> 
> P *is derived* from H, so the behaviour of P depends on the behaviour of 
> H. Therefore it *does* matter what H does.
> 
> Because of the above H and P are *interdependent* variables. If you want 
> to treat H as an independent variable, then you must insure that P 
> remains invariant, i.e. that the copy of H within P remains the same 
> regardless of any changes you make to the outermost H.
> 
> If the outermost H doesn't halt the simulation of P (i.e. if you disable 
> the ability of the outermost H to abort simulations, and *only* the 
> outermost H), then the copy of H inside P will abort the simulation of 
> its input, at which point P *will* halt.
> 

Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞
if M applied to wM halts, and

Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn
if M applied to wM does not halt

The question can be rephrased this way in the hypothetical case where 
the H/P is replaced with an x86 emulator and the hypothetical case where 
the halt decider embedded at Ĥ.qx is replaced with a UTM

we can know that the original P(P) and Ĥ(⟨Ĥ⟩) are correctly decided as 
computations that never halt by a simulating halt decider if the above 
computations never halt because a simulating halt acts only as a x86 
emulator / UTM until after its input demonstrates an infinitely 
repeating behavior pattern.

That people have difficulty comprehending the necessary truth of this 
does not count as any rebuttal what-so-ever.



>> If the result of purely hypothetical H that never aborts its 
>> simulation/execution of P would result in the infinite execution of P 
>> then we know axiomatically that H decides that P never halts correctly.
>>
>> Premise(1) Every computation that never halts unless its simulation is 
>> aborted is a computation that never halts. This verified as true on 
>> the basis of the meaning of its words.
> 
> No, it isn't, because it is entirely unclear what 'its simulation' 
> refers to. No claim with such sloppy wording can be 'verified as true on 
> the basis of the meaning of its words.'
> 
> And in actual proofs, we show things to be true based on the fact that 
> they can be derived from axioms using accepted rules of inference, not 
> 'on the basis of the meaning of [their] words'. What you're engaging in 
> is simply word-games.
> 
> André
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2855 — Re: What if a cat barks? [ sound deduction is a proof ]

Fromolcott <NoOne@NoWhere.com>
Date2021-06-25 08:53 -0500
SubjectRe: What if a cat barks? [ sound deduction is a proof ]
Message-ID<2YCdneL_7ZhbQkj9nZ2dnUU7-evNnZ2d@giganews.com>
In reply to#2853
On 6/24/2021 7:51 PM, André G. Isaak wrote:
> On 2021-06-24 15:40, olcott wrote:
> 
> <snip>
> 
>> The question can be rephrased this way in the hypothetical case where 
>> the H/P is replaced with an x86 emulator and the hypothetical case 
>> where the halt decider embedded at Ĥ.qx is replaced with a UTM
> 
> If you want to test your claim that the halt decider *MUST* terminate 
> its input, you change the behaviour of the halt decider so it can't 
> terminate its input. (Or, better yet, you just run P(P) directly without 
> making any changes at all -- your aversion to this option is truly 
> mystifying).
> 

It is silly that I have to repeat my words like this so that you pay 
attention, you should just pay attention.

hypothetical case
hypothetical case
hypothetical case
hypothetical case

> What you *CAN'T* do is change the behaviour of the input to the decider 
> which is what you are doing if you also change the H which is contained 
> inside P. By doing this, you change P(P) into an entirely different 
> computation.
> 
> You claim that H is an independent variable and P is a dependent 
> variable. If you change both P and H, then P is not an independent 
> variable. P and H are interdependent variables, which means any test you 
> perform is worthless.
> 
>> we can know that the original P(P) and Ĥ(⟨Ĥ⟩) are correctly decided as 
>> computations that never halt by a simulating halt decider if the above 
>> computations never halt because a simulating halt acts only as a x86 
>> emulator / UTM until after its input demonstrates an infinitely 
>> repeating behavior pattern.
>>
>> That people have difficulty comprehending the necessary truth of this 
>> does not count as any rebuttal what-so-ever.
> 
> People comprehend things just fine. They comprehend that to test you 
> claim we must change *only* the topmost H, not the copy of H embedded in P.
> 
> André
> 
> 

In the computation P(P) if any invocation of the infinite chain of 
invocations must be terminated to prevent the infinite execution of this 
chain then we know that P(P) does specify an infinite chain of invocations.

I have finally gotten my words clear enough that any disagreement would 
look quite foolish. On the above key point this took six months and 
thousands of reviews.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2857 — Re: What if a cat barks? [ sound deduction is a proof ](axiom)

Fromolcott <NoOne@NoWhere.com>
Date2021-06-25 11:33 -0500
SubjectRe: What if a cat barks? [ sound deduction is a proof ](axiom)
Message-ID<fO6dnQEYd73PmEv9nZ2dnUU7-TmdnZ2d@giganews.com>
In reply to#2849
On 6/24/2021 9:39 PM, Richard Damon wrote:
> On 6/24/21 11:42 AM, olcott wrote:
>> On 6/24/2021 6:29 AM, Richard Damon wrote:
>>> On 6/23/21 11:03 PM, olcott wrote:
>>>> If the result of purely hypothetical H that never aborts its
>>>> simulation/execution of P would result in the infinite execution of P
>>>> then we know axiomatically that H decides that P never halts correctly.
>>>
>>> Right, The P based on the never aborting H has infinite execution, but
>>> that isn't the P we are looking at,
>>
>> That hypothetical H/P proves beyond all possible doubt that the in the
>> actual H(P,P) the input to H never halts on the basis of this axiom:
>>
>> Premise(1) Every computation that never halts unless its simulation is
>> aborted is a computation that never halts. This verified as true on the
>> basis of the meaning of its words.
>>
> 
> Except that that the two P's are different. You are saying that the
> Black cat is white because you are looking at the white dog instead.
> 
> Remember, EVERY time you change the properties of H, you get a DIFFERENT P.

Not when the H and the P are both hypothetical.

Of the two hypothetical possibilities: (independent variable)
(1) H aborts the simulation of P
(2) H never aborts the simulation of P

We ask what is the effect on the behavior of P? (dependent variable)

(1) P halts
(2) P never halts

If the result of purely hypothetical H that never aborts its 
simulation/execution of P would result in the infinite execution of P 
then we know axiomatically that H decides that P never halts correctly.

Axiom(1) Every computation that never halts unless its simulation is 
aborted is a computation that never halts. This verified as true on the 
basis of the meaning of its words.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2859 — Re: What if a cat barks? [ sound deduction is a proof ](axiom)

Fromolcott <NoOne@NoWhere.com>
Date2021-06-25 13:50 -0500
SubjectRe: What if a cat barks? [ sound deduction is a proof ](axiom)
Message-ID<eKednajHd_LtuEv9nZ2dnUU7-TvNnZ2d@giganews.com>
In reply to#2857
On 6/25/2021 12:14 PM, Richard Damon wrote:
> On 6/25/21 12:33 PM, olcott wrote:
>> On 6/24/2021 9:39 PM, Richard Damon wrote:
>>> On 6/24/21 11:42 AM, olcott wrote:
>>>> On 6/24/2021 6:29 AM, Richard Damon wrote:
>>>>> On 6/23/21 11:03 PM, olcott wrote:
>>>>>> If the result of purely hypothetical H that never aborts its
>>>>>> simulation/execution of P would result in the infinite execution of P
>>>>>> then we know axiomatically that H decides that P never halts
>>>>>> correctly.
>>>>>
>>>>> Right, The P based on the never aborting H has infinite execution, but
>>>>> that isn't the P we are looking at,
>>>>
>>>> That hypothetical H/P proves beyond all possible doubt that the in the
>>>> actual H(P,P) the input to H never halts on the basis of this axiom:
>>>>
>>>> Premise(1) Every computation that never halts unless its simulation is
>>>> aborted is a computation that never halts. This verified as true on the
>>>> basis of the meaning of its words.
>>>>
>>>
>>> Except that that the two P's are different. You are saying that the
>>> Black cat is white because you are looking at the white dog instead.
>>>
>>> Remember, EVERY time you change the properties of H, you get a
>>> DIFFERENT P.
>>
>> Not when the H and the P are both hypothetical.
> 
> WRONG. P is DEFINED based on H. If you Hypothetically create a P that
> doesn't follow that form, then you are hypothetically creating nonsense
> and can't use it to for anything logical.
> 

Of every possible encoding of simulating partial halt decider H that can 
possibly exist  H*, if H* never aborts the simulation of its input 
results in the infinite execution of the invocation of of P(P) then a 
simulating halt decider H that does abort its simulation of this input 
does correctly decide that this input does specify the never halting 
behavior of an infinite chain of invocations.

>>
>> Of the two hypothetical possibilities: (independent variable)
>> (1) H aborts the simulation of P
>> (2) H never aborts the simulation of P
>>
>> We ask what is the effect on the behavior of P? (dependent variable)
>>
>> (1) P halts
>> (2) P never halts
> 

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2860 — Re: What if a cat barks? [ sound deduction is a proof ](axiom)

Fromolcott <NoOne@NoWhere.com>
Date2021-06-25 17:56 -0500
SubjectRe: What if a cat barks? [ sound deduction is a proof ](axiom)
Message-ID<BuOdncUXaL2swkv9nZ2dnUU7-W-dnZ2d@giganews.com>
In reply to#2859
On 6/25/2021 4:59 PM, Richard Damon wrote:
> On 6/25/21 4:40 PM, olcott wrote:
>> On 6/25/2021 3:11 PM, Richard Damon wrote:
>>> On 6/25/21 2:50 PM, olcott wrote:
>>>> On 6/25/2021 12:14 PM, Richard Damon wrote:
>>>>
>>>>> WRONG. P is DEFINED based on H. If you Hypothetically create a P that
>>>>> doesn't follow that form, then you are hypothetically creating nonsense
>>>>> and can't use it to for anything logical.
>>>>>
>>>>
>>>> Of every possible encoding of simulating partial halt decider H that can
>>>> possibly exist  H*, if H* never aborts the simulation of its input
>>>> results in the infinite execution of the invocation of of P(P) then a
>>>> simulating halt decider H that does abort its simulation of this input
>>>> does correctly decide that this input does specify the never halting
>>>> behavior of an infinite chain of invocations.
>>>
>>> Yes, if H* is an element of the set of non-aborting deciders (Hn), P
>>> will result in infinite recursion,
>>
>> Which logically entails beyond all possible doubt that the set of
>> encodings of simulating partial halt deciders H2* that do abort the
>> simulation of the (P,P) input would correctly report that this input
>> never halts.
> 
> WHY?
> 

Axiom(1) Every computation that never halts unless its simulation is 
aborted is a computation that never halts. This verified as true on the 
basis of the meaning of its words.


> In what universe does the properties of a Dog define the properties of a
> Cat.
> 
> The logic shows that Ha can correctly decide that Pn(Pn) is non-Halting.
> Since your logic NEVER looked at Pa and determined anything about its
> behavior, it makes no determination about them. You are ignoring that P
> is a function of H, and thus if you change H then you have changed P so
> this whole argument isn't valid. You CAN'T decide the properties of one
> P based on another, which means you can't argue about one H based on
> another H.
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2861 — Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)

Fromolcott <NoOne@NoWhere.com>
Date2021-06-25 20:01 -0500
SubjectRe: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)
Message-ID<RKCdnSS4Ifj44Uv9nZ2dnUU7-VvNnZ2d@giganews.com>
In reply to#2860
On 6/25/2021 7:40 PM, Richard Damon wrote:
> On 6/25/21 6:56 PM, olcott wrote:
>> On 6/25/2021 4:59 PM, Richard Damon wrote:
>>> On 6/25/21 4:40 PM, olcott wrote:
>>>> On 6/25/2021 3:11 PM, Richard Damon wrote:
>>>>> On 6/25/21 2:50 PM, olcott wrote:
>>>>>> On 6/25/2021 12:14 PM, Richard Damon wrote:
>>>>>>
>>>>>>> WRONG. P is DEFINED based on H. If you Hypothetically create a P that
>>>>>>> doesn't follow that form, then you are hypothetically creating
>>>>>>> nonsense
>>>>>>> and can't use it to for anything logical.
>>>>>>>
>>>>>>
>>>>>> Of every possible encoding of simulating partial halt decider H
>>>>>> that can
>>>>>> possibly exist  H*, if H* never aborts the simulation of its input
>>>>>> results in the infinite execution of the invocation of of P(P) then a
>>>>>> simulating halt decider H that does abort its simulation of this input
>>>>>> does correctly decide that this input does specify the never halting
>>>>>> behavior of an infinite chain of invocations.
>>>>>
>>>>> Yes, if H* is an element of the set of non-aborting deciders (Hn), P
>>>>> will result in infinite recursion,
>>>>
>>>> Which logically entails beyond all possible doubt that the set of
>>>> encodings of simulating partial halt deciders H2* that do abort the
>>>> simulation of the (P,P) input would correctly report that this input
>>>> never halts.
>>>
>>> WHY?
>>>
>>
>> Axiom(1) Every computation that never halts unless its simulation is
>> aborted is a computation that never halts. This verified as true on the
>> basis of the meaning of its words.
> 
> WRONG.
> 
> Your test does not match the plain meaning of the words, as has been
> explained many times.
> 

Those words may be over your head, yet several others understand that 
they are necessarily correct.

> Note, it is easy to show that your interpretation is wrong since even
> you admit that Linz H^, now called P by you will come to its end and
> halt when given it own representation as its input, and thus is BY
> DEFINITION a Halting Computation, Thus the H deciding it didn't need to
> abort its execution to get the wrong answer of Non-Halting.
> 

Because at least one invocation of the infinite invocation chain 
specified by P(P) had to be terminated to prevent the infinite execution 
of this infinite invocation chain it is confirmed beyond all possible 
doubt that P(P) specifies an invocation chain.

That terminating a single invocation of this infinite invocation chain 
terminates the whole chain is to be expected when any infinitely 
recursive chain is broken.

To a guy that truly believes that functions called in infinite recursion 
must return a value to their caller this all may be way over your head.

> You FAULTY language is thus shown to be incorrect and leads to
> inconsistent logic, as you whole argument has shown.
> 
> I will again repeat, that statement does NOT need to be made an Axiom,
> it can actually be formally proven with the right interpretation of the
> words, you only need to try to make is an (incorrect) axiom because you
> can't show your false version to be true any other way.
> 
> Face it, your logic generates so many contradictions that it gets hard
> to find anything that actually has a real factual basis.
> 
>>
>>
>>> In what universe does the properties of a Dog define the properties of a
>>> Cat.
>>>
>>> The logic shows that Ha can correctly decide that Pn(Pn) is non-Halting.
>>> Since your logic NEVER looked at Pa and determined anything about its
>>> behavior, it makes no determination about them. You are ignoring that P
>>> is a function of H, and thus if you change H then you have changed P so
>>> this whole argument isn't valid. You CAN'T decide the properties of one
>>> P based on another, which means you can't argue about one H based on
>>> another H.
>>>
>>
>>
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2862 — Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)

Fromolcott <NoOne@NoWhere.com>
Date2021-06-25 20:46 -0500
SubjectRe: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)
Message-ID<I8WdnT2QqrV5G0v9nZ2dnUU7-WvNnZ2d@giganews.com>
In reply to#2861
On 6/25/2021 8:37 PM, Richard Damon wrote:
> On 6/25/21 9:01 PM, olcott wrote:
>> On 6/25/2021 7:40 PM, Richard Damon wrote:
>>> On 6/25/21 6:56 PM, olcott wrote:
>>>> On 6/25/2021 4:59 PM, Richard Damon wrote:
>>>>> On 6/25/21 4:40 PM, olcott wrote:
>>>>>> On 6/25/2021 3:11 PM, Richard Damon wrote:
>>>>>>> On 6/25/21 2:50 PM, olcott wrote:
>>>>>>>> On 6/25/2021 12:14 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>>> WRONG. P is DEFINED based on H. If you Hypothetically create a P
>>>>>>>>> that
>>>>>>>>> doesn't follow that form, then you are hypothetically creating
>>>>>>>>> nonsense
>>>>>>>>> and can't use it to for anything logical.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Of every possible encoding of simulating partial halt decider H
>>>>>>>> that can
>>>>>>>> possibly exist  H*, if H* never aborts the simulation of its input
>>>>>>>> results in the infinite execution of the invocation of of P(P)
>>>>>>>> then a
>>>>>>>> simulating halt decider H that does abort its simulation of this
>>>>>>>> input
>>>>>>>> does correctly decide that this input does specify the never halting
>>>>>>>> behavior of an infinite chain of invocations.
>>>>>>>
>>>>>>> Yes, if H* is an element of the set of non-aborting deciders (Hn), P
>>>>>>> will result in infinite recursion,
>>>>>>
>>>>>> Which logically entails beyond all possible doubt that the set of
>>>>>> encodings of simulating partial halt deciders H2* that do abort the
>>>>>> simulation of the (P,P) input would correctly report that this input
>>>>>> never halts.
>>>>>
>>>>> WHY?
>>>>>
>>>>
>>>> Axiom(1) Every computation that never halts unless its simulation is
>>>> aborted is a computation that never halts. This verified as true on the
>>>> basis of the meaning of its words.
>>>
>>> WRONG.
>>>
>>> Your test does not match the plain meaning of the words, as has been
>>> explained many times.
>>>
>>
>> Those words may be over your head, yet several others understand that
>> they are necessarily correct.
> 
> I have seen NO ONE agree to your interpretation of it. The plain meaning
> is that if it can be shown that if the given instance of the simulator
> simulating a given input doesn't stop its simulation that this
> simulation will run forevr, then the machine that is being simulated can
> be corrected decided as non-Halting.
> 
> An more formal way to say that is if UTM(P,I) is non-halting then it is
> correct for H(P,I) to return the non-halting result.
> 
> This actually follows since UTM(P,I) will be non-halting if and only if
> P(I) is non-halting by the definition of a UTM, so that statement is
> trivially proven.
> 
> Your interpretation, where even if a copy of the algorithm of H is
> included in P and that included copy needs to abort the simulation of
> the copy of the machine that it was given, can be PROVEN wrong, as even
> you have shown that P(P) in this case does Halt, thus your claimed
> correct answer is wrong by the definition of the problem.
> 
> Only if you define that your answer isn't actually supposed to be the
> answer to the halting problem can you justify your answer to be correct,
> but then you proof doesn't achieve the goal you claim.
> 
>>
>>> Note, it is easy to show that your interpretation is wrong since even
>>> you admit that Linz H^, now called P by you will come to its end and
>>> halt when given it own representation as its input, and thus is BY
>>> DEFINITION a Halting Computation, Thus the H deciding it didn't need to
>>> abort its execution to get the wrong answer of Non-Halting.
>>>
>>
>> Because at least one invocation of the infinite invocation chain
>> specified by P(P) had to be terminated to prevent the infinite execution
>> of this infinite invocation chain it is confirmed beyond all possible
>> doubt that P(P) specifies an invocation chain.
> 
> WRONG. Given that we have an H that can answer H(P,P) because it knows
> at least enough to terminate the pattern you describe, then when we run
> P(P) then because the H within it also knows to abort this sequence
> (since it is built on the same algorithm) this P is NOT part of an
> infinite chain of execution, and thus its H can return its (wrong)
> answer to it and that P can then Halt.

P(P) specifies in infinite invocation sequence that is terminated on its 
third invocation of H(P,P).

P(P) specifies in infinite invocation sequence that is terminated on its 
third invocation of H(P,P).

P(P) specifies in infinite invocation sequence that is terminated on its 
third invocation of H(P,P).

P(P) specifies in infinite invocation sequence that is terminated on its 
third invocation of H(P,P).

P(P) specifies in infinite invocation sequence that is terminated on its 
third invocation of H(P,P).

Now I have told this this several hundred times.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2863 — Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)

Fromolcott <NoOne@NoWhere.com>
Date2021-06-25 22:07 -0500
SubjectRe: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)
Message-ID<yr2dnWJMMpJLBEv9nZ2dnUU7-dvNnZ2d@giganews.com>
In reply to#2862
On 6/25/2021 9:07 PM, Richard Damon wrote:
> On 6/25/21 9:46 PM, olcott wrote:
>> On 6/25/2021 8:37 PM, Richard Damon wrote:
>>> On 6/25/21 9:01 PM, olcott wrote:
>>>> On 6/25/2021 7:40 PM, Richard Damon wrote:
>>>>> On 6/25/21 6:56 PM, olcott wrote:
>>>>>> On 6/25/2021 4:59 PM, Richard Damon wrote:
>>>>>>> On 6/25/21 4:40 PM, olcott wrote:
>>>>>>>> On 6/25/2021 3:11 PM, Richard Damon wrote:
>>>>>>>>> On 6/25/21 2:50 PM, olcott wrote:
>>>>>>>>>> On 6/25/2021 12:14 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>>> WRONG. P is DEFINED based on H. If you Hypothetically create a P
>>>>>>>>>>> that
>>>>>>>>>>> doesn't follow that form, then you are hypothetically creating
>>>>>>>>>>> nonsense
>>>>>>>>>>> and can't use it to for anything logical.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Of every possible encoding of simulating partial halt decider H
>>>>>>>>>> that can
>>>>>>>>>> possibly exist  H*, if H* never aborts the simulation of its input
>>>>>>>>>> results in the infinite execution of the invocation of of P(P)
>>>>>>>>>> then a
>>>>>>>>>> simulating halt decider H that does abort its simulation of this
>>>>>>>>>> input
>>>>>>>>>> does correctly decide that this input does specify the never
>>>>>>>>>> halting
>>>>>>>>>> behavior of an infinite chain of invocations.
>>>>>>>>>
>>>>>>>>> Yes, if H* is an element of the set of non-aborting deciders
>>>>>>>>> (Hn), P
>>>>>>>>> will result in infinite recursion,
>>>>>>>>
>>>>>>>> Which logically entails beyond all possible doubt that the set of
>>>>>>>> encodings of simulating partial halt deciders H2* that do abort the
>>>>>>>> simulation of the (P,P) input would correctly report that this input
>>>>>>>> never halts.
>>>>>>>
>>>>>>> WHY?
>>>>>>>
>>>>>>
>>>>>> Axiom(1) Every computation that never halts unless its simulation is
>>>>>> aborted is a computation that never halts. This verified as true on
>>>>>> the
>>>>>> basis of the meaning of its words.
>>>>>
>>>>> WRONG.
>>>>>
>>>>> Your test does not match the plain meaning of the words, as has been
>>>>> explained many times.
>>>>>
>>>>
>>>> Those words may be over your head, yet several others understand that
>>>> they are necessarily correct.
>>>
>>> I have seen NO ONE agree to your interpretation of it. The plain meaning
>>> is that if it can be shown that if the given instance of the simulator
>>> simulating a given input doesn't stop its simulation that this
>>> simulation will run forevr, then the machine that is being simulated can
>>> be corrected decided as non-Halting.
>>>
>>> An more formal way to say that is if UTM(P,I) is non-halting then it is
>>> correct for H(P,I) to return the non-halting result.
>>>
>>> This actually follows since UTM(P,I) will be non-halting if and only if
>>> P(I) is non-halting by the definition of a UTM, so that statement is
>>> trivially proven.
>>>
>>> Your interpretation, where even if a copy of the algorithm of H is
>>> included in P and that included copy needs to abort the simulation of
>>> the copy of the machine that it was given, can be PROVEN wrong, as even
>>> you have shown that P(P) in this case does Halt, thus your claimed
>>> correct answer is wrong by the definition of the problem.
>>>
>>> Only if you define that your answer isn't actually supposed to be the
>>> answer to the halting problem can you justify your answer to be correct,
>>> but then you proof doesn't achieve the goal you claim.
>>>
>>>>
>>>>> Note, it is easy to show that your interpretation is wrong since even
>>>>> you admit that Linz H^, now called P by you will come to its end and
>>>>> halt when given it own representation as its input, and thus is BY
>>>>> DEFINITION a Halting Computation, Thus the H deciding it didn't need to
>>>>> abort its execution to get the wrong answer of Non-Halting.
>>>>>
>>>>
>>>> Because at least one invocation of the infinite invocation chain
>>>> specified by P(P) had to be terminated to prevent the infinite execution
>>>> of this infinite invocation chain it is confirmed beyond all possible
>>>> doubt that P(P) specifies an invocation chain.
>>>
>>> WRONG. Given that we have an H that can answer H(P,P) because it knows
>>> at least enough to terminate the pattern you describe, then when we run
>>> P(P) then because the H within it also knows to abort this sequence
>>> (since it is built on the same algorithm) this P is NOT part of an
>>> infinite chain of execution, and thus its H can return its (wrong)
>>> answer to it and that P can then Halt.
>>
>> P(P) specifies in infinite invocation sequence that is terminated on its
>> third invocation of H(P,P).
>>
>> P(P) specifies in infinite invocation sequence that is terminated on its
>> third invocation of H(P,P).
>>
>> P(P) specifies in infinite invocation sequence that is terminated on its
>> third invocation of H(P,P).
>>
>> P(P) specifies in infinite invocation sequence that is terminated on its
>> third invocation of H(P,P).
>>
>> P(P) specifies in infinite invocation sequence that is terminated on its
>> third invocation of H(P,P).
>>
>> Now I have told this this several hundred times.
>>
>>
> 
> WRONG.
> 
> P(P) starts.
> 
> Calls H(P,P)
> 
> H starts the simulation.
> 
> H simulates P starting
> 
> H simulates P calling H
> 
> H simulates H starting its simulation
> 
> H simulates H simulating P starting
> 
> H simulates H simulating P calling H
> 
> The first H about here detects what it THINKS is an infinite execution
> 
> THe first H aborts its simulation
> 
> The first H returns its answer (Non-Halting) to its caller
> 
> P then Halts
> 
> Showing P is a Halting Computation.

As you already admitted P ONLY halts because some H aborts some P 
otherwise P never ever halts.

As you already admitted P ONLY halts because some H aborts some P 
otherwise P never ever halts.

As you already admitted P ONLY halts because some H aborts some P 
otherwise P never ever halts.

As you already admitted P ONLY halts because some H aborts some P 
otherwise P never ever halts.

As you already admitted P ONLY halts because some H aborts some P 
otherwise P never ever halts.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#2864 — Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2021-06-26 01:11 -0700
SubjectRe: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)
Message-ID<sb6nfj$i1b$1@gioia.aioe.org>
In reply to#2863
On 6/25/2021 8:07 PM, olcott wrote:
> On 6/25/2021 9:07 PM, Richard Damon wrote:
>> On 6/25/21 9:46 PM, olcott wrote:
>>> On 6/25/2021 8:37 PM, Richard Damon wrote:
>>>> On 6/25/21 9:01 PM, olcott wrote:
>>>>> On 6/25/2021 7:40 PM, Richard Damon wrote:
>>>>>> On 6/25/21 6:56 PM, olcott wrote:
>>>>>>> On 6/25/2021 4:59 PM, Richard Damon wrote:
>>>>>>>> On 6/25/21 4:40 PM, olcott wrote:
>>>>>>>>> On 6/25/2021 3:11 PM, Richard Damon wrote:
>>>>>>>>>> On 6/25/21 2:50 PM, olcott wrote:
>>>>>>>>>>> On 6/25/2021 12:14 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>>> WRONG. P is DEFINED based on H. If you Hypothetically create 
>>>>>>>>>>>> a P
>>>>>>>>>>>> that
>>>>>>>>>>>> doesn't follow that form, then you are hypothetically creating
>>>>>>>>>>>> nonsense
>>>>>>>>>>>> and can't use it to for anything logical.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Of every possible encoding of simulating partial halt decider H
>>>>>>>>>>> that can
>>>>>>>>>>> possibly exist  H*, if H* never aborts the simulation of its 
>>>>>>>>>>> input
>>>>>>>>>>> results in the infinite execution of the invocation of of P(P)
>>>>>>>>>>> then a
>>>>>>>>>>> simulating halt decider H that does abort its simulation of this
>>>>>>>>>>> input
>>>>>>>>>>> does correctly decide that this input does specify the never
>>>>>>>>>>> halting
>>>>>>>>>>> behavior of an infinite chain of invocations.
>>>>>>>>>>
>>>>>>>>>> Yes, if H* is an element of the set of non-aborting deciders
>>>>>>>>>> (Hn), P
>>>>>>>>>> will result in infinite recursion,
>>>>>>>>>
>>>>>>>>> Which logically entails beyond all possible doubt that the set of
>>>>>>>>> encodings of simulating partial halt deciders H2* that do abort 
>>>>>>>>> the
>>>>>>>>> simulation of the (P,P) input would correctly report that this 
>>>>>>>>> input
>>>>>>>>> never halts.
>>>>>>>>
>>>>>>>> WHY?
>>>>>>>>
>>>>>>>
>>>>>>> Axiom(1) Every computation that never halts unless its simulation is
>>>>>>> aborted is a computation that never halts. This verified as true on
>>>>>>> the
>>>>>>> basis of the meaning of its words.
>>>>>>
>>>>>> WRONG.
>>>>>>
>>>>>> Your test does not match the plain meaning of the words, as has been
>>>>>> explained many times.
>>>>>>
>>>>>
>>>>> Those words may be over your head, yet several others understand that
>>>>> they are necessarily correct.
>>>>
>>>> I have seen NO ONE agree to your interpretation of it. The plain 
>>>> meaning
>>>> is that if it can be shown that if the given instance of the simulator
>>>> simulating a given input doesn't stop its simulation that this
>>>> simulation will run forevr, then the machine that is being simulated 
>>>> can
>>>> be corrected decided as non-Halting.
>>>>
>>>> An more formal way to say that is if UTM(P,I) is non-halting then it is
>>>> correct for H(P,I) to return the non-halting result.
>>>>
>>>> This actually follows since UTM(P,I) will be non-halting if and only if
>>>> P(I) is non-halting by the definition of a UTM, so that statement is
>>>> trivially proven.
>>>>
>>>> Your interpretation, where even if a copy of the algorithm of H is
>>>> included in P and that included copy needs to abort the simulation of
>>>> the copy of the machine that it was given, can be PROVEN wrong, as even
>>>> you have shown that P(P) in this case does Halt, thus your claimed
>>>> correct answer is wrong by the definition of the problem.
>>>>
>>>> Only if you define that your answer isn't actually supposed to be the
>>>> answer to the halting problem can you justify your answer to be 
>>>> correct,
>>>> but then you proof doesn't achieve the goal you claim.
>>>>
>>>>>
>>>>>> Note, it is easy to show that your interpretation is wrong since even
>>>>>> you admit that Linz H^, now called P by you will come to its end and
>>>>>> halt when given it own representation as its input, and thus is BY
>>>>>> DEFINITION a Halting Computation, Thus the H deciding it didn't 
>>>>>> need to
>>>>>> abort its execution to get the wrong answer of Non-Halting.
>>>>>>
>>>>>
>>>>> Because at least one invocation of the infinite invocation chain
>>>>> specified by P(P) had to be terminated to prevent the infinite 
>>>>> execution
>>>>> of this infinite invocation chain it is confirmed beyond all possible
>>>>> doubt that P(P) specifies an invocation chain.
>>>>
>>>> WRONG. Given that we have an H that can answer H(P,P) because it knows
>>>> at least enough to terminate the pattern you describe, then when we run
>>>> P(P) then because the H within it also knows to abort this sequence
>>>> (since it is built on the same algorithm) this P is NOT part of an
>>>> infinite chain of execution, and thus its H can return its (wrong)
>>>> answer to it and that P can then Halt.
>>>
>>> P(P) specifies in infinite invocation sequence that is terminated on its
>>> third invocation of H(P,P).
>>>
>>> P(P) specifies in infinite invocation sequence that is terminated on its
>>> third invocation of H(P,P).
>>>
>>> P(P) specifies in infinite invocation sequence that is terminated on its
>>> third invocation of H(P,P).
>>>
>>> P(P) specifies in infinite invocation sequence that is terminated on its
>>> third invocation of H(P,P).
>>>
>>> P(P) specifies in infinite invocation sequence that is terminated on its
>>> third invocation of H(P,P).
>>>
>>> Now I have told this this several hundred times.
>>>
>>>
>>
>> WRONG.
>>
>> P(P) starts.
>>
>> Calls H(P,P)
>>
>> H starts the simulation.
>>
>> H simulates P starting
>>
>> H simulates P calling H
>>
>> H simulates H starting its simulation
>>
>> H simulates H simulating P starting
>>
>> H simulates H simulating P calling H
>>
>> The first H about here detects what it THINKS is an infinite execution
>>
>> THe first H aborts its simulation
>>
>> The first H returns its answer (Non-Halting) to its caller
>>
>> P then Halts
>>
>> Showing P is a Halting Computation.
> 
> As you already admitted P ONLY halts because some H aborts some P 
> otherwise P never ever halts.
> 
> As you already admitted P ONLY halts because some H aborts some P 
> otherwise P never ever halts.
> 
> As you already admitted P ONLY halts because some H aborts some P 
> otherwise P never ever halts.
> 
> As you already admitted P ONLY halts because some H aborts some P 
> otherwise P never ever halts.
> 
> As you already admitted P ONLY halts because some H aborts some P 
> otherwise P never ever halts.
> 

Are you nuts, or are recovering from a recent head injury?

[toc] | [prev] | [next] | [standalone]


#2865 — Re: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)

FromJeff Barnett <jbb@notatt.com>
Date2021-06-26 04:27 -0600
SubjectRe: What if a cat barks? [ sound deduction is a proof ](infinite invocation chain)
Message-ID<faf6990d-6146-45f1-a2d9-be79919177b4@notatt.com>
In reply to#2864
On 6/26/2021 2:11 AM, Chris M. Thomasson wrote:
> On 6/25/2021 8:07 PM, olcott wrote:
>> On 6/25/2021 9:07 PM, Richard Damon wrote:
>>> On 6/25/21 9:46 PM, olcott wrote:
>>>> On 6/25/2021 8:37 PM, Richard Damon wrote:
>>>>> On 6/25/21 9:01 PM, olcott wrote:
>>>>>> On 6/25/2021 7:40 PM, Richard Damon wrote:
>>>>>>> On 6/25/21 6:56 PM, olcott wrote:
>>>>>>>> On 6/25/2021 4:59 PM, Richard Damon wrote:
>>>>>>>>> On 6/25/21 4:40 PM, olcott wrote:
>>>>>>>>>> On 6/25/2021 3:11 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/25/21 2:50 PM, olcott wrote:
>>>>>>>>>>>> On 6/25/2021 12:14 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> WRONG. P is DEFINED based on H. If you Hypothetically 
>>>>>>>>>>>>> create a P
>>>>>>>>>>>>> that
>>>>>>>>>>>>> doesn't follow that form, then you are hypothetically creating
>>>>>>>>>>>>> nonsense
>>>>>>>>>>>>> and can't use it to for anything logical.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Of every possible encoding of simulating partial halt decider H
>>>>>>>>>>>> that can
>>>>>>>>>>>> possibly exist  H*, if H* never aborts the simulation of its 
>>>>>>>>>>>> input
>>>>>>>>>>>> results in the infinite execution of the invocation of of P(P)
>>>>>>>>>>>> then a
>>>>>>>>>>>> simulating halt decider H that does abort its simulation of 
>>>>>>>>>>>> this
>>>>>>>>>>>> input
>>>>>>>>>>>> does correctly decide that this input does specify the never
>>>>>>>>>>>> halting
>>>>>>>>>>>> behavior of an infinite chain of invocations.
>>>>>>>>>>>
>>>>>>>>>>> Yes, if H* is an element of the set of non-aborting deciders
>>>>>>>>>>> (Hn), P
>>>>>>>>>>> will result in infinite recursion,
>>>>>>>>>>
>>>>>>>>>> Which logically entails beyond all possible doubt that the set of
>>>>>>>>>> encodings of simulating partial halt deciders H2* that do 
>>>>>>>>>> abort the
>>>>>>>>>> simulation of the (P,P) input would correctly report that this 
>>>>>>>>>> input
>>>>>>>>>> never halts.
>>>>>>>>>
>>>>>>>>> WHY?
>>>>>>>>>
>>>>>>>>
>>>>>>>> Axiom(1) Every computation that never halts unless its 
>>>>>>>> simulation is
>>>>>>>> aborted is a computation that never halts. This verified as true on
>>>>>>>> the
>>>>>>>> basis of the meaning of its words.
>>>>>>>
>>>>>>> WRONG.
>>>>>>>
>>>>>>> Your test does not match the plain meaning of the words, as has been
>>>>>>> explained many times.
>>>>>>>
>>>>>>
>>>>>> Those words may be over your head, yet several others understand that
>>>>>> they are necessarily correct.
>>>>>
>>>>> I have seen NO ONE agree to your interpretation of it. The plain 
>>>>> meaning
>>>>> is that if it can be shown that if the given instance of the simulator
>>>>> simulating a given input doesn't stop its simulation that this
>>>>> simulation will run forevr, then the machine that is being 
>>>>> simulated can
>>>>> be corrected decided as non-Halting.
>>>>>
>>>>> An more formal way to say that is if UTM(P,I) is non-halting then 
>>>>> it is
>>>>> correct for H(P,I) to return the non-halting result.
>>>>>
>>>>> This actually follows since UTM(P,I) will be non-halting if and 
>>>>> only if
>>>>> P(I) is non-halting by the definition of a UTM, so that statement is
>>>>> trivially proven.
>>>>>
>>>>> Your interpretation, where even if a copy of the algorithm of H is
>>>>> included in P and that included copy needs to abort the simulation of
>>>>> the copy of the machine that it was given, can be PROVEN wrong, as 
>>>>> even
>>>>> you have shown that P(P) in this case does Halt, thus your claimed
>>>>> correct answer is wrong by the definition of the problem.
>>>>>
>>>>> Only if you define that your answer isn't actually supposed to be the
>>>>> answer to the halting problem can you justify your answer to be 
>>>>> correct,
>>>>> but then you proof doesn't achieve the goal you claim.
>>>>>
>>>>>>
>>>>>>> Note, it is easy to show that your interpretation is wrong since 
>>>>>>> even
>>>>>>> you admit that Linz H^, now called P by you will come to its end and
>>>>>>> halt when given it own representation as its input, and thus is BY
>>>>>>> DEFINITION a Halting Computation, Thus the H deciding it didn't 
>>>>>>> need to
>>>>>>> abort its execution to get the wrong answer of Non-Halting.
>>>>>>>
>>>>>>
>>>>>> Because at least one invocation of the infinite invocation chain
>>>>>> specified by P(P) had to be terminated to prevent the infinite 
>>>>>> execution
>>>>>> of this infinite invocation chain it is confirmed beyond all possible
>>>>>> doubt that P(P) specifies an invocation chain.
>>>>>
>>>>> WRONG. Given that we have an H that can answer H(P,P) because it knows
>>>>> at least enough to terminate the pattern you describe, then when we 
>>>>> run
>>>>> P(P) then because the H within it also knows to abort this sequence
>>>>> (since it is built on the same algorithm) this P is NOT part of an
>>>>> infinite chain of execution, and thus its H can return its (wrong)
>>>>> answer to it and that P can then Halt.
>>>>
>>>> P(P) specifies in infinite invocation sequence that is terminated on 
>>>> its
>>>> third invocation of H(P,P).
>>>>
>>>> P(P) specifies in infinite invocation sequence that is terminated on 
>>>> its
>>>> third invocation of H(P,P).
>>>>
>>>> P(P) specifies in infinite invocation sequence that is terminated on 
>>>> its
>>>> third invocation of H(P,P).
>>>>
>>>> P(P) specifies in infinite invocation sequence that is terminated on 
>>>> its
>>>> third invocation of H(P,P).
>>>>
>>>> P(P) specifies in infinite invocation sequence that is terminated on 
>>>> its
>>>> third invocation of H(P,P).
>>>>
>>>> Now I have told this this several hundred times.
>>>>
>>>>
>>>
>>> WRONG.
>>>
>>> P(P) starts.
>>>
>>> Calls H(P,P)
>>>
>>> H starts the simulation.
>>>
>>> H simulates P starting
>>>
>>> H simulates P calling H
>>>
>>> H simulates H starting its simulation
>>>
>>> H simulates H simulating P starting
>>>
>>> H simulates H simulating P calling H
>>>
>>> The first H about here detects what it THINKS is an infinite execution
>>>
>>> THe first H aborts its simulation
>>>
>>> The first H returns its answer (Non-Halting) to its caller
>>>
>>> P then Halts
>>>
>>> Showing P is a Halting Computation.
>>
>> As you already admitted P ONLY halts because some H aborts some P 
>> otherwise P never ever halts.
>>
>> As you already admitted P ONLY halts because some H aborts some P 
>> otherwise P never ever halts.
>>
>> As you already admitted P ONLY halts because some H aborts some P 
>> otherwise P never ever halts.
>>
>> As you already admitted P ONLY halts because some H aborts some P 
>> otherwise P never ever halts.
>>
>> As you already admitted P ONLY halts because some H aborts some P 
>> otherwise P never ever halts.
>>
> 
> Are you nuts, or are recovering from a recent head injury?

It's not recent. It seems he's been at it for a few decades.
-- 
Jeff Barnett

[toc] | [prev] | [next] | [standalone]


Page 1 of 3  [1] 2 3  Next page →

Back to top | Article view | comp.software-eng


csiph-web