On 1/30/2022 10:40 AM, Richard Damon wrote:
> On 1/30/22 10:32 AM, olcott wrote:
>> On 1/30/2022 7:44 AM, Richard Damon wrote:
>>> On 1/30/22 8:13 AM, olcott wrote:
>>>> On 1/29/2022 11:34 AM, Ben Bacarisse wrote:
>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>
>>>>>> And the 'actual behavior of its actual inputs' is DEFINED to be what
>>>>>> the computation the input actually does when run as an independent
>>>>>> machine, or what a UTM will do when simulating that input.
>>>>>>
>>>>>> If that isn't the meaning you are using, then you are just lying that
>>>>>> you are working on the halting problem, which is what seems to be the
>>>>>> case. (That you are lying that is).
>>>>>
>>>>> It is certainly true that PO is not addressing the halting
>>>>> problem.  He
>>>>> has been 100% clear that false is, in his "opinion", the correct
>>>>> result
>>>>> for at least one halting computation.  This is not in dispute (unless
>>>>> he's retracted that and I missed it).
>>>>>
>>>>> To you and I, this means that he's not working on the halting problem,
>>>>> but I am not sure you can say he is lying about that.  For one thing,
>>>>> how can he be intending to deceive (a core part of lying) when he's
>>>>> been
>>>>> clear the he accepts the wrong answer as being the right one?  If
>>>>> someone claims to be working on "the addition problem", and also
>>>>> claims
>>>>> that 2+2=5 is correct, it's hard to consider either claim to be a lie.
>>>>> The person is just deeply confused.
>>>>>
>>>>> But what sort of confused can explain this nonsense?  I think the
>>>>> answer
>>>>> lies in PO's background.  The "binary square root" function is not
>>>>> computable as far as a mathematician is concerned because no TM can
>>>>> halt
>>>>> with, say, sqrt(0b10) on the tape.  But to an engineer, the function
>>>>> poses no problem because we can get as close as we like.  If
>>>>> 0b1.01101010000 is not good enough, just add more digits.
>>>>>
>>>>> The point is I think PO does not know what a formal, mathematical
>>>>> problem really is.  To him, anything about code, machines or
>>>>> programs is
>>>>> about solving an engineering problem "well enough" -- with "well
>>>>> enough"
>>>>> open to be defined by PO himself.
>>>>>
>>>>> More disturbing to me is that he is not even talking about Turing
>>>>> machines, again as evidenced by his own plain words.  It is not in
>>>>> dispute that he claims that two (deterministic) TMs, one an identical
>>>>> copy of the other, can transition to different states despite both
>>>>> being
>>>>> presented with identical input.  These are not Turing machines but
>>>>> Magic
>>>>> machines, and I can't see how any discussion can be had while the
>>>>> action
>>>>> of the things being considered is not a simple function of the
>>>>> input and
>>>>> the state transition graph.
>>>>>
>>>>
>>>> Although Turing machines might not be able to tell that two
>>>> computations differ on their basis of their machine address x86
>>>> machines can do this.
>>>
>>> But the proof is on Turing Machines, and not all x86 'programs' are
>>> the equivalent to Turing Machines, only those that meet the
>>> requirements of being a Computation.
>>>
>>> This seems to be the core of your problem, you don't understand what
>>> a computation actually is, and want to use the WRONG definition of it
>>> being anything a modern computer does. Wrong defintions, wrong results.
>>>
>>
>> When a halt decider bases its halt status decision on the behavior of
>> the correct simulation of a finite number of N steps of its input
>> there is nothing about this that is not a computation.
>
> Except that that is the WRONG definition of Halting. You can NOT
> accurate determine halting with only FIXED number N of steps.
>

This is a stupid mistake on your part.

It is dead obvious that the correct simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ by
embedded_H shows an infinitely repeating pattern in less than four
simulation cycles.

That you deny things that are dead obvious is what I call your mistakes
stupid mistakes rather than simply mistakes.

>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> When the copy of H embedded at Ĥ.qx correctly recognizes this
>> repeating pattern:
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>
>> Then these steps would keep repeating:
>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>> ⟨Ĥ5⟩...

>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3

--
Copyright 2021 Pete Olcott

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

On 1/30/2022 9:05 AM, olcott wrote:
> halt nonsense

Get a brain soon you ass.

On 1/30/2022 1:45 PM, Richard Damon wrote:
> On 1/30/22 2:18 PM, olcott wrote:
>> On 1/30/2022 11:41 AM, Richard Damon wrote:
>>> On 1/30/22 12:05 PM, olcott wrote:
>>>> On 1/30/2022 10:40 AM, Richard Damon wrote:
>>>>> On 1/30/22 10:32 AM, olcott wrote:
>>>>>> On 1/30/2022 7:44 AM, Richard Damon wrote:
>>>>>>> On 1/30/22 8:13 AM, olcott wrote:
>>>>>>>> On 1/29/2022 11:34 AM, Ben Bacarisse wrote:
>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>
>>>>>>>>>> And the 'actual behavior of its actual inputs' is DEFINED to
>>>>>>>>>> be what
>>>>>>>>>> the computation the input actually does when run as an
>>>>>>>>>> independent
>>>>>>>>>> machine, or what a UTM will do when simulating that input.
>>>>>>>>>>
>>>>>>>>>> If that isn't the meaning you are using, then you are just
>>>>>>>>>> lying that
>>>>>>>>>> you are working on the halting problem, which is what seems to
>>>>>>>>>> be the
>>>>>>>>>> case. (That you are lying that is).
>>>>>>>>>
>>>>>>>>> It is certainly true that PO is not addressing the halting
>>>>>>>>> problem.  He
>>>>>>>>> has been 100% clear that false is, in his "opinion", the
>>>>>>>>> correct result
>>>>>>>>> for at least one halting computation.  This is not in dispute
>>>>>>>>> (unless
>>>>>>>>> he's retracted that and I missed it).
>>>>>>>>>
>>>>>>>>> To you and I, this means that he's not working on the halting
>>>>>>>>> problem,
>>>>>>>>> but I am not sure you can say he is lying about that.  For one
>>>>>>>>> thing,
>>>>>>>>> how can he be intending to deceive (a core part of lying) when
>>>>>>>>> he's been
>>>>>>>>> clear the he accepts the wrong answer as being the right one?  If
>>>>>>>>> someone claims to be working on "the addition problem", and
>>>>>>>>> also claims
>>>>>>>>> that 2+2=5 is correct, it's hard to consider either claim to be
>>>>>>>>> a lie.
>>>>>>>>> The person is just deeply confused.
>>>>>>>>>
>>>>>>>>> But what sort of confused can explain this nonsense?  I think
>>>>>>>>> the answer
>>>>>>>>> lies in PO's background.  The "binary square root" function is not
>>>>>>>>> computable as far as a mathematician is concerned because no TM
>>>>>>>>> can halt
>>>>>>>>> with, say, sqrt(0b10) on the tape.  But to an engineer, the
>>>>>>>>> function
>>>>>>>>> poses no problem because we can get as close as we like.  If
>>>>>>>>> 0b1.01101010000 is not good enough, just add more digits.
>>>>>>>>>
>>>>>>>>> The point is I think PO does not know what a formal, mathematical
>>>>>>>>> problem really is.  To him, anything about code, machines or
>>>>>>>>> programs is
>>>>>>>>> about solving an engineering problem "well enough" -- with
>>>>>>>>> "well enough"
>>>>>>>>> open to be defined by PO himself.
>>>>>>>>>
>>>>>>>>> More disturbing to me is that he is not even talking about Turing
>>>>>>>>> machines, again as evidenced by his own plain words.  It is not in
>>>>>>>>> dispute that he claims that two (deterministic) TMs, one an
>>>>>>>>> identical
>>>>>>>>> copy of the other, can transition to different states despite
>>>>>>>>> both being
>>>>>>>>> presented with identical input.  These are not Turing machines
>>>>>>>>> but Magic
>>>>>>>>> machines, and I can't see how any discussion can be had while
>>>>>>>>> the action
>>>>>>>>> of the things being considered is not a simple function of the
>>>>>>>>> input and
>>>>>>>>> the state transition graph.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Although Turing machines might not be able to tell that two
>>>>>>>> computations differ on their basis of their machine address x86
>>>>>>>> machines can do this.
>>>>>>>
>>>>>>> But the proof is on Turing Machines, and not all x86 'programs'
>>>>>>> are the equivalent to Turing Machines, only those that meet the
>>>>>>> requirements of being a Computation.
>>>>>>>
>>>>>>> This seems to be the core of your problem, you don't understand
>>>>>>> what a computation actually is, and want to use the WRONG
>>>>>>> definition of it being anything a modern computer does. Wrong
>>>>>>> defintions, wrong results.
>>>>>>>
>>>>>>
>>>>>> When a halt decider bases its halt status decision on the behavior
>>>>>> of the correct simulation of a finite number of N steps of its
>>>>>> input there is nothing about this that is not a computation.
>>>>>
>>>>> Except that that is the WRONG definition of Halting. You can NOT
>>>>> accurate determine halting with only FIXED number N of steps.
>>>>>
>>>>
>>>> This is a stupid mistake on your part.
>>>>
>>>> It is dead obvious that the correct simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> by embedded_H shows an infinitely repeating pattern in less than
>>>> four simulation cycles.
>>>>
>>>> That you deny things that are dead obvious is what I call your
>>>> mistakes stupid mistakes rather than simply mistakes.
>>>
>>> You need to use the right definition, based on the Halting Problem.
>>>
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>
> Right, NOT "When a halt decider bases its halt status decision on the
> behavior of the correct simulation of a finite number of N steps of its
> input there is nothing about this that is not a computation."
>
> We need to look at the ACTUAL TURING MACHINE, even if you want to call
> that comming in the 'back door;

Because all simulating halt deciders are deciders they are only
accountable for computing the mapping from their input finite strings to
an accept or reject state on the basis of whether or not their correct
simulation of this input can possibly reach the final state of this
simulated input in any finite number of steps.

>>
>>> The fact that you need to change it just proves that your haven't got
>>> a prayer with the right definitions.
>>>
>>> NOTHING in the actual definition mentions anything about the behavior
>>> of the decider in determining if the computation actually halts.
>>>
>>> In fact, if you knew the first thing of Computation Theory, you would
>>> know that such a definition that includes that would actually be
>>> IMPOSSIBLE, as Halting is a Property of the Computation itself, and
>>> needs to be the same no matter what decider tries to decide on it.
>>>
>>> The fact that you rely on things that seem 'dead obvious' to you
>>> shows that you just don't understand how actual logic and proofs
>>> work. You don't start with things that are 'obvious', you start with
>>> the things DEFINED to be true, and the things that have been proven
>>> to be true based on those definition.
>>>
>>> Using the 'obvious' is one of the biggest sources of fallacies.
>>>
>>>
>>> We can show that your 'claim' is not true, at least for a H that
>>> aborts its simulation and goes to H.Qn,
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> So in other words you believe that when embedded_H aborts the
>> simulation of its input that this aborted input transitions to ⟨Ĥ⟩.qn
>> even though it has been aborted?
>>
>
> You mincing your words again.
>
> The DEFINITION of the operation that determines the 'Halting Behavior of
> the Input', is the ACTUAL RUNNING OF THE MACHINE REPRESENTED BY THE INPUT.
>
> That machine does not halt just because H/embedded_H aborts its
> simulation of its input.
>
> So, YES, when embedded_H aborts ITS PARTIAL simulation of its input,
> that the ACTUAL MACHINE it represents will continue on to H^.Qn.
Because all simulating halt deciders are deciders they are only
accountable for computing the mapping from their input finite strings to
an accept or reject state on the basis of whether or not their correct
simulation of this input can possibly reach the final state of this
simulated input in any finite number of steps.

On 1/30/2022 6:01 PM, Richard Damon wrote:
> On 1/30/22 6:35 PM, olcott wrote:
>> On 1/30/2022 5:30 PM, Richard Damon wrote:
>>> On 1/30/22 6:12 PM, olcott wrote:
>>>> On 1/30/2022 4:39 PM, Richard Damon wrote:
>>>>> On 1/30/22 4:21 PM, olcott wrote:
>>>>>> On 1/30/2022 2:54 PM, Richard Damon wrote:
>>>>>>> On 1/30/22 3:09 PM, olcott wrote:
>>>>>>
>>>>>>>> Because all simulating halt deciders are deciders they are only
>>>>>>>> accountable for computing the mapping from their input finite
>>>>>>>> strings to an accept or reject state on the basis of whether or
>>>>>>>> not their correct simulation of this input can possibly reach
>>>>>>>> the final state of this simulated input in any finite number of
>>>>>>>> steps.
>>>>>>>>
>>>>>>>> It is like you put a guard on the front door that is supposed to
>>>>>>>> report anyone coming in the front door (the actual inputs). Then
>>>>>>>> someone comes in the back door (non inputs) and the guard does
>>>>>>>> not report this. Since the guard is only supposed to report
>>>>>>>> people coming in the front door it is incorrect to say that the
>>>>>>>> guard made a mistake by not reporting people that came in the
>>>>>>>> back door.
>>>>>>>>
>>>>>>>> embedded_H is not supposed to report on the halt status of the
>>>>>>>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> So, you have just admitted that you aren't working on the Halting
>>>>>>> Problem, so any claims therein are just lies.
>>>>>>>
>>>>>>> Since the definition of the Halting Problem refers to the ACTUAL
>>>>>>> behavior of the machine the input represents, and NOT the partial
>>>>>>> simulation that some simulating halt decider might do, you are
>>>>>>> admitting that you H is NOT using the Halting Problem definition
>>>>>>> and thus your claims that your results apply to the Halting
>>>>>>> problem are just lies.
>>>>>>>
>>>>>>> For the Halting Problem, the correct results for the inputs is
>>>>>>> based on the actual behavior of the machine, or its equivalent
>>>>>>> the simulation of the input with a REAL UTM. Thus the 'Front
>>>>>>> Door' to the problem s based on that, so either you your guards
>>>>>>> are lying or, what seems more likely, you posted them to the
>>>>>>> wrong door.
>>>>>>>
>>>>>>> You have basically just proved that you have totally wasted the
>>>>>>> last years of your life, as you have been working on the wrong
>>>>>>> problem, because you just don't understand what the problem you
>>>>>>> wanted to solve actually was.
>>>>>>>
>>>>>>> FAIL.
>>>>>>
>>>>>> Sum(int X, int Y) { return X + Y );
>>>>>>
>>>>>> It is true that halt deciders must report on the actual behavior
>>>>>> of their actual inputs in the same way that Sum(2,5) must return 7.
>>>>>
>>>>> Right, and the correct answer for if H(wM, w) should report halting
>>>>> is if M x will reach a final state in a finite number of steps.
>>>>> This is identical to if UTM(wM, w) will halt. Dosn't matter what
>>>>> you think otherwise, that IS the definition of the actual behavior.
>>>>>
>>>>> It is NOT something based on the partial simulation that H does.
>>>>>
>>>>
>>>> The you cannot understand how all kinds of infinite behavior
>>>> patterns can be easily recognized in a finite number of steps is not
>>>> any mistake on my part:
>>>
>>> Yes, MANY can, but not ALL.
>>>
>>> If you need to change the definition, then you are not working on the
>>> halting problem.
>>>
>>>
>>
>> I don't have to change the definition I merely make it much more precise:
>
> Except that the original definition IS exactly precise. The is a single
> WELL DEFINED answer for any instance of the question. The fact that you
> see some abiguity just shows you don't really understand the field.
>
>>
>> (1) Halting is defined as reaching a final state.
>
> But you change the 'of what'.

A directly executed TM halts when it reaches the final state of this
directly executed TM.

A simulated TM description halts when the simulated TM description
reaches it final state.

If you weren't focused on rebuttal and instead focused on truth you
would have agreed to this long ago.

>> (2) Halt deciders like all deciders can and must ignore everything
>> that is not a direct input.
>>
>
> And the 'direct input' of <H^> <H^> directly refers to the computation
> of H^ applied to <H^> by DEFINITION.
>

Stupidly WRONG !!!

Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

The direct input to embedded_H is ⟨Ĥ⟩ ⟨Ĥ⟩ and is not Ĥ applied to ⟨Ĥ⟩.

If you weren't focused on rebuttal and instead focused on truth you
would have agreed to this long ago.

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

On 1/30/2022 8:20 PM, Richard Damon wrote:
> On 1/30/22 9:05 PM, olcott wrote:

>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> These statements need the conditions, that H^ goes to H^.Qy/H^.Qn iff
>>> H goes to that corresponding state.
>>>
>>
>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H in the
>> same way that (5,3) is syntactically specified as an input to Sum(5,3)
>
> Right, and the
>
>>
>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to embedded_H in the
>> same way that (1,2) is NOT syntactically specified as an input to
>> Sum(5,3)
>
>
> Right, but perhaps you don't understand that from you above statement
> the right answer is based on if UTM(<H^>,<H^>) Halts which by the
> definition of a UTM means if H^ applied to <H^> Halts.
>

The biggest reason for your huge mistakes is that you cannot stay
sharply focused on a single point. It is as if you either have attention
deficit disorder ADD or are addicted to methamphetamine.

>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H and
Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.

After we have mutual agreement on this point we will move on to the
points that logically follow from this one.

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

On 1/30/2022 8:20 PM, Richard Damon wrote:
> On 1/30/22 9:05 PM, olcott wrote:
>> On 1/30/2022 7:45 PM, Richard Damon wrote:
>>> On 1/30/22 7:21 PM, olcott wrote:
>>>> On 1/30/2022 6:01 PM, Richard Damon wrote:
>>>>> On 1/30/22 6:35 PM, olcott wrote:
>>>>>> On 1/30/2022 5:30 PM, Richard Damon wrote:
>>>>>>> On 1/30/22 6:12 PM, olcott wrote:
>>>>>>>> On 1/30/2022 4:39 PM, Richard Damon wrote:
>>>>>>>>> On 1/30/22 4:21 PM, olcott wrote:
>>>>>>>>>> On 1/30/2022 2:54 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/30/22 3:09 PM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>>> Because all simulating halt deciders are deciders they are
>>>>>>>>>>>> only accountable for computing the mapping from their input
>>>>>>>>>>>> finite strings to an accept or reject state on the basis of
>>>>>>>>>>>> whether or not their correct simulation of this input can
>>>>>>>>>>>> possibly reach the final state of this simulated input in
>>>>>>>>>>>> any finite number of steps.
>>>>>>>>>>>>
>>>>>>>>>>>> It is like you put a guard on the front door that is
>>>>>>>>>>>> supposed to report anyone coming in the front door (the
>>>>>>>>>>>> actual inputs). Then someone comes in the back door (non
>>>>>>>>>>>> inputs) and the guard does not report this. Since the guard
>>>>>>>>>>>> is only supposed to report people coming in the front door
>>>>>>>>>>>> it is incorrect to say that the guard made a mistake by not
>>>>>>>>>>>> reporting people that came in the back door.
>>>>>>>>>>>>
>>>>>>>>>>>> embedded_H is not supposed to report on the halt status of
>>>>>>>>>>>> the computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So, you have just admitted that you aren't working on the
>>>>>>>>>>> Halting Problem, so any claims therein are just lies.
>>>>>>>>>>>
>>>>>>>>>>> Since the definition of the Halting Problem refers to the
>>>>>>>>>>> ACTUAL behavior of the machine the input represents, and NOT
>>>>>>>>>>> the partial simulation that some simulating halt decider
>>>>>>>>>>> might do, you are admitting that you H is NOT using the
>>>>>>>>>>> Halting Problem definition and thus your claims that your
>>>>>>>>>>> results apply to the Halting problem are just lies.
>>>>>>>>>>>
>>>>>>>>>>> For the Halting Problem, the correct results for the inputs
>>>>>>>>>>> is based on the actual behavior of the machine, or its
>>>>>>>>>>> equivalent the simulation of the input with a REAL UTM. Thus
>>>>>>>>>>> the 'Front Door' to the problem s based on that, so either
>>>>>>>>>>> you your guards are lying or, what seems more likely, you
>>>>>>>>>>> posted them to the wrong door.
>>>>>>>>>>>
>>>>>>>>>>> You have basically just proved that you have totally wasted
>>>>>>>>>>> the last years of your life, as you have been working on the
>>>>>>>>>>> wrong problem, because you just don't understand what the
>>>>>>>>>>> problem you wanted to solve actually was.
>>>>>>>>>>>
>>>>>>>>>>> FAIL.
>>>>>>>>>>
>>>>>>>>>> Sum(int X, int Y) { return X + Y );
>>>>>>>>>>
>>>>>>>>>> It is true that halt deciders must report on the actual
>>>>>>>>>> behavior of their actual inputs in the same way that Sum(2,5)
>>>>>>>>>> must return 7.
>>>>>>>>>
>>>>>>>>> Right, and the correct answer for if H(wM, w) should report
>>>>>>>>> halting is if M x will reach a final state in a finite number
>>>>>>>>> of steps. This is identical to if UTM(wM, w) will halt. Dosn't
>>>>>>>>> matter what you think otherwise, that IS the definition of the
>>>>>>>>> actual behavior.
>>>>>>>>>
>>>>>>>>> It is NOT something based on the partial simulation that H does.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The you cannot understand how all kinds of infinite behavior
>>>>>>>> patterns can be easily recognized in a finite number of steps is
>>>>>>>> not any mistake on my part:
>>>>>>>
>>>>>>> Yes, MANY can, but not ALL.
>>>>>>>
>>>>>>> If you need to change the definition, then you are not working on
>>>>>>> the halting problem.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> I don't have to change the definition I merely make it much more
>>>>>> precise:
>>>>>
>>>>> Except that the original definition IS exactly precise. The is a
>>>>> single WELL DEFINED answer for any instance of the question. The
>>>>> fact that you see some abiguity just shows you don't really
>>>>> understand the field.
>>>>>
>>>>>>
>>>>>> (1) Halting is defined as reaching a final state.
>>>>>
>>>>> But you change the 'of what'.
>>>>
>>>> A directly executed TM halts when it reaches the final state of this
>>>> directly executed TM.
>>>>
>>>> A simulated TM description halts when the simulated TM description
>>>> reaches it final state.
>>>>
>>>
>>> Right, but if the simulator isn't a real UTM and stops simulating,
>>> the 'pure simulation' continues until it either halts or runs for ever.
>>>
>>
>> H.q0 Wm W ⊢* H.qy
>> iff UTM Wm W reaches its final state
>>
>> H.q0 Wm W ⊢* H.qn
>> iff UTM Wm W never reaches its final state
>
>
> Right, and that is the REAL UTM, not H playing one on TV and stopping
> when it thinks it has an answer.
As your scatterbrained mind keep repeating....
Yet I have kept correcting. It is not necessary for a simulating halt
decider to execute an infinite number of steps of an infinite sequence
of configurations for it to determine that a pure simulation of its
input would never stop running.

_Infinite_Loop()
[00000946](01) 55 push ebp
[00000947](02) 8bec mov ebp,esp
[00000949](02) ebfe jmp 00000949
[0000094b](01) 5d pop ebp
[0000094c](01) c3 ret
Size in bytes:(0007) [0000094c]

It is self-evident that the second time the instruction at [00000949] is
executed with no other instructions inbetween an infinite loop has been
recognized.

_Infinite_Recursion()
[00000926](01) 55 push ebp
[00000927](02) 8bec mov ebp,esp
[00000929](03) 8b4508 mov eax,[ebp+08]
[0000092c](01) 50 push eax
[0000092d](05) e8f4ffffff call 00000926
[00000932](03) 83c404 add esp,+04
[00000935](01) 5d pop ebp
[00000936](01) c3 ret
Size in bytes:(0017) [00000936]

Begin Local Halt Decider Simulation Execution Trace Stored at:211356

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00000926][00211342][00211346] 55 push ebp
[00000927][00211342][00211346] 8bec mov ebp,esp
[00000929][00211342][00211346] 8b4508 mov eax,[ebp+08]
[0000092c][0021133e][00000777] 50 push eax
[0000092d][0021133a][00000932] e8f4ffffff call 00000926
[00000926][00211336][00211342] 55 push ebp
[00000927][00211336][00211342] 8bec mov ebp,esp
[00000929][00211336][00211342] 8b4508 mov eax,[ebp+08]
[0000092c][00211332][00000777] 50 push eax
[0000092d][0021132e][00000932] e8f4ffffff call 00000926
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

On 1/31/2022 8:06 AM, olcott wrote:
> On 1/30/2022 8:20 PM, Richard Damon wrote:
>> On 1/30/22 9:05 PM, olcott wrote:
>
>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> These statements need the conditions, that H^ goes to H^.Qy/H^.Qn
>>>> iff H goes to that corresponding state.
>>>>
>>>
>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H in the
>>> same way that (5,3) is syntactically specified as an input to Sum(5,3)
>>
>> Right, and the
>>
>>>
>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to embedded_H in the
>>> same way that (1,2) is NOT syntactically specified as an input to
>>> Sum(5,3)
>>
>>
>> Right, but perhaps you don't understand that from you above statement
>> the right answer is based on if UTM(<H^>,<H^>) Halts which by the
>> definition of a UTM means if H^ applied to <H^> Halts.
>>
>
> The biggest reason for your huge mistakes is that you cannot stay
> sharply focused on a single point. It is as if you either have attention
> deficit disorder ADD or are addicted to methamphetamine.
>
> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H and
> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>
> After we have mutual agreement on this point we will move on to the
> points that logically follow from this one.
>

Holy shit try to post something that makes sense.

On 1/31/2022 6:41 PM, Richard Damon wrote:
> On 1/31/22 3:24 PM, olcott wrote:
>> On 1/31/2022 2:10 PM, Ben wrote:
>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>
>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> These statements need the conditions, that H^ goes to H^.Qy/H^.Qn
>>>>>>> iff H goes to that corresponding state.
>>>>>>>
>>>>>>
>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H in
>>>>>> the same way that (5,3) is syntactically specified as an input to
>>>>>> Sum(5,3)
>>>>>
>>>>> Right, and the
>>>>>
>>>>>>
>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to embedded_H in
>>>>>> the same way that (1,2) is NOT syntactically specified as an input
>>>>>> to Sum(5,3)
>>>>>
>>>>>
>>>>> Right, but perhaps you don't understand that from you above
>>>>> statement the right answer is based on if UTM(<H^>,<H^>) Halts
>>>>> which by the definition of a UTM means if H^ applied to <H^> Halts.
>>>>>
>>>>
>>>> The biggest reason for your huge mistakes is that you cannot stay
>>>> sharply focused on a single point. It is as if you either have
>>>> attention deficit disorder ADD or are addicted to methamphetamine.
>>>>
>>>>  >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>  >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H and
>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>
>>>> After we have mutual agreement on this point we will move on to the
>>>> points that logically follow from this one.
>>>>
>>>
>>> Holy shit try to post something that makes sense.
>>>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> Richard does not accept that the input to the copy of Linz H embedded
>> at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that it is Ĥ ⟨Ĥ⟩.
>>
>>
>
> No, but apparently you can't understand actual English words.
>
> The INPUT to H is <H^> <H^> but the CORRECT ANSWER that H must give is
> based on the behavior of H^ applied to <H^> BECAUSE OF THE DEFINITION of H.

In other words Sum(3,5) must return the value of Sum(7,8)?

Any moron knows that a function is only accountable for its actual inputs.

embedded_H is only accountable for the actual behavior specified by its
actual inputs ⟨Ĥ⟩ ⟨Ĥ⟩.

Since the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at Ĥ.qx cannot possibly transition to
its final state: ⟨Ĥ⟩.qn we know that this input never halts even if it
stops running.

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

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

On 1/31/2022 10:17 PM, Richard Damon wrote:
> On 1/31/22 10:40 PM, olcott wrote:
>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>> On 1/31/22 3:24 PM, olcott wrote:
>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>
>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> These statements need the conditions, that H^ goes to
>>>>>>>>> H^.Qy/H^.Qn iff H goes to that corresponding state.
>>>>>>>>>
>>>>>>>>
>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H in
>>>>>>>> the same way that (5,3) is syntactically specified as an input
>>>>>>>> to Sum(5,3)
>>>>>>>
>>>>>>> Right, and the
>>>>>>>
>>>>>>>>
>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to embedded_H
>>>>>>>> in the same way that (1,2) is NOT syntactically specified as an
>>>>>>>> input to Sum(5,3)
>>>>>>>
>>>>>>>
>>>>>>> Right, but perhaps you don't understand that from you above
>>>>>>> statement the right answer is based on if UTM(<H^>,<H^>) Halts
>>>>>>> which by the definition of a UTM means if H^ applied to <H^> Halts.
>>>>>>>
>>>>>>
>>>>>> The biggest reason for your huge mistakes is that you cannot stay
>>>>>> sharply focused on a single point. It is as if you either have
>>>>>> attention deficit disorder ADD or are addicted to methamphetamine.
>>>>>>
>>>>>>  >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>  >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H and
>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>
>>>>>> After we have mutual agreement on this point we will move on to
>>>>>> the points that logically follow from this one.
>>>>>>
>>>>>
>>>>> Holy shit try to post something that makes sense.
>>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> Richard does not accept that the input to the copy of Linz H
>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that it is Ĥ ⟨Ĥ⟩.
>>>>
>>>>
>>>
>>> No, but apparently you can't understand actual English words.
>>>
>>> The INPUT to H is <H^> <H^> but the CORRECT ANSWER that H must give
>>> is based on the behavior of H^ applied to <H^> BECAUSE OF THE
>>> DEFINITION of H.
>>
>> In other words Sum(3,5) must return the value of Sum(7,8)?
>
> Don't know how you get that from what I said.
>
>>
>> Any moron knows that a function is only accountable for its actual
>> inputs.
>
>
> And the actual input to H is <H^> <H^> which MEANS by the DEFINITION of
> the Halting Problem that H is being asked to decide on the Halting
> Status of H^ applied to <H^>
No that is not it. That is like saying "by definition" Sum(3,5) is being
asked about Sum(7,8).

Halt decider are deciders thus are only ever accountable for the
properties of their actual inputs.

The function that embedded_H computes is being asked about the actual
behavior of the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ at Ĥ.qx.

--
Copyright 2021 Pete Olcott

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

On 1/31/2022 10:33 PM, Richard Damon wrote:
>
> On 1/31/22 11:24 PM, olcott wrote:
>> On 1/31/2022 10:17 PM, Richard Damon wrote:
>>> On 1/31/22 10:40 PM, olcott wrote:
>>>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>>>> On 1/31/22 3:24 PM, olcott wrote:
>>>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>>>
>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> These statements need the conditions, that H^ goes to
>>>>>>>>>>> H^.Qy/H^.Qn iff H goes to that corresponding state.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H
>>>>>>>>>> in the same way that (5,3) is syntactically specified as an
>>>>>>>>>> input to Sum(5,3)
>>>>>>>>>
>>>>>>>>> Right, and the
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to embedded_H
>>>>>>>>>> in the same way that (1,2) is NOT syntactically specified as
>>>>>>>>>> an input to Sum(5,3)
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, but perhaps you don't understand that from you above
>>>>>>>>> statement the right answer is based on if UTM(<H^>,<H^>) Halts
>>>>>>>>> which by the definition of a UTM means if H^ applied to <H^>
>>>>>>>>> Halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The biggest reason for your huge mistakes is that you cannot
>>>>>>>> stay sharply focused on a single point. It is as if you either
>>>>>>>> have attention deficit disorder ADD or are addicted to
>>>>>>>> methamphetamine.
>>>>>>>>
>>>>>>>>  >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>  >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H and
>>>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>>>
>>>>>>>> After we have mutual agreement on this point we will move on to
>>>>>>>> the points that logically follow from this one.
>>>>>>>>
>>>>>>>
>>>>>>> Holy shit try to post something that makes sense.
>>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> Richard does not accept that the input to the copy of Linz H
>>>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that it is Ĥ ⟨Ĥ⟩.
>>>>>>
>>>>>>
>>>>>
>>>>> No, but apparently you can't understand actual English words.
>>>>>
>>>>> The INPUT to H is <H^> <H^> but the CORRECT ANSWER that H must give
>>>>> is based on the behavior of H^ applied to <H^> BECAUSE OF THE
>>>>> DEFINITION of H.
>>>>
>>>> In other words Sum(3,5) must return the value of Sum(7,8)?
>>>
>>> Don't know how you get that from what I said.
>>>
>>>>
>>>> Any moron knows that a function is only accountable for its actual
>>>> inputs.
>>>
>>>
>>> And the actual input to H is <H^> <H^> which MEANS by the DEFINITION
>>> of the Halting Problem that H is being asked to decide on the Halting
>>> Status of H^ applied to <H^>
>> No that is not it. That is like saying "by definition" Sum(3,5) is
>> being asked about Sum(7,8).
>
> Again your RED HERRING.
>
> H is being asked EXACTLY what it being asked
>
> H wM w -> H.Qy if M applied to w Halts, and H.Qn if it doesn't
>
> AGREED?
>

No that is wrong. embedded_H is being asked:
Can the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ possibly transition to ⟨Ĥ⟩.qn ?

--
Copyright 2021 Pete Olcott

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

On 1/31/2022 11:25 PM, Richard Damon wrote:
>
> On 1/31/22 11:42 PM, olcott wrote:
>> On 1/31/2022 10:33 PM, Richard Damon wrote:
>>>
>>> On 1/31/22 11:24 PM, olcott wrote:
>>>> On 1/31/2022 10:17 PM, Richard Damon wrote:
>>>>> On 1/31/22 10:40 PM, olcott wrote:
>>>>>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>>>>>> On 1/31/22 3:24 PM, olcott wrote:
>>>>>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> These statements need the conditions, that H^ goes to
>>>>>>>>>>>>> H^.Qy/H^.Qn iff H goes to that corresponding state.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H
>>>>>>>>>>>> in the same way that (5,3) is syntactically specified as an
>>>>>>>>>>>> input to Sum(5,3)
>>>>>>>>>>>
>>>>>>>>>>> Right, and the
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to
>>>>>>>>>>>> embedded_H in the same way that (1,2) is NOT syntactically
>>>>>>>>>>>> specified as an input to Sum(5,3)
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Right, but perhaps you don't understand that from you above
>>>>>>>>>>> statement the right answer is based on if UTM(<H^>,<H^>)
>>>>>>>>>>> Halts which by the definition of a UTM means if H^ applied to
>>>>>>>>>>> <H^> Halts.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The biggest reason for your huge mistakes is that you cannot
>>>>>>>>>> stay sharply focused on a single point. It is as if you either
>>>>>>>>>> have attention deficit disorder ADD or are addicted to
>>>>>>>>>> methamphetamine.
>>>>>>>>>>
>>>>>>>>>>  >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>  >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H and
>>>>>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>>>>>
>>>>>>>>>> After we have mutual agreement on this point we will move on
>>>>>>>>>> to the points that logically follow from this one.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Holy shit try to post something that makes sense.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> Richard does not accept that the input to the copy of Linz H
>>>>>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that it is Ĥ ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> No, but apparently you can't understand actual English words.
>>>>>>>
>>>>>>> The INPUT to H is <H^> <H^> but the CORRECT ANSWER that H must
>>>>>>> give is based on the behavior of H^ applied to <H^> BECAUSE OF
>>>>>>> THE DEFINITION of H.
>>>>>>
>>>>>> In other words Sum(3,5) must return the value of Sum(7,8)?
>>>>>
>>>>> Don't know how you get that from what I said.
>>>>>
>>>>>>
>>>>>> Any moron knows that a function is only accountable for its actual
>>>>>> inputs.
>>>>>
>>>>>
>>>>> And the actual input to H is <H^> <H^> which MEANS by the
>>>>> DEFINITION of the Halting Problem that H is being asked to decide
>>>>> on the Halting Status of H^ applied to <H^>
>>>> No that is not it. That is like saying "by definition" Sum(3,5) is
>>>> being asked about Sum(7,8).
>>>
>>> Again your RED HERRING.
>>>
>>> H is being asked EXACTLY what it being asked
>>>
>>> H wM w -> H.Qy if M applied to w Halts, and H.Qn if it doesn't
>>>
>>> AGREED?
>>>
>>
>> No that is wrong. embedded_H is being asked:
>> Can the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ possibly transition to ⟨Ĥ⟩.qn ?
>>
>
> If you say 'No', then you aren't doing the halting problem, as the
> requirement I stated is EXACTLY the requirement of the Halting Problem.

The halting problem is vague on the definition of halting, it includes
that a machine has stopped running and that a machine cannot reach its
final state. My definition only includes the latter.

The halting problem does not bother to mention the requirement that
because all halt deciders are deciders they are only accountable for
computing the mapping from their finite string inputs to an accept or
reject state on the basis of the actual behavior specified by this input.

The halting problem does not specifically examine simulating halt
deciders, none-the-less the behavior of a correctly simulated machine
description is known to be equivalent to the behavior of the direct
execution of this same machine.

Since a simulating halt decider is merely a UTM for simulated inputs
that reach their final state when a simulating halt decider correctly
determines that its simulated its input cannot possibly reach its final
state this is complete proof that this simulated input never halts.

--
Copyright 2021 Pete Olcott

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

On 2/1/2022 10:33 AM, wij wrote:
> On Tuesday, 1 February 2022 at 23:22:32 UTC+8, olcott wrote:
>> On 1/31/2022 11:25 PM, Richard Damon wrote:
>>>
>>> On 1/31/22 11:42 PM, olcott wrote:
>>>> On 1/31/2022 10:33 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/31/22 11:24 PM, olcott wrote:
>>>>>> On 1/31/2022 10:17 PM, Richard Damon wrote:
>>>>>>> On 1/31/22 10:40 PM, olcott wrote:
>>>>>>>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>>>>>>>> On 1/31/22 3:24 PM, olcott wrote:
>>>>>>>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>>>>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>>>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> These statements need the conditions, that H^ goes to
>>>>>>>>>>>>>>> H^.Qy/H^.Qn iff H goes to that corresponding state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H
>>>>>>>>>>>>>> in the same way that (5,3) is syntactically specified as an
>>>>>>>>>>>>>> input to Sum(5,3)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, and the
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to
>>>>>>>>>>>>>> embedded_H in the same way that (1,2) is NOT syntactically
>>>>>>>>>>>>>> specified as an input to Sum(5,3)
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, but perhaps you don't understand that from you above
>>>>>>>>>>>>> statement the right answer is based on if UTM(<H^>,<H^>)
>>>>>>>>>>>>> Halts which by the definition of a UTM means if H^ applied to
>>>>>>>>>>>>> <H^> Halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The biggest reason for your huge mistakes is that you cannot
>>>>>>>>>>>> stay sharply focused on a single point. It is as if you either
>>>>>>>>>>>> have attention deficit disorder ADD or are addicted to
>>>>>>>>>>>> methamphetamine.
>>>>>>>>>>>>
>>>>>>>>>>>> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H and
>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>>>>>>>
>>>>>>>>>>>> After we have mutual agreement on this point we will move on
>>>>>>>>>>>> to the points that logically follow from this one.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Holy shit try to post something that makes sense.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> Richard does not accept that the input to the copy of Linz H
>>>>>>>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that it is Ĥ ⟨Ĥ⟩.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, but apparently you can't understand actual English words.
>>>>>>>>>
>>>>>>>>> The INPUT to H is <H^> <H^> but the CORRECT ANSWER that H must
>>>>>>>>> give is based on the behavior of H^ applied to <H^> BECAUSE OF
>>>>>>>>> THE DEFINITION of H.
>>>>>>>>
>>>>>>>> In other words Sum(3,5) must return the value of Sum(7,8)?
>>>>>>>
>>>>>>> Don't know how you get that from what I said.
>>>>>>>
>>>>>>>>
>>>>>>>> Any moron knows that a function is only accountable for its actual
>>>>>>>> inputs.
>>>>>>>
>>>>>>>
>>>>>>> And the actual input to H is <H^> <H^> which MEANS by the
>>>>>>> DEFINITION of the Halting Problem that H is being asked to decide
>>>>>>> on the Halting Status of H^ applied to <H^>
>>>>>> No that is not it. That is like saying "by definition" Sum(3,5) is
>>>>>> being asked about Sum(7,8).
>>>>>
>>>>> Again your RED HERRING.
>>>>>
>>>>> H is being asked EXACTLY what it being asked
>>>>>
>>>>> H wM w -> H.Qy if M applied to w Halts, and H.Qn if it doesn't
>>>>>
>>>>> AGREED?
>>>>>
>>>>
>>>> No that is wrong. embedded_H is being asked:
>>>> Can the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ possibly transition to ⟨Ĥ⟩.qn ?
>>>>
>>>
>>> If you say 'No', then you aren't doing the halting problem, as the
>>> requirement I stated is EXACTLY the requirement of the Halting Problem.
>> The halting problem is vague on the definition of halting, it includes
>> that a machine has stopped running and that a machine cannot reach its
>> final state. My definition only includes the latter.
>
> Sounds like a NDTM.
>
> The Halting Problem has a definite, commonly recognized meaning. It refers to a
> real machine, no ambiguity, no one can change it, not even Linz.
> Your halt-problem is absolutely certain not Linz's, or of any? textbook.
> Your claim contradicts experimental truth. Otherwise, show your x86utm operating
> system proof. I guess you would say xxx thousands pages, I believe there are
> only few lines are yours. Show your codes.
>

You did not even read what I said before you claimed that it was
incorrect. The general principles that I outlined below directly apply
to the actual Linz proof:

If I am incorrect in anything that I said below then the specific error
could be pointed out.

>> The halting problem does not bother to mention the requirement that
>> because all halt deciders are deciders they are only accountable for
>> computing the mapping from their finite string inputs to an accept or
>> reject state on the basis of the actual behavior specified by this input.
>>
>> The halting problem does not specifically examine simulating halt
>> deciders, none-the-less the behavior of a correctly simulated machine
>> description is known to be equivalent to the behavior of the direct
>> execution of this same machine.
>>
>> Since a simulating halt decider is merely a UTM for simulated inputs
>> that reach their final state when a simulating halt decider correctly
>> determines that its simulated its input cannot possibly reach its final
>> state this is complete proof that this simulated input never halts.
>> --
>> Copyright 2021 Pete Olcott
>>
>> Talent hits a target no one else can hit;
>> Genius hits a target no one else can see.
>> Arthur Schopenhauer

On 2/1/2022 10:33 AM, wij wrote:
> On Tuesday, 1 February 2022 at 23:22:32 UTC+8, olcott wrote:
>> On 1/31/2022 11:25 PM, Richard Damon wrote:
>>>
>>> On 1/31/22 11:42 PM, olcott wrote:
>>>> On 1/31/2022 10:33 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/31/22 11:24 PM, olcott wrote:
>>>>>> On 1/31/2022 10:17 PM, Richard Damon wrote:
>>>>>>> On 1/31/22 10:40 PM, olcott wrote:
>>>>>>>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>>>>>>>> On 1/31/22 3:24 PM, olcott wrote:
>>>>>>>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>>>>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>>>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> These statements need the conditions, that H^ goes to
>>>>>>>>>>>>>>> H^.Qy/H^.Qn iff H goes to that corresponding state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H
>>>>>>>>>>>>>> in the same way that (5,3) is syntactically specified as an
>>>>>>>>>>>>>> input to Sum(5,3)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, and the
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to
>>>>>>>>>>>>>> embedded_H in the same way that (1,2) is NOT syntactically
>>>>>>>>>>>>>> specified as an input to Sum(5,3)
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, but perhaps you don't understand that from you above
>>>>>>>>>>>>> statement the right answer is based on if UTM(<H^>,<H^>)
>>>>>>>>>>>>> Halts which by the definition of a UTM means if H^ applied to
>>>>>>>>>>>>> <H^> Halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The biggest reason for your huge mistakes is that you cannot
>>>>>>>>>>>> stay sharply focused on a single point. It is as if you either
>>>>>>>>>>>> have attention deficit disorder ADD or are addicted to
>>>>>>>>>>>> methamphetamine.
>>>>>>>>>>>>
>>>>>>>>>>>> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H and
>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>>>>>>>
>>>>>>>>>>>> After we have mutual agreement on this point we will move on
>>>>>>>>>>>> to the points that logically follow from this one.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Holy shit try to post something that makes sense.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> Richard does not accept that the input to the copy of Linz H
>>>>>>>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that it is Ĥ ⟨Ĥ⟩.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, but apparently you can't understand actual English words.
>>>>>>>>>
>>>>>>>>> The INPUT to H is <H^> <H^> but the CORRECT ANSWER that H must
>>>>>>>>> give is based on the behavior of H^ applied to <H^> BECAUSE OF
>>>>>>>>> THE DEFINITION of H.
>>>>>>>>
>>>>>>>> In other words Sum(3,5) must return the value of Sum(7,8)?
>>>>>>>
>>>>>>> Don't know how you get that from what I said.
>>>>>>>
>>>>>>>>
>>>>>>>> Any moron knows that a function is only accountable for its actual
>>>>>>>> inputs.
>>>>>>>
>>>>>>>
>>>>>>> And the actual input to H is <H^> <H^> which MEANS by the
>>>>>>> DEFINITION of the Halting Problem that H is being asked to decide
>>>>>>> on the Halting Status of H^ applied to <H^>
>>>>>> No that is not it. That is like saying "by definition" Sum(3,5) is
>>>>>> being asked about Sum(7,8).
>>>>>
>>>>> Again your RED HERRING.
>>>>>
>>>>> H is being asked EXACTLY what it being asked
>>>>>
>>>>> H wM w -> H.Qy if M applied to w Halts, and H.Qn if it doesn't
>>>>>
>>>>> AGREED?
>>>>>
>>>>
>>>> No that is wrong. embedded_H is being asked:
>>>> Can the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ possibly transition to ⟨Ĥ⟩.qn ?
>>>>
>>>
>>> If you say 'No', then you aren't doing the halting problem, as the
>>> requirement I stated is EXACTLY the requirement of the Halting Problem.
>> The halting problem is vague on the definition of halting, it includes
>> that a machine has stopped running and that a machine cannot reach its
>> final state. My definition only includes the latter.
>
> Sounds like a NDTM.

https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine

It is not a NDTM, a Turing Machine only actually halts when it reaches
its own final state. People not very familiar with this material may get
confused and believe that a TM halts when its stops running because its
simulation has been aborted. This key distinction is not typically
specified in most halting problem proofs.

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

Halting problem undecidability and infinitely nested simulation (V3)

https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3

--
Copyright 2021 Pete Olcott

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

On 2/1/2022 3:23 PM, wij wrote:
> On Wednesday, 2 February 2022 at 02:37:17 UTC+8, olcott wrote:
>> On 2/1/2022 10:33 AM, wij wrote:
>>> On Tuesday, 1 February 2022 at 23:22:32 UTC+8, olcott wrote:
>>>> On 1/31/2022 11:25 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/31/22 11:42 PM, olcott wrote:
>>>>>> On 1/31/2022 10:33 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/31/22 11:24 PM, olcott wrote:
>>>>>>>> On 1/31/2022 10:17 PM, Richard Damon wrote:
>>>>>>>>> On 1/31/22 10:40 PM, olcott wrote:
>>>>>>>>>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/31/22 3:24 PM, olcott wrote:
>>>>>>>>>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>>>>>>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>>>>>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> These statements need the conditions, that H^ goes to
>>>>>>>>>>>>>>>>> H^.Qy/H^.Qn iff H goes to that corresponding state.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H
>>>>>>>>>>>>>>>> in the same way that (5,3) is syntactically specified as an
>>>>>>>>>>>>>>>> input to Sum(5,3)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, and the
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to
>>>>>>>>>>>>>>>> embedded_H in the same way that (1,2) is NOT syntactically
>>>>>>>>>>>>>>>> specified as an input to Sum(5,3)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, but perhaps you don't understand that from you above
>>>>>>>>>>>>>>> statement the right answer is based on if UTM(<H^>,<H^>)
>>>>>>>>>>>>>>> Halts which by the definition of a UTM means if H^ applied to
>>>>>>>>>>>>>>> <H^> Halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The biggest reason for your huge mistakes is that you cannot
>>>>>>>>>>>>>> stay sharply focused on a single point. It is as if you either
>>>>>>>>>>>>>> have attention deficit disorder ADD or are addicted to
>>>>>>>>>>>>>> methamphetamine.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H and
>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> After we have mutual agreement on this point we will move on
>>>>>>>>>>>>>> to the points that logically follow from this one.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Holy shit try to post something that makes sense.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> Richard does not accept that the input to the copy of Linz H
>>>>>>>>>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that it is Ĥ ⟨Ĥ⟩.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, but apparently you can't understand actual English words.
>>>>>>>>>>>
>>>>>>>>>>> The INPUT to H is <H^> <H^> but the CORRECT ANSWER that H must
>>>>>>>>>>> give is based on the behavior of H^ applied to <H^> BECAUSE OF
>>>>>>>>>>> THE DEFINITION of H.
>>>>>>>>>>
>>>>>>>>>> In other words Sum(3,5) must return the value of Sum(7,8)?
>>>>>>>>>
>>>>>>>>> Don't know how you get that from what I said.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Any moron knows that a function is only accountable for its actual
>>>>>>>>>> inputs.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And the actual input to H is <H^> <H^> which MEANS by the
>>>>>>>>> DEFINITION of the Halting Problem that H is being asked to decide
>>>>>>>>> on the Halting Status of H^ applied to <H^>
>>>>>>>> No that is not it. That is like saying "by definition" Sum(3,5) is
>>>>>>>> being asked about Sum(7,8).
>>>>>>>
>>>>>>> Again your RED HERRING.
>>>>>>>
>>>>>>> H is being asked EXACTLY what it being asked
>>>>>>>
>>>>>>> H wM w -> H.Qy if M applied to w Halts, and H.Qn if it doesn't
>>>>>>>
>>>>>>> AGREED?
>>>>>>>
>>>>>>
>>>>>> No that is wrong. embedded_H is being asked:
>>>>>> Can the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ possibly transition to ⟨Ĥ⟩.qn ?
>>>>>>
>>>>>
>>>>> If you say 'No', then you aren't doing the halting problem, as the
>>>>> requirement I stated is EXACTLY the requirement of the Halting Problem.
>>>> The halting problem is vague on the definition of halting, it includes
>>>> that a machine has stopped running and that a machine cannot reach its
>>>> final state. My definition only includes the latter.
>>>
>>> Sounds like a NDTM.
>> https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine
>>
>> It is not a NDTM, a Turing Machine only actually halts when it reaches
>> its own final state. People not very familiar with this material may get
>> confused and believe that a TM halts when its stops running because its
>> simulation has been aborted. This key distinction is not typically
>> specified in most halting problem proofs.
>> computation that halts … the Turing machine will halt whenever it enters
>> a final state. (Linz:1990:234)
>
> Where did Linz mention 'simulation' and 'abort'?

I have shown how my system directly applies to the actual halting
problem and it can be understood as correct by anyone that understands
the halting problem at a much deeper level than rote memorization.

On 2/1/2022 4:25 PM, wij wrote:
> On Wednesday, 2 February 2022 at 06:19:04 UTC+8, olcott wrote:
>> On 2/1/2022 4:12 PM, wij wrote:
>>> On Wednesday, 2 February 2022 at 05:36:39 UTC+8, olcott wrote:
>>>> On 2/1/2022 3:23 PM, wij wrote:
>>>>> On Wednesday, 2 February 2022 at 02:37:17 UTC+8, olcott wrote:
>>>>>> On 2/1/2022 10:33 AM, wij wrote:
>>>>>>> On Tuesday, 1 February 2022 at 23:22:32 UTC+8, olcott wrote:
>>>>>>>> On 1/31/2022 11:25 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 1/31/22 11:42 PM, olcott wrote:
>>>>>>>>>> On 1/31/2022 10:33 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/31/22 11:24 PM, olcott wrote:
>>>>>>>>>>>> On 1/31/2022 10:17 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/31/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/31/22 3:24 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>>>>>>>>>>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> These statements need the conditions, that H^ goes to
>>>>>>>>>>>>>>>>>>>>> H^.Qy/H^.Qn iff H goes to that corresponding state.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H
>>>>>>>>>>>>>>>>>>>> in the same way that (5,3) is syntactically specified as an
>>>>>>>>>>>>>>>>>>>> input to Sum(5,3)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, and the
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to
>>>>>>>>>>>>>>>>>>>> embedded_H in the same way that (1,2) is NOT syntactically
>>>>>>>>>>>>>>>>>>>> specified as an input to Sum(5,3)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, but perhaps you don't understand that from you above
>>>>>>>>>>>>>>>>>>> statement the right answer is based on if UTM(<H^>,<H^>)
>>>>>>>>>>>>>>>>>>> Halts which by the definition of a UTM means if H^ applied to
>>>>>>>>>>>>>>>>>>> <H^> Halts.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The biggest reason for your huge mistakes is that you cannot
>>>>>>>>>>>>>>>>>> stay sharply focused on a single point. It is as if you either
>>>>>>>>>>>>>>>>>> have attention deficit disorder ADD or are addicted to
>>>>>>>>>>>>>>>>>> methamphetamine.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H and
>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> After we have mutual agreement on this point we will move on
>>>>>>>>>>>>>>>>>> to the points that logically follow from this one.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Holy shit try to post something that makes sense.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Richard does not accept that the input to the copy of Linz H
>>>>>>>>>>>>>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that it is Ĥ ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, but apparently you can't understand actual English words.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The INPUT to H is <H^> <H^> but the CORRECT ANSWER that H must
>>>>>>>>>>>>>>> give is based on the behavior of H^ applied to <H^> BECAUSE OF
>>>>>>>>>>>>>>> THE DEFINITION of H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In other words Sum(3,5) must return the value of Sum(7,8)?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Don't know how you get that from what I said.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Any moron knows that a function is only accountable for its actual
>>>>>>>>>>>>>> inputs.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And the actual input to H is <H^> <H^> which MEANS by the
>>>>>>>>>>>>> DEFINITION of the Halting Problem that H is being asked to decide
>>>>>>>>>>>>> on the Halting Status of H^ applied to <H^>
>>>>>>>>>>>> No that is not it. That is like saying "by definition" Sum(3,5) is
>>>>>>>>>>>> being asked about Sum(7,8).
>>>>>>>>>>>
>>>>>>>>>>> Again your RED HERRING.
>>>>>>>>>>>
>>>>>>>>>>> H is being asked EXACTLY what it being asked
>>>>>>>>>>>
>>>>>>>>>>> H wM w -> H.Qy if M applied to w Halts, and H.Qn if it doesn't
>>>>>>>>>>>
>>>>>>>>>>> AGREED?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No that is wrong. embedded_H is being asked:
>>>>>>>>>> Can the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ possibly transition to ⟨Ĥ⟩.qn ?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If you say 'No', then you aren't doing the halting problem, as the
>>>>>>>>> requirement I stated is EXACTLY the requirement of the Halting Problem.
>>>>>>>> The halting problem is vague on the definition of halting, it includes
>>>>>>>> that a machine has stopped running and that a machine cannot reach its
>>>>>>>> final state. My definition only includes the latter.
>>>>>>>
>>>>>>> Sounds like a NDTM.
>>>>>> https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine
>>>>>>
>>>>>> It is not a NDTM, a Turing Machine only actually halts when it reaches
>>>>>> its own final state. People not very familiar with this material may get
>>>>>> confused and believe that a TM halts when its stops running because its
>>>>>> simulation has been aborted. This key distinction is not typically
>>>>>> specified in most halting problem proofs.
>>>>>> computation that halts … the Turing machine will halt whenever it enters
>>>>>> a final state. (Linz:1990:234)
>>>>>
>>>>> Where did Linz mention 'simulation' and 'abort'?
>>>> I have shown how my system directly applies to the actual halting
>>>> problem and it can be understood as correct by anyone that understands
>>>> the halting problem at a much deeper level than rote memorization.
>>>>
>>>> The following simplifies the syntax for the definition of the Linz
>>>> Turing machine Ĥ, it is now a single machine with a single start state.
>>>> A copy of Linz H is embedded at Ĥ.qx.
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition to
>>>> ⟨Ĥ⟩.qn ? (No means that ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt).
>>>>> You are defining POOP [Richard Damon]
>>>>> André had recommended many online sites for you to learn or test, I forget which posts it is.
>>>>> But I think C program is more simpler.
>>>>>
>>>>>> Halting problem undecidability and infinitely nested simulation (V3)
>>>>>>
>>>>>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>>>>> --
>>>>>> Copyright 2021 Pete Olcott
>>>>>>
>>>>>> Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see.
>>>>>> Arthur Schopenhauer
>>>>>
>>>>>
>>>>>
>>>>
>>>>
>>>> --
>>>> Copyright 2021 Pete Olcott
>>>>
>>>> Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see.
>>>> Arthur Schopenhauer
>>>
>>> André had recommended many online sites for you to learn or test, I forget which posts it is.
>>> Type it into a TM simulator and prove your claim, your words are meaningless.
>> I have already proved that I know one key fact about halt deciders that
>> no one else here seems to know.
>>
>> No one here understands that because a halt decider is a decider that it
>> must compute the mapping from its inputs to an accept of reject state on
>> the basis of the actual behavior specified by these inputs.
>> --
>> Copyright 2021 Pete Olcott
>>
>> Talent hits a target no one else can hit;
>> Genius hits a target no one else can see.
>> Arthur Schopenhauer
>
> There is no 'actual TM' until you it into a TM simulator,
> otherwise all empty talks.
> (I would expect to see you 'reinterpret' again)

On 2/1/2022 5:57 PM, Richard Damon wrote:
> On 2/1/22 10:22 AM, olcott wrote:
>> On 1/31/2022 11:25 PM, Richard Damon wrote:
>>>
>>> On 1/31/22 11:42 PM, olcott wrote:
>>>> On 1/31/2022 10:33 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/31/22 11:24 PM, olcott wrote:
>>>>>> On 1/31/2022 10:17 PM, Richard Damon wrote:
>>>>>>> On 1/31/22 10:40 PM, olcott wrote:
>>>>>>>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>>>>>>>> On 1/31/22 3:24 PM, olcott wrote:
>>>>>>>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>>>>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>>>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> These statements need the conditions, that H^ goes to
>>>>>>>>>>>>>>> H^.Qy/H^.Qn iff H goes to that corresponding state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to
>>>>>>>>>>>>>> embedded_H in the same way that (5,3) is syntactically
>>>>>>>>>>>>>> specified as an input to Sum(5,3)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, and the
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to
>>>>>>>>>>>>>> embedded_H in the same way that (1,2) is NOT syntactically
>>>>>>>>>>>>>> specified as an input to Sum(5,3)
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, but perhaps you don't understand that from you above
>>>>>>>>>>>>> statement the right answer is based on if UTM(<H^>,<H^>)
>>>>>>>>>>>>> Halts which by the definition of a UTM means if H^ applied
>>>>>>>>>>>>> to <H^> Halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The biggest reason for your huge mistakes is that you cannot
>>>>>>>>>>>> stay sharply focused on a single point. It is as if you
>>>>>>>>>>>> either have attention deficit disorder ADD or are addicted
>>>>>>>>>>>> to methamphetamine.
>>>>>>>>>>>>
>>>>>>>>>>>>  >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>  >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H and
>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>>>>>>>
>>>>>>>>>>>> After we have mutual agreement on this point we will move on
>>>>>>>>>>>> to the points that logically follow from this one.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Holy shit try to post something that makes sense.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> Richard does not accept that the input to the copy of Linz H
>>>>>>>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that it is Ĥ ⟨Ĥ⟩.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, but apparently you can't understand actual English words.
>>>>>>>>>
>>>>>>>>> The INPUT to H is <H^> <H^> but the CORRECT ANSWER that H must
>>>>>>>>> give is based on the behavior of H^ applied to <H^> BECAUSE OF
>>>>>>>>> THE DEFINITION of H.
>>>>>>>>
>>>>>>>> In other words Sum(3,5) must return the value of Sum(7,8)?
>>>>>>>
>>>>>>> Don't know how you get that from what I said.
>>>>>>>
>>>>>>>>
>>>>>>>> Any moron knows that a function is only accountable for its
>>>>>>>> actual inputs.
>>>>>>>
>>>>>>>
>>>>>>> And the actual input to H is <H^> <H^> which MEANS by the
>>>>>>> DEFINITION of the Halting Problem that H is being asked to decide
>>>>>>> on the Halting Status of H^ applied to <H^>
>>>>>> No that is not it. That is like saying "by definition" Sum(3,5) is
>>>>>> being asked about Sum(7,8).
>>>>>
>>>>> Again your RED HERRING.
>>>>>
>>>>> H is being asked EXACTLY what it being asked
>>>>>
>>>>> H wM w -> H.Qy if M applied to w Halts, and H.Qn if it doesn't
>>>>>
>>>>> AGREED?
>>>>>
>>>>
>>>> No that is wrong. embedded_H is being asked:
>>>> Can the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ possibly transition to ⟨Ĥ⟩.qn ?
>>>>
>>>
>>> If you say 'No', then you aren't doing the halting problem, as the
>>> requirement I stated is EXACTLY the requirement of the Halting Problem.
>>
>> The halting problem is vague on the definition of halting, it includes
>> that a machine has stopped running and that a machine cannot reach its
>> final state. My definition only includes the latter.
>>
>
> No, it is NOT 'Vague', a machine will EITHER stop running because it
> will reach a final state, or it can NEVER reach such a state.
>
> Please show a machine that doesn't reach its final state but also
> doesn't run forever?
>
> You seem to think that it is possible for a machine to be in some middle
> state.
>
> Please provide an example of such a machine.
>

A simulated machine description that specifies an infinite sequence of
configurations stops running yet never halts when its simulation has
been aborted.

> Note, the definition is stated the way it is because a simulator that
> aborts its simulation does NOT indicate either of the cases and does not
> provide evidence of the Halting state of a computation.
>

Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition to
⟨Ĥ⟩.qn ? (An answer of "no" means that ⟨Ĥ⟩ applied to ⟨Ĥ⟩ never halts).

>> The halting problem does not bother to mention the requirement that
>> because all halt deciders are deciders they are only accountable for
>> computing the mapping from their finite string inputs to an accept or
>> reject state on the basis of the actual behavior specified by this input.
>
> But if they do not compute the mapping per the definition, they are NOT
> 'Halt Deciders', that is your problem, what you are doing is trying to
> define a POOP decider can call it a Halt Decider.
>

You keep erroneously believing that embedded_H computes the mapping from
⟨Ĥ⟩ ⟨Ĥ⟩ to an accept or reject state on the basis of the behavior of Ĥ
applied to ⟨Ĥ⟩ rather than the actual behavior of its actual input.

On 2/1/2022 6:20 PM, Richard Damon wrote:
> On 2/1/22 1:37 PM, olcott wrote:
>> On 2/1/2022 10:33 AM, wij wrote:
>>> On Tuesday, 1 February 2022 at 23:22:32 UTC+8, olcott wrote:
>>>> On 1/31/2022 11:25 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/31/22 11:42 PM, olcott wrote:
>>>>>> On 1/31/2022 10:33 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/31/22 11:24 PM, olcott wrote:
>>>>>>>> On 1/31/2022 10:17 PM, Richard Damon wrote:
>>>>>>>>> On 1/31/22 10:40 PM, olcott wrote:
>>>>>>>>>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/31/22 3:24 PM, olcott wrote:
>>>>>>>>>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>>>>>>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>>>>>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> These statements need the conditions, that H^ goes to
>>>>>>>>>>>>>>>>> H^.Qy/H^.Qn iff H goes to that corresponding state.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to
>>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>>> in the same way that (5,3) is syntactically specified as an
>>>>>>>>>>>>>>>> input to Sum(5,3)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, and the
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to
>>>>>>>>>>>>>>>> embedded_H in the same way that (1,2) is NOT syntactically
>>>>>>>>>>>>>>>> specified as an input to Sum(5,3)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, but perhaps you don't understand that from you above
>>>>>>>>>>>>>>> statement the right answer is based on if UTM(<H^>,<H^>)
>>>>>>>>>>>>>>> Halts which by the definition of a UTM means if H^
>>>>>>>>>>>>>>> applied to
>>>>>>>>>>>>>>> <H^> Halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The biggest reason for your huge mistakes is that you cannot
>>>>>>>>>>>>>> stay sharply focused on a single point. It is as if you
>>>>>>>>>>>>>> either
>>>>>>>>>>>>>> have attention deficit disorder ADD or are addicted to
>>>>>>>>>>>>>> methamphetamine.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>   >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>   >>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to
>>>>>>>>>>>>>> embedded_H and
>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> After we have mutual agreement on this point we will move on
>>>>>>>>>>>>>> to the points that logically follow from this one.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Holy shit try to post something that makes sense.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> Richard does not accept that the input to the copy of Linz H
>>>>>>>>>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that it is Ĥ
>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, but apparently you can't understand actual English words.
>>>>>>>>>>>
>>>>>>>>>>> The INPUT to H is <H^> <H^> but the CORRECT ANSWER that H must
>>>>>>>>>>> give is based on the behavior of H^ applied to <H^> BECAUSE OF
>>>>>>>>>>> THE DEFINITION of H.
>>>>>>>>>>
>>>>>>>>>> In other words Sum(3,5) must return the value of Sum(7,8)?
>>>>>>>>>
>>>>>>>>> Don't know how you get that from what I said.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Any moron knows that a function is only accountable for its
>>>>>>>>>> actual
>>>>>>>>>> inputs.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And the actual input to H is <H^> <H^> which MEANS by the
>>>>>>>>> DEFINITION of the Halting Problem that H is being asked to decide
>>>>>>>>> on the Halting Status of H^ applied to <H^>
>>>>>>>> No that is not it. That is like saying "by definition" Sum(3,5) is
>>>>>>>> being asked about Sum(7,8).
>>>>>>>
>>>>>>> Again your RED HERRING.
>>>>>>>
>>>>>>> H is being asked EXACTLY what it being asked
>>>>>>>
>>>>>>> H wM w -> H.Qy if M applied to w Halts, and H.Qn if it doesn't
>>>>>>>
>>>>>>> AGREED?
>>>>>>>
>>>>>>
>>>>>> No that is wrong. embedded_H is being asked:
>>>>>> Can the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ possibly transition to ⟨Ĥ⟩.qn ?
>>>>>>
>>>>>
>>>>> If you say 'No', then you aren't doing the halting problem, as the
>>>>> requirement I stated is EXACTLY the requirement of the Halting
>>>>> Problem.
>>>> The halting problem is vague on the definition of halting, it includes
>>>> that a machine has stopped running and that a machine cannot reach its
>>>> final state. My definition only includes the latter.
>>> Sounds like a NDTM.
>>
>> https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine
>>
>> It is not a NDTM, a Turing Machine only actually halts when it reaches
>> its own final state. People not very familiar with this material may
>> get confused and believe that a TM halts when its stops running
>> because its simulation has been aborted. This key distinction is not
>> typically specified in most halting problem proofs.
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>>
>> Halting problem undecidability and infinitely nested simulation (V3)
>>
>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>
>>
>
> And the point that you seem to miss is that the Turing Machine doesn't
> stop just because some simulation of its representation gave up on
> simulating it.
>
> And actual Turing machine will continue to run until it his a final
> state or els it will continue to run for an unbounded number of steps.
>
> Non-Halting can only be show by showing that the actual running of the
> machine will continue for an unbounded number of steps, not just that
> there is some N that it doesn't stop in.

On 2/1/2022 6:24 PM, Richard Damon wrote:
> On 2/1/22 4:36 PM, olcott wrote:
>> On 2/1/2022 3:23 PM, wij wrote:
>>> On Wednesday, 2 February 2022 at 02:37:17 UTC+8, olcott wrote:
>>>> On 2/1/2022 10:33 AM, wij wrote:
>>>>> On Tuesday, 1 February 2022 at 23:22:32 UTC+8, olcott wrote:
>>>>>> On 1/31/2022 11:25 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/31/22 11:42 PM, olcott wrote:
>>>>>>>> On 1/31/2022 10:33 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 1/31/22 11:24 PM, olcott wrote:
>>>>>>>>>> On 1/31/2022 10:17 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/31/22 10:40 PM, olcott wrote:
>>>>>>>>>>>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/31/22 3:24 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>>>>>>>>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> These statements need the conditions, that H^ goes to
>>>>>>>>>>>>>>>>>>> H^.Qy/H^.Qn iff H goes to that corresponding state.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to
>>>>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>>>>> in the same way that (5,3) is syntactically specified
>>>>>>>>>>>>>>>>>> as an
>>>>>>>>>>>>>>>>>> input to Sum(5,3)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, and the
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to
>>>>>>>>>>>>>>>>>> embedded_H in the same way that (1,2) is NOT
>>>>>>>>>>>>>>>>>> syntactically
>>>>>>>>>>>>>>>>>> specified as an input to Sum(5,3)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, but perhaps you don't understand that from you
>>>>>>>>>>>>>>>>> above
>>>>>>>>>>>>>>>>> statement the right answer is based on if UTM(<H^>,<H^>)
>>>>>>>>>>>>>>>>> Halts which by the definition of a UTM means if H^
>>>>>>>>>>>>>>>>> applied to
>>>>>>>>>>>>>>>>> <H^> Halts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The biggest reason for your huge mistakes is that you
>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>> stay sharply focused on a single point. It is as if you
>>>>>>>>>>>>>>>> either
>>>>>>>>>>>>>>>> have attention deficit disorder ADD or are addicted to
>>>>>>>>>>>>>>>> methamphetamine.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to
>>>>>>>>>>>>>>>> embedded_H and
>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> After we have mutual agreement on this point we will
>>>>>>>>>>>>>>>> move on
>>>>>>>>>>>>>>>> to the points that logically follow from this one.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Holy shit try to post something that makes sense.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Richard does not accept that the input to the copy of Linz H
>>>>>>>>>>>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that it is
>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, but apparently you can't understand actual English words.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The INPUT to H is <H^> <H^> but the CORRECT ANSWER that H must
>>>>>>>>>>>>> give is based on the behavior of H^ applied to <H^> BECAUSE OF
>>>>>>>>>>>>> THE DEFINITION of H.
>>>>>>>>>>>>
>>>>>>>>>>>> In other words Sum(3,5) must return the value of Sum(7,8)?
>>>>>>>>>>>
>>>>>>>>>>> Don't know how you get that from what I said.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Any moron knows that a function is only accountable for its
>>>>>>>>>>>> actual
>>>>>>>>>>>> inputs.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And the actual input to H is <H^> <H^> which MEANS by the
>>>>>>>>>>> DEFINITION of the Halting Problem that H is being asked to
>>>>>>>>>>> decide
>>>>>>>>>>> on the Halting Status of H^ applied to <H^>
>>>>>>>>>> No that is not it. That is like saying "by definition"
>>>>>>>>>> Sum(3,5) is
>>>>>>>>>> being asked about Sum(7,8).
>>>>>>>>>
>>>>>>>>> Again your RED HERRING.
>>>>>>>>>
>>>>>>>>> H is being asked EXACTLY what it being asked
>>>>>>>>>
>>>>>>>>> H wM w -> H.Qy if M applied to w Halts, and H.Qn if it doesn't
>>>>>>>>>
>>>>>>>>> AGREED?
>>>>>>>>>
>>>>>>>>
>>>>>>>> No that is wrong. embedded_H is being asked:
>>>>>>>> Can the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ possibly transition to
>>>>>>>> ⟨Ĥ⟩.qn ?
>>>>>>>>
>>>>>>>
>>>>>>> If you say 'No', then you aren't doing the halting problem, as the
>>>>>>> requirement I stated is EXACTLY the requirement of the Halting
>>>>>>> Problem.
>>>>>> The halting problem is vague on the definition of halting, it
>>>>>> includes
>>>>>> that a machine has stopped running and that a machine cannot reach
>>>>>> its
>>>>>> final state. My definition only includes the latter.
>>>>>
>>>>> Sounds like a NDTM.
>>>> https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine
>>>>
>>>> It is not a NDTM, a Turing Machine only actually halts when it reaches
>>>> its own final state. People not very familiar with this material may
>>>> get
>>>> confused and believe that a TM halts when its stops running because its
>>>> simulation has been aborted. This key distinction is not typically
>>>> specified in most halting problem proofs.
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters
>>>> a final state. (Linz:1990:234)
>>>
>>> Where did Linz mention 'simulation' and 'abort'?
>>
>> I have shown how my system directly applies to the actual halting
>> problem and it can be understood as correct by anyone that understands
>> the halting problem at a much deeper level than rote memorization.
>>
>> The following simplifies the syntax for the definition of the Linz
>> Turing machine Ĥ, it is now a single machine with a single start
>> state. A copy of Linz H is embedded at Ĥ.qx.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition to
>> ⟨Ĥ⟩.qn ?  (No means that ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt).
>
>
> But unless embedded_H actually IS a real UTM, that doesn't matter.
>

On 2/1/2022 6:25 PM, Richard Damon wrote:
> On 2/1/22 5:18 PM, olcott wrote:
>> On 2/1/2022 4:12 PM, wij wrote:
>>> On Wednesday, 2 February 2022 at 05:36:39 UTC+8, olcott wrote:
>>>> On 2/1/2022 3:23 PM, wij wrote:
>>>>> On Wednesday, 2 February 2022 at 02:37:17 UTC+8, olcott wrote:
>>>>>> On 2/1/2022 10:33 AM, wij wrote:
>>>>>>> On Tuesday, 1 February 2022 at 23:22:32 UTC+8, olcott wrote:
>>>>>>>> On 1/31/2022 11:25 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 1/31/22 11:42 PM, olcott wrote:
>>>>>>>>>> On 1/31/2022 10:33 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/31/22 11:24 PM, olcott wrote:
>>>>>>>>>>>> On 1/31/2022 10:17 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/31/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/31/22 3:24 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>>>>>>>>>>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> These statements need the conditions, that H^ goes to
>>>>>>>>>>>>>>>>>>>>> H^.Qy/H^.Qn iff H goes to that corresponding state.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to
>>>>>>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>>>>>>> in the same way that (5,3) is syntactically
>>>>>>>>>>>>>>>>>>>> specified as an
>>>>>>>>>>>>>>>>>>>> input to Sum(5,3)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, and the
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to
>>>>>>>>>>>>>>>>>>>> embedded_H in the same way that (1,2) is NOT
>>>>>>>>>>>>>>>>>>>> syntactically
>>>>>>>>>>>>>>>>>>>> specified as an input to Sum(5,3)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, but perhaps you don't understand that from you
>>>>>>>>>>>>>>>>>>> above
>>>>>>>>>>>>>>>>>>> statement the right answer is based on if UTM(<H^>,<H^>)
>>>>>>>>>>>>>>>>>>> Halts which by the definition of a UTM means if H^
>>>>>>>>>>>>>>>>>>> applied to
>>>>>>>>>>>>>>>>>>> <H^> Halts.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The biggest reason for your huge mistakes is that you
>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>> stay sharply focused on a single point. It is as if
>>>>>>>>>>>>>>>>>> you either
>>>>>>>>>>>>>>>>>> have attention deficit disorder ADD or are addicted to
>>>>>>>>>>>>>>>>>> methamphetamine.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to
>>>>>>>>>>>>>>>>>> embedded_H and
>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> After we have mutual agreement on this point we will
>>>>>>>>>>>>>>>>>> move on
>>>>>>>>>>>>>>>>>> to the points that logically follow from this one.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Holy shit try to post something that makes sense.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Richard does not accept that the input to the copy of
>>>>>>>>>>>>>>>> Linz H
>>>>>>>>>>>>>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that it
>>>>>>>>>>>>>>>> is Ĥ ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, but apparently you can't understand actual English
>>>>>>>>>>>>>>> words.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The INPUT to H is <H^> <H^> but the CORRECT ANSWER that H
>>>>>>>>>>>>>>> must
>>>>>>>>>>>>>>> give is based on the behavior of H^ applied to <H^>
>>>>>>>>>>>>>>> BECAUSE OF
>>>>>>>>>>>>>>> THE DEFINITION of H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In other words Sum(3,5) must return the value of Sum(7,8)?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Don't know how you get that from what I said.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Any moron knows that a function is only accountable for
>>>>>>>>>>>>>> its actual
>>>>>>>>>>>>>> inputs.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And the actual input to H is <H^> <H^> which MEANS by the
>>>>>>>>>>>>> DEFINITION of the Halting Problem that H is being asked to
>>>>>>>>>>>>> decide
>>>>>>>>>>>>> on the Halting Status of H^ applied to <H^>
>>>>>>>>>>>> No that is not it. That is like saying "by definition"
>>>>>>>>>>>> Sum(3,5) is
>>>>>>>>>>>> being asked about Sum(7,8).
>>>>>>>>>>>
>>>>>>>>>>> Again your RED HERRING.
>>>>>>>>>>>
>>>>>>>>>>> H is being asked EXACTLY what it being asked
>>>>>>>>>>>
>>>>>>>>>>> H wM w -> H.Qy if M applied to w Halts, and H.Qn if it doesn't
>>>>>>>>>>>
>>>>>>>>>>> AGREED?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No that is wrong. embedded_H is being asked:
>>>>>>>>>> Can the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ possibly transition to
>>>>>>>>>> ⟨Ĥ⟩.qn ?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If you say 'No', then you aren't doing the halting problem, as the
>>>>>>>>> requirement I stated is EXACTLY the requirement of the Halting
>>>>>>>>> Problem.
>>>>>>>> The halting problem is vague on the definition of halting, it
>>>>>>>> includes
>>>>>>>> that a machine has stopped running and that a machine cannot
>>>>>>>> reach its
>>>>>>>> final state. My definition only includes the latter.
>>>>>>>
>>>>>>> Sounds like a NDTM.
>>>>>> https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine
>>>>>>
>>>>>> It is not a NDTM, a Turing Machine only actually halts when it
>>>>>> reaches
>>>>>> its own final state. People not very familiar with this material
>>>>>> may get
>>>>>> confused and believe that a TM halts when its stops running
>>>>>> because its
>>>>>> simulation has been aborted. This key distinction is not typically
>>>>>> specified in most halting problem proofs.
>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>> enters
>>>>>> a final state. (Linz:1990:234)
>>>>>
>>>>> Where did Linz mention 'simulation' and 'abort'?
>>>> I have shown how my system directly applies to the actual halting
>>>> problem and it can be understood as correct by anyone that understands
>>>> the halting problem at a much deeper level than rote memorization.
>>>>
>>>> The following simplifies the syntax for the definition of the Linz
>>>> Turing machine Ĥ, it is now a single machine with a single start state.
>>>> A copy of Linz H is embedded at Ĥ.qx.
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition to
>>>> ⟨Ĥ⟩.qn ? (No means that ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt).
>>>>> You are defining POOP [Richard Damon]
>>>>> André had recommended many online sites for you to learn or test, I
>>>>> forget which posts it is.
>>>>> But I think C program is more simpler.
>>>>>
>>>>>> Halting problem undecidability and infinitely nested simulation (V3)
>>>>>>
>>>>>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>>>>>
>>>>>> --
>>>>>> Copyright 2021 Pete Olcott
>>>>>>
>>>>>> Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see.
>>>>>> Arthur Schopenhauer
>>>>>
>>>>>
>>>>>
>>>>
>>>>
>>>> --
>>>> Copyright 2021 Pete Olcott
>>>>
>>>> Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see.
>>>> Arthur Schopenhauer
>>>
>>> André had recommended many online sites for you to learn or test, I
>>> forget which posts it is.
>>> Type it into a TM simulator and prove your claim, your words are
>>> meaningless.
>>
>> I have already proved that I know one key fact about halt deciders
>> that no one else here seems to know.
>>
>> No one here understands that because a halt decider is a decider that
>> it must compute the mapping from its inputs to an accept of reject
>> state on the basis of the actual behavior specified by these inputs.
>
>
> And the ACTUAL BEHAVIOR of the input <H^> <H^> is EXACTLY the behavior
> of H^ applied to <H^> which does Halt if H goes to H.Qn.

On 2/1/2022 6:58 PM, André G. Isaak wrote:
> On 2022-01-30 19:05, olcott wrote:
>> On 1/30/2022 7:45 PM, Richard Damon wrote:
>>> On 1/30/22 7:21 PM, olcott wrote:
>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> These statements need the conditions, that H^ goes to H^.Qy/H^.Qn iff
>>> H goes to that corresponding state.
>>>
>>
>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H in the
>> same way that (5,3) is syntactically specified as an input to Sum(5,3)
>>
>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to embedded_H in the
>> same way that (1,2) is NOT syntactically specified as an input to
>> Sum(5,3)
>
> I promised myself I wouldn't involve myself in your nonsense any
> further, but here you've made such a terribly inaccurate analogy that I
> thought I had to comment.
>
> The inputs to a function such as SUM(X, Y) are two REPRESENTATIONS of
> integers. If SUM were a Turing Machine, these would be two strings in
> the alphabet of the TM. if this were a C function, X and X would be
> strings of bits which form the twos complement representation of some
> integer. In neither case would the inputs be actual, mathematical
> integers. C might use the term 'integer' as one of its built in types,
> but C integers are NOT elements of ℤ. They are REPRESENTATIONS of the
> supported subset of ℤ.
>
> So ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H in the same sense that ⟨5⟩ ⟨3⟩ are
> the inputs to SUM.
>
> Ĥ ⟨Ĥ⟩ is not the input to embedded_H in the same sense that the actual
> mathematical integers 3 and 5 are not inputs to SUM.
>

We are on the same page so far. (acknowledging when there is agreement
is an essential part of an honest dialogue).

> If your going to make analogies, at least make ones that are accurate.
>
> SUM takes REPRESENTATIONS of integers as its inputs, but it answers
> about the ACTUAL integers described by those representations. To talk
> about the sum of two representations is meaningless. Only actual
> integers have sums.
>
> In exactly the same way, embedded_H takes a REPRESENTATION of some TM
> ⟨Ĥ⟩ as part of its input but it answers about the ACTUAL TM described by
> that input, Ĥ.
> To talk about whether a representation of a TM halts is
> meaningless since only actual TMs, not representations of TMs, can halt.
> The conditions which Richard indicates above (following Linz) are
> therefore the correct ones.
>
> In a previous post which I can't be botherered to find, you claimed that
> when the input to embedded_H is ⟨Ĥ⟩ ⟨Ĥ⟩ that embedded_H can only be
> expected to answer about its actual inputs and not its 'enclosing TM'.
>
> Yes, it must answer about its input, but if its input is ⟨Ĥ⟩ ⟨Ĥ⟩, then
> BY THE DEFINITION OF A HALT DECIDER is must determine whether Ĥ applied
> to ⟨Ĥ⟩ halts.

No you are flat out wrong about this. You are wrong because of your
ignorance of how deciders work. Deciders compute the mapping from their
finite string inputs to an accept or reject state on the basis of the
actual properties of these actual inputs.

Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition to
⟨Ĥ⟩.qn ?

An answer of "no" means that ⟨Ĥ⟩ applied to ⟨Ĥ⟩ never halts, and nothing
in the universe can possibly overcome this.

Because all simulating halt deciders are deciders they are only
accountable for computing the mapping from their input finite strings to
an accept or reject state on the basis of whether or not their correct
simulation of this input could ever reach its final state.

embedded_H is only accountable for the behavior of its input ⟨Ĥ⟩ applied
to ⟨Ĥ⟩. embedded_H is not accountable for the behavior of the
computation that it is contained within: Ĥ applied to ⟨Ĥ⟩.

Halting problem undecidability and infinitely nested simulation (V3)

https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3

> And that computation happens to be the EXACT SAME
> computation as its 'enclosing TM'. So it is answering about *both*.
>
> André
>

--
Copyright 2021 Pete Olcott

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

On 2/1/2022 7:40 PM, Richard Damon wrote:
>
> On 2/1/22 8:03 PM, olcott wrote:
>> On 2/1/2022 6:25 PM, Richard Damon wrote:
>>> On 2/1/22 5:18 PM, olcott wrote:
>>>> On 2/1/2022 4:12 PM, wij wrote:
>>>>> On Wednesday, 2 February 2022 at 05:36:39 UTC+8, olcott wrote:
>>>>>> On 2/1/2022 3:23 PM, wij wrote:
>>>>>>> On Wednesday, 2 February 2022 at 02:37:17 UTC+8, olcott wrote:
>>>>>>>> On 2/1/2022 10:33 AM, wij wrote:
>>>>>>>>> On Tuesday, 1 February 2022 at 23:22:32 UTC+8, olcott wrote:
>>>>>>>>>> On 1/31/2022 11:25 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/31/22 11:42 PM, olcott wrote:
>>>>>>>>>>>> On 1/31/2022 10:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 1/31/22 11:24 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/31/2022 10:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/31/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/31/22 3:24 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> These statements need the conditions, that H^
>>>>>>>>>>>>>>>>>>>>>>> goes to
>>>>>>>>>>>>>>>>>>>>>>> H^.Qy/H^.Qn iff H goes to that corresponding state.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to
>>>>>>>>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>>>>>>>>> in the same way that (5,3) is syntactically
>>>>>>>>>>>>>>>>>>>>>> specified as an
>>>>>>>>>>>>>>>>>>>>>> input to Sum(5,3)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Right, and the
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to
>>>>>>>>>>>>>>>>>>>>>> embedded_H in the same way that (1,2) is NOT
>>>>>>>>>>>>>>>>>>>>>> syntactically
>>>>>>>>>>>>>>>>>>>>>> specified as an input to Sum(5,3)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Right, but perhaps you don't understand that from
>>>>>>>>>>>>>>>>>>>>> you above
>>>>>>>>>>>>>>>>>>>>> statement the right answer is based on if
>>>>>>>>>>>>>>>>>>>>> UTM(<H^>,<H^>)
>>>>>>>>>>>>>>>>>>>>> Halts which by the definition of a UTM means if H^
>>>>>>>>>>>>>>>>>>>>> applied to
>>>>>>>>>>>>>>>>>>>>> <H^> Halts.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The biggest reason for your huge mistakes is that
>>>>>>>>>>>>>>>>>>>> you cannot
>>>>>>>>>>>>>>>>>>>> stay sharply focused on a single point. It is as if
>>>>>>>>>>>>>>>>>>>> you either
>>>>>>>>>>>>>>>>>>>> have attention deficit disorder ADD or are addicted to
>>>>>>>>>>>>>>>>>>>> methamphetamine.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to
>>>>>>>>>>>>>>>>>>>> embedded_H and
>>>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> After we have mutual agreement on this point we will
>>>>>>>>>>>>>>>>>>>> move on
>>>>>>>>>>>>>>>>>>>> to the points that logically follow from this one.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Holy shit try to post something that makes sense.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Richard does not accept that the input to the copy of
>>>>>>>>>>>>>>>>>> Linz H
>>>>>>>>>>>>>>>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that
>>>>>>>>>>>>>>>>>> it is Ĥ ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, but apparently you can't understand actual English
>>>>>>>>>>>>>>>>> words.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The INPUT to H is <H^> <H^> but the CORRECT ANSWER that
>>>>>>>>>>>>>>>>> H must
>>>>>>>>>>>>>>>>> give is based on the behavior of H^ applied to <H^>
>>>>>>>>>>>>>>>>> BECAUSE OF
>>>>>>>>>>>>>>>>> THE DEFINITION of H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> In other words Sum(3,5) must return the value of Sum(7,8)?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Don't know how you get that from what I said.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Any moron knows that a function is only accountable for
>>>>>>>>>>>>>>>> its actual
>>>>>>>>>>>>>>>> inputs.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And the actual input to H is <H^> <H^> which MEANS by the
>>>>>>>>>>>>>>> DEFINITION of the Halting Problem that H is being asked
>>>>>>>>>>>>>>> to decide
>>>>>>>>>>>>>>> on the Halting Status of H^ applied to <H^>
>>>>>>>>>>>>>> No that is not it. That is like saying "by definition"
>>>>>>>>>>>>>> Sum(3,5) is
>>>>>>>>>>>>>> being asked about Sum(7,8).
>>>>>>>>>>>>>
>>>>>>>>>>>>> Again your RED HERRING.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H is being asked EXACTLY what it being asked
>>>>>>>>>>>>>
>>>>>>>>>>>>> H wM w -> H.Qy if M applied to w Halts, and H.Qn if it doesn't
>>>>>>>>>>>>>
>>>>>>>>>>>>> AGREED?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> No that is wrong. embedded_H is being asked:
>>>>>>>>>>>> Can the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ possibly transition to
>>>>>>>>>>>> ⟨Ĥ⟩.qn ?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If you say 'No', then you aren't doing the halting problem,
>>>>>>>>>>> as the
>>>>>>>>>>> requirement I stated is EXACTLY the requirement of the
>>>>>>>>>>> Halting Problem.
>>>>>>>>>> The halting problem is vague on the definition of halting, it
>>>>>>>>>> includes
>>>>>>>>>> that a machine has stopped running and that a machine cannot
>>>>>>>>>> reach its
>>>>>>>>>> final state. My definition only includes the latter.
>>>>>>>>>
>>>>>>>>> Sounds like a NDTM.
>>>>>>>> https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine
>>>>>>>>
>>>>>>>> It is not a NDTM, a Turing Machine only actually halts when it
>>>>>>>> reaches
>>>>>>>> its own final state. People not very familiar with this material
>>>>>>>> may get
>>>>>>>> confused and believe that a TM halts when its stops running
>>>>>>>> because its
>>>>>>>> simulation has been aborted. This key distinction is not typically
>>>>>>>> specified in most halting problem proofs.
>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>> it enters
>>>>>>>> a final state. (Linz:1990:234)
>>>>>>>
>>>>>>> Where did Linz mention 'simulation' and 'abort'?
>>>>>> I have shown how my system directly applies to the actual halting
>>>>>> problem and it can be understood as correct by anyone that
>>>>>> understands
>>>>>> the halting problem at a much deeper level than rote memorization.
>>>>>>
>>>>>> The following simplifies the syntax for the definition of the Linz
>>>>>> Turing machine Ĥ, it is now a single machine with a single start
>>>>>> state.
>>>>>> A copy of Linz H is embedded at Ĥ.qx.
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition to
>>>>>> ⟨Ĥ⟩.qn ? (No means that ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt).
>>>>>>> You are defining POOP [Richard Damon]
>>>>>>> André had recommended many online sites for you to learn or test,
>>>>>>> I forget which posts it is.
>>>>>>> But I think C program is more simpler.
>>>>>>>
>>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>>> (V3)
>>>>>>>>
>>>>>>>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>>>>>>>
>>>>>>>> --
>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>
>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>> Genius hits a target no one else can see.
>>>>>>>> Arthur Schopenhauer
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>> --
>>>>>> Copyright 2021 Pete Olcott
>>>>>>
>>>>>> Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see.
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> André had recommended many online sites for you to learn or test, I
>>>>> forget which posts it is.
>>>>> Type it into a TM simulator and prove your claim, your words are
>>>>> meaningless.
>>>>
>>>> I have already proved that I know one key fact about halt deciders
>>>> that no one else here seems to know.
>>>>
>>>> No one here understands that because a halt decider is a decider
>>>> that it must compute the mapping from its inputs to an accept of
>>>> reject state on the basis of the actual behavior specified by these
>>>> inputs.
>>>
>>>
>>> And the ACTUAL BEHAVIOR of the input <H^> <H^> is EXACTLY the
>>> behavior of H^ applied to <H^> which does Halt if H goes to H.Qn.
>>
>>
>> Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition to
>> ⟨Ĥ⟩.qn ?
>
> Doesn't matter if embedded_H is not a ACTUAL UTM.
>

On 2/1/2022 5:33 PM, olcott wrote:

Shut up moron.

On 2/1/2022 7:55 PM, Richard Damon wrote:
> On 2/1/22 8:47 PM, olcott wrote:
>> On 2/1/2022 7:40 PM, Richard Damon wrote:
>>>
>>> On 2/1/22 8:03 PM, olcott wrote:
>>>> On 2/1/2022 6:25 PM, Richard Damon wrote:
>>>>> On 2/1/22 5:18 PM, olcott wrote:
>>>>>> On 2/1/2022 4:12 PM, wij wrote:
>>>>>>> On Wednesday, 2 February 2022 at 05:36:39 UTC+8, olcott wrote:
>>>>>>>> On 2/1/2022 3:23 PM, wij wrote:
>>>>>>>>> On Wednesday, 2 February 2022 at 02:37:17 UTC+8, olcott wrote:
>>>>>>>>>> On 2/1/2022 10:33 AM, wij wrote:
>>>>>>>>>>> On Tuesday, 1 February 2022 at 23:22:32 UTC+8, olcott wrote:
>>>>>>>>>>>> On 1/31/2022 11:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 1/31/22 11:42 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/31/2022 10:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 1/31/22 11:24 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/31/2022 10:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/31/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/31/22 3:24 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> These statements need the conditions, that H^
>>>>>>>>>>>>>>>>>>>>>>>>> goes to
>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qy/H^.Qn iff H goes to that corresponding
>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input
>>>>>>>>>>>>>>>>>>>>>>>> to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>> in the same way that (5,3) is syntactically
>>>>>>>>>>>>>>>>>>>>>>>> specified as an
>>>>>>>>>>>>>>>>>>>>>>>> input to Sum(5,3)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Right, and the
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to
>>>>>>>>>>>>>>>>>>>>>>>> embedded_H in the same way that (1,2) is NOT
>>>>>>>>>>>>>>>>>>>>>>>> syntactically
>>>>>>>>>>>>>>>>>>>>>>>> specified as an input to Sum(5,3)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Right, but perhaps you don't understand that from
>>>>>>>>>>>>>>>>>>>>>>> you above
>>>>>>>>>>>>>>>>>>>>>>> statement the right answer is based on if
>>>>>>>>>>>>>>>>>>>>>>> UTM(<H^>,<H^>)
>>>>>>>>>>>>>>>>>>>>>>> Halts which by the definition of a UTM means if
>>>>>>>>>>>>>>>>>>>>>>> H^ applied to
>>>>>>>>>>>>>>>>>>>>>>> <H^> Halts.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The biggest reason for your huge mistakes is that
>>>>>>>>>>>>>>>>>>>>>> you cannot
>>>>>>>>>>>>>>>>>>>>>> stay sharply focused on a single point. It is as
>>>>>>>>>>>>>>>>>>>>>> if you either
>>>>>>>>>>>>>>>>>>>>>> have attention deficit disorder ADD or are
>>>>>>>>>>>>>>>>>>>>>> addicted to
>>>>>>>>>>>>>>>>>>>>>> methamphetamine.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to
>>>>>>>>>>>>>>>>>>>>>> embedded_H and
>>>>>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> After we have mutual agreement on this point we
>>>>>>>>>>>>>>>>>>>>>> will move on
>>>>>>>>>>>>>>>>>>>>>> to the points that logically follow from this one.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Holy shit try to post something that makes sense.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Richard does not accept that the input to the copy
>>>>>>>>>>>>>>>>>>>> of Linz H
>>>>>>>>>>>>>>>>>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting that
>>>>>>>>>>>>>>>>>>>> it is Ĥ ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, but apparently you can't understand actual
>>>>>>>>>>>>>>>>>>> English words.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The INPUT to H is <H^> <H^> but the CORRECT ANSWER
>>>>>>>>>>>>>>>>>>> that H must
>>>>>>>>>>>>>>>>>>> give is based on the behavior of H^ applied to <H^>
>>>>>>>>>>>>>>>>>>> BECAUSE OF
>>>>>>>>>>>>>>>>>>> THE DEFINITION of H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> In other words Sum(3,5) must return the value of
>>>>>>>>>>>>>>>>>> Sum(7,8)?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Don't know how you get that from what I said.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Any moron knows that a function is only accountable
>>>>>>>>>>>>>>>>>> for its actual
>>>>>>>>>>>>>>>>>> inputs.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And the actual input to H is <H^> <H^> which MEANS by the
>>>>>>>>>>>>>>>>> DEFINITION of the Halting Problem that H is being asked
>>>>>>>>>>>>>>>>> to decide
>>>>>>>>>>>>>>>>> on the Halting Status of H^ applied to <H^>
>>>>>>>>>>>>>>>> No that is not it. That is like saying "by definition"
>>>>>>>>>>>>>>>> Sum(3,5) is
>>>>>>>>>>>>>>>> being asked about Sum(7,8).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Again your RED HERRING.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H is being asked EXACTLY what it being asked
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H wM w -> H.Qy if M applied to w Halts, and H.Qn if it
>>>>>>>>>>>>>>> doesn't
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> AGREED?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No that is wrong. embedded_H is being asked:
>>>>>>>>>>>>>> Can the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ possibly transition
>>>>>>>>>>>>>> to ⟨Ĥ⟩.qn ?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you say 'No', then you aren't doing the halting problem,
>>>>>>>>>>>>> as the
>>>>>>>>>>>>> requirement I stated is EXACTLY the requirement of the
>>>>>>>>>>>>> Halting Problem.
>>>>>>>>>>>> The halting problem is vague on the definition of halting,
>>>>>>>>>>>> it includes
>>>>>>>>>>>> that a machine has stopped running and that a machine cannot
>>>>>>>>>>>> reach its
>>>>>>>>>>>> final state. My definition only includes the latter.
>>>>>>>>>>>
>>>>>>>>>>> Sounds like a NDTM.
>>>>>>>>>> https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine
>>>>>>>>>>
>>>>>>>>>> It is not a NDTM, a Turing Machine only actually halts when it
>>>>>>>>>> reaches
>>>>>>>>>> its own final state. People not very familiar with this
>>>>>>>>>> material may get
>>>>>>>>>> confused and believe that a TM halts when its stops running
>>>>>>>>>> because its
>>>>>>>>>> simulation has been aborted. This key distinction is not
>>>>>>>>>> typically
>>>>>>>>>> specified in most halting problem proofs.
>>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>>> it enters
>>>>>>>>>> a final state. (Linz:1990:234)
>>>>>>>>>
>>>>>>>>> Where did Linz mention 'simulation' and 'abort'?
>>>>>>>> I have shown how my system directly applies to the actual halting
>>>>>>>> problem and it can be understood as correct by anyone that
>>>>>>>> understands
>>>>>>>> the halting problem at a much deeper level than rote memorization.
>>>>>>>>
>>>>>>>> The following simplifies the syntax for the definition of the Linz
>>>>>>>> Turing machine Ĥ, it is now a single machine with a single start
>>>>>>>> state.
>>>>>>>> A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>> Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly
>>>>>>>> transition to
>>>>>>>> ⟨Ĥ⟩.qn ? (No means that ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt).
>>>>>>>>> You are defining POOP [Richard Damon]
>>>>>>>>> André had recommended many online sites for you to learn or
>>>>>>>>> test, I forget which posts it is.
>>>>>>>>> But I think C program is more simpler.
>>>>>>>>>
>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>> simulation (V3)
>>>>>>>>>>
>>>>>>>>>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>>>>>>>>>
>>>>>>>>>> --
>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>
>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> --
>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>
>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>> Genius hits a target no one else can see.
>>>>>>>> Arthur Schopenhauer
>>>>>>>
>>>>>>> André had recommended many online sites for you to learn or test,
>>>>>>> I forget which posts it is.
>>>>>>> Type it into a TM simulator and prove your claim, your words are
>>>>>>> meaningless.
>>>>>>
>>>>>> I have already proved that I know one key fact about halt deciders
>>>>>> that no one else here seems to know.
>>>>>>
>>>>>> No one here understands that because a halt decider is a decider
>>>>>> that it must compute the mapping from its inputs to an accept of
>>>>>> reject state on the basis of the actual behavior specified by
>>>>>> these inputs.
>>>>>
>>>>>
>>>>> And the ACTUAL BEHAVIOR of the input <H^> <H^> is EXACTLY the
>>>>> behavior of H^ applied to <H^> which does Halt if H goes to H.Qn.
>>>>
>>>>
>>>> Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition
>>>> to ⟨Ĥ⟩.qn ?
>>>
>>> Doesn't matter if embedded_H is not a ACTUAL UTM.
>>>
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>
>> As soon as embedded_H correctly recognizes this as an infinite
>> behavior pattern:
>>
>> Then these steps would keep repeating:
>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>> ⟨Ĥ5⟩...
>>
>> Then embedded_H can correctly abort the simulation of its input and
>> correctly transition to Ĥ.qn.
>>
>> The above words can be verified as completely true entirely on the
>> basis of their meaning.
>>
>
>
> Nope, proven otherwise.
>

On 2/1/2022 8:08 PM, André G. Isaak wrote:
> On 2022-02-01 18:33, olcott wrote:
>> On 2/1/2022 6:58 PM, André G. Isaak wrote:
>>> On 2022-01-30 19:05, olcott wrote:
>>>> On 1/30/2022 7:45 PM, Richard Damon wrote:
>>>>> On 1/30/22 7:21 PM, olcott wrote:
>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> These statements need the conditions, that H^ goes to H^.Qy/H^.Qn
>>>>> iff H goes to that corresponding state.
>>>>>
>>>>
>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input to embedded_H in the
>>>> same way that (5,3) is syntactically specified as an input to Sum(5,3)
>>>>
>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an input to embedded_H in
>>>> the same way that (1,2) is NOT syntactically specified as an input
>>>> to Sum(5,3)
>>>
>>> I promised myself I wouldn't involve myself in your nonsense any
>>> further, but here you've made such a terribly inaccurate analogy that
>>> I thought I had to comment.
>>>
>>> The inputs to a function such as SUM(X, Y) are two REPRESENTATIONS of
>>> integers. If SUM were a Turing Machine, these would be two strings in
>>> the alphabet of the TM. if this were a C function, X and X would be
>>> strings of bits which form the twos complement representation of some
>>> integer. In neither case would the inputs be actual, mathematical
>>> integers. C might use the term 'integer' as one of its built in
>>> types, but C integers are NOT elements of ℤ. They are REPRESENTATIONS
>>> of the supported subset of ℤ.
>>>
>>> So ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to embedded_H in the same sense that ⟨5⟩ ⟨3⟩
>>> are the inputs to SUM.
>>>
>>> Ĥ ⟨Ĥ⟩ is not the input to embedded_H in the same sense that the
>>> actual mathematical integers 3 and 5 are not inputs to SUM.
>>>
>>
>> We are on the same page so far. (acknowledging when there is agreement
>> is an essential part of an honest dialogue).
>>
>>> If your going to make analogies, at least make ones that are accurate.
>>>
>>> SUM takes REPRESENTATIONS of integers as its inputs, but it answers
>>> about the ACTUAL integers described by those representations. To talk
>>> about the sum of two representations is meaningless. Only actual
>>> integers have sums.
>>>
>>> In exactly the same way, embedded_H takes a REPRESENTATION of some TM
>>> ⟨Ĥ⟩ as part of its input but it answers about the ACTUAL TM described
>>> by that input, Ĥ.
>>> To talk about whether a representation of a TM halts is meaningless
>>> since only actual TMs, not representations of TMs, can halt. The
>>> conditions which Richard indicates above (following Linz) are
>>> therefore the correct ones.
>>>
>>> In a previous post which I can't be botherered to find, you claimed
>>> that when the input to embedded_H is ⟨Ĥ⟩ ⟨Ĥ⟩ that embedded_H can only
>>> be expected to answer about its actual inputs and not its 'enclosing
>>> TM'.
>>>
>>> Yes, it must answer about its input, but if its input is ⟨Ĥ⟩ ⟨Ĥ⟩,
>>> then BY THE DEFINITION OF A HALT DECIDER is must determine whether Ĥ
>>> applied to ⟨Ĥ⟩ halts.
>>
>> No you are flat out wrong about this. You are wrong because of your
>> ignorance of how deciders work. Deciders compute the mapping from
>> their finite string inputs to an accept or reject state on the basis
>> of the actual properties of these actual inputs.
>
> I am perfectly aware of how deciders work and an actual property of ⟨Ĥ⟩
> is that it represents the Turing Machine Ĥ. And a halt decider is
> required to accept ⟨Ĥ⟩ ⟨Ĥ⟩ if and only if Ĥ ⟨Ĥ⟩ halts.
>
> In much the same way a TM which performs SUMS might take two input
> strings ⟨x⟩ and ⟨y⟩ and output some third string ⟨z⟩, but specification
> of such a machine would be that it maps ⟨x⟩ ⟨y⟩ to ⟨z⟩ such that x + y =
> z. There are ⟨brackets⟩ around the inputs, but not around the entities
> in the specification.
>
> It *IS* mapping from its inputs to its output, but the mapping is based
> on an operation over the entities which the inputs and outputs
> represent. That's how *all* Turing Machines work.
>

We still seem to agree. (points of mutual agreement are required for
honest dialogues).

>> Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition to
>> ⟨Ĥ⟩.qn ?
>
> ⟨Ĥ⟩ applied to ⟨Ĥ⟩ is completely meaningless.

Sure and so is the "I am going to go to the" part of
"I am going to go to the store to buy some ice cream."

When you don't cut off what I said in the middle of the sentence then it
makes much more sense.

Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition to
⟨Ĥ⟩.qn ?

> You apply TMs to inputs.
> You can't apply  a string to a string any more than you can add the
> strings "2" and "3". You can add the integers they represent, but not
> the strings themselves.
>

I said that ⟨Ĥ⟩ applied to ⟨Ĥ⟩ is being simulated by embedded_H. That
you cut me off in the middle of the sentence to form you rebuttal seems
ridiculously dishonest. It is like you don't even care that everyone
reading this will know that you are being deliberately deceptive.

It is the case that when ⟨Ĥ⟩ applied to ⟨Ĥ⟩ is correctly simulated by
embedded_H and cannot possibly reach ⟨Ĥ⟩.qn that embedded_H is correct
to report that its input does not halt.

There is no dodgy double talk way around this.

--
Copyright 2021 Pete Olcott

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

On 2/1/2022 8:21 PM, Richard Damon wrote:
> On 2/1/22 9:14 PM, olcott wrote:
>> On 2/1/2022 7:55 PM, Richard Damon wrote:
>>> On 2/1/22 8:47 PM, olcott wrote:
>>>> On 2/1/2022 7:40 PM, Richard Damon wrote:
>>>>>
>>>>> On 2/1/22 8:03 PM, olcott wrote:
>>>>>> On 2/1/2022 6:25 PM, Richard Damon wrote:
>>>>>>> On 2/1/22 5:18 PM, olcott wrote:
>>>>>>>> On 2/1/2022 4:12 PM, wij wrote:
>>>>>>>>> On Wednesday, 2 February 2022 at 05:36:39 UTC+8, olcott wrote:
>>>>>>>>>> On 2/1/2022 3:23 PM, wij wrote:
>>>>>>>>>>> On Wednesday, 2 February 2022 at 02:37:17 UTC+8, olcott wrote:
>>>>>>>>>>>> On 2/1/2022 10:33 AM, wij wrote:
>>>>>>>>>>>>> On Tuesday, 1 February 2022 at 23:22:32 UTC+8, olcott wrote:
>>>>>>>>>>>>>> On 1/31/2022 11:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 1/31/22 11:42 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/31/2022 10:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 1/31/22 11:24 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/31/2022 10:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/31/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/31/2022 6:41 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/31/22 3:24 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/31/2022 2:10 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/31/2022 8:06 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/30/2022 8:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/30/22 9:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> These statements need the conditions, that H^
>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to
>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qy/H^.Qn iff H goes to that corresponding
>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is syntactically specified as an input
>>>>>>>>>>>>>>>>>>>>>>>>>> to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>> in the same way that (5,3) is syntactically
>>>>>>>>>>>>>>>>>>>>>>>>>> specified as an
>>>>>>>>>>>>>>>>>>>>>>>>>> input to Sum(5,3)
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Right, and the
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is NOT syntactically specified as an
>>>>>>>>>>>>>>>>>>>>>>>>>> input to
>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H in the same way that (1,2) is NOT
>>>>>>>>>>>>>>>>>>>>>>>>>> syntactically
>>>>>>>>>>>>>>>>>>>>>>>>>> specified as an input to Sum(5,3)
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Right, but perhaps you don't understand that
>>>>>>>>>>>>>>>>>>>>>>>>> from you above
>>>>>>>>>>>>>>>>>>>>>>>>> statement the right answer is based on if
>>>>>>>>>>>>>>>>>>>>>>>>> UTM(<H^>,<H^>)
>>>>>>>>>>>>>>>>>>>>>>>>> Halts which by the definition of a UTM means if
>>>>>>>>>>>>>>>>>>>>>>>>> H^ applied to
>>>>>>>>>>>>>>>>>>>>>>>>> <H^> Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The biggest reason for your huge mistakes is
>>>>>>>>>>>>>>>>>>>>>>>> that you cannot
>>>>>>>>>>>>>>>>>>>>>>>> stay sharply focused on a single point. It is as
>>>>>>>>>>>>>>>>>>>>>>>> if you either
>>>>>>>>>>>>>>>>>>>>>>>> have attention deficit disorder ADD or are
>>>>>>>>>>>>>>>>>>>>>>>> addicted to
>>>>>>>>>>>>>>>>>>>>>>>> methamphetamine.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The single point is that ⟨Ĥ⟩ ⟨Ĥ⟩ is the input to
>>>>>>>>>>>>>>>>>>>>>>>> embedded_H and
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ ⟨Ĥ⟩ is the NOT the input to embedded_H.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> After we have mutual agreement on this point we
>>>>>>>>>>>>>>>>>>>>>>>> will move on
>>>>>>>>>>>>>>>>>>>>>>>> to the points that logically follow from this one.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Holy shit try to post something that makes sense.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Richard does not accept that the input to the copy
>>>>>>>>>>>>>>>>>>>>>> of Linz H
>>>>>>>>>>>>>>>>>>>>>> embedded at Ĥ.qx is ⟨Ĥ⟩ ⟨Ĥ⟩. He keeps insisting
>>>>>>>>>>>>>>>>>>>>>> that it is Ĥ ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, but apparently you can't understand actual
>>>>>>>>>>>>>>>>>>>>> English words.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The INPUT to H is <H^> <H^> but the CORRECT ANSWER
>>>>>>>>>>>>>>>>>>>>> that H must
>>>>>>>>>>>>>>>>>>>>> give is based on the behavior of H^ applied to <H^>
>>>>>>>>>>>>>>>>>>>>> BECAUSE OF
>>>>>>>>>>>>>>>>>>>>> THE DEFINITION of H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> In other words Sum(3,5) must return the value of
>>>>>>>>>>>>>>>>>>>> Sum(7,8)?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Don't know how you get that from what I said.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Any moron knows that a function is only accountable
>>>>>>>>>>>>>>>>>>>> for its actual
>>>>>>>>>>>>>>>>>>>> inputs.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And the actual input to H is <H^> <H^> which MEANS by
>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>> DEFINITION of the Halting Problem that H is being
>>>>>>>>>>>>>>>>>>> asked to decide
>>>>>>>>>>>>>>>>>>> on the Halting Status of H^ applied to <H^>
>>>>>>>>>>>>>>>>>> No that is not it. That is like saying "by definition"
>>>>>>>>>>>>>>>>>> Sum(3,5) is
>>>>>>>>>>>>>>>>>> being asked about Sum(7,8).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Again your RED HERRING.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H is being asked EXACTLY what it being asked
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H wM w -> H.Qy if M applied to w Halts, and H.Qn if it
>>>>>>>>>>>>>>>>> doesn't
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> AGREED?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No that is wrong. embedded_H is being asked:
>>>>>>>>>>>>>>>> Can the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ possibly transition
>>>>>>>>>>>>>>>> to ⟨Ĥ⟩.qn ?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If you say 'No', then you aren't doing the halting
>>>>>>>>>>>>>>> problem, as the
>>>>>>>>>>>>>>> requirement I stated is EXACTLY the requirement of the
>>>>>>>>>>>>>>> Halting Problem.
>>>>>>>>>>>>>> The halting problem is vague on the definition of halting,
>>>>>>>>>>>>>> it includes
>>>>>>>>>>>>>> that a machine has stopped running and that a machine
>>>>>>>>>>>>>> cannot reach its
>>>>>>>>>>>>>> final state. My definition only includes the latter.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Sounds like a NDTM.
>>>>>>>>>>>> https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine
>>>>>>>>>>>>
>>>>>>>>>>>> It is not a NDTM, a Turing Machine only actually halts when
>>>>>>>>>>>> it reaches
>>>>>>>>>>>> its own final state. People not very familiar with this
>>>>>>>>>>>> material may get
>>>>>>>>>>>> confused and believe that a TM halts when its stops running
>>>>>>>>>>>> because its
>>>>>>>>>>>> simulation has been aborted. This key distinction is not
>>>>>>>>>>>> typically
>>>>>>>>>>>> specified in most halting problem proofs.
>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>> whenever it enters
>>>>>>>>>>>> a final state. (Linz:1990:234)
>>>>>>>>>>>
>>>>>>>>>>> Where did Linz mention 'simulation' and 'abort'?
>>>>>>>>>> I have shown how my system directly applies to the actual halting
>>>>>>>>>> problem and it can be understood as correct by anyone that
>>>>>>>>>> understands
>>>>>>>>>> the halting problem at a much deeper level than rote
>>>>>>>>>> memorization.
>>>>>>>>>>
>>>>>>>>>> The following simplifies the syntax for the definition of the
>>>>>>>>>> Linz
>>>>>>>>>> Turing machine Ĥ, it is now a single machine with a single
>>>>>>>>>> start state.
>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>> Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly
>>>>>>>>>> transition to
>>>>>>>>>> ⟨Ĥ⟩.qn ? (No means that ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt).
>>>>>>>>>>> You are defining POOP [Richard Damon]
>>>>>>>>>>> André had recommended many online sites for you to learn or
>>>>>>>>>>> test, I forget which posts it is.
>>>>>>>>>>> But I think C program is more simpler.
>>>>>>>>>>>
>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>> simulation (V3)
>>>>>>>>>>>>
>>>>>>>>>>>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>>>>>>>>>>>
>>>>>>>>>>>> --
>>>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>>>
>>>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> --
>>>>>>>>>> Copyright 2021 Pete Olcott
>>>>>>>>>>
>>>>>>>>>> Talent hits a target no one else can hit;
>>>>>>>>>> Genius hits a target no one else can see.
>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>
>>>>>>>>> André had recommended many online sites for you to learn or
>>>>>>>>> test, I forget which posts it is.
>>>>>>>>> Type it into a TM simulator and prove your claim, your words
>>>>>>>>> are meaningless.
>>>>>>>>
>>>>>>>> I have already proved that I know one key fact about halt
>>>>>>>> deciders that no one else here seems to know.
>>>>>>>>
>>>>>>>> No one here understands that because a halt decider is a decider
>>>>>>>> that it must compute the mapping from its inputs to an accept of
>>>>>>>> reject state on the basis of the actual behavior specified by
>>>>>>>> these inputs.
>>>>>>>
>>>>>>>
>>>>>>> And the ACTUAL BEHAVIOR of the input <H^> <H^> is EXACTLY the
>>>>>>> behavior of H^ applied to <H^> which does Halt if H goes to H.Qn.
>>>>>>
>>>>>>
>>>>>> Can ⟨Ĥ⟩ applied to ⟨Ĥ⟩ simulated by embedded_H possibly transition
>>>>>> to ⟨Ĥ⟩.qn ?
>>>>>
>>>>> Doesn't matter if embedded_H is not a ACTUAL UTM.
>>>>>
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>
>>>> As soon as embedded_H correctly recognizes this as an infinite
>>>> behavior pattern:
>>>>
>>>> Then these steps would keep repeating:
>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>>>> ⟨Ĥ5⟩...
>>>>
>>>> Then embedded_H can correctly abort the simulation of its input and
>>>> correctly transition to Ĥ.qn.
>>>>
>>>> The above words can be verified as completely true entirely on the
>>>> basis of their meaning.
>>>>
>>>
>>>
>>> Nope, proven otherwise.
>>>
>>
>> What I said above is true by logical necessity and you simply aren't
>> bright enough to understand this.
>>
>
> Then you can provide a step by step proof of it?
>
>> If X then Y and if Y then Z and X then Z. There is no way around this.
>
> And what are your X, Y and Z?
>
>
>>
>> If embedded_H correctly recognizes that its input specifies non
>> halting behavior then it is necessarily correct for embedded_H to
>> report this
>> non halting behavior.
>
> *IF* it correct recognizes. Since there is no pattern in H's simulation
> of <H^> <H^> THAT IS a proof of non-halting
You must be a liar.