On 1/3/22 4:04 PM, olcott wrote:
> On 1/3/2022 2:54 PM, Richard Damon wrote:
>> On 1/3/22 3:30 PM, olcott wrote:
>>> On 1/3/2022 2:20 PM, Richard Damon wrote:
>>>> On 1/3/22 2:59 PM, olcott wrote:
>>>>> On 1/3/2022 1:48 PM, Richard Damon wrote:
>>>>>> On 1/3/22 2:32 PM, olcott wrote:
>>>>>>> On 1/3/2022 12:59 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/3/22 1:26 PM, olcott wrote:
>>>>>>>>> On 1/3/2022 12:18 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 1/3/22 12:37 PM, olcott wrote:
>>>>>>>>>>> On 1/3/2022 11:10 AM, Richard Damon wrote:
>>>>>>>>>>>> On 1/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>>> On 1/3/2022 10:43 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/3/22 11:34 AM, olcott wrote:
>>>>>>>>>>>>>>> On 1/3/2022 9:28 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 1/3/22 10:24 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/3/2022 9:18 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 1/3/22 9:25 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> Revised Linz H halt deciding criteria (My criteria
>>>>>>>>>>>>>>>>>>> Ben's notation)
>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>>>>>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The above means that the simulating halt decider H
>>>>>>>>>>>>>>>>>>> bases its halt status decision on the behavior of the
>>>>>>>>>>>>>>>>>>> pure UTM simulation of its input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H examines this behavior looking for infinite
>>>>>>>>>>>>>>>>>>> behavior patterns. When H detects an infinite
>>>>>>>>>>>>>>>>>>> behavior pattern it aborts the simulation of its
>>>>>>>>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This pattern does not exist as a finite pattern.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Proved, and accepted by failure to rebut.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>>>>>>>>>>>>>>>>>> Date: 2021-12-30 19:31:49 GMT
>>>>>>>>>>>>>>>>>> Subject: Re: Concise refutation of halting problem
>>>>>>>>>>>>>>>>>> proofs V42 [compute the mapping]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Infinite behavior patterns are cases where the the
>>>>>>>>>>>>>>>>>>> pure UTM simulation of the input would never reach
>>>>>>>>>>>>>>>>>>> the final state of this input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> For simplicity we will refer to the copy of Linz H at
>>>>>>>>>>>>>>>>>>> Ĥ.qx embedded_H.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would
>>>>>>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This shows that the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would
>>>>>>>>>>>>>>>>>>> never reach its final state thus conclusively proving
>>>>>>>>>>>>>>>>>>> that this input never halts.
>>>>>>>>>>>>>>>>>>> This enables embedded_H to correctly transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>>>>>> LIAR !!!
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> PROVE IT, or YOUR the LIAR.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I have shown my proof, which you have failed to give a
>>>>>>>>>>>>>>>> rebuttal that actually tries to rebut it.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> IF embedded_H doesn't abort, then H never gets to Qn as
>>>>>>>>>>>>>>>> claimed
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If embedded_H does abort and go to Qn, then H^ also goes
>>>>>>>>>>>>>>>> to Qn and Halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> embedded_H is only accountable for mapping the behavior
>>>>>>>>>>>>>>> of the pure simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to an accept
>>>>>>>>>>>>>>> / reject state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, and to correctly answer the input <H^> <H^> then
>>>>>>>>>>>>>> H/embedded_H must go to the state that matches the
>>>>>>>>>>>>>> behavior of the Computation of H^ applied to <H^>.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> WRONG:
>>>>>>>>>>>>> embedded_H must go to the state that correctly describes
>>>>>>>>>>>>> the behavior of the pure simulation of the input to
>>>>>>>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>
>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> That only happens if embedded_H never aborts its simulation
>>>>>>>>>>>> of its input.
>>>>>>>>>>>>
>>>>>>>>>>>> And if that happens, it can never then abort and go to Qn to
>>>>>>>>>>>> be 'right', as all copies of an algorithm when given the
>>>>>>>>>>>> same input behave the same.
>>>>>>>>>>>>
>>>>>>>>>>> The criteria that H uses is what the behavior would be if H
>>>>>>>>>>> never aborted the simulation of its input.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Which is gthe WRONG criteria!!!!
>>>>>>>>>>
>>>>>>>>>> THe criteria NEEDS to be what is the behavior of the machine
>>>>>>>>>> the input represents, or of a REAL UTM given that same input.
>>>>>>>>>>
>>>>>>>>>> So, THERE'S YOUR PROBLEM!
>>>>>>>>>
>>>>>>>>> The criteria of H is whether or not the pure simulation of its
>>>>>>>>> input would ever reach its final state. The pure simulation of
>>>>>>>>> the input to embedded_H would never reach its final state.
>>>>>>>>
>>>>>>>> This was just explained to you.
>>>>>>>>
>>>>>>>> IF you actually mean this, then that means that H has to be
>>>>>>>> defined as never going to H.qn, as if it does, then the pure
>>>>>>>> simulation of it input will end up stopping in H^.qn
>>>>>>>>
>>>>>>>
>>>>>>> As I keep telling you and you keep stupidly ignoring the fact
>>>>>>> that the input stops running because its simulation was aborted
>>>>>>> is no indication what-so-ever that this simulated input halts.
>>>>>>> HALTING IS ONLY REACHING A FINAL STATE.
>>>>>>>
>>>>>>
>>>>>> No, YOU are stupidly ignoring that it is only the simulation done
>>>>>> by a UTM, or the direct execution of the computation that shows
>>>>>> halting.
>>>>>>
>>>>>> The behavior of its input is UTM(<H^>,<H^>) which WILL halt and
>>>>>> reach its final state if H aborts its simulation and goes to H.qn
>>>>>>
>>>>>
>>>>> Since you know that the infinite simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>> embedded_H is not enough to ever reach the halting state of this
>>>>> input and infinity is the maximum now that you say that this input
>>>>> will reach its final state can only be a lie.
>>>>>
>>>>> Or are you so stupid that you believe an aborted simulation
>>>>> magically reaches the final state of this aborted simulated input?
>>>>>
>>>>
>>>> You Lie with Double Speak.
>>>>
>>>> Your H/embedded_H is a Schrodinger's Turing Machine, which doesn't
>>>> actually exist. Some times you say it will simulate forever, other
>>>> times you say it will abort its simulation and go to H.qn. Since it
>>>> can't do both for the same machine, it just doesn't exist. PERIDD
>>>>
>>>
>>> I NEVER SAY THAT EMBEDDED_H WILL SIMULATE FOR EVER YOU FREAKING
>>> KNUCKLEHEAD
>>>
>>> I SAY THAT THE CRITERION MEASURE FOR EMBEDDED_H TO ABORT ITS
>>> SIMULATION AND TRANSITION TO ITS REJECT STATE IS WHAT WOULD HAPPEN IF
>>> EMBEDDED_H SIMULATED ITS INPUT FOREVER.
>>>
>>>
>>
>> Since H/embedded_H WON'T simulate forever (by your criteria) you can't
>> just imagine that it does, as that is a false premise.
>>
>> That would be like saying that since if your cat was a dog, it could
>> bark, that means that cats can bark.
>>
>> This applies since you are claiming GLOBAL change of the definition of
>> H, to the point of changing the representation of H^ to include that
>> 'hypothetical H'.
>>
>> You COULD say, "if I changed THIS COPY of H/embedded_H to not abort",
>> but kept all the copies in the input as there original aborting
>> version. We can do this, because that is just asking what would a UTM
>> do on the same input, by replacing THIS copy with a UTM to check the
>> answer.
>>
>> Summary:
>>
>> What would happen if H never aborted it simulation, NOT VALID, as H
>> doesn't behave that way so this is a contradiction, so do this you
>> need to change the input.
>>
>
> void Infinite_Loop(int N)
> {
>   HERE: goto HERE;
> }
>  _Infinite_Loop()
> [00000cb5](01)  55              push ebp
> [00000cb6](02)  8bec            mov ebp,esp
> [00000cb8](02)  ebfe            jmp 00000cb8
> [00000cba](01)  5d              pop ebp
> [00000cbb](01)  c3              ret
> Size in bytes:(0007) [00000cbb]
>
> H can see what the behavior of the above would be if H never aborted the
> simulation of this input.
>
> That you say that H can not do his has to be dishonest because you are
> not that stupid.
>

RED HERRING.

H can correctly determine SOME machines, but NOT H^, so it FAILS.

YOU are the dishonest one for bringing up this dishonest dodge.

You have done this exact thing before, to this same response.

This is proof that you have no answer to the actual question.

You continued failure to even attempt to answer the actual flaws pointed
out is just the proof that is needed to show that you have nothing to
support your claims.

Just be aware that it is somewhat likely that if/when you do get to
submitting your paper, if you ever dare to, some review is apt to do a
search that will bring up this discussion, and if you can't answer ALL
the objections that people have brought up, you are apt to be asked
about them, and if you can't answer us, why do you think you will be
able to answer then.

Also, you will NOT have the opertunity to back off and try again with a
different tack, as that will just be the proof they need that you don't
really know what you are talking about.

So, either work on coming up with actual answers to the objections, i.e.
in this case, how can H figure out the actual behavior of H^ when that
depends on the answer that H gives to H^, and get the right answer.

I have previous given you hints on a technique that does better than
your H, but it does necessarily admit that it can't give the right
answer to H^, since there is none.

FAIL.