On 9/28/2022 9:36 PM, Richard Damon wrote:
> On 9/28/22 10:32 PM, olcott wrote:
>> On 9/28/2022 9:25 PM, Richard Damon wrote:
>>> On 9/28/22 10:13 PM, olcott wrote:
>>>> 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.
>>>
>>> No, I didn't/
>>>
>>>>
>>>> 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.
>>>>
>>>
>>> So, the single step being simulated correctly does NOT mean that the
>>> input was simulated correct.
>>>
>> Exactly what a despicable lying bastard would say.
>> That one step of an input is simulated correctly DOES MEAN
>> That one step of an input is simulated correctly.
>>
>>
>
> But doesn't mean that the INPUT has been simulated correctly.

Maybe Electrical Engineers are clueless about tautologies?

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer