On 9/28/2022 8:24 PM, Richard Damon wrote:
> On 9/28/22 9:05 PM, olcott wrote:
>> On 9/28/2022 7:57 PM, Richard Damon wrote:
>>> On 9/28/22 8:26 PM, olcott wrote:
>>>> On 9/28/2022 7:19 PM, Richard Damon wrote:
>>>>> On 9/28/22 7:56 PM, olcott wrote:
>>>>>> 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.
>>>>>>
>>>>>
>>>>> Infinite steps, or more steps than it takes to reach the final
>>>>> state, yes.
>>>>>
>>>> On 9/28/2022 6:56 PM, olcott wrote:
>>>>  > *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.
>>>>  >
>>>>
>>>> *The problem is that you are a despicable lying bastard*
>>>> Trying to pretend that you didn't see
>>>>
>>>> 1 to ∞ simulated steps
>>>> 1 to ∞ simulated steps
>>>> 1 to ∞ simulated steps
>>>> 1 to ∞ simulated steps
>>>>
>>>
>>> So ARE you claiming that all the Px are the same input, and thus the
>>> behavior of Px doesn't depend on the Hx it calls?
>>>
>> None of the Px elements of the infinite set of Hx/Px pairs reaches its
>> final state and halts when 1 to ∞ steps of Px are simulated (or
>> directly executed) by some Hx.
>>
>> This is enough for anyone with sufficient technical competence that is
>> not a despicable lying bastard to acknowledge that Px is non-halting.
>>
>>
>
> No, it isn't. An infinite number of incomplete answers does not add up
> to a correct answer.

Because you are a despicable lying bastard you change the subject to a
different point before any point is ever made and validated.

The only point being made here is that a correct simulation is not
required to be a complete simulation. If a single step is correctly
simulated then this single step is simulated correctly.

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