On 9/28/2022 6:37 PM, Richard Damon wrote:
> 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?

If you weren't a despicable lying bastard you would already acknowledge
that 1 to ∞ simulated steps of a machine description is necessarily
computationally equivalent to a corresponding 1 to ∞ steps of direct
execution.

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