On 5/20/23 3:29 PM, olcott wrote:
> On 5/20/2023 1:54 PM, Richard Damon wrote:
>> On 5/20/23 2:46 PM, olcott wrote:
>>> On 5/20/2023 1:15 PM, Richard Damon wrote:
>>>> On 5/20/23 1:09 PM, olcott wrote:
>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote:
>>>>>> On 5/20/23 11:24 AM, olcott wrote:
>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote:
>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:
>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote:
>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote:
>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:
>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Wrong Question!
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In other words the question is over you head.
>>>>>>>>>>>>>>>>> It took me many years to recognize this same dodge by Ben.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, it is the WRONG question once you try to apply the
>>>>>>>>>>>>>>>> answer to the Halting Problem, which you do.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So the software engineering really is over your head?
>>>>>>>>>>>>>>> I see, so like Ben you have never actually written any code.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But you aren't talking about Software Engineering unless
>>>>>>>>>>>>>> you are lying about this applying to the Halting Problem
>>>>>>>>>>>>>> described by Linz, since that is the Halting Problem of
>>>>>>>>>>>>>> Computability Theory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Of course, the likely explanation is that you are just
>>>>>>>>>>>>>> ignorant of what you are talking about, so you don't
>>>>>>>>>>>>>> understand the diference.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ben kept masking his coding incompetence this way.
>>>>>>>>>>>>>>> It never occurred to me that you have never written any
>>>>>>>>>>>>>>> code.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I have possibly written more WORKING code than you have.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I don't believe you. Your inability to answer an straight
>>>>>>>>>>>>> forward
>>>>>>>>>>>>> software engineering question seems to prove otherwise.
>>>>>>>>>>>>
>>>>>>>>>>>> What software engineering question?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>> Can D simulated by H terminate normally?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The answer to that question is NO,
>>>>>>>>>
>>>>>>>>> Finally you admit an easily verified fact.
>>>>>>>>>
>>>>>>>>>> but that is because H doesn't, and can never do an accurarte
>>>>>>>>>> simulation per the definition of a UTM.
>>>>>>>>>>
>>>>>>>>> If the simulation by a UTM would be wrong then you would have
>>>>>>>>> to be able
>>>>>>>>> to point out the mistake in the simulation of D by H,
>>>>>>>>
>>>>>>>> No, the simulation by a ACTUAL UTM will reach a final state.
>>>>>>>>
>>>>>>> I don't know why you say this when you already know that ⟨Ĥ⟩
>>>>>>> correctly
>>>>>>> simulated by embedded_H cannot possibly terminate normally.
>>>>>>
>>>>>>
>>>>>> Because embedded_H doesn't actually "Correctly Simulate" its input
>>>>>> by the definintion aquired by your mentioning of a UTM.
>>>>>>
>>>>> You have already agreed that it does simulate the first N steps
>>>>> correctly. It is just as obvious that the behavior pattern of N
>>>>> steps of
>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate
>>>>> normally
>>>>> even if the value of N is ∞.
>>>>>
>>>>
>>>> But N steps in not ALL steps as required by the actual definition of
>>>> a UTM.
>>>>
>>>
>>> Actually N steps is the exact definition of a UTM for those N steps.
>>> Just like with the H/D example after N steps we can see that neither
>>> D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by embedded_H
>>> can possibly terminate normally.
>>>
>>
>> Nope, UTMs have no concept of only doing a partial simulation.
>>
> When a simulating halt decider correctly simulates N steps of its input
> it derives the exact same N steps that a pure UTM would derive because
> it is itself a UTM with extra features.
>

Just like a racing car is a street legal care with extra features that
makes it no longer street legal.

The fact that H aborts its simulation part way means it is no longer a
UTM because it fails to meet the requriements, thus the fact that its
simulation doesn't meet a final state doesn't mean the program is
non-halting.

That is like saying if you run a program for just N steps, and then stop
it and it hasn't meet a final state, that shows that the program, even
if allowed to run to completion, will never halt. That is incorrect, it
just shows that the step where it reaches its final state, if it does,
is at a step greater than N.

> (a) Watching the behavior doesn't change it.
> (b) Matching non-halting behavior patterns doesn't change it
> (c) Even aborting the simulation after N steps doesn't change the first
> N steps.

but does change the over all behavior of the machine doing it.

Since embedded_H does its analysis of its simulation presuming that the
copy of embedded_H it sees is actually a UTM, since embeded_H does abort
its simulation, and thus isn't one, means that embedded_H used a false
premise in its analysis,

>
> Because of all this we can know that the first N steps of input D
> simulated by simulating halt decider H are the actual behavior that D
> presents to H for these same N steps.

Right, but that doesn't give actual behavior of a CORRECT (per
definition of a UTM) simulation.

If you are saying that a simulation of N steps done correctly is your
definition of a "Correct Simulation" you can't use the properties of a
UTM, since your simulation doesn't meet the requirements to be a UTM.

>
> When we can see after N steps of correct simulation that D correctly
> simulated by H cannot possibly terminate normally (as you already
> admitted) we can equally see after N steps of correct simulation that
> ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate
> normally.

But, since H isn't actually a UTM, that doesn't matter.

We CAN see that a UTM simulation of the input will halt becuase it will
see the first copy of embedded_H simulated will eventually abort its
simulation (making it not a UTM) and returning the INCORRECT answer of
non-halting to the copy of D that called it, and that copy halting, we
see that the CORRECT simulation of the input Halts.

>
> You really look quite foolish denying this.
> It is like you agreed that 2 + 3 = 5
> yet vehemently disagree that 3 + 2 = 5.
>

Nope, You are just lying. I never said that.

You are the one claiming that H does a correct simulation by the
requirements of a UTM, when it doesn't, so you "proof" is based on LIES,
and unsound logic.