On 3/17/24 8:30 PM, olcott wrote:
> On 3/17/2024 7:27 PM, immibis wrote:
>> On 18/03/24 00:27, olcott wrote:
>>> The head games of a Troll.
>>>
>>> For every possible way that H can be encoded and D(D)
>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>> never stops running.
>>>
>>
>> Wrong.
>
> So you want me to start ignoring all your of your posts?

Why, is he showing how stupid you are too?

On 3/17/2024 10:32 PM, Richard Damon wrote:
> On 3/17/24 8:14 PM, olcott wrote:
>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>> On 3/17/24 4:27 PM, olcott wrote:
>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer
>>>>>>>>>>>>>>>>>>> the question correctly.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have
>>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates
>>>>>>>>>>>>>>>>>> its input D until
>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would
>>>>>>>>>>>>>>>>>> never stop running
>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't
>>>>>>>>>>>>>>> prove what you need it to.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>
>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>
>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>
>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>
>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>
>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>
>>>>>>>> Do you fully understand the spec?
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Yes, but I think not the way you do.
>>>>>>>
>>>>>>> To me, for H to NEED to abort its simulation, that means that
>>>>>>> when giving the input to a correct simulator, that simulator will
>>>>>>> not halt.
>>>>>>>
>>>>>> Yes that is correct.
>>>>>
>>>>> You have just proven that H doesn't need abort its simulation and
>>>>> the abort decision is incorrect.
>>>>
>>>> The head games of a Troll.
>>>>
>>>> For every possible way that H can be encoded and D(D)
>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>> never stops running.
>>>>
>>>
>>> Which prove NOTHING, as D varies with H, so no D that was built with
>>> an H that aborts its simulation has had its actual halting status
>>> tested.
>>
>> *That merely changes the wording of the same truism*
>> ∀H ∈ TM ∀D ∈ TMD such that
>> H(D,D) simulates its input and
>> D calls H(D,D) and
>> H(D,D) does not abort its simulation
>> necessitates simulated D(D) never stops running.
>>
>>
>
> Third times and still not a charm.
>
> All those D still use an H that doesn't abort

On 3/17/2024 7:28 PM, immibis wrote:
> On 18/03/24 00:24, olcott wrote:
>> On 3/17/2024 12:35 PM, immibis wrote:
>>> On 17/03/24 17:47, olcott wrote:
>>>> It is an empirically verified fact that either
>>>> Sipser_H(Sipser_D, Sipser_D) aborts its simulation or neither
>>>> Sipser_H(Sipser_D, Sipser_D) nor Sipser_D(Sipser_D) ever stops
>>>> running (not counting stack overflow).
>>>
>>> Sipser_H and Sipser_D are the same code that you called H and D in
>>> x86utm, right?
>>>
>> Not quite.
>> int Sipser_D(int (*M)())
>> {
>>    if ( Sipser_H(M, M) )
>>      return 0;
>>    return 1;
>> }
>>
>> Sipser_H is the same and Sipser_H(Sipser_D, Sipser_D)
>> is isomorphic to H(D,D)
>>
>>> It is an empirically verified fact that H(D,D) aborts its simulation.
>> That is not the question.
>>
>> We are verifying that it is proven to be correct.
>> [Proof that H(D,D) meets its abort criteria --self-evident truth--]
>
> === DEFINITION OF CORRECT ===
>
> Output Q of a halt decider H(X,Y) is correct if and only if:
> 1. Q==1 and X(Y) halts, or
> 2. Q==0 and X(Y) does not halt
>
> === CONCLUSION ===
> it is incorrect
>

∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
(1) H(D,D) does not abort its simulation then simulated D(D) never stops
running.
(2) H(D,D) aborts its simulation then simulated D(D) stops running.

>>
>> For every possible way that H can be encoded and D(D)
>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>> never stops running.
>>
>>
>

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

On 3/17/24 9:00 PM, olcott wrote:
> On 3/17/2024 10:32 PM, Richard Damon wrote:
>> On 3/17/24 8:14 PM, olcott wrote:
>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer
>>>>>>>>>>>>>>>>>>>> the question correctly.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have
>>>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement
>>>>>>>>>>>>>>>>>>> of clairvoyance*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates
>>>>>>>>>>>>>>>>>>> its input D until
>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would
>>>>>>>>>>>>>>>>>>> never stop running
>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until
>>>>>>>>>>>>>>>>>>> H correctly
>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or
>>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't
>>>>>>>>>>>>>>>> prove what you need it to.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>
>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>> (b) Determine if it needs to stop simulating its input to
>>>>>>>>>>> prevent
>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>
>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>
>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>
>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>
>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>
>>>>>>>> To me, for H to NEED to abort its simulation, that means that
>>>>>>>> when giving the input to a correct simulator, that simulator
>>>>>>>> will not halt.
>>>>>>>>
>>>>>>> Yes that is correct.
>>>>>>
>>>>>> You have just proven that H doesn't need abort its simulation and
>>>>>> the abort decision is incorrect.
>>>>>
>>>>> The head games of a Troll.
>>>>>
>>>>> For every possible way that H can be encoded and D(D)
>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>> never stops running.
>>>>>
>>>>
>>>> Which prove NOTHING, as D varies with H, so no D that was built with
>>>> an H that aborts its simulation has had its actual halting status
>>>> tested.
>>>
>>> *That merely changes the wording of the same truism*
>>> ∀H ∈ TM ∀D ∈ TMD such that
>>> H(D,D) simulates its input and
>>> D calls H(D,D) and
>>> H(D,D) does not abort its simulation
>>> necessitates simulated D(D) never stops running.
>>>
>>>
>>
>> Third times and still not a charm.
>>
>> All those D still use an H that doesn't abort
>
> *You keep talking in circles, there are only two sets*
> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
> (1) H(D,D) does not abort its simulation then simulated D(D) never stops
> running.
> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>
>

On 3/17/2024 11:39 PM, Richard Damon wrote:
> On 3/17/24 9:00 PM, olcott wrote:
>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>> On 3/17/24 8:14 PM, olcott wrote:
>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer
>>>>>>>>>>>>>>>>>>>>> the question correctly.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you
>>>>>>>>>>>>>>>>>>>>> have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement
>>>>>>>>>>>>>>>>>>>> of clairvoyance*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates
>>>>>>>>>>>>>>>>>>>> its input D until
>>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would
>>>>>>>>>>>>>>>>>>>> never stop running
>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until
>>>>>>>>>>>>>>>>>>>> H correctly
>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting
>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or
>>>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't
>>>>>>>>>>>>>>>>> prove what you need it to.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>
>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input to
>>>>>>>>>>>> prevent
>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>
>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>
>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>
>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>
>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>
>>>>>>>>> To me, for H to NEED to abort its simulation, that means that
>>>>>>>>> when giving the input to a correct simulator, that simulator
>>>>>>>>> will not halt.
>>>>>>>>>
>>>>>>>> Yes that is correct.
>>>>>>>
>>>>>>> You have just proven that H doesn't need abort its simulation and
>>>>>>> the abort decision is incorrect.
>>>>>>
>>>>>> The head games of a Troll.
>>>>>>
>>>>>> For every possible way that H can be encoded and D(D)
>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>> never stops running.
>>>>>>
>>>>>
>>>>> Which prove NOTHING, as D varies with H, so no D that was built
>>>>> with an H that aborts its simulation has had its actual halting
>>>>> status tested.
>>>>
>>>> *That merely changes the wording of the same truism*
>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>> H(D,D) simulates its input and
>>>> D calls H(D,D) and
>>>> H(D,D) does not abort its simulation
>>>> necessitates simulated D(D) never stops running.
>>>>
>>>>
>>>
>>> Third times and still not a charm.
>>>
>>> All those D still use an H that doesn't abort
>>
>> *You keep talking in circles, there are only two sets*
>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>> (1) H(D,D) does not abort its simulation then simulated D(D) never
>> stops running.
>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>>
>>
>
> And your top line says NOTHING about the Ds in set (2), since nothing
> showed them not to run
>
> but your (2) admitts that D(D) will stop running, and thus the top level
> H didn't need to abort its simulation.
>

On 18/03/24 05:00, olcott wrote:
> On 3/17/2024 10:32 PM, Richard Damon wrote:
>> On 3/17/24 8:14 PM, olcott wrote:
>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer
>>>>>>>>>>>>>>>>>>>> the question correctly.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have
>>>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement
>>>>>>>>>>>>>>>>>>> of clairvoyance*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates
>>>>>>>>>>>>>>>>>>> its input D until
>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would
>>>>>>>>>>>>>>>>>>> never stop running
>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until
>>>>>>>>>>>>>>>>>>> H correctly
>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or
>>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't
>>>>>>>>>>>>>>>> prove what you need it to.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>
>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>> (b) Determine if it needs to stop simulating its input to
>>>>>>>>>>> prevent
>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>
>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>
>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>
>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>
>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>
>>>>>>>> To me, for H to NEED to abort its simulation, that means that
>>>>>>>> when giving the input to a correct simulator, that simulator
>>>>>>>> will not halt.
>>>>>>>>
>>>>>>> Yes that is correct.
>>>>>>
>>>>>> You have just proven that H doesn't need abort its simulation and
>>>>>> the abort decision is incorrect.
>>>>>
>>>>> The head games of a Troll.
>>>>>
>>>>> For every possible way that H can be encoded and D(D)
>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>> never stops running.
>>>>>
>>>>
>>>> Which prove NOTHING, as D varies with H, so no D that was built with
>>>> an H that aborts its simulation has had its actual halting status
>>>> tested.
>>>
>>> *That merely changes the wording of the same truism*
>>> ∀H ∈ TM ∀D ∈ TMD such that
>>> H(D,D) simulates its input and
>>> D calls H(D,D) and
>>> H(D,D) does not abort its simulation
>>> necessitates simulated D(D) never stops running.
>>>
>>>
>>
>> Third times and still not a charm.
>>
>> All those D still use an H that doesn't abort
>
> *You keep talking in circles, there are only two sets*
> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
> (1) H(D,D) does not abort its simulation then simulated D(D) never stops
> running.
> (2) H(D,D) aborts its simulation then simulated D(D) stops running.

On 18/03/24 04:30, olcott wrote:
> On 3/17/2024 7:27 PM, immibis wrote:
>> On 18/03/24 00:27, olcott wrote:
>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>> On 17/03/24 14:11, olcott wrote:
>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the
>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have
>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates
>>>>>>>>>>>>>>>>> its input D until
>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would never
>>>>>>>>>>>>>>>>> stop running
>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't
>>>>>>>>>>>>>> prove what you need it to.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig
>>>>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>
>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope.
>>>>>>>>>>>
>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>
>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And thus not a specific algorithm?
>>>>>>>>
>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>
>>>>>>>> That is not an algorithmic step.
>>>>>>>>
>>>>>>>> We can only verify that in retrospect.
>>>>>>>
>>>>>>> Do you fully understand the spec?
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Yes, but I think not the way you do.
>>>>>>
>>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>>> giving the input to a correct simulator, that simulator will not
>>>>>> halt.
>>>>>>
>>>>> Yes that is correct.
>>>>
>>>> You have just proven that H doesn't need abort its simulation and
>>>> the abort decision is incorrect.
>>>
>>> The head games of a Troll.
>>>
>>> For every possible way that H can be encoded and D(D)
>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>> never stops running.
>>>
>>
>> Wrong.
>
> So you want me to start ignoring all your of your posts?

On 18/03/24 05:30, olcott wrote:
> On 3/17/2024 7:28 PM, immibis wrote:
>> On 18/03/24 00:24, olcott wrote:
>>> On 3/17/2024 12:35 PM, immibis wrote:
>>>> On 17/03/24 17:47, olcott wrote:
>>>>> It is an empirically verified fact that either
>>>>> Sipser_H(Sipser_D, Sipser_D) aborts its simulation or neither
>>>>> Sipser_H(Sipser_D, Sipser_D) nor Sipser_D(Sipser_D) ever stops
>>>>> running (not counting stack overflow).
>>>>
>>>> Sipser_H and Sipser_D are the same code that you called H and D in
>>>> x86utm, right?
>>>>
>>> Not quite.
>>> int Sipser_D(int (*M)())
>>> {
>>>    if ( Sipser_H(M, M) )
>>>      return 0;
>>>    return 1;
>>> }
>>>
>>> Sipser_H is the same and Sipser_H(Sipser_D, Sipser_D)
>>> is isomorphic to H(D,D)
>>>
>>>> It is an empirically verified fact that H(D,D) aborts its simulation.
>>> That is not the question.
>>>
>>> We are verifying that it is proven to be correct.
>>> [Proof that H(D,D) meets its abort criteria --self-evident truth--]
>>
>> === DEFINITION OF CORRECT ===
>>
>> Output Q of a halt decider H(X,Y) is correct if and only if:
>> 1. Q==1 and X(Y) halts, or
>> 2. Q==0 and X(Y) does not halt
>>
>> === CONCLUSION ===
>> it is incorrect
>>
>
> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
> (1) H(D,D) does not abort its simulation then simulated D(D) never stops
> running.
> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>
>

=== DEFINITION OF CORRECT ===

Output Q of a halt decider H(X,Y) is correct if and only if:
1. Q==1 and X(Y) halts, or
2. Q==0 and X(Y) does not halt

=== OBSERVATION ===
Q is output of x86utm H(D,D)
Q==0 and D(D) halts

=== CONCLUSION ===
H is not correct

On 18/03/24 05:42, olcott wrote:
> Do you understand that each H(D,D) must either abort or fail to abort?
>

Do you understand that D(D) halts?

On 3/17/24 9:42 PM, olcott wrote:
> On 3/17/2024 11:39 PM, Richard Damon wrote:
>> On 3/17/24 9:00 PM, olcott wrote:
>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer
>>>>>>>>>>>>>>>>>>>>>> the question correctly.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you
>>>>>>>>>>>>>>>>>>>>>> have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the
>>>>>>>>>>>>>>>>>>>>> impossible requirement
>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does
>>>>>>>>>>>>>>>>>>>>> not actually see.
>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement
>>>>>>>>>>>>>>>>>>>>> of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly
>>>>>>>>>>>>>>>>>>>>> simulates its input D until
>>>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would
>>>>>>>>>>>>>>>>>>>>> never stop running
>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D
>>>>>>>>>>>>>>>>>>>>> until H correctly
>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting
>>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or
>>>>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't
>>>>>>>>>>>>>>>>>> prove what you need it to.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>
>>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input to
>>>>>>>>>>>>> prevent
>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>
>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>
>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>
>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>
>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>
>>>>>>>>>> To me, for H to NEED to abort its simulation, that means that
>>>>>>>>>> when giving the input to a correct simulator, that simulator
>>>>>>>>>> will not halt.
>>>>>>>>>>
>>>>>>>>> Yes that is correct.
>>>>>>>>
>>>>>>>> You have just proven that H doesn't need abort its simulation
>>>>>>>> and the abort decision is incorrect.
>>>>>>>
>>>>>>> The head games of a Troll.
>>>>>>>
>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>> never stops running.
>>>>>>>
>>>>>>
>>>>>> Which prove NOTHING, as D varies with H, so no D that was built
>>>>>> with an H that aborts its simulation has had its actual halting
>>>>>> status tested.
>>>>>
>>>>> *That merely changes the wording of the same truism*
>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>> H(D,D) simulates its input and
>>>>> D calls H(D,D) and
>>>>> H(D,D) does not abort its simulation
>>>>> necessitates simulated D(D) never stops running.
>>>>>
>>>>>
>>>>
>>>> Third times and still not a charm.
>>>>
>>>> All those D still use an H that doesn't abort
>>>
>>> *You keep talking in circles, there are only two sets*
>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>> (1) H(D,D) does not abort its simulation then simulated D(D) never
>>> stops running.
>>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>>>
>>>
>>
>> And your top line says NOTHING about the Ds in set (2), since nothing
>> showed them not to run
>>
>> but your (2) admitts that D(D) will stop running, and thus the top
>> level H didn't need to abort its simulation.
>>
>
> Do you understand that each H(D,D) must either abort or fail to abort?
>
>

On 3/18/2024 12:11 AM, Richard Damon wrote:
> On 3/17/24 9:42 PM, olcott wrote:
>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>> On 3/17/24 9:00 PM, olcott wrote:
>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does
>>>>>>>>>>>>>>>>>>>>>>> answer the question correctly.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you
>>>>>>>>>>>>>>>>>>>>>>> have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the
>>>>>>>>>>>>>>>>>>>>>> impossible requirement
>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does
>>>>>>>>>>>>>>>>>>>>>> not actually see.
>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the
>>>>>>>>>>>>>>>>>>>>>> requirement of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly
>>>>>>>>>>>>>>>>>>>>>> simulates its input D until
>>>>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would
>>>>>>>>>>>>>>>>>>>>>> never stop running
>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D
>>>>>>>>>>>>>>>>>>>>>> until H correctly
>>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting
>>>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and
>>>>>>>>>>>>>>>>>>>> D(D) calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't
>>>>>>>>>>>>>>>>>>> prove what you need it to.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>>>>> determines whether or not it needs to abort this
>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input to
>>>>>>>>>>>>>> prevent
>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>
>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>
>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>
>>>>>>>>>>> To me, for H to NEED to abort its simulation, that means that
>>>>>>>>>>> when giving the input to a correct simulator, that simulator
>>>>>>>>>>> will not halt.
>>>>>>>>>>>
>>>>>>>>>> Yes that is correct.
>>>>>>>>>
>>>>>>>>> You have just proven that H doesn't need abort its simulation
>>>>>>>>> and the abort decision is incorrect.
>>>>>>>>
>>>>>>>> The head games of a Troll.
>>>>>>>>
>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>> never stops running.
>>>>>>>>
>>>>>>>
>>>>>>> Which prove NOTHING, as D varies with H, so no D that was built
>>>>>>> with an H that aborts its simulation has had its actual halting
>>>>>>> status tested.
>>>>>>
>>>>>> *That merely changes the wording of the same truism*
>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>> H(D,D) simulates its input and
>>>>>> D calls H(D,D) and
>>>>>> H(D,D) does not abort its simulation
>>>>>> necessitates simulated D(D) never stops running.
>>>>>>
>>>>>>
>>>>>
>>>>> Third times and still not a charm.
>>>>>
>>>>> All those D still use an H that doesn't abort
>>>>
>>>> *You keep talking in circles, there are only two sets*
>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>> (1) H(D,D) does not abort its simulation then simulated D(D) never
>>>> stops running.
>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>>>>
>>>>
>>>
>>> And your top line says NOTHING about the Ds in set (2), since nothing
>>> showed them not to run
>>>
>>> but your (2) admitts that D(D) will stop running, and thus the top
>>> level H didn't need to abort its simulation.
>>>
>>
>> Do you understand that each H(D,D) must either abort or fail to abort?
>>
>>
>
> And do you understand

On 3/17/2024 11:50 PM, immibis wrote:
> On 18/03/24 05:42, olcott wrote:
>> Do you understand that each H(D,D) must either abort or fail to abort?
>>
>
> Do you understand that D(D) halts?

*We are talking about the abort criteria*
That is false. One set halts and the other does not halt.

*there are only two sets*
∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
(1) H(D,D) does not abort its simulation then simulated D(D) never stops
running.
(2) H(D,D) aborts its simulation then simulated D(D) stops running.

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

On 3/17/24 10:25 PM, olcott wrote:
> On 3/17/2024 11:50 PM, immibis wrote:
>> On 18/03/24 05:42, olcott wrote:
>>> Do you understand that each H(D,D) must either abort or fail to abort?
>>>
>>
>> Do you understand that D(D) halts?
>
> *We are talking about the abort criteria*
> That is false. One set halts and the other does not halt.
>
> *there are only two sets*
> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
> (1) H(D,D) does not abort its simulation then simulated D(D) never stops
> running.
> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>
>
>

No, you have shown that set (1) does not halt, and needed to have been
aborted, but none of them were.

Set (2) is aborted, but hasn't been proven that THOSE inputs (which are
different then the ones in (1)) actually needed to be aborted.

In fact, by the agreed upon definition, none of them do need to be
aborted, as UTM(D,D) will halt, so H never actually needed to abort them.

So, you are just shown to be repeating the disproven and admitted lies.

On 3/17/24 10:22 PM, olcott wrote:
> On 3/18/2024 12:11 AM, Richard Damon wrote:
>> On 3/17/24 9:42 PM, olcott wrote:
>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does
>>>>>>>>>>>>>>>>>>>>>>>> answer the question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you
>>>>>>>>>>>>>>>>>>>>>>>> have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the
>>>>>>>>>>>>>>>>>>>>>>> impossible requirement
>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does
>>>>>>>>>>>>>>>>>>>>>>> not actually see.
>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the
>>>>>>>>>>>>>>>>>>>>>>> requirement of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly
>>>>>>>>>>>>>>>>>>>>>>> simulates its input D until
>>>>>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would
>>>>>>>>>>>>>>>>>>>>>>> never stop running
>>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D
>>>>>>>>>>>>>>>>>>>>>>> until H correctly
>>>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting
>>>>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about
>>>>>>>>>>>>>>>>>>>>> the self-evident truth*
>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and
>>>>>>>>>>>>>>>>>>>>> D(D) calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this
>>>>>>>>>>>>>>>>>>>> doesn't prove what you need it to.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>>>>>> determines whether or not it needs to abort this
>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input to
>>>>>>>>>>>>>>> prevent
>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>
>>>>>>>>>>>> To me, for H to NEED to abort its simulation, that means
>>>>>>>>>>>> that when giving the input to a correct simulator, that
>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>
>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>
>>>>>>>>>> You have just proven that H doesn't need abort its simulation
>>>>>>>>>> and the abort decision is incorrect.
>>>>>>>>>
>>>>>>>>> The head games of a Troll.
>>>>>>>>>
>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>> never stops running.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Which prove NOTHING, as D varies with H, so no D that was built
>>>>>>>> with an H that aborts its simulation has had its actual halting
>>>>>>>> status tested.
>>>>>>>
>>>>>>> *That merely changes the wording of the same truism*
>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>> H(D,D) simulates its input and
>>>>>>> D calls H(D,D) and
>>>>>>> H(D,D) does not abort its simulation
>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Third times and still not a charm.
>>>>>>
>>>>>> All those D still use an H that doesn't abort
>>>>>
>>>>> *You keep talking in circles, there are only two sets*
>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>> (1) H(D,D) does not abort its simulation then simulated D(D) never
>>>>> stops running.
>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>>>>>
>>>>>
>>>>
>>>> And your top line says NOTHING about the Ds in set (2), since
>>>> nothing showed them not to run
>>>>
>>>> but your (2) admitts that D(D) will stop running, and thus the top
>>>> level H didn't need to abort its simulation.
>>>>
>>>
>>> Do you understand that each H(D,D) must either abort or fail to abort?
>>>
>>>
>>
>> And do you understand
>
> Yes that is what I am asking. It seems that you don't understand
> the difference between X being a member of a set and X not being
> a member of a set. Very elemental set theory.

On 2024-03-17 16:35:32 +0000, olcott said:

> On 3/17/2024 11:09 AM, Mikko wrote:
>> On 2024-03-17 13:53:03 +0000, olcott said:
>>
>>> On 3/17/2024 8:49 AM, Mikko wrote:
>>>> On 2024-03-17 13:04:19 +0000, olcott said:
>>>>
>>>>> On 3/17/2024 4:14 AM, Mikko wrote:
>>>>>> On 2024-03-16 14:48:51 +0000, olcott said:
>>>>>>
>>>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>>>> On 3/15/2024 1:45 PM, immibis wrote:
>>>>>>>>>>>> On 15/03/24 19:39, olcott wrote:
>>>>>>>>>>>>> On 3/15/2024 1:38 PM, immibis wrote:
>>>>>>>>>>>>>> On 15/03/24 18:52, olcott wrote:
>>>>>>>>>>>>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>>>>>>>>>>>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates its input D until
>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would never stop running
>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>>>>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp ; begin main()
>>>>>>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp ; enter D(D)
>>>>>>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax ; push D
>>>>>>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx ; push D
>>>>>>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called with its same
>>>>>>>>>>>>>>>>> inputs and there are no conditional branch instructions between the
>>>>>>>>>>>>>>>>> invocation of D(D) and its call to H(D,D).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except that D calling H(D,D) does NOT prove the required (a), since the
>>>>>>>>>>>>>>>> simulated D WILL stop running because *ITS* H will abort *ITS*
>>>>>>>>>>>>>>>> simulation and returm 0 so that simulated D will halt.
>>>>>>>>>>>>>>> You keep saying that H(D,D) never really needs to abort the
>>>>>>>>>>>>>>> simulation of its input because after H(D,D) has aborted the
>>>>>>>>>>>>>>> simulation of this input it no longer needs to be aborted.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You keep thinking there is more than one H(D,D) and then when it's
>>>>>>>>>>>>>> convenient for you you think there is only one H(D,D). Why is that?
>>>>>>>>>>>>>
>>>>>>>>>>>>> The first H(D,D) to see that the abort criteria has been met
>>>>>>>>>>>>> (the outermost one) must abort the simulation of its input or
>>>>>>>>>>>>> none of them ever abort.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> that's wrong. They all abort,
>>>>>>>>>>>
>>>>>>>>>>> I was baffled by this for three days when I first investigated this.
>>>>>>>>>>> Because every H has the exact same code, if the first one to see that
>>>>>>>>>>> the abort criteria has been met does not abort then none of them abort.
>>>>>>>>>>
>>>>>>>>>> And thus you look at a strawman. A case where H isn't the H that we
>>>>>>>>>> started with.
>>>>>>>>>>
>>>>>>>>>> If you change the H used by D, you change the quesition being asked.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> We cannot reference the behavior of what D(D) does after H(D,D)
>>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure
>>>>>>>>> for this H(D,D).
>>>>>>>>
>>>>>>>> Then you cannot prove that H is a halting decider, as that is what
>>>>>>>> you need to reference in the proof.
>>>>>>>>
>>>>>>>
>>>>>>> I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
>>>>>>> that H correctly determined that it had to abort the simulation
>>>>>>> of its input to prevent the infinite execution of this input.
>>>>>>>
>>>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>>>> and H never aborts its simulation.
>>>>>>
>>>>>> The set from wich such H could be chosen is so small that
>>>>>> it is no surprise that any H that simulates D(D) to its
>>>>>> termination is not in that set.
>>>>>>
>>>>>
>>>>> As soon as we hit complete proof of this we can move on
>>>>> to another point.
>>>>
>>>> A complete proof of what?
>>>>
>>> [Proof that H(D,D) meets its abort criteria]
>>
>> It is possible that you don't find such proof.
>>
>
> Been there done that many times.

On 2024-03-18 03:07:18 +0000, olcott said:

> On 3/17/2024 9:35 PM, Richard Damon wrote:
>> On 3/17/24 4:27 PM, olcott wrote:
>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>> On 17/03/24 14:11, olcott wrote:
>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of reporting on what it does not see.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the question correctly.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have no concept of real truth,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible requirement
>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not actually see.
>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable requirement.
>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of clairvoyance*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates its input D until
>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would never stop running
>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H correctly
>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior pattern.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it incorrect or invalid.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the self-evident truth*
>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D) calls H(D,D)
>>>>>>>>>>>>>>> either H(D,D) aborts its simulation or D(D) never stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't prove what you
>>>>>>>>>>>>>> need it to.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig D(D), but H
>>>>>>>>>>>>>> doesn't answwer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>
>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope.
>>>>>>>>>>>
>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>
>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And thus not a specific algorithm?
>>>>>>>>
>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>
>>>>>>>> That is not an algorithmic step.
>>>>>>>>
>>>>>>>> We can only verify that in retrospect.
>>>>>>>
>>>>>>> Do you fully understand the spec?
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Yes, but I think not the way you do.
>>>>>>
>>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>>> giving the input to a correct simulator, that simulator will not halt.
>>>>>>
>>>>> Yes that is correct.
>>>>
>>>> You have just proven that H doesn't need abort its simulation and the
>>>> abort decision is incorrect.
>>>
>>> The head games of a Troll.
>>>
>>> For every possible way that H can be encoded and D(D)
>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>> never stops running.
>>>
>>
>> Which prove NOTHING, as D varies with H, so no D that was built with an
>> H that aborts its simulation has had its actual halting status tested.
>>
>
> *That merely changes the wording of the same truism*
> ∀H ∀D such that H(D,D) simulates its input and D calls H(D,D)
> H(D,D) does not abort its simulation necessitates simulated D(D)
> never stops running.

You should restrict your H so that any H that simulates D(D) forever
is excluded, as simulating forver makes it a non-decider.

Also, "implies" is better than "necessitates", and even better if
you only use "and", "or", and "not".

--
Mikko

On 2024-03-17 16:31:57 +0000, olcott said:

> On 3/17/2024 11:13 AM, Mikko wrote:
>> On 2024-03-17 13:52:31 +0000, olcott said:
>>
>>> On 3/17/2024 8:46 AM, Mikko wrote:
>>>> On 2024-03-16 15:18:33 +0000, olcott said:
>>>>
>>>>> On 3/16/2024 3:19 AM, Mikko wrote:
>>>>>> On 2024-03-15 16:20:35 +0000, olcott said:
>>>>>>
>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>
>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>>> (a) If simulating halt decider H correctly simulates its input D until
>>>>>>> H correctly determines that its simulated D would never stop running
>>>>>>> unless aborted then
>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>
>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>> Will you halt if you never abort your simulation?
>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>
>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>
>>>>>>> int D(int (*x)())
>>>>>>> {
>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>    if (Halt_Status)
>>>>>>>      HERE: goto HERE;
>>>>>>>    return Halt_Status;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>> }
>>>>>>>
>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>   address   address   data      code       language
>>>>>>>   ========  ========  ========  =========  =============
>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>>
>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>> Address_of_H:1522
>>>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>
>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>> H(D,D) correctly determines that itself is being called with its same
>>>>>>> inputs and there are no conditional branch instructions between the
>>>>>>> invocation of D(D) and its call to H(D,D).
>>>>>>
>>>>>> This proof is not simpler or more convinceing than earlier proofs of
>>>>>> the same.
>>>>>>
>>>>>> It is also as uninteresting as the proved claim. As long as H does
>>>>>> not meet the specification of halting decider it does not matter
>>>>>> what it meets instead.
>>>>>>
>>>>>
>>>>> The original halt status criteria has the impossible requirement
>>>>> that H(D,D) must report on behavior that it does not actually see.
>>>>
>>>> The requirement is not specifically about behaviour that the decider
>>>> does not actually see but requires reporting anyway, whether the
>>>> decider sees or not. So it turns out that it is not possible to
>>>> meet the specification in all cases.
>>>>
>>> I think that the decider can meet its abort criteria in all cases.
>>
>> But cannot meet its specification.
>>
>
> First we must come to mutual agreement that H(D,D) is correct
> to abort its simulation.

You may need. I don't, and I don't think anyone else needs, either.

> Then we must come to mutual agreement the an abort decider
> can always be correct.

You may need. I don't, and I don't think anyone else needs, either.

> We do this by failing to derive any counter-example.

A failure is not a proof. One may call it a proof of your stupidity
but strictly speaking it is not.

--
Mikko

On 2024-03-17 23:47:01 +0000, olcott said:

> On 3/17/2024 2:45 PM, Richard Damon wrote:
>> On 3/17/24 9:31 AM, olcott wrote:
>>> On 3/17/2024 11:13 AM, Mikko wrote:
>>>> On 2024-03-17 13:52:31 +0000, olcott said:
>>>>
>>>>> On 3/17/2024 8:46 AM, Mikko wrote:
>>>>>> On 2024-03-16 15:18:33 +0000, olcott said:
>>>>>>
>>>>>>> On 3/16/2024 3:19 AM, Mikko wrote:
>>>>>>>> On 2024-03-15 16:20:35 +0000, olcott said:
>>>>>>>>
>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>
>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>>>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>>>>> (a) If simulating halt decider H correctly simulates its input D until
>>>>>>>>> H correctly determines that its simulated D would never stop running
>>>>>>>>> unless aborted then
>>>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>
>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>
>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>
>>>>>>>>> int D(int (*x)())
>>>>>>>>> {
>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>    if (Halt_Status)
>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>    return Halt_Status;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>   address   address   data      code       language
>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>>>>
>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>> Address_of_H:1522
>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>
>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>> H(D,D) correctly determines that itself is being called with its same
>>>>>>>>> inputs and there are no conditional branch instructions between the
>>>>>>>>> invocation of D(D) and its call to H(D,D).
>>>>>>>>
>>>>>>>> This proof is not simpler or more convinceing than earlier proofs of
>>>>>>>> the same.
>>>>>>>>
>>>>>>>> It is also as uninteresting as the proved claim. As long as H does
>>>>>>>> not meet the specification of halting decider it does not matter
>>>>>>>> what it meets instead.
>>>>>>>>
>>>>>>>
>>>>>>> The original halt status criteria has the impossible requirement
>>>>>>> that H(D,D) must report on behavior that it does not actually see.
>>>>>>
>>>>>> The requirement is not specifically about behaviour that the decider
>>>>>> does not actually see but requires reporting anyway, whether the
>>>>>> decider sees or not. So it turns out that it is not possible to
>>>>>> meet the specification in all cases.
>>>>>>
>>>>> I think that the decider can meet its abort criteria in all cases.
>>>>
>>>> But cannot meet its specification.
>>>>
>>>
>>> First we must come to mutual agreement that H(D,D) is correct
>>> to abort its simulation.
>>
>> Which means we need to first come to an aggreement of what that means.
>>
>> You DID agree earlier to this:
>>
>> On 3/17/24 6:11 AM, olcott wrote:
>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>> To me, for H to NEED to abort its simulation, that means that when
>>>> giving the input to a correct simulator, that simulator will not halt.
>>>>
>>> Yes that is correct.
>>>
>>
>
> For every possible way that H can be encoded and D(D)
> calls H(D,D) either H(D,D) aborts its simulation or D(D)
> never stops running.

That is ambiguous: does D(D) call H(D,D) if H is encoded in another way
than the one that D(D) calls?

--
Mikko

On 3/18/2024 1:04 AM, Richard Damon wrote:
> On 3/17/24 10:22 PM, olcott wrote:
>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>> On 3/17/24 9:42 PM, olcott wrote:
>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does
>>>>>>>>>>>>>>>>>>>>>>>>> answer the question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you
>>>>>>>>>>>>>>>>>>>>>>>>> have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the
>>>>>>>>>>>>>>>>>>>>>>>> impossible requirement
>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does
>>>>>>>>>>>>>>>>>>>>>>>> not actually see.
>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the
>>>>>>>>>>>>>>>>>>>>>>>> requirement of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly
>>>>>>>>>>>>>>>>>>>>>>>> simulates its input D until
>>>>>>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D
>>>>>>>>>>>>>>>>>>>>>>>> would never stop running
>>>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D
>>>>>>>>>>>>>>>>>>>>>>>> until H correctly
>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting
>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about
>>>>>>>>>>>>>>>>>>>>>> the self-evident truth*
>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and
>>>>>>>>>>>>>>>>>>>>>> D(D) calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this
>>>>>>>>>>>>>>>>>>>>> doesn't prove what you need it to.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>>>>>>> determines whether or not it needs to abort this
>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input
>>>>>>>>>>>>>>>> to prevent
>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To me, for H to NEED to abort its simulation, that means
>>>>>>>>>>>>> that when giving the input to a correct simulator, that
>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>
>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>
>>>>>>>>>>> You have just proven that H doesn't need abort its simulation
>>>>>>>>>>> and the abort decision is incorrect.
>>>>>>>>>>
>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>
>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>> never stops running.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Which prove NOTHING, as D varies with H, so no D that was built
>>>>>>>>> with an H that aborts its simulation has had its actual halting
>>>>>>>>> status tested.
>>>>>>>>
>>>>>>>> *That merely changes the wording of the same truism*
>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>> H(D,D) simulates its input and
>>>>>>>> D calls H(D,D) and
>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Third times and still not a charm.
>>>>>>>
>>>>>>> All those D still use an H that doesn't abort
>>>>>>
>>>>>> *You keep talking in circles, there are only two sets*
>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>> (1) H(D,D) does not abort its simulation then simulated D(D) never
>>>>>> stops running.
>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>>>>>>
>>>>>>
>>>>>
>>>>> And your top line says NOTHING about the Ds in set (2), since
>>>>> nothing showed them not to run
>>>>>
>>>>> but your (2) admitts that D(D) will stop running, and thus the top
>>>>> level H didn't need to abort its simulation.
>>>>>
>>>>
>>>> Do you understand that each H(D,D) must either abort or fail to abort?
>>>>
>>>>
>>>
>>> And do you understand
>>
>> Yes that is what I am asking. It seems that you don't understand
>> the difference between X being a member of a set and X not being
>> a member of a set. Very elemental set theory.
>
> And you seem to be trying to convientely forget that each D that you
> talk about is DIFFERENT, base on the H that it was designed to confound.

Op 18.mrt.2024 om 15:44 schreef olcott:
> On 3/18/2024 1:04 AM, Richard Damon wrote:
>> On 3/17/24 10:22 PM, olcott wrote:
>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does
>>>>>>>>>>>>>>>>>>>>>>>>>> answer the question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of
>>>>>>>>>>>>>>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as
>>>>>>>>>>>>>>>>>>>>>>>>>> you have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the
>>>>>>>>>>>>>>>>>>>>>>>>> impossible requirement
>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it
>>>>>>>>>>>>>>>>>>>>>>>>> does not actually see.
>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an
>>>>>>>>>>>>>>>>>>>>>>>>> unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the
>>>>>>>>>>>>>>>>>>>>>>>>> requirement of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly
>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input D until
>>>>>>>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D
>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running
>>>>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D
>>>>>>>>>>>>>>>>>>>>>>>>> until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting
>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make
>>>>>>>>>>>>>>>>>>>>>>>> it incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about
>>>>>>>>>>>>>>>>>>>>>>> the self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and
>>>>>>>>>>>>>>>>>>>>>>> D(D) calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this
>>>>>>>>>>>>>>>>>>>>>> doesn't prove what you need it to.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>>>>>>>> determines whether or not it needs to abort this
>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input
>>>>>>>>>>>>>>>>> to prevent
>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To me, for H to NEED to abort its simulation, that means
>>>>>>>>>>>>>> that when giving the input to a correct simulator, that
>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>
>>>>>>>>>>>> You have just proven that H doesn't need abort its
>>>>>>>>>>>> simulation and the abort decision is incorrect.
>>>>>>>>>>>
>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>
>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>> never stops running.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Which prove NOTHING, as D varies with H, so no D that was
>>>>>>>>>> built with an H that aborts its simulation has had its actual
>>>>>>>>>> halting status tested.
>>>>>>>>>
>>>>>>>>> *That merely changes the wording of the same truism*
>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>> D calls H(D,D) and
>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Third times and still not a charm.
>>>>>>>>
>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>
>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>> (1) H(D,D) does not abort its simulation then simulated D(D)
>>>>>>> never stops running.
>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> And your top line says NOTHING about the Ds in set (2), since
>>>>>> nothing showed them not to run
>>>>>>
>>>>>> but your (2) admitts that D(D) will stop running, and thus the top
>>>>>> level H didn't need to abort its simulation.
>>>>>>
>>>>>
>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
>>>>>
>>>>>
>>>>
>>>> And do you understand
>>>
>>> Yes that is what I am asking. It seems that you don't understand
>>> the difference between X being a member of a set and X not being
>>> a member of a set. Very elemental set theory.
>>
>> And you seem to be trying to convientely forget that each D that you
>> talk about is DIFFERENT, base on the H that it was designed to confound.
>
> *You keep talking in circles, there are only two sets*
> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
> (1) H(D,D) does not abort its simulation then simulated D(D) never stops
> running.
> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
> *By whatever means H(D,D) places itself in (2) then H(D,D) is correct*
>

On 3/18/24 7:44 AM, olcott wrote:
> On 3/18/2024 1:04 AM, Richard Damon wrote:
>> On 3/17/24 10:22 PM, olcott wrote:
>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does
>>>>>>>>>>>>>>>>>>>>>>>>>> answer the question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of
>>>>>>>>>>>>>>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as
>>>>>>>>>>>>>>>>>>>>>>>>>> you have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the
>>>>>>>>>>>>>>>>>>>>>>>>> impossible requirement
>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it
>>>>>>>>>>>>>>>>>>>>>>>>> does not actually see.
>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an
>>>>>>>>>>>>>>>>>>>>>>>>> unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the
>>>>>>>>>>>>>>>>>>>>>>>>> requirement of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly
>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input D until
>>>>>>>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D
>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running
>>>>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D
>>>>>>>>>>>>>>>>>>>>>>>>> until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting
>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make
>>>>>>>>>>>>>>>>>>>>>>>> it incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about
>>>>>>>>>>>>>>>>>>>>>>> the self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and
>>>>>>>>>>>>>>>>>>>>>>> D(D) calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this
>>>>>>>>>>>>>>>>>>>>>> doesn't prove what you need it to.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>>>>>>>> determines whether or not it needs to abort this
>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input
>>>>>>>>>>>>>>>>> to prevent
>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To me, for H to NEED to abort its simulation, that means
>>>>>>>>>>>>>> that when giving the input to a correct simulator, that
>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>
>>>>>>>>>>>> You have just proven that H doesn't need abort its
>>>>>>>>>>>> simulation and the abort decision is incorrect.
>>>>>>>>>>>
>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>
>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>> never stops running.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Which prove NOTHING, as D varies with H, so no D that was
>>>>>>>>>> built with an H that aborts its simulation has had its actual
>>>>>>>>>> halting status tested.
>>>>>>>>>
>>>>>>>>> *That merely changes the wording of the same truism*
>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>> D calls H(D,D) and
>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Third times and still not a charm.
>>>>>>>>
>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>
>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>> (1) H(D,D) does not abort its simulation then simulated D(D)
>>>>>>> never stops running.
>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> And your top line says NOTHING about the Ds in set (2), since
>>>>>> nothing showed them not to run
>>>>>>
>>>>>> but your (2) admitts that D(D) will stop running, and thus the top
>>>>>> level H didn't need to abort its simulation.
>>>>>>
>>>>>
>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
>>>>>
>>>>>
>>>>
>>>> And do you understand
>>>
>>> Yes that is what I am asking. It seems that you don't understand
>>> the difference between X being a member of a set and X not being
>>> a member of a set. Very elemental set theory.
>>
>> And you seem to be trying to convientely forget that each D that you
>> talk about is DIFFERENT, base on the H that it was designed to confound.
>
> *You keep talking in circles, there are only two sets*

On 18/03/24 16:11, Fred. Zwarts wrote:
> Op 18.mrt.2024 om 15:44 schreef olcott:
>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>> On 3/17/24 10:22 PM, olcott wrote:
>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does
>>>>>>>>>>>>>>>>>>>>>>>>>>> answer the question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of
>>>>>>>>>>>>>>>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as
>>>>>>>>>>>>>>>>>>>>>>>>>>> you have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the
>>>>>>>>>>>>>>>>>>>>>>>>>> impossible requirement
>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it
>>>>>>>>>>>>>>>>>>>>>>>>>> does not actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an
>>>>>>>>>>>>>>>>>>>>>>>>>> unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the
>>>>>>>>>>>>>>>>>>>>>>>>>> requirement of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input D until
>>>>>>>>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D
>>>>>>>>>>>>>>>>>>>>>>>>>> would never stop running
>>>>>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D
>>>>>>>>>>>>>>>>>>>>>>>>>> until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make
>>>>>>>>>>>>>>>>>>>>>>>>> it incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about
>>>>>>>>>>>>>>>>>>>>>>>> the self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and
>>>>>>>>>>>>>>>>>>>>>>>> D(D) calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this
>>>>>>>>>>>>>>>>>>>>>>> doesn't prove what you need it to.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its input and
>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>> determines whether or not it needs to abort this
>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input
>>>>>>>>>>>>>>>>>> to prevent
>>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To me, for H to NEED to abort its simulation, that means
>>>>>>>>>>>>>>> that when giving the input to a correct simulator, that
>>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You have just proven that H doesn't need abort its
>>>>>>>>>>>>> simulation and the abort decision is incorrect.
>>>>>>>>>>>>
>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>
>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Which prove NOTHING, as D varies with H, so no D that was
>>>>>>>>>>> built with an H that aborts its simulation has had its actual
>>>>>>>>>>> halting status tested.
>>>>>>>>>>
>>>>>>>>>> *That merely changes the wording of the same truism*
>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Third times and still not a charm.
>>>>>>>>>
>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>
>>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>> (1) H(D,D) does not abort its simulation then simulated D(D)
>>>>>>>> never stops running.
>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> And your top line says NOTHING about the Ds in set (2), since
>>>>>>> nothing showed them not to run
>>>>>>>
>>>>>>> but your (2) admitts that D(D) will stop running, and thus the
>>>>>>> top level H didn't need to abort its simulation.
>>>>>>>
>>>>>>
>>>>>> Do you understand that each H(D,D) must either abort or fail to
>>>>>> abort?
>>>>>>
>>>>>>
>>>>>
>>>>> And do you understand
>>>>
>>>> Yes that is what I am asking. It seems that you don't understand
>>>> the difference between X being a member of a set and X not being
>>>> a member of a set. Very elemental set theory.
>>>
>>> And you seem to be trying to convientely forget that each D that you
>>> talk about is DIFFERENT, base on the H that it was designed to confound.
>>
>> *You keep talking in circles, there are only two sets*
>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>> (1) H(D,D) does not abort its simulation then simulated D(D) never
>> stops running.
>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>> *By whatever means H(D,D) places itself in (2) then H(D,D) is correct*
>>
>
> By repeating yourself, you run in circles.
> There are three possible categories of H functions:
>
> 1. Hah, It aborts and reports halting.
> 2. Han, It aborts and repeats non halting.
> 3. Hss does not abort, but simply simulates.
>
> From each of them we can construct a D: Dah, Dan and Dss, respectively.
> Hah(Dah,Dah) should report on its input, which halts, because it
> contains a copy of Hah. So if Hah aborts before it sees that Dah halts,
> it closes it eyes too soon and misses the easily verified fact that Dah
> halts. So it is wrong when it assumes that Dah does not halt and an
> abort is needed.
> Hah(Dah,Dah) should not assume that Dah behaves like Dss, because Dss is
> an non-input and behaves differently from Dah.

On 18/03/24 06:25, olcott wrote:
> On 3/17/2024 11:50 PM, immibis wrote:
>> On 18/03/24 05:42, olcott wrote:
>>> Do you understand that each H(D,D) must either abort or fail to abort?
>>>
>>
>> Do you understand that D(D) halts?
>
> *We are talking about the abort criteria*

Strawman deception. H is a halt decider if it tells whether the direct
execution of its input would halt.

On 18/03/2024 15:11, Fred. Zwarts wrote:
> Op 18.mrt.2024 om 15:44 schreef olcott:
>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>> On 3/17/24 10:22 PM, olcott wrote:
>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of reporting on what it does
>>>>>>>>>>>>>>>>>>>>>>>>>>>> not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have no concept of real
>>>>>>>>>>>>>>>>>>>>>>>>>>> truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible requirement
>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates its input D until
>>>>>>>>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would never stop running
>>>>>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D) calls H(D,D) either
>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) aborts its simulation or D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't prove what you need it to.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig D(D), but H
>>>>>>>>>>>>>>>>>>>>>>> doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To me, for H to NEED to abort its simulation, that means that when giving the input
>>>>>>>>>>>>>>> to a correct simulator, that simulator will not halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You have just proven that H doesn't need abort its simulation and the abort decision is
>>>>>>>>>>>>> incorrect.
>>>>>>>>>>>>
>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>
>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Which prove NOTHING, as D varies with H, so no D that was built with an H that aborts its
>>>>>>>>>>> simulation has had its actual halting status tested.
>>>>>>>>>>
>>>>>>>>>> *That merely changes the wording of the same truism*
>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Third times and still not a charm.
>>>>>>>>>
>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>
>>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>> (1) H(D,D) does not abort its simulation then simulated D(D) never stops running.
>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> And your top line says NOTHING about the Ds in set (2), since nothing showed them not to run
>>>>>>>
>>>>>>> but your (2) admitts that D(D) will stop running, and thus the top level H didn't need to
>>>>>>> abort its simulation.
>>>>>>>
>>>>>>
>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
>>>>>>
>>>>>>
>>>>>
>>>>> And do you understand
>>>>
>>>> Yes that is what I am asking. It seems that you don't understand
>>>> the difference between X being a member of a set and X not being
>>>> a member of a set. Very elemental set theory.
>>>
>>> And you seem to be trying to convientely forget that each D that you talk about is DIFFERENT,
>>> base on the H that it was designed to confound.
>>
>> *You keep talking in circles, there are only two sets*
>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>> (1) H(D,D) does not abort its simulation then simulated D(D) never stops running.
>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>> *By whatever means H(D,D) places itself in (2) then H(D,D) is correct*
>>
>
> By repeating yourself, you run in circles.
> There are three possible categories of H functions:
>
> 1. Hah, It aborts and reports halting.
> 2. Han, It aborts and repeats non halting.
> 3. Hss does not abort, but simply simulates.
>
> From each of them we can construct a D: Dah, Dan and Dss, respectively.
> Hah(Dah,Dah) should report on its input, which halts, because it contains a copy of Hah. So if Hah
> aborts before it sees that Dah halts, it closes it eyes too soon and misses the easily verified fact
> that Dah halts. So it is wrong when it assumes that Dah does not halt and an abort is needed.
> Hah(Dah,Dah) should not assume that Dah behaves like Dss, because Dss is an non-input and behaves
> differently from Dah.

Perhaps a clearer way of pointing it out:

On 3/18/24 7:44 AM, olcott wrote:
>
> *You keep talking in circles, there are only two sets*
> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))

Which hides a condition, let make it more explicit:

∀H ∈ TM | H Simulates its input, (And is claimed to be a decider)
∀D ∈ TMD | D calls the selected H(D,D)

Note, the ∀D is looking at a very restricted set of Ds, and not really ∀D

Thus, your division is NOT about ∀H ∈ TM ∀D ∈ TMD, as you imply, but
only dividing a small subset of that space.

> (1) H(D,D) does not abort its simulation then simulated D(D) never stops
> running.
> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
> *By whatever means H(D,D) places itself in (2) then H(D,D) is correct*

Thus, your division is on the H, into those that will not aborts the D
that calls THEM, and thos H that wiil abor the D that calls THEM.

Set (1) shows that D that call a set (1) H are non-halting, but say
nothing about Ds that call a set (2) H, since they never looked at them.

Thus, your set (2) has nothing to base its claim on.

In fact, ALL these Ds in set(2) will Halt, as shown by giving them to a
set (1) decider.