On 1/15/22 12:44 PM, olcott wrote:
> On 1/15/2022 11:22 AM, Richard Damon wrote:
>> On 1/15/22 11:37 AM, olcott wrote:
>>> On 1/15/2022 9:54 AM, Richard Damon wrote:
>>>> On 1/15/22 9:33 AM, olcott wrote:
>>>>> On 1/15/2022 5:06 AM, Richard Damon wrote:
>>>>>> On 1/14/22 11:51 PM, olcott wrote:
>>>>>>> On 1/14/2022 10:34 PM, Richard Damon wrote:
>>>>>>>> On 1/14/22 11:26 PM, olcott wrote:
>>>>>>>>> On 1/14/2022 10:16 PM, Richard Damon wrote:
>>>>>>>>>> On 1/14/22 10:44 PM, olcott wrote:
>>>>>>>>>>> On 1/14/2022 9:31 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/14/22 10:21 PM, olcott wrote:
>>>>>>>>>>>>> On 1/14/2022 8:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 1/14/22 1:49 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/14/2022 12:11 PM, Alex C wrote:
>>>>>>>>>>>>>>>> On Friday, January 14, 2022 at 5:59:13 PM UTC+1, olcott
>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>> On 1/14/2022 10:36 AM, Alex C wrote:
>>>>>>>>>>>>>>>>>> On Thursday, January 13, 2022 at 9:34:08 PM UTC+1,
>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is the case that the copy of H (called embedded_H)
>>>>>>>>>>>>>>>>>>> at Ĥ.qx must abort
>>>>>>>>>>>>>>>>>>> the simulation of its input or Ĥ applied to ⟨Ĥ⟩ would
>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A simulating halt decider simulates N steps of its
>>>>>>>>>>>>>>>>>>> input until its input
>>>>>>>>>>>>>>>>>>> halts on its own or it correctly determines that a
>>>>>>>>>>>>>>>>>>> pure simulation of
>>>>>>>>>>>>>>>>>>> its input would never stop running.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal Languages
>>>>>>>>>>>>>>>>>>> and Automata.
>>>>>>>>>>>>>>>>>>> Lexington/Toronto: D. C. Heath and Company. (315-320)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A Turing machine applied to some input reaches one
>>>>>>>>>>>>>>>>>> final state or one infinite loop, not two different
>>>>>>>>>>>>>>>>>> ones. This is a consequence of the definition of
>>>>>>>>>>>>>>>>>> determinism.
>>>>>>>>>>>>>>>>> In the case of Linz Ĥ applied to ⟨Ĥ⟩, embedded_H at
>>>>>>>>>>>>>>>>> Ĥ.qx correctly
>>>>>>>>>>>>>>>>> transitions to its final state of Ĥ.qn on the basis
>>>>>>>>>>>>>>>>> that a mathematical
>>>>>>>>>>>>>>>>> mapping between ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.qn is proven. It is
>>>>>>>>>>>>>>>>> proven on the basis
>>>>>>>>>>>>>>>>> that the input ⟨Ĥ⟩ ⟨Ĥ⟩ specifies infinitely nested
>>>>>>>>>>>>>>>>> simulation to the
>>>>>>>>>>>>>>>>> simulating halt decider of embedded_H.
>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ??
>>>>>>>>>>>>>>>> is a question. A question that has only one answer. We
>>>>>>>>>>>>>>>> can find the answer by passing the arguments ⟨Ĥ.q0⟩ and
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ to a UTM. Otherwise it is like saying:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 2+2 = 4
>>>>>>>>>>>>>>>> 2+2 = 5
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That is not the question and you know it.
>>>>>>>>>>>>>>> I can't really understand your motivation to lie.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This is the actual question: embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>>>>>>>>>>>>>> and the answer is: Ĥ.qn.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except it isn't
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The DEFINITION of a correct H was
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H <X> y -> H.Qn iff X y did not halt. (and to H.Qy if it
>>>>>>>>>>>>>> does)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>>>>> Ĥ.qy or Ĥ.qn based on the actual behavior specified by its
>>>>>>>>>>>>> input: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Do you understand that this is correct, or do you not know
>>>>>>>>>>>>> computer science well enough to understand that this is
>>>>>>>>>>>>> correct?
>>>>>>>>>>>>
>>>>>>>>>>>> Right, AS DETERMINED BY UTM(<H^>,<H^>) which is the same as
>>>>>>>>>>>> H^ applied to <H^> (BY DEFINITION) which goes to H^.Qn and
>>>>>>>>>>>> Halts if the copy of H in it goes to H.Qn, which it does if
>>>>>>>>>>>> H mapped <H^> <H^> to H.Qn which you claim, so the behavior
>>>>>>>>>>>> specified by the input is HALTING.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I won't count that as wrong because the part that you got
>>>>>>>>>>> wrong was outside the scope of the original question.
>>>>>>>>>>>
>>>>>>>>>>> You 100% agree with this:
>>>>>>>>>>> The actual correct definition is embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>>> Ĥ.qy or
>>>>>>>>>>> Ĥ.qn based on the actual behavior specified by its input: ⟨Ĥ⟩
>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>
>>>>>>>>>>> The next step after we agree on that point is:
>>>>>>>>>>> How we measure the actual behavior of the input to
>>>>>>>>>>> embedded_H: ⟨Ĥ⟩ ⟨Ĥ⟩ ?
>>>>>>>>>>
>>>>>>>>>>  From the definition of the problem: it is defined as the
>>>>>>>>>> behavior of H^ applied to <H^> or its equivalent of
>>>>>>>>>> UTM(<H^>,<H^>) and nothing else.
>>>>>>>>> Ah so you don't understand enough computer science to know that
>>>>>>>>> every decider implements a computable function that maps its
>>>>>>>>> input(s) to an accept reject state.
>>>>>>>>>
>>>>>>>>> Unless you understand this we cannot proceed. It makes sense
>>>>>>>>> that I apply this same threshold of understanding to all of my
>>>>>>>>> reviewers.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, I understand that perfectly, H needs to compute a mapping
>>>>>>>> from its inputs, but the definition of the mapping, in this case
>>>>>>>> is the Halting Function, which it turns out is NOT directly
>>>>>>>> computatable from the inputs.
>>>>>>>>
>>>>>>>
>>>>>>> Because you tend to weasel word all over the place and have your
>>>>>>> rebuttal ignore what I am currently saying and instead refer to
>>>>>>> something that I said 50 posts ago let's be perfectly clear:
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
>>>>>>> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>>>>>>
>>>>>> So, no answer?
>>>>>>
>>>>>
>>>>> I am asking whether or not you agree with the above,
>>>>> Linz says it in a less precise way that can be misinterpreted.
>>>>>
>>>>> Unless and until you understand enough computer science to
>>>>> know that the way that I said it is correct we cannot proceed.
>>>>>
>>>>> DO YOU PERFECTLY AGREE THAT THIS IS 100% CORRECT?
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> That is a NONSENSE statement without the conditions on it.
>>>>>
>>>>> The copy of H at Ĥ.qx  referred to as embedded_H must compute the
>>>>> mapping of its own inputs: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn
>>>>
>>>> Right.
>>>>
>>>> AND the input <H^> <H^> is a description of the whole computation
>>>> being preformed.
>>>>
>>>> Note, this puts H in a bind,
>>>
>>> There is no H, there is only a copy of H at Ĥ.qx that is referred to
>>> as embedded_H.
>>
>> And you are wrong there. The HAD to be an H first to build H^ from.
>>
>> H is the decider that you want to make the CLAIM to be a correct
>> Halting Decider.
>>
>
> I wanted to make it clear that the subject of  the discussion is not H
> applied to ⟨Ĥ⟩ ⟨Ĥ⟩. The subject of the discussion is embedded_H applied
> to ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> It seems that you apply great skill and creativity to make sure that you
> always refer to things that are not being discussed.
>
>> If you are willing to stipulate that there is no such machine, fine,
>> that mean you concede the question.
>>
>> You seem to have forgotten what you are trying to do.
>>
>> You DO underestand that you can have more than 1 Turing Machine in
>> existence at a time, they all run independently, but more than one do
>> exist.
>>
>>>
>>>>  if its algorithm decides that this input should take it to the Qn
>>>> state, then the actual behavior of the computatiion this input
>>>> represents will be HALTING
>>>
>>> There is no "represents", there is only the actual behavior specified by
>>> the actual input to embedded_H: ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>>
>> And what 'behavior' does a string of symbol have?
>>
>> How did we get that string of symbols?
>>
>
> The behavior specified by a string of symbols is the actual behavior of
> the simulation of this string of symbols.

And the behavior for the Halting Problem would be that simulation by a
REAL UTM, not some 'partial' simulator.

Remember are claiming to work on an established problem, so you need to
use the established definitions.

>
>>>
>>> embedded_H computes the mapping from its input: ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn.
>>>
>>> The actual behavior of this actual input is measured by the pure
>>> simulation of N steps by embedded_H of its input ⟨Ĥ⟩ applied to ⟨Ĥ⟩.
>>>
>>
>> No, if anything the actual behavior of this input is measured by the
>> ACTUAL pure simulation of that input but a REAL UTM until it either
>> halts or NEVER halts.
>>
>
> No one is stupid enough to believe that a halt decider must wait an
> infinite amount of time for an infinite loop to stop running.

No one says the halt decider needs to compute its answer that way, this
is the difference between the IMPLEMENTATION done by the Halt Decider,
and the REQUIREMENTS specified for it.

H CAN'T wait forever to get its answer, it needs to answer in finite time.

The DEFINITION of the Halting Function is based on something that at
least naively, can take an infinite time. The key is that to claim that
this is actually 'computable' means that you are claiming that this
apparently infinite time operation can be done in finite time.

Remember, the Halting Problem STARTED with a 'Function' also known as a
mapping of machines and inputs to a Halting or Non-Halting property.

So Halting is a mapping of (M,w) -> {Halting, Non-Halting} based on the
condition that (M,w) -> Halting iff M applied to w will Halt in a finite
number of steps, and (M, w) -> Non-Halting if M applied to w will NEVER
halt.

The claim is that there exists no Turing Machine H, that can take as an
input a representation of this 'input' to the Halting Function, and
computate the answer.

That machine, if it existed, would have the following specification:

H wM w -> H.Qy if M w will Halt, and -> H.Qn if M w will never halt.

Given this specification, Turing (and Linz) have shown that it is
possible to create a machine H^ that uses this H, and that H can never
give the right answer to.

If you want to try to disprove this, you need to actually show that you
can do it. Yes, H CAN'T just wait forever to get the answer, and that is
the problem. You make lots of 'claims' about what you can do, but all
these claims contain Unicorns, a claim that you can do something that is
impossible, and you NEVER actually show how you claim to do it.

You arguements just FAIL.

>
> Some people are smart enough to understand that infinite loops, infinite
> recursion and infinitely nested simulation demonstrate infinite behavior
> patterns that can be recognized in a finite number of steps.

Proven incorrect.

Mesage ID <FOnzJ.162569$np6.119786@fx46.iad>
Date: 2021-12-30 19:31:49 GMT
Subject: Re: Concise refutation of halting problem proofs V42 [compute
the mapping]

It is well established that there is no finite exhaustive enumeration of
non-halting behavior.

>
>> You are forgetting the problem you are trying to solve and have gone
>> off into mental Unicorn land.
>>
>> FAIL.
>>
>
>