On 9/28/22 7:31 PM, olcott wrote:
> On 9/28/2022 6:08 PM, Richard Damon wrote:
>> On 9/28/22 11:44 AM, olcott wrote:
>>> On 9/28/2022 6:28 AM, Richard Damon wrote:
>>>> On 9/27/22 11:04 PM, olcott wrote:
>>>>> On 9/27/2022 9:46 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/27/22 10:30 PM, olcott wrote:
>>>>>>> On 9/27/2022 9:24 PM, Richard Damon wrote:
>>>>>>>> On 9/27/22 10:02 PM, olcott wrote:
>>>>>>>>> On 9/27/2022 8:50 PM, Richard Damon wrote:
>>>>>>>>>> On 9/27/22 9:33 PM, olcott wrote:
>>>>>>>>>>> On 9/27/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/27/22 9:00 PM, olcott wrote:
>>>>>>>>>>>>> On 9/27/2022 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/27/22 11:19 AM, olcott wrote:
>>>>>>>>>>>>>>> On 9/27/2022 6:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/26/22 11:49 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/26/2022 10:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/26/22 11:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 9:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 10:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 9:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 8:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 7:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 6:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/22 2:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:48 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:42:02 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 12:19 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Mon, 26 Sep 2022 12:15:15 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <none-ya@beez-waxes.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/26/2022 11:05 AM, Kaz Kylheku
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-09-26, Lew Pitcher
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <lew.pitcher@digitalfreehold.ca>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sorry, guy, but comp.lang.c is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not the place to discuss this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sort of thing. Why don't you try
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> comp.theory ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because Olcott postings will push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you out of visibility?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If people would give me a fair and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> honest review I could quit
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posting. You gave up on me before I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> could point out the error with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diagonalization argument that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you relied on for your rebuttal:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The diagonalization argument merely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that no value returned
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to P from its call to H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correct. This argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally ignores that the return
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> value from H is unreachable by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated P caller when H is based
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This makes it impossible for P to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do the opposite of whatever H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decides.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Complete halt deciding system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (Visual Studio Project)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) x86utm operating system
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) complete x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Several halt deciders and their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs contained within Halt7.c
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep making the same mistake
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> again and again. H IS NOT SUPPOSED
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO BE RECURSIVE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not recursive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your H is recursive because P isn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive and yet you have to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your infinite recursion: the recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is caused by your H and not by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P.  Nowhere in any halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof does it state that the call to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H by P is recursive in nature BECAUSE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H IS NOT SUPPOSED TO EXECUTE P, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS SUPPOSED TO *ANALYSE* P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nowhere in any HP proof (besides mine)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is the idea of a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider (SHD) ever thought all the way
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the proof doesn't care at all
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> how the decider got the answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies that the correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a machine description provides the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of the underlying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine whenever any simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must abort its simulation to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prevent infinite simulation it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to report that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which means it CAN'T be a UTM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and thus *ITS* simulation does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> define the "behavior of the input".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the correct simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input is its actual behavior. That H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly predicts that its correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation never stops running unless
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted conclusively proves that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input would never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its own final state in 1 to ∞ steps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of correct simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But the behavior the halting problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> asking for is the behavior of the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only within the context that no one ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bothered to think the application of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider all the way through.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, the DEFINITION of a Halt Decider is to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> decide on the behavior of the Actual Machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> That definition is made obsolete by a
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the definition IS the definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You don't get to change it.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I created a new concept that makes earlier
>>>>>>>>>>>>>>>>>>>>>>>>> ideas about this obsolete:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Because the definition of a UTM specifies that
>>>>>>>>>>>>>>>>>>>>>>>>> the correct simulation of a machine description
>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior of the underlying
>>>>>>>>>>>>>>>>>>>>>>>>> machine whenever any simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>> must abort its simulation to prevent infinite
>>>>>>>>>>>>>>>>>>>>>>>>> simulation it is necessarily correct to report
>>>>>>>>>>>>>>>>>>>>>>>>> that this input does not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Because the above is verified as correct on the
>>>>>>>>>>>>>>>>>>>>>>>>> basis of the meaning of its words it is
>>>>>>>>>>>>>>>>>>>>>>>>> irrefutable.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Right, but H isn't a UTM, so its simulation
>>>>>>>>>>>>>>>>>>>>>>>> doesn't matter.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Unless you can specify that material difference
>>>>>>>>>>>>>>>>>>>>>>> between the two, that would seem to prove that
>>>>>>>>>>>>>>>>>>>>>>> you are technically incompetent.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H doesn't correctly repoduce the behavior of a
>>>>>>>>>>>>>>>>>>>>>> non-halting input.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Thus, it isn't a UTM.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩      // subscripts
>>>>>>>>>>>>>>>>>>>>> indicate unique finite strings
>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H simulates
>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Then these steps would keep repeating: (unless
>>>>>>>>>>>>>>>>>>>>> their simulation is aborted)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Note, you say "unless their simulation is aborted"
>>>>>>>>>>>>>>>>>>>> but your defiition of H DOES abort its simulation,
>>>>>>>>>>>>>>>>>>>> thus this doesn't occur.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates
>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates
>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2 simulates
>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This exact same behavior occurs when we replace H
>>>>>>>>>>>>>>>>>>>>> with a UTM.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But since H ISN'T a UTM, you can't assume that it is.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H is designed to predict the result of 1 to ∞
>>>>>>>>>>>>>>>>>>> correctly simulated steps, thus predict the behavior
>>>>>>>>>>>>>>>>>>> of a UTM simulation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Except it doesn't do that.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H does correctly predict the actual behavior of 1 to ∞
>>>>>>>>>>>>>>>>> simulated steps of P.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, since we have shown that if H(P,P) returns 0, then
>>>>>>>>>>>>>>>> P(P) will Halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *That is false and you know it so you are a liar for the
>>>>>>>>>>>>>>> 500th time*
>>>>>>>>>>>>>>> *You know that you are not referring to the behavior of
>>>>>>>>>>>>>>> an input to H*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, I am refering to the input to H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The input to H(P,P) represents the computation P(P), or
>>>>>>>>>>>>>> your P isn't the required "impossible Program".
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You cannot find a competent source that agrees that the
>>>>>>>>>>>>> actual behavior of the input is not provided by the correct
>>>>>>>>>>>>> simulation of this input.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Correct AND COMPLETE simulation of the input.
>>>>>>>>>>>>
>>>>>>>>>>> So like I said you have no source, you and most other are
>>>>>>>>>>> only going by learned-by-rote so when a new issue comes up
>>>>>>>>>>> your flounder. The others here not going by learned-by-rote
>>>>>>>>>>> are going by total cluelessness.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> What about the Linz definition of a Halt Decider, the one YOU
>>>>>>>>>> quote.
>>>>>>>>>
>>>>>>>>> He does not say that the correct simulation of an input does
>>>>>>>>> not provide the actual behavior of this input. You will find no
>>>>>>>>> competent person that will disagree with me on this point.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> But he DOES say that the DEFINITION of the right answer is the
>>>>>>>> behavior of the machine that input describes, so THAT is the
>>>>>>>> behavior that counts.
>>>>>>>>
>>>>>>> People that know these things more deeply than learned-by-rote
>>>>>>> will understand that my alternative definition is sound.
>>>>>>
>>>>>> No, it is WRONG, since it doesn't match.
>>>>>>
>>>>>> That is like saying Two is the right answer to the question of How
>>>>>> many cats you have, when you have one cats and one dog, because
>>>>>> dogs are really pretty much like a cat.
>>>>>>
>>>>>> FAIL.
>>>>>>
>>>>>>>
>>>>>>> We can know that it is sound by simply knowing that the correct
>>>>>>> simulation of the input does provide the actual behavior of this
>>>>>>> input. We know this on the basis of the definition of a UTM.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> The CORRECT AND COMPLETE.
>>>>>>
>>>>>> Not being complete, it CAN'T show the actual behavior.
>>>>>>
>>>>>> That is like getting off the highway at the second exit, well
>>>>>> before you get into the city, and announce that traffic is clear
>>>>>> into the city, because you didn't see any traffic.
>>>>>>
>>>>>> You are just PROVING our stupidity.
>>>>>
>>>>> Mike already corrected you on this.
>>>>> The correct simulation of 1 to ∞ steps of the input *is*
>>>>> computationally equivalent to the direct execution of 1 to ∞ steps
>>>>> of the input.
>>>>>
>>>>> How can you disagree with this besides lying?
>>>>>
>>>>>
>>>>
>>>> So, what SINGLED EXACT INPUT have you done this for?
>>>>
>>>> Remember, exact of your members of Px are DIFFERENT!
>>>>
>>>> You only "correctly simulate" a given input once, for a single
>>>> number between 1 and infinity, so you never have a valuation of 1 to
>>>> infinite steps for any input except those that are basd on an Hx
>>>> that never stops them, and thos Hx never abort.
>>>>
>>>
>>> You cannot find a competent source that agrees that the actual
>>> behavior of the input is not provided by the correct simulation of
>>> this input therefore
>>>
>>
>> Except that the problem is that "Correct Simulation" is generally
>> taken to be a Correct and Complete Simulation,
>
> *No it is not and Mike already corrected you on this*
> You stubbornly insistent on lying.

The ONLY definition of "simulation" for Turing Machines that I know of
is the UTM, and it only does a complete simulation of its input.

Care to provide a reliable source that defines a "Correct Simulation" as
to include a partial one that is applicable here?

>
>> which your H does do.
>>
>
>