On 9/5/22 10:10 PM, olcott wrote:
> On 9/5/2022 8:59 PM, Richard Damon wrote:
>>
>> On 9/5/22 9:46 PM, olcott wrote:
>>> On 9/5/2022 7:40 PM, Richard Damon wrote:
>>>>
>>>> On 9/5/22 8:07 PM, olcott wrote:
>>>>> On 9/5/2022 5:14 PM, Richard Damon wrote:
>>>>>> On 9/5/22 5:47 PM, olcott wrote:
>>>>>>> On 9/5/2022 3:54 PM, Richard Damon wrote:
>>>>>>>> On 9/5/22 4:44 PM, olcott wrote:
>>>>>>>>> On 9/5/2022 3:27 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/5/22 4:20 PM, olcott wrote:
>>>>>>>>>>> On 9/5/2022 3:11 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 9/5/22 3:52 PM, olcott wrote:
>>>>>>>>>>>>> On 9/5/2022 2:48 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/5/22 3:34 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/5/2022 11:01 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/5/22 11:56 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/5/2022 10:21 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 9/5/22 10:51 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/5/2022 5:49 AM, Otto J. Makela wrote:
>>>>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:45 AM, Otto J. Makela wrote:
>>>>>>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>> In every case where the simulation of the input
>>>>>>>>>>>>>>>>>>>>>>> by H would never
>>>>>>>>>>>>>>>>>>>>>>> stop running H aborts its simulation and returns 0.
>>>>>>>>>>>>>>>>>>>>>> Why would a simulation of H() not return a value,
>>>>>>>>>>>>>>>>>>>>>> once it had done
>>>>>>>>>>>>>>>>>>>>>> the same kind of deduction?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> A simulating halt decider must abort the simulation
>>>>>>>>>>>>>>>>>>>>> of every otherwise
>>>>>>>>>>>>>>>>>>>>> non-terminating input. It does this by correctly
>>>>>>>>>>>>>>>>>>>>> recognizing
>>>>>>>>>>>>>>>>>>>>> non-terminating behavior patterns.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You did not answer my question: if H() always
>>>>>>>>>>>>>>>>>>>> returns a value, why would
>>>>>>>>>>>>>>>>>>>> a simulated H() also not always return a value in
>>>>>>>>>>>>>>>>>>>> the simulation?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I will give you the short answer, the simulated H is
>>>>>>>>>>>>>>>>>>> never invoked.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> "Because I defined it so" is not a sufficient answer
>>>>>>>>>>>>>>>>>>>> here.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A simulating halt decider (SHD) always bases its halt
>>>>>>>>>>>>>>>>>>> status decision on correctly predicting whether or
>>>>>>>>>>>>>>>>>>> not it must abort the correct simulation of its input
>>>>>>>>>>>>>>>>>>> to prevent the infinite execution of this input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And thus isn't a correct halt decider as its criterion
>>>>>>>>>>>>>>>>>> is different from the Halting Criteria.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A simulating halt decider that does not abort its
>>>>>>>>>>>>>>>>>>> simulation of its input performs a correct and
>>>>>>>>>>>>>>>>>>> complete simulation of this input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, and never gives a non-halting answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The definition of a UTM says that any correct and
>>>>>>>>>>>>>>>>>>> complete simulation of an input derives the actual
>>>>>>>>>>>>>>>>>>> behavior of this simulated input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, so a UTM never aborts.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Thus if the correct and complete simulation of an
>>>>>>>>>>>>>>>>>>> input never reaches the final state of this input
>>>>>>>>>>>>>>>>>>> this means that this input specifies a non-halting
>>>>>>>>>>>>>>>>>>> sequence of instructions.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The fact that the simulation of this input is aborted
>>>>>>>>>>>>>>>>>>> does not change the fact that this correctly
>>>>>>>>>>>>>>>>>>> simulated input cannot possibly reach its own final
>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, but note, your arguments above were looking at
>>>>>>>>>>>>>>>>>> a P(P) that called an H(P,P) that doesn't abort. Once
>>>>>>>>>>>>>>>>>> you CHANGE the behavior of H, you have changed the
>>>>>>>>>>>>>>>>>> input, and thus need to re-evaluate.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Once we know that the correctly simulated cannot
>>>>>>>>>>>>>>>>>>> possibly reach its own final state this input can be
>>>>>>>>>>>>>>>>>>> rejected as non-halting on the basis of the
>>>>>>>>>>>>>>>>>>> definition of non-halting: *never reaches its final
>>>>>>>>>>>>>>>>>>> state*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Except you did your logic wrong, because you intial
>>>>>>>>>>>>>>>>>> assumption that the simulation never reached a final
>>>>>>>>>>>>>>>>>> state was based on assuming that H never aborts its
>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Since it does, the logic is unsound.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When H(P,P) DOES abort its simulation UTM(P,P) will
>>>>>>>>>>>>>>>>>> Halt, and thus your arguement that it doesn't is untrue.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>> [000010f2](01)  55             push ebp
>>>>>>>>>>>>>>>>>>> [000010f3](02)  8bec           mov ebp,esp
>>>>>>>>>>>>>>>>>>> [000010f5](01)  51             push ecx
>>>>>>>>>>>>>>>>>>> [000010f6](03)  8b4508         mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>> [000010f9](01)  50             push eax       // push P
>>>>>>>>>>>>>>>>>>> [000010fa](03)  8b4d08         mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>> [000010fd](01)  51             push ecx       // push P
>>>>>>>>>>>>>>>>>>> [000010fe](05)  e88ffdffff     call 00000e92  // call H
>>>>>>>>>>>>>>>>>>> [00001103](03)  83c408         add esp,+08
>>>>>>>>>>>>>>>>>>> [00001106](03)  8945fc         mov [ebp-04],eax
>>>>>>>>>>>>>>>>>>> [00001109](04)  837dfc00       cmp dword [ebp-04],+00
>>>>>>>>>>>>>>>>>>> [0000110d](02)  7402           jz 00001111
>>>>>>>>>>>>>>>>>>> [0000110f](02)  ebfe           jmp 0000110f
>>>>>>>>>>>>>>>>>>> [00001111](02)  8be5           mov esp,ebp
>>>>>>>>>>>>>>>>>>> [00001113](01)  5d             pop ebp
>>>>>>>>>>>>>>>>>>> [00001114](01)  c3             ret
>>>>>>>>>>>>>>>>>>> Size in bytes:(0035) [00001114]
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This is what happens if H never aborts the simulation
>>>>>>>>>>>>>>>>>>> of its input:
>>>>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, if H never aborts.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When P is correctly simulated by H and H does not
>>>>>>>>>>>>>>>>>>> abort its simulation of P the first 8 instructions of
>>>>>>>>>>>>>>>>>>> P are simulated endlessly.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope, you built that logic on the assumption that H
>>>>>>>>>>>>>>>>>> doesn't abort, thus you can't have H abort.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The only job of H is to correctly determine whether or
>>>>>>>>>>>>>>>>> not its correctly simulated input can possibly reach
>>>>>>>>>>>>>>>>> the final state of this input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, it is to determine if *THE* correctly and
>>>>>>>>>>>>>>>> completely simulated input will reach a final state or
>>>>>>>>>>>>>>>> not. Not *ITS*, because if H aborts its simulation, that
>>>>>>>>>>>>>>>> definition is INCORRECT because it doesn't match the
>>>>>>>>>>>>>>>> ACTAUL defintion of Halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That is because it is different than determining if a
>>>>>>>>>>>>>>>> DIFFERENT version of the decider, when that difference
>>>>>>>>>>>>>>>> changes the input, would be halting or not.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Since UTM(Px,Px) Halts whe Hx(Px,Px) returns 0, the
>>>>>>>>>>>>>>>> clear meaning of your words says that Hx was wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>   int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>   if (Halt_Status)
>>>>>>>>>>>>>>>>>     HERE: goto HERE;
>>>>>>>>>>>>>>>>>   return;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *EXISTENTIAL QUANTIFICATION PROVES MY POINT*
>>>>>>>>>>>>>>>>> No function Hx can be defined such that its correct
>>>>>>>>>>>>>>>>> simulation of its input Px would reach the final state
>>>>>>>>>>>>>>>>> of this simulated Px in any finite number of steps.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So. UTM(Hx,Hx) does Halt, so the correct and complete
>>>>>>>>>>>>>>>> simulation halts, so the correct answer is Halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *You are not paying attention*
>>>>>>>>>>>>>>> *Your boiler plate reply does not apply to what I just said*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *The above refers to the infinite set of Hx/Px pairs
>>>>>>>>>>>>>>> where Hx*
>>>>>>>>>>>>>>> *correctly simulates its input Px, some halt others do not*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, are you saying that UTM(Px,Px) doesn't ever halt when
>>>>>>>>>>>>>> Hx(Px,Px) returns 0?
>>>>>>>>>>>>>>
>>>>>>>>>>>>> *No I specifically said that I am not saying that*
>>>>>>>>>>>>> *Hx/Px specifies an infinite set of pairs some halt others
>>>>>>>>>>>>> do not*
>>>>>>>>>>>>>
>>>>>>>>>>>>> The one thing that is the same across *ALL* of these pairs
>>>>>>>>>>>>> is that the input to Hx(Px,Px) correctly simulated by Hx
>>>>>>>>>>>>> never reaches the final state of Px.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So, are you thus asserting that Hx is NOT a Halt Decider?
>>>>>>>>>>>
>>>>>>>>>>> I didn't say that. I am saying that in every possible pair of
>>>>>>>>>>> Hx/Px combinations where Hx correctly simulates its input Px
>>>>>>>>>>> never halts.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, are you saying that it is supposed to meet the
>>>>>>>>>> requirements of a Halt Decider?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I didn't say that either.
>>>>>>>>
>>>>>>>> Yes, we've noticed. YOu have a problem, either your Hx's ARE
>>>>>>>> Halt Deciders and must follow the definition of a Halt Decider,
>>>>>>>> in which case the fact that UTM(Px,Px) Halt means they are
>>>>>>>> wrong, or you admit tha t
>>>>>>>>
>>>>>>>>>
>>>>>>>>>> As I have said, it doesn't matter that no Hx ever correct
>>>>>>>>>> simulates its input Px to a final state, that just means that
>>>>>>>>>> no Hx can PROVE that its input is Halting, not that it isn't
>>>>>>>>>> halting.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If none of the Hx/Px pairs where Hx correctly simulates Px
>>>>>>>>> reaches a final state of Px, then Px does not halt in any of
>>>>>>>>> these cases.
>>>>>>>>
>>>>>>>> Nope. In EVERY case that Hx aborts its simulation (and returns
>>>>>>>> 0) it is NOT a source of truth that its input is non-halting,
>>>>>>>> and in fact, as you have tactfully agreed by not disagreeing, it
>>>>>>>> has been shown that UTM(Px,Px) will Halt, so the input is HALTING.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> We know that all male humans are humans categorically.
>>>>>>>>>
>>>>>>>>> We know that all inputs that do not halt are non-halting
>>>>>>>>> inputs, categorically.
>>>>>>>>
>>>>>>>> Except tha not reaching a final state in an ABORTED and thus
>>>>>>>> PARTIAL simulation does not mean they are non-halting,
>>>>>>>
>>>>>>> If in the entire Hx/Px template none of the correctly simulated
>>>>>>> inputs to Hx reach their final state then every Hx element of
>>>>>>> this set that reports that its correctly simulated input would
>>>>>>> never reach its final state is necessarily correct.
>>>>>>
>>>>>> Nope, do you have a reliable reference for that idea?
>>>>>>
>>>>>> Or is this just another of your pathetic lies that you clam are
>>>>>> true by the meaning of the words when you don't actually seem to
>>>>>> know the meaning of the words.
>>>>> In the entire Hx/Px template none of the inputs correctly simulated
>>>>> by Hx reach their final state.
>>>>>
>>>>
>>>> So, You don't have anything that says this means what you say.
>>>>
>>>>> In other words you are saying that an idea as simple as this is too
>>>>> difficult for you to verify?
>>>>>
>>>>
>>>> It is just wrong,
>>>
>>> If it is "just wrong" then you can show exactly how one element of
>>> the set of Hx/Px pairs where Hx correctly simulates its input and Px
>>> reaches its final state.
>>
>> Why, what is wrong is your claim that a member needs to.
>>
>> No evidence provided for the rule, thus an incorrect claim.
>
> If you say that I am wrong you must show the basis for this assessment
> otherwise your assertion that I am wrong is baseless.
>
> *No amount of weasel worded double-talk can get around that*
>
>

On 9/5/2022 9:13 PM, Richard Damon wrote:
>
> On 9/5/22 9:46 PM, olcott wrote:
>> On 9/5/2022 7:40 PM, Richard Damon wrote:
>>>
>>> On 9/5/22 8:07 PM, olcott wrote:
>>>> In the entire Hx/Px template none of the inputs correctly simulated
>>>> by Hx reach their final state.
>>>>
>>>
>>> So, You don't have anything that says this means what you say.
>>>
>>>> In other words you are saying that an idea as simple as this is too
>>>> difficult for you to verify?
>>>>
>>>
>>> It is just wrong,
>>
>> If it is "just wrong" then you can show exactly how one element of the
>> set of Hx/Px pairs where Hx correctly simulates its input and Px
>> reaches its final state.
>>
>> Alternatively you implicitly prove that you are using deception as
>> your basis for rebuttal.
>
>
> By the way, your reply show how stupid and dishonest you are. First, you
> trim quotes to mislead, the FULL quote of the statement is shown below:
>
>>> It is just wrong, as is shown by the fact that UTM(Px,Px) Halts for
>>> all the Px that are based on a Hx that returns 0 from Hx(Px,Px).
>
> Note, I am not saying you are wrong about the fact that no Hx will ever
> simulate its input to a Halting state,

Great we finally agree on something.

Do you still reject the notion of a UTM:
The correct and complete simulation of machine description necessarily
derives the actual behavior specified by this machine description?

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

On 9/5/22 10:29 PM, olcott wrote:
> On 9/5/2022 9:13 PM, Richard Damon wrote:
>>
>> On 9/5/22 9:46 PM, olcott wrote:
>>> On 9/5/2022 7:40 PM, Richard Damon wrote:
>>>>
>>>> On 9/5/22 8:07 PM, olcott wrote:
>>>>> In the entire Hx/Px template none of the inputs correctly simulated
>>>>> by Hx reach their final state.
>>>>>
>>>>
>>>> So, You don't have anything that says this means what you say.
>>>>
>>>>> In other words you are saying that an idea as simple as this is too
>>>>> difficult for you to verify?
>>>>>
>>>>
>>>> It is just wrong,
>>>
>>> If it is "just wrong" then you can show exactly how one element of
>>> the set of Hx/Px pairs where Hx correctly simulates its input and Px
>>> reaches its final state.
>>>
>>> Alternatively you implicitly prove that you are using deception as
>>> your basis for rebuttal.
>>
>>
>> By the way, your reply show how stupid and dishonest you are. First,
>> you trim quotes to mislead, the FULL quote of the statement is shown
>> below:
>>
>>>> It is just wrong, as is shown by the fact that UTM(Px,Px) Halts for
>>>> all the Px that are based on a Hx that returns 0 from Hx(Px,Px).
>>
>> Note, I am not saying you are wrong about the fact that no Hx will
>> ever simulate its input to a Halting state,
>
> Great we finally agree on something.
>
> Do you still reject the notion of a UTM:
> The correct and complete simulation of machine description necessarily
> derives the actual behavior specified by this machine description?
>

Right, and an Hx that answers 0 is not a UTM BY DEFINTION.

And, since you agree that the correct and complete simulation of the
input to Hx(Px,Px) determines its behavior, which is UTM(Px,Px) then the
fact that UTM(Px,Px) Halts, shows that the answer is wrong.

Right?

Remember, the behavior of UTM(P,d) is exactly the same as P(d). and you
have already acepted that P(P) Halts.

Right?

YOU LOSE.

On 9/5/2022 10:01 PM, Richard Damon wrote:
>
> On 9/5/22 10:29 PM, olcott wrote:
>> On 9/5/2022 9:13 PM, Richard Damon wrote:
>>>
>>> On 9/5/22 9:46 PM, olcott wrote:
>>>> On 9/5/2022 7:40 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/5/22 8:07 PM, olcott wrote:
>>>>>> In the entire Hx/Px template none of the inputs correctly
>>>>>> simulated by Hx reach their final state.
>>>>>>
>>>>>
>>>>> So, You don't have anything that says this means what you say.
>>>>>
>>>>>> In other words you are saying that an idea as simple as this is
>>>>>> too difficult for you to verify?
>>>>>>
>>>>>
>>>>> It is just wrong,
>>>>
>>>> If it is "just wrong" then you can show exactly how one element of
>>>> the set of Hx/Px pairs where Hx correctly simulates its input and Px
>>>> reaches its final state.
>>>>
>>>> Alternatively you implicitly prove that you are using deception as
>>>> your basis for rebuttal.
>>>
>>>
>>> By the way, your reply show how stupid and dishonest you are. First,
>>> you trim quotes to mislead, the FULL quote of the statement is shown
>>> below:
>>>
>>>>> It is just wrong, as is shown by the fact that UTM(Px,Px) Halts for
>>>>> all the Px that are based on a Hx that returns 0 from Hx(Px,Px).
>>>
>>> Note, I am not saying you are wrong about the fact that no Hx will
>>> ever simulate its input to a Halting state,
>>
>> Great we finally agree on something.
>>
>> Do you still reject the notion of a UTM:
>> The correct and complete simulation of machine description necessarily
>> derives the actual behavior specified by this machine description?
>>
>
> Right, and an Hx that answers 0 is not a UTM BY DEFINTION.
>
There is no element of the infinite set of Hx/Px pairs, where Hx
correctly simulates its input and Px reaches its final state.

In the subset of this set where Hx correctly and completely simulates
its input, (thus Hx is a UTM) still no Px every reaches its final state.

Since we know that the correct and complete simulation of a machine
description (a UTM) does derive the actual behavior specified by this
machine description and the entire set of every correct and complete
simulation of the input to the every Hx never reaches the the final
state of Px, we know that Px is non-halting.

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

On 9/5/22 11:26 PM, olcott wrote:
> On 9/5/2022 10:01 PM, Richard Damon wrote:
>>
>> On 9/5/22 10:29 PM, olcott wrote:
>>> On 9/5/2022 9:13 PM, Richard Damon wrote:
>>>>
>>>> On 9/5/22 9:46 PM, olcott wrote:
>>>>> On 9/5/2022 7:40 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/5/22 8:07 PM, olcott wrote:
>>>>>>> In the entire Hx/Px template none of the inputs correctly
>>>>>>> simulated by Hx reach their final state.
>>>>>>>
>>>>>>
>>>>>> So, You don't have anything that says this means what you say.
>>>>>>
>>>>>>> In other words you are saying that an idea as simple as this is
>>>>>>> too difficult for you to verify?
>>>>>>>
>>>>>>
>>>>>> It is just wrong,
>>>>>
>>>>> If it is "just wrong" then you can show exactly how one element of
>>>>> the set of Hx/Px pairs where Hx correctly simulates its input and
>>>>> Px reaches its final state.
>>>>>
>>>>> Alternatively you implicitly prove that you are using deception as
>>>>> your basis for rebuttal.
>>>>
>>>>
>>>> By the way, your reply show how stupid and dishonest you are. First,
>>>> you trim quotes to mislead, the FULL quote of the statement is shown
>>>> below:
>>>>
>>>>>> It is just wrong, as is shown by the fact that UTM(Px,Px) Halts
>>>>>> for all the Px that are based on a Hx that returns 0 from Hx(Px,Px).
>>>>
>>>> Note, I am not saying you are wrong about the fact that no Hx will
>>>> ever simulate its input to a Halting state,
>>>
>>> Great we finally agree on something.
>>>
>>> Do you still reject the notion of a UTM:
>>> The correct and complete simulation of machine description
>>> necessarily derives the actual behavior specified by this machine
>>> description?
>>>
>>
>> Right, and an Hx that answers 0 is not a UTM BY DEFINTION.
>>
> There is no element of the infinite set of Hx/Px pairs, where Hx
> correctly simulates its input and Px reaches its final state.
>
> In the subset of this set where Hx correctly and completely simulates
> its input, (thus Hx is a UTM) still no Px every reaches its final state.
>
> Since we know that the correct and complete simulation of a machine
> description (a UTM) does derive the actual behavior specified by this
> machine description and the entire set of every correct and complete
> simulation of the input to the every Hx never reaches the the final
> state of Px, we know that Px is non-halting.
>

So, you don't understand what a computation is, You prove that you have
failed.

Yes, there are elements of the set Hx that do a complete simulation of
their inputs, and do show that their Px is non-halting, but those do not
answer.

Other Hx that are not part of the sub-set do abort their simualtion, but
their input Px is not from that sub-set either, so those Hx aren't being
given those inputs that were part of the sub-set that was shown to be
halting.

Is you whole problem that you don't understand the different meanings of
"Algorithms" used in differ parts of Computer Science?

Computation Theory in its definition of a Computation, Algorithm is a
VERY SPEICIFC definition what the machine is supposed to do. It is a
PRECISE STEP BY STEP set of instructions.

This differs from programming which often uses "Algorithm" in a generic
form meaning the general method and not the specific details.

That definition does not apply to this part of Computation Theory.

You are just showing your utter stupidity if this is your problem. For
someone claiming to use logic based on the Meaning of Words in Natural
Lnaguage, you should understand this behavior of words.

Sorry, you are just proving you are an idiot.

On 9/5/2022 10:52 PM, Richard Damon wrote:
>
> On 9/5/22 11:26 PM, olcott wrote:
>> On 9/5/2022 10:01 PM, Richard Damon wrote:
>>>
>>> On 9/5/22 10:29 PM, olcott wrote:
>>>> On 9/5/2022 9:13 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/5/22 9:46 PM, olcott wrote:
>>>>>> On 9/5/2022 7:40 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/5/22 8:07 PM, olcott wrote:
>>>>>>>> In the entire Hx/Px template none of the inputs correctly
>>>>>>>> simulated by Hx reach their final state.
>>>>>>>>
>>>>>>>
>>>>>>> So, You don't have anything that says this means what you say.
>>>>>>>
>>>>>>>> In other words you are saying that an idea as simple as this is
>>>>>>>> too difficult for you to verify?
>>>>>>>>
>>>>>>>
>>>>>>> It is just wrong,
>>>>>>
>>>>>> If it is "just wrong" then you can show exactly how one element of
>>>>>> the set of Hx/Px pairs where Hx correctly simulates its input and
>>>>>> Px reaches its final state.
>>>>>>
>>>>>> Alternatively you implicitly prove that you are using deception as
>>>>>> your basis for rebuttal.
>>>>>
>>>>>
>>>>> By the way, your reply show how stupid and dishonest you are.
>>>>> First, you trim quotes to mislead, the FULL quote of the statement
>>>>> is shown below:
>>>>>
>>>>>>> It is just wrong, as is shown by the fact that UTM(Px,Px) Halts
>>>>>>> for all the Px that are based on a Hx that returns 0 from Hx(Px,Px).
>>>>>
>>>>> Note, I am not saying you are wrong about the fact that no Hx will
>>>>> ever simulate its input to a Halting state,
>>>>
>>>> Great we finally agree on something.
>>>>
>>>> Do you still reject the notion of a UTM:
>>>> The correct and complete simulation of machine description
>>>> necessarily derives the actual behavior specified by this machine
>>>> description?
>>>>
>>>
>>> Right, and an Hx that answers 0 is not a UTM BY DEFINTION.
>>>
>> There is no element of the infinite set of Hx/Px pairs, where Hx
>> correctly simulates its input and Px reaches its final state.
>>
>> In the subset of this set where Hx correctly and completely simulates
>> its input, (thus Hx is a UTM) still no Px every reaches its final state.
>>
>> Since we know that the correct and complete simulation of a machine
>> description (a UTM) does derive the actual behavior specified by this
>> machine description and the entire set of every correct and complete
>> simulation of the input to the every Hx never reaches the the final
>> state of Px, we know that Px is non-halting.
>>
>
> So, you don't understand what a computation is, You prove that you have
> failed.
>
> Yes, there are elements of the set Hx that do a complete simulation of
> their inputs, and do show that their Px is non-halting, but those do not
> answer.
>

The fact that every element of the infinite set of Hx/Px pairs where Hx
correctly and completely simulates its and input Px never halts proves
that Px never halts.

If all X are Y one cannot correctly say that some X are not Y.

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

On 9/6/22 12:09 AM, olcott wrote:
> On 9/5/2022 10:52 PM, Richard Damon wrote:
>>
>> On 9/5/22 11:26 PM, olcott wrote:
>>> On 9/5/2022 10:01 PM, Richard Damon wrote:
>>>>
>>>> On 9/5/22 10:29 PM, olcott wrote:
>>>>> On 9/5/2022 9:13 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/5/22 9:46 PM, olcott wrote:
>>>>>>> On 9/5/2022 7:40 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/5/22 8:07 PM, olcott wrote:
>>>>>>>>> In the entire Hx/Px template none of the inputs correctly
>>>>>>>>> simulated by Hx reach their final state.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, You don't have anything that says this means what you say.
>>>>>>>>
>>>>>>>>> In other words you are saying that an idea as simple as this is
>>>>>>>>> too difficult for you to verify?
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is just wrong,
>>>>>>>
>>>>>>> If it is "just wrong" then you can show exactly how one element
>>>>>>> of the set of Hx/Px pairs where Hx correctly simulates its input
>>>>>>> and Px reaches its final state.
>>>>>>>
>>>>>>> Alternatively you implicitly prove that you are using deception
>>>>>>> as your basis for rebuttal.
>>>>>>
>>>>>>
>>>>>> By the way, your reply show how stupid and dishonest you are.
>>>>>> First, you trim quotes to mislead, the FULL quote of the statement
>>>>>> is shown below:
>>>>>>
>>>>>>>> It is just wrong, as is shown by the fact that UTM(Px,Px) Halts
>>>>>>>> for all the Px that are based on a Hx that returns 0 from
>>>>>>>> Hx(Px,Px).
>>>>>>
>>>>>> Note, I am not saying you are wrong about the fact that no Hx will
>>>>>> ever simulate its input to a Halting state,
>>>>>
>>>>> Great we finally agree on something.
>>>>>
>>>>> Do you still reject the notion of a UTM:
>>>>> The correct and complete simulation of machine description
>>>>> necessarily derives the actual behavior specified by this machine
>>>>> description?
>>>>>
>>>>
>>>> Right, and an Hx that answers 0 is not a UTM BY DEFINTION.
>>>>
>>> There is no element of the infinite set of Hx/Px pairs, where Hx
>>> correctly simulates its input and Px reaches its final state.
>>>
>>> In the subset of this set where Hx correctly and completely simulates
>>> its input, (thus Hx is a UTM) still no Px every reaches its final state.
>>>
>>> Since we know that the correct and complete simulation of a machine
>>> description (a UTM) does derive the actual behavior specified by this
>>> machine description and the entire set of every correct and complete
>>> simulation of the input to the every Hx never reaches the the final
>>> state of Px, we know that Px is non-halting.
>>>
>>
>> So, you don't understand what a computation is, You prove that you
>> have failed.
>>
>> Yes, there are elements of the set Hx that do a complete simulation of
>> their inputs, and do show that their Px is non-halting, but those do
>> not answer.
>>
>
> The fact that every element of the infinite set of Hx/Px pairs where Hx
> correctly and completely simulates its and input Px never halts proves
> that Px never halts.
>
> If all X are Y one cannot correctly say that some X are not Y.
>

Nope, Not what you have shown.

You have shown that for the Hx that NEVER abort, that their Px(Px) is
non-halting, but those Hx never give the answer, so they are still wrong.

You have also shown that for the Hx that DO abort, their PARTIAL
simulation never reaches its final state, which doesn't prove
non-halting, but proves that they can not prove Halting. The fact that
for these cases, UTM(Px,Px) Halts, shows their answer is also wrong.

So you have proved that ALL Your Hx are WRONG, therefore NO Hx is Correct.

FAIL.

Maybe you have proved that All Hx are correct POOP deciders.

Again, you are showing your utter stupidity and ignorance by claiming
that an aborted simulation can, by itself, prove non-halting. The fact
that, as you have been shown, UTM of the input Halts, yet you persist in
saying it must be non-halting, proves you are a pathological liar.

Sorry, you have dug a hole so deep you aren't going to get out of it.

Sorry you have wasted your life on such a idiotic pursuit, but you HAVE
wasted all those years you have attempted to disprove the Halting
THeorem, for which you went after totally unprepared.

In some ways I feel a little guilty at pointing all this out to you,
after all, you went out into a battle of wits unarmed.

On 9/6/2022 6:29 AM, Richard Damon wrote:
>
> On 9/6/22 12:09 AM, olcott wrote:
>> On 9/5/2022 10:52 PM, Richard Damon wrote:
>>>
>>> On 9/5/22 11:26 PM, olcott wrote:
>>>> On 9/5/2022 10:01 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/5/22 10:29 PM, olcott wrote:
>>>>>> On 9/5/2022 9:13 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/5/22 9:46 PM, olcott wrote:
>>>>>>>> On 9/5/2022 7:40 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/5/22 8:07 PM, olcott wrote:
>>>>>>>>>> In the entire Hx/Px template none of the inputs correctly
>>>>>>>>>> simulated by Hx reach their final state.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, You don't have anything that says this means what you say.
>>>>>>>>>
>>>>>>>>>> In other words you are saying that an idea as simple as this
>>>>>>>>>> is too difficult for you to verify?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is just wrong,
>>>>>>>>
>>>>>>>> If it is "just wrong" then you can show exactly how one element
>>>>>>>> of the set of Hx/Px pairs where Hx correctly simulates its input
>>>>>>>> and Px reaches its final state.
>>>>>>>>
>>>>>>>> Alternatively you implicitly prove that you are using deception
>>>>>>>> as your basis for rebuttal.
>>>>>>>
>>>>>>>
>>>>>>> By the way, your reply show how stupid and dishonest you are.
>>>>>>> First, you trim quotes to mislead, the FULL quote of the
>>>>>>> statement is shown below:
>>>>>>>
>>>>>>>>> It is just wrong, as is shown by the fact that UTM(Px,Px) Halts
>>>>>>>>> for all the Px that are based on a Hx that returns 0 from
>>>>>>>>> Hx(Px,Px).
>>>>>>>
>>>>>>> Note, I am not saying you are wrong about the fact that no Hx
>>>>>>> will ever simulate its input to a Halting state,
>>>>>>
>>>>>> Great we finally agree on something.
>>>>>>
>>>>>> Do you still reject the notion of a UTM:
>>>>>> The correct and complete simulation of machine description
>>>>>> necessarily derives the actual behavior specified by this machine
>>>>>> description?
>>>>>>
>>>>>
>>>>> Right, and an Hx that answers 0 is not a UTM BY DEFINTION.
>>>>>
>>>> There is no element of the infinite set of Hx/Px pairs, where Hx
>>>> correctly simulates its input and Px reaches its final state.
>>>>
>>>> In the subset of this set where Hx correctly and completely
>>>> simulates its input, (thus Hx is a UTM) still no Px every reaches
>>>> its final state.
>>>>
>>>> Since we know that the correct and complete simulation of a machine
>>>> description (a UTM) does derive the actual behavior specified by
>>>> this machine description and the entire set of every correct and
>>>> complete simulation of the input to the every Hx never reaches the
>>>> the final state of Px, we know that Px is non-halting.
>>>>
>>>
>>> So, you don't understand what a computation is, You prove that you
>>> have failed.
>>>
>>> Yes, there are elements of the set Hx that do a complete simulation
>>> of their inputs, and do show that their Px is non-halting, but those
>>> do not answer.
>>>
>>
>> The fact that every element of the infinite set of Hx/Px pairs where
>> Hx correctly and completely simulates its and input Px never halts
>> proves that Px never halts.
>>
>> If all X are Y one cannot correctly say that some X are not Y.
>>
>
> Nope, Not what you have shown.
>
> You have shown that for the Hx that NEVER abort, that their Px(Px) is
> non-halting, but those Hx never give the answer, so they are still wrong.
>

Since every correct UTM simulation By Hx of Px from an infinite set of
Hx/Px pairs never halts we know that the actual behavior actually
specified by Px never halts. Not a single element of this infinite set
halts.

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

On Tuesday, September 6, 2022 at 2:17:50 PM UTC+1, olcott wrote:
> Since every correct UTM simulation By Hx of Px from an infinite set of
> Hx/Px pairs never halts we know that the actual behavior actually
> specified by Px never halts. Not a single element of this infinite set
> halts.

If Hx is a function which correctly simulates its input and reports in finite time whether it halts, then there are no such Hx. So there are no Hx/Px pairs where Px halts, and no Hx/Px pairs where Px does not halt.

If you know "all X are Y", you cannot deduce "some X are Y" unless you also know that some X actually exist.

On 9/6/2022 8:51 AM, Paul N wrote:
> On Tuesday, September 6, 2022 at 2:17:50 PM UTC+1, olcott wrote:
>> Since every correct UTM simulation By Hx of Px from an infinite set of
>> Hx/Px pairs never halts we know that the actual behavior actually
>> specified by Px never halts. Not a single element of this infinite set
>> halts.
>
> If Hx is a function which correctly simulates its input and reports in finite time whether it halts, then there are no such Hx.

void Px(ptr x)
{ int Halt_Status = Hx(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", Hx(Px, Px));
}

There are zero elements of infinite set of Hx/Px pairs such that the
correct simulation of Px by Hx reaches the final state of Px.

There are elements of the infinite set of Hx/Px pairs such that Hx does
a correct partial simulation of its input that correctly predicts that
the correct and complete simulation of this input would never reach the
final state of the simulated Px.

Because we know that every element of the infinite set of Hx/Px pairs
where Hx does a correct and complete simulation of its input never
reaches the final state of this simulated input we have proof that the
prior paragraph is correct.

H0(Infinite_Loop) and
H(Infinite_Recursion, 0x777)

do a correct partial simulation of their input that correctly predicts
that the correct and complete simulation of their input never reaches
the final state of this simulated input.

> So there are no Hx/Px pairs where Px halts, and no Hx/Px pairs where Px does not halt.
>
> If you know "all X are Y", you cannot deduce "some X are Y" unless you also know that some X actually exist.

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

On 9/6/2022 8:51 AM, Paul N wrote:
> On Tuesday, September 6, 2022 at 2:17:50 PM UTC+1, olcott wrote:
>> Since every correct UTM simulation By Hx of Px from an infinite set of
>> Hx/Px pairs never halts we know that the actual behavior actually
>> specified by Px never halts. Not a single element of this infinite set
>> halts.
>
> If Hx is a function which correctly simulates its input and reports in finite time whether it halts, then there are no such Hx. So there are no Hx/Px pairs where Px halts, and no Hx/Px pairs where Px does not halt.
>

void Px(ptr x)
{ int Halt_Status = Hx(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", Hx(Px, Px));
}

There are zero elements of infinite set of Hx/Px pairs such that the
correct *partial or complete* simulation of Px by Hx reaches the final
state of Px.

There are elements of the infinite set of Hx/Px pairs such that Hx does
a *correct partial simulation* of its input that correctly predicts that
the *correct and complete simulation* of this input would never reach
the final state of the simulated Px.

Because we know that every element of the infinite set of Hx/Px pairs
where Hx does a *correct and complete simulation* of its input never
reaches the final state of this simulated input we have proof that the
prior paragraph is correct.

H0(Infinite_Loop) and
H(Infinite_Recursion, 0x777)

do a correct partial simulation of their input that correctly predicts
that the correct and complete simulation of their input never reaches
the final state of this simulated input.

> If you know "all X are Y", you cannot deduce "some X are Y" unless you also know that some X actually exist.

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

On Tuesday, September 6, 2022 at 3:15:35 PM UTC+1, olcott wrote:
> On 9/6/2022 8:51 AM, Paul N wrote:
> > On Tuesday, September 6, 2022 at 2:17:50 PM UTC+1, olcott wrote:
> >> Since every correct UTM simulation By Hx of Px from an infinite set of
> >> Hx/Px pairs never halts we know that the actual behavior actually
> >> specified by Px never halts. Not a single element of this infinite set
> >> halts.
> >
> > If Hx is a function which correctly simulates its input and reports in finite time whether it halts, then there are no such Hx.
> void Px(ptr x)
> {
> int Halt_Status = Hx(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", Hx(Px, Px));
> }
> There are zero elements of infinite set of Hx/Px pairs such that the
> correct simulation of Px by Hx reaches the final state of Px.
>
> There are elements of the infinite set of Hx/Px pairs such that Hx does
> a correct partial simulation of its input that correctly predicts that
> the correct and complete simulation of this input would never reach the
> final state of the simulated Px.
>
> Because we know that every element of the infinite set of Hx/Px pairs
> where Hx does a correct and complete simulation of its input never
> reaches the final state of this simulated input we have proof that the
> prior paragraph is correct.
>
> H0(Infinite_Loop) and
> H(Infinite_Recursion, 0x777)
>
> do a correct partial simulation of their input that correctly predicts
> that the correct and complete simulation of their input never reaches
> the final state of this simulated input.

You've shown that H0 and H give a correct results for some inputs, but you haven't shown that they give a correct result for Px.

> > So there are no Hx/Px pairs where Px halts, and no Hx/Px pairs where Px does not halt.
> >
> > If you know "all X are Y", you cannot deduce "some X are Y" unless you also know that some X actually exist.

On 9/6/2022 9:50 AM, Paul N wrote:
> On Tuesday, September 6, 2022 at 3:15:35 PM UTC+1, olcott wrote:
>> On 9/6/2022 8:51 AM, Paul N wrote:
>>> On Tuesday, September 6, 2022 at 2:17:50 PM UTC+1, olcott wrote:
>>>> Since every correct UTM simulation By Hx of Px from an infinite set of
>>>> Hx/Px pairs never halts we know that the actual behavior actually
>>>> specified by Px never halts. Not a single element of this infinite set
>>>> halts.
>>>
>>> If Hx is a function which correctly simulates its input and reports in finite time whether it halts, then there are no such Hx.
>> void Px(ptr x)
>> {
>> int Halt_Status = Hx(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", Hx(Px, Px));
>> }
>> There are zero elements of infinite set of Hx/Px pairs such that the
>> correct simulation of Px by Hx reaches the final state of Px.
>>
>> There are elements of the infinite set of Hx/Px pairs such that Hx does
>> a correct partial simulation of its input that correctly predicts that
>> the correct and complete simulation of this input would never reach the
>> final state of the simulated Px.
>>
>> Because we know that every element of the infinite set of Hx/Px pairs
>> where Hx does a correct and complete simulation of its input never
>> reaches the final state of this simulated input we have proof that the
>> prior paragraph is correct.
>>
>> H0(Infinite_Loop) and
>> H(Infinite_Recursion, 0x777)
>>
>> do a correct partial simulation of their input that correctly predicts
>> that the correct and complete simulation of their input never reaches
>> the final state of this simulated input.
>
> You've shown that H0 and H give a correct results for some inputs, but you haven't shown that they give a correct result for Px.

Yes I have see my my clarification.
If every element of an infinite that does a correct and complete
simulation of its input never reaches the final state of this input
and a correct and complete simulation of this input derives the actual
behavior of this input then the actual behavior of this input never
reaches the final state of this input.

>
>>> So there are no Hx/Px pairs where Px halts, and no Hx/Px pairs where Px does not halt.
>>>
>>> If you know "all X are Y", you cannot deduce "some X are Y" unless you also know that some X actually exist.

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

On 9/6/2022 9:50 AM, Paul N wrote:
> On Tuesday, September 6, 2022 at 3:15:35 PM UTC+1, olcott wrote:
>> On 9/6/2022 8:51 AM, Paul N wrote:
>>> On Tuesday, September 6, 2022 at 2:17:50 PM UTC+1, olcott wrote:
>>>> Since every correct UTM simulation By Hx of Px from an infinite set of
>>>> Hx/Px pairs never halts we know that the actual behavior actually
>>>> specified by Px never halts. Not a single element of this infinite set
>>>> halts.
>>>
>>> If Hx is a function which correctly simulates its input and reports in finite time whether it halts, then there are no such Hx.
>> void Px(ptr x)
>> {
>> int Halt_Status = Hx(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", Hx(Px, Px));
>> }
>> There are zero elements of infinite set of Hx/Px pairs such that the
>> correct simulation of Px by Hx reaches the final state of Px.
>>
>> There are elements of the infinite set of Hx/Px pairs such that Hx does
>> a correct partial simulation of its input that correctly predicts that
>> the correct and complete simulation of this input would never reach the
>> final state of the simulated Px.
>>
>> Because we know that every element of the infinite set of Hx/Px pairs
>> where Hx does a correct and complete simulation of its input never
>> reaches the final state of this simulated input we have proof that the
>> prior paragraph is correct.
>>
>> H0(Infinite_Loop) and
>> H(Infinite_Recursion, 0x777)
>>
>> do a correct partial simulation of their input that correctly predicts
>> that the correct and complete simulation of their input never reaches
>> the final state of this simulated input.
>
> You've shown that H0 and H give a correct results for some inputs, but you haven't shown that they give a correct result for Px.

*Yes I have see my my clarification*

If every element of the infinite set of Hx/Px pairs that does a correct
and complete simulation of its input never reaches the final state of
this input and a correct and complete simulation of this input derives
the actual behavior of this input then the actual behavior of this input
never reaches the final state of this input.

>
>>> So there are no Hx/Px pairs where Px halts, and no Hx/Px pairs where Px does not halt.
>>>
>>> If you know "all X are Y", you cannot deduce "some X are Y" unless you also know that some X actually exist.

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

On 9/6/2022 9:50 AM, Paul N wrote:
> On Tuesday, September 6, 2022 at 3:15:35 PM UTC+1, olcott wrote:
>> On 9/6/2022 8:51 AM, Paul N wrote:
>>> On Tuesday, September 6, 2022 at 2:17:50 PM UTC+1, olcott wrote:
>>>> Since every correct UTM simulation By Hx of Px from an infinite set of
>>>> Hx/Px pairs never halts we know that the actual behavior actually
>>>> specified by Px never halts. Not a single element of this infinite set
>>>> halts.
>>>
>>> If Hx is a function which correctly simulates its input and reports in finite time whether it halts, then there are no such Hx.
>> void Px(ptr x)
>> {
>> int Halt_Status = Hx(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", Hx(Px, Px));
>> }
>> There are zero elements of infinite set of Hx/Px pairs such that the
>> correct simulation of Px by Hx reaches the final state of Px.
>>
>> There are elements of the infinite set of Hx/Px pairs such that Hx does
>> a correct partial simulation of its input that correctly predicts that
>> the correct and complete simulation of this input would never reach the
>> final state of the simulated Px.
>>
>> Because we know that every element of the infinite set of Hx/Px pairs
>> where Hx does a correct and complete simulation of its input never
>> reaches the final state of this simulated input we have proof that the
>> prior paragraph is correct.
>>
>> H0(Infinite_Loop) and
>> H(Infinite_Recursion, 0x777)
>>
>> do a correct partial simulation of their input that correctly predicts
>> that the correct and complete simulation of their input never reaches
>> the final state of this simulated input.
>
> You've shown that H0 and H give a correct results for some inputs, but you haven't shown that they give a correct result for Px.
void Px(ptr x)
{ int Halt_Status = Hx(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", Hx(Px, Px));
}

*THIS HAS BEEN AGREED TO*
There are zero elements of infinite set of Hx/Px pairs such that the
correct *partial or complete* simulation of Px by Hx reaches the final
state of Px.

*THIS LOGICALLY FOLLOWS (as a subset) FROM ABOVE*
(A) Every element of the infinite set of Hx/Px pairs that does a correct
and complete simulation of its input never reaches the final state of
this input.

*THIS IS THE DEFINITION OF A UTM THUS KNOWN TO BE TRUE*
(B) A correct and complete simulation of this input derives the actual
behavior of this input.

*THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
(C) The actual behavior of this input never reaches the final state of
this input.

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

On 9/6/22 9:17 AM, olcott wrote:
> On 9/6/2022 6:29 AM, Richard Damon wrote:
>>
>> On 9/6/22 12:09 AM, olcott wrote:
>>> On 9/5/2022 10:52 PM, Richard Damon wrote:
>>>>
>>>> On 9/5/22 11:26 PM, olcott wrote:
>>>>> On 9/5/2022 10:01 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/5/22 10:29 PM, olcott wrote:
>>>>>>> On 9/5/2022 9:13 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/5/22 9:46 PM, olcott wrote:
>>>>>>>>> On 9/5/2022 7:40 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/5/22 8:07 PM, olcott wrote:
>>>>>>>>>>> In the entire Hx/Px template none of the inputs correctly
>>>>>>>>>>> simulated by Hx reach their final state.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, You don't have anything that says this means what you say.
>>>>>>>>>>
>>>>>>>>>>> In other words you are saying that an idea as simple as this
>>>>>>>>>>> is too difficult for you to verify?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is just wrong,
>>>>>>>>>
>>>>>>>>> If it is "just wrong" then you can show exactly how one element
>>>>>>>>> of the set of Hx/Px pairs where Hx correctly simulates its
>>>>>>>>> input and Px reaches its final state.
>>>>>>>>>
>>>>>>>>> Alternatively you implicitly prove that you are using deception
>>>>>>>>> as your basis for rebuttal.
>>>>>>>>
>>>>>>>>
>>>>>>>> By the way, your reply show how stupid and dishonest you are.
>>>>>>>> First, you trim quotes to mislead, the FULL quote of the
>>>>>>>> statement is shown below:
>>>>>>>>
>>>>>>>>>> It is just wrong, as is shown by the fact that UTM(Px,Px)
>>>>>>>>>> Halts for all the Px that are based on a Hx that returns 0
>>>>>>>>>> from Hx(Px,Px).
>>>>>>>>
>>>>>>>> Note, I am not saying you are wrong about the fact that no Hx
>>>>>>>> will ever simulate its input to a Halting state,
>>>>>>>
>>>>>>> Great we finally agree on something.
>>>>>>>
>>>>>>> Do you still reject the notion of a UTM:
>>>>>>> The correct and complete simulation of machine description
>>>>>>> necessarily derives the actual behavior specified by this machine
>>>>>>> description?
>>>>>>>
>>>>>>
>>>>>> Right, and an Hx that answers 0 is not a UTM BY DEFINTION.
>>>>>>
>>>>> There is no element of the infinite set of Hx/Px pairs, where Hx
>>>>> correctly simulates its input and Px reaches its final state.
>>>>>
>>>>> In the subset of this set where Hx correctly and completely
>>>>> simulates its input, (thus Hx is a UTM) still no Px every reaches
>>>>> its final state.
>>>>>
>>>>> Since we know that the correct and complete simulation of a machine
>>>>> description (a UTM) does derive the actual behavior specified by
>>>>> this machine description and the entire set of every correct and
>>>>> complete simulation of the input to the every Hx never reaches the
>>>>> the final state of Px, we know that Px is non-halting.
>>>>>
>>>>
>>>> So, you don't understand what a computation is, You prove that you
>>>> have failed.
>>>>
>>>> Yes, there are elements of the set Hx that do a complete simulation
>>>> of their inputs, and do show that their Px is non-halting, but those
>>>> do not answer.
>>>>
>>>
>>> The fact that every element of the infinite set of Hx/Px pairs where
>>> Hx correctly and completely simulates its and input Px never halts
>>> proves that Px never halts.
>>>
>>> If all X are Y one cannot correctly say that some X are not Y.
>>>
>>
>> Nope, Not what you have shown.
>>
>> You have shown that for the Hx that NEVER abort, that their Px(Px) is
>> non-halting, but those Hx never give the answer, so they are still wrong.
>>
>
> Since every correct UTM simulation By Hx of Px from an infinite set of
> Hx/Px pairs never halts we know that the actual behavior actually
> specified by Px never halts. Not a single element of this infinite set
> halts.
>
>

The only Hx that do a UTM simulation of the input to prove the input to
be non-halting never answer.

EVERY Hx that answers Hx(Px,Px), isn't a UTM (by definition since it
aborted is simulation) and it turns out that UTM(Px, Px) for these
machies Halts.

Therefore Hx was wrong.

Note, the halting problem proof deals with a SPECIFEC halt decider at at
time, not a "class".

Each element of the class fails on its own.

Note, a given program for a claimed H is a specific implementation of
your generic algorithm and the P it needs to get right is based on that
particual H, not the "class"

Try to write a "C" Halt Decider that actually implements the rules of
the "class" and not a specific implementation of it. You won't be able
to do it (with leaving out some function).

Thus your "class" isn't a Halt Decider.

FAIL.