Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)

Liste des GroupesRevenir à s logic 
Sujet : Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)
De : polcott2 (at) *nospam* gmail.com (olcott)
Groupes : comp.theory sci.logic
Date : 08. Mar 2024, 21:40:20
Autres entêtes
Organisation : A noiseless patient Spider
Message-ID : <usfpj4$1sh6e$1@dont-email.me>
References : 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
User-Agent : Mozilla Thunderbird
On 3/8/2024 1:05 PM, Richard Damon wrote:
On 3/8/24 10:08 AM, olcott wrote:
On 3/8/2024 11:47 AM, Richard Damon wrote:
On 3/8/24 9:33 AM, olcott wrote:
On 3/8/2024 1:50 AM, Richard Damon wrote:
On 3/7/24 11:21 PM, olcott wrote:
On 3/8/2024 12:49 AM, Richard Damon wrote:
On 3/7/24 10:09 PM, olcott wrote:
On 3/7/2024 11:36 PM, Richard Damon wrote:
On 3/7/24 9:18 PM, olcott wrote:
Olcott machines can compute the difference between H1(D,D) and H(D,D)
because Olcott machines can correctly determine whether or not they
themselves were called in recursive simulation.
>
For H1(D,D) and H(D,D)it is the extra inputs of 00001422 and 00001522
For H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> the extra inputs are shown.
>
When I keep repeating the above a few hundred more times
you will quit immediately forgetting that I ever said it.
>
All you have done is show why your H / H1 have been disqualified from being Halt Deciders.
>
Not at all. Not in the least little bit.
I have proved that a slight reconfiguration of Turing machines
defines a machine that is exactly a Turing machine except can
always correctly determine whether or not itself is called in
recursive simulation.
>
Nope.
>
You tried, but failed.
>
>
All that you have done is disagree with verified facts.
You always said that H1(D,D) and H(D,D) cannot compute different outputs. I proved exactly how they do this and how it is computable
and you simply ignore what I say.
>
They can't if they are copies of the same computation.
>
Exact copies of the same machine with different inputs can and
do compute different results. I really should not have to bring
this up again and again all day long for you to notice that
I said it at least once.
>
Yes, but they are given the same input, at least when yo follow the rules an not use a strawwman.
>
The DEFINITION of H^ is that it uses an exact copy of the algorithm it is refuting, and gives it the exact same input that it would have when deciding on it.
>
The fact that you just rotely parrot the H^ for Turing Mchines when you try to apply it to Olcott-Machine just says you don't understand Linz's proof.
>
>
>
You are just proving that they aren't, as either they use a "Hidden Input" in your x86UTM claiming to be Turing Equivalent model, or they now have a different input in the Olcott-Machine model.
>
>
When H1 and H both have access to their own machine address this is equivalent to H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ>
>
Right, so they are getting different inputs, so they can create different outputs,
>
Yes.
>
So H1 doesn't show that the algorithm of H gave the right answer.
>
>
but that also means they are not Halt Deciders, as they are USING that extra data that Halt Deciders can't use (at least an be a CORRECT Halt Decider).
>
They are using extra inputs that Turing machines cannot use.
Thus my proof does not show that halting is Turing computable.
Instead my proof shows that Church-Turing is not true.
>
Not "Can't", but weren't given.
>
Olcott machines make providing this input mandatory thus
closing the loophole that Turing machines leave open.
 And thus can not be actually asked objective questions, but only a subjective variation.
 
Deciders really need to know whether or not their input
would get themselves stuck in recursive simulation.
Denying them this ability is a weaker form of computation
that prevents them from making sure that they always halt.

You then need to PROVE that the subjective answer is in fact, 0objective. (Which you admit it isn't for Halt Deciders).
 
>
>
You are just proving yourself to be an idiot.
>
My Mensa test showed I am in the top 3%.
 So, you made yourself stupid after that.
 
>
Remember, the defition of a Computation includes ALL the inputs given, so your Olcott machines are not doing the same computation as the Turing Machines, and the Turing Machines COULD do that same computation if given the extra data.
>
That is correct except:
Olcott machines make providing this input mandatory thus
closing the loophole that Turing machines leave open.
 Nope.
 
>
All you have done is LIMIT what Olcott machines can be shown to compute, and to claim they do the same computation as the Turing Machine they appear to be, you have to first proe they don't use that extra information.
>
>
Olcott machines (by definition) compute all of the functions
that Turing machines compute and have the extra ability to
always detect when they are about to simulate themselves in
recursive simulation.
 Nope.
 Olcott Machine can not be defined in a way that the machine MUST be computing an Objective question, as it ALWAYS gets an "I" parameter.
Deciders really need to know whether or not their input
would get themselves stuck in recursive simulation.
Denying them this ability is a weaker form of computation
that prevents them from making sure that they always halt.

Thus, we can not on the face presume that an Olcott machine is doing an objective function, but need to verify that it is infact not using that extra input.
 The key point of Turing Machines, and what makes them useful, is that you KNOW, just from that fact that the algorithm has been expressed as a Turing Machine, that the algorithm is a function of EXACTLY the parameters given.
Deciders really need to know whether or not their input
would get themselves stuck in recursive simulation.
Denying them this ability is a weaker form of computation
that prevents them from making sure that they always halt.

You are just proving you utter ignorance of how the field of Computation Theory works, or even what the core definitions are.
 
>
Your whole problem is you don't understand what a "Compuation" is.
>
I consistently proved otherwise and you have not correctly
pointed out a single error.
 Nope.
 
>
Even H(D,D) really does prove that from its own POV its input
specifies a non-halting computation. So I never made a mistake
on that either. What I said about that is merely unconventional
it is not incorrect.
 Nope. "Own Point of view" is based on the Strawman question, so a LIE.
MIT Professor Michael Sipser agreed that this verbatim paragraph is correct
(a) If simulating halt decider H correctly simulates its input D until H correctly determines that its simulated D would never stop running unless aborted then
(b) H can abort its simulation of D and correctly report that D specifies a non-halting sequence of configurations.
A simulating termination analyzer must determine when its input
would cause itself to never halt. When Turing machines cannot
do that and the Olcott reconfiguration of Turing machines can
then Olcott machines are more powerful than Turing machines.

The ONLY critera is does the computation represented by the input halt.
 H(D,D) says No, but D(D) Halts, so H is wrong.
 You saying it was "right" just shows you are a LIAR, in fact you are a pathetic hypocritical pathological lying idiot.
 
>
>
Olcott machines compute everything that Turing Machines compute
and have the extra ability to correctly detect that they themselves
are about to simulate themselves in recursive simulation.
>
Nope.
>
I have proven this and you provided no evidence to the contrary.
The above reply is exactly what I mean by you using dogma instead
of reasoning.
 So, show an ACTUAL COMPUTATION that an Olcott Machine can compute that we can not make a Turing Machine do the same thing.
 
We cannot make the Turing Machine Linz H have the ability to
see whether or not it is about to simulate a copy of itself.
The Turing Machine Linz H can provide this ability to its
slaves. The copy of Linz H within Linz Ĥ would not be able
to use an ability that Linz H does not have.

Remember, that Turing Machine that computes the same thing as the Olcott Machine could just be a UTM that has been modified to move the description of the Olcott Machine given to it to the end of the virutal Olcott's machines virtual tape and then running it.
 
>
None-the-less when you do pay attention to a key detail
this does provide a good basis for me to debug my words.
>
It is not that my words were incorrect, they were simply
too difficult to understand.
 No they are incorrect.
>
>
>
You are just showing how little you understand of the field and the meaning of its words.
>
>
You have not correctly pointed out even a single mistake.
>
Sure I have, you are just to stupid to understand, because you don't know what you are talking about.
>
All of the "mistakes" that you pointed out have been false
assumptions that are based on your lack of attention to
the details of what I am saying.
 Then point out the errors quoting SOURCES that show I am wrong. Not just restate your INCORRECT ideas with no sources to back them up.
Your rebuttals are based on three things:
(a) Simply saying nope.
(b) Failing to pay attention to what I said.
(c) A strawman deception.

 Your problem is you have no real sources backing you up, because you haven't actually studied the real theory.
 
Because Olcott machines are fully anchored in a reconfiguration
of Turing machines and the extra ability that they have is derived
from simple string comparison of a pair of params what I have
said is already anchored in real sources.

>
>
>
Your H and H1 likely will never answer when given the properly designed H^ input.
>
You are just a total failure, again.
>
And are just lying about it because you refuse to face the facts.
>
>
They are not Computations using only the description of the Computation to be decided on.
>
This PROVES that they are not correct Halt Deciders.
>
And you are proved to be just a pathetic and pathological liar.
>
>
>
>
>
>
>
 
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Date Sujet#  Auteur
7 Mar 24 * We finally know exactly how H1(D,D) derives a different result than H(D,D)52olcott
8 Mar 24 +* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)49Richard Damon
8 Mar 24 i`* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)48olcott
8 Mar 24 i +* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)18olcott
8 Mar 24 i i+* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)2olcott
8 Mar 24 i ii`- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)1Richard Damon
8 Mar 24 i i+* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)10olcott
8 Mar 24 i ii+- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)1Richard Damon
8 Mar 24 i ii`* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)8Richard Damon
8 Mar 24 i ii `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)7olcott
8 Mar 24 i ii  `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)6Richard Damon
8 Mar 24 i ii   `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)5olcott
8 Mar 24 i ii    `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)4Richard Damon
8 Mar 24 i ii     `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)3olcott
8 Mar 24 i ii      `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)2olcott
8 Mar 24 i ii       `- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)1olcott
8 Mar 24 i i`* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)5olcott
8 Mar 24 i i `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)4olcott
8 Mar 24 i i  `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D) --closure yet?--3olcott
8 Mar 24 i i   `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D) --closure yet?--2olcott
9 Mar 24 i i    `- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D) --Richard goes around in circles--1immibis
8 Mar 24 i `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)29André G. Isaak
8 Mar 24 i  +* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)27immibis
8 Mar 24 i  i+* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)23olcott
8 Mar 24 i  ii`* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)22Richard Damon
8 Mar 24 i  ii `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)21olcott
8 Mar 24 i  ii  `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)20Richard Damon
8 Mar 24 i  ii   `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)19olcott
8 Mar 24 i  ii    `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)18Yaxley Peaks
15 Mar 24 i  ii     `* Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees --outermost H--17olcott
15 Mar 24 i  ii      +* Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees --outermost H--13Fred. Zwarts
15 Mar 24 i  ii      i`* Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees --outermost H--12olcott
15 Mar 24 i  ii      i +* Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees --outermost H--2Richard Damon
15 Mar 24 i  ii      i i`- Re: H(D,D)==0 is correct when reports on the actual behavior that it sees --outermost H--1olcott
15 Mar 24 i  ii      i `* Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees --outermost H--9immibis
15 Mar 24 i  ii      i  `* Re: H(D,D)==0 is correct when reports on the actual behavior that it sees --outermost H--8olcott
15 Mar 24 i  ii      i   +* Re: H(D,D)==0 is correct when reports on the actual behavior that it sees --outermost H--5immibis
15 Mar 24 i  ii      i   i`* Re: H(D,D)==0 is correct when reports on the actual behavior that it sees --outermost H--4olcott
15 Mar 24 i  ii      i   i `* Re: H(D,D)==0 is correct when reports on the actual behavior that it sees --outermost H--3immibis
15 Mar 24 i  ii      i   i  `* Re: H(D,D)==0 is correct when reports on the actual behavior that it sees --outermost H--2olcott
15 Mar 24 i  ii      i   i   `- Re: H(D,D)==0 is correct when reports on the actual behavior that it sees --outermost H--1immibis
15 Mar 24 i  ii      i   `* Re: H(D,D)==0 is correct when reports on the actual behavior that it sees --outermost H--2Richard Damon
15 Mar 24 i  ii      i    `- Re: H(D,D)==0 is correct when reports on the actual behavior that it sees --outermost H--1olcott
15 Mar 24 i  ii      `* Re: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees --outermost H--3immibis
15 Mar 24 i  ii       `* Re: H(D,D) ==0 is correct when reports on the actual behavior that it sees --outermost H--2olcott
15 Mar 24 i  ii        `- Re: H(D,D) ==0 is correct when reports on the actual behavior that it sees --outermost H--1immibis
8 Mar 24 i  i`* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)3Richard Damon
8 Mar 24 i  i `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)2immibis
8 Mar 24 i  i  `- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)1olcott
8 Mar 24 i  `- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)1olcott
8 Mar 24 `* Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)2immibis
8 Mar 24  `- Re: We finally know exactly how H1(D,D) derives a different result than H(D,D)1olcott

Haut de la page

Les messages affichés proviennent d'usenet.

NewsPortal