Op 18.mrt.2024 om 21:26 schreef olcott:
> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>> On 3/18/2024 10:11 AM, 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.
>>>>
>>>
>>> What H(D,D) reports is off-topic for this post.
>>> *We are only looking at this*
>>> [Proof that H(D,D) meets its abort criteria --self-evident truth--]
>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>
>>
>> Be clear in the naming. Is it Dan that is considered, or Dss? Dss must
>> be aborted, because is does not halt, but Dan does halt and does not
>> need to be aborted.
>
> (a) If simulating abort decider H correctly simulates its input D until
> H correctly determines that its simulated D would never stop running
> unless aborted...
>
> *This is what those naming conventions derive*
> Everyone is saying that because H(D,D) did need to abort its simulation
> to prevent D(D) from infinite execution that this proves that it never
> needed to abort its simulation because it can rely on the fact that it
> already aborted its simulation thus never needed to abort it.
>

On 3/18/2024 5:37 PM, Fred. Zwarts wrote:
> Op 18.mrt.2024 om 23:25 schreef olcott:
>> On 3/18/2024 4:56 PM, Fred. Zwarts wrote:
>>> Op 18.mrt.2024 om 22:48 schreef olcott:
>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>> Op 18.mrt.2024 om 21:40 schreef olcott:
>>>>>>>> On 3/18/2024 3:30 PM, immibis wrote:
>>>>>>>>> On 18/03/24 21:20, olcott wrote:
>>>>>>>>>> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>>>>>>>>>>> On 3/18/2024 10:11 AM, 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.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident
>>>>>>>>>>>> truth--]
>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Be clear in the naming. Is it Dan that is considered, or Dss?
>>>>>>>>>>> Dss must be aborted, because is does not halt, but Dan does
>>>>>>>>>>> halt and does not need to be aborted.
>>>>>>>>>>
>>>>>>>>>> *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.
>>>>>>>>>>
>>>>>>>>>> (a) If simulating abort decider H correctly simulates its
>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>> would never stop running unless aborted...
>>>>>>>>>>
>>>>>>>>>> *Therefore*
>>>>>>>>>> *Every element of (1) is incorrect and every element of (2) is
>>>>>>>>>> correct*
>>>>>>>>>> *Pathological thinking to make them both seem incorrect is
>>>>>>>>>> incorrect*
>>>>>>>>>>
>>>>>>>>>>> So, Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>> The Hss that meets the abort criteria does not abort and the
>>>>>>>>>>> Han that does not meet its abort criteria does abort. So,
>>>>>>>>>>> both are wrong.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Is it Dan that is considered, or Dss? Dss must be aborted,
>>>>>>>>> because is does not halt, but Dan does halt and does not need
>>>>>>>>> to be aborted.
>>>>>>>>
>>>>>>>> *This is what those naming conventions derive*
>>>>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>>>>> simulation
>>>>>>>> to prevent D(D) from infinite execution that this proves that it
>>>>>>>> never
>>>>>>>> needed to abort its simulation because it can rely on the fact
>>>>>>>> that it
>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>
>>>>>>>
>>>>>>> You are almost there. If you stop naming all different H which
>>>>>>> the same name and all different D with the same name, your
>>>>>>> confusion may disappear.
>>>>>>
>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>
>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>> The Hss that meets the abort criteria does not abort and the Han
>>>>>>> that does not meet its abort criteria does abort. So, both are
>>>>>>> wrong.
>>>>>>>
>>>>>
>>>>> Olcott does not understand that if the H in the simulated D aborts,
>>>>> then the simulating H should not abort
>>>>
>>>> *You are confused*
>>>> If the H in the simulated D aborts then the directly executed H did
>>>> not abort. Since the directly executed H sees one more execution
>>>> trace then the simulated H then the H in the simulated D never aborts.
>>>>
>>>
>>> No, Olcott told us that the simulating H aborts before it sees that
>>> the simulated D halts. It only sees that D calls H, but it does not
>>> see that the called H aborts, because the simulation stops at the
>>> call, which is too early.
>>>
>>
>> DD correctly simulated by HH cannot possibly reach past its
>> own first line, thus cannot possibly halt.
>
> Olcott does not understand that if the call to HH were correctly
> simulated, then this HH would abort its simulation and return and
> therefore DD would continue

On 3/18/2024 5:49 AM, Mikko wrote:
> 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.
>
> You have presented nothing that even looks like proof, let alone is.
>

On 3/18/2024 6:26 AM, Mikko wrote:
> 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.
>

On 3/18/2024 6:43 AM, Mikko wrote:
> 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?
>

I have no idea what you are meaning.
It is assumed that H and D are C functions.

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

On 18/03/24 23:50, olcott wrote:
> On 3/18/2024 5:49 AM, Mikko wrote:
>> 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:
>>>>>>> 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.
>>
>> You have presented nothing that even looks like proof, let alone is.
>
> That you don't understand that this is proof does not
> entail that it is not proof.
> [execution trace removed]

The execution trace of H(D,D) only proves that H(D,D) returns 0 and does
not prove that 0 is the correct return value of a halt decider. Actually
1 is the correct return value of a halt decider. Therefore, H isn't a
halt decider.

On 18/03/24 23:49, olcott wrote:
> On 3/18/2024 5:37 PM, Fred. Zwarts wrote:
>> Op 18.mrt.2024 om 23:25 schreef olcott:
>>> On 3/18/2024 4:56 PM, Fred. Zwarts wrote:
>>>> Op 18.mrt.2024 om 22:48 schreef olcott:
>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>> Op 18.mrt.2024 om 21:40 schreef olcott:
>>>>>>>>> On 3/18/2024 3:30 PM, immibis wrote:
>>>>>>>>>> On 18/03/24 21:20, olcott wrote:
>>>>>>>>>>> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>>>>>>>>>>>> On 3/18/2024 10:11 AM, 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.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident
>>>>>>>>>>>>> truth--]
>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Be clear in the naming. Is it Dan that is considered, or
>>>>>>>>>>>> Dss? Dss must be aborted, because is does not halt, but Dan
>>>>>>>>>>>> does halt and does not need to be aborted.
>>>>>>>>>>>
>>>>>>>>>>> *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.
>>>>>>>>>>>
>>>>>>>>>>> (a) If simulating abort decider H correctly simulates its
>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>> would never stop running unless aborted...
>>>>>>>>>>>
>>>>>>>>>>> *Therefore*
>>>>>>>>>>> *Every element of (1) is incorrect and every element of (2)
>>>>>>>>>>> is correct*
>>>>>>>>>>> *Pathological thinking to make them both seem incorrect is
>>>>>>>>>>> incorrect*
>>>>>>>>>>>
>>>>>>>>>>>> So, Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and the
>>>>>>>>>>>> Han that does not meet its abort criteria does abort. So,
>>>>>>>>>>>> both are wrong.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Is it Dan that is considered, or Dss? Dss must be aborted,
>>>>>>>>>> because is does not halt, but Dan does halt and does not need
>>>>>>>>>> to be aborted.
>>>>>>>>>
>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>>>>>> simulation
>>>>>>>>> to prevent D(D) from infinite execution that this proves that
>>>>>>>>> it never
>>>>>>>>> needed to abort its simulation because it can rely on the fact
>>>>>>>>> that it
>>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You are almost there. If you stop naming all different H which
>>>>>>>> the same name and all different D with the same name, your
>>>>>>>> confusion may disappear.
>>>>>>>
>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>
>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>> The Hss that meets the abort criteria does not abort and the Han
>>>>>>>> that does not meet its abort criteria does abort. So, both are
>>>>>>>> wrong.
>>>>>>>>
>>>>>>
>>>>>> Olcott does not understand that if the H in the simulated D
>>>>>> aborts, then the simulating H should not abort
>>>>>
>>>>> *You are confused*
>>>>> If the H in the simulated D aborts then the directly executed H did
>>>>> not abort. Since the directly executed H sees one more execution
>>>>> trace then the simulated H then the H in the simulated D never aborts.
>>>>>
>>>>
>>>> No, Olcott told us that the simulating H aborts before it sees that
>>>> the simulated D halts. It only sees that D calls H, but it does not
>>>> see that the called H aborts, because the simulation stops at the
>>>> call, which is too early.
>>>>
>>>
>>> DD correctly simulated by HH cannot possibly reach past its
>>> own first line, thus cannot possibly halt.
>>
>> Olcott does not understand that if the call to HH were correctly
>> simulated, then this HH would abort its simulation and return and
>> therefore DD would continue
>
> *When HH aborts its simulation DD immediately becomes 100%
> totally dead along with the entire simulation chain. I don't
> think that Richard understands this either.
>

On 3/18/2024 11:18 AM, immibis wrote:
> 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.

If you can't even understand that H is a correct abort decider then
you can't understand anything else that requires the prerequisite
knowledge that H is a correct abort decider.

--
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/18/24 1:41 PM, olcott wrote:
> On 3/18/2024 3:33 PM, Richard Damon wrote:
>> On 3/18/24 12:39 PM, olcott wrote:
>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>> What H(D,D) reports is off-topic for this post.
>>>>> *We are only looking at this*
>>>>> [Proof that H(D,D) meets its abort criteria --self-evident truth--]
>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>
>>>>> (a) If *simulating abort decider H* correctly simulates its input D
>>>>> until H correctly determines that its simulated D would never stop
>>>>> running unless aborted then
>>>>
>>>> So, it needs to simulate UNTIL it ACTUALLY CORRECTLY DETERMINES that
>>>> its D will never stop running, unless THIS H aborts it.
>>>>
>>>
>>> You never seemed to get the idea that X is a member of set Y
>>> otherwise X is not a member of set Y.
>>>
>>
>> And what are you defining X and set Y to be?
>>
>> That seems to be your problem, you are listing TWO distinct sets,
>> which hae two distinct set of Deciders and two distince to of inputs.
>>
>> You can't argue about an input built on a different decider tells you
>> anything about the input built on THIS decider.
>
> *This is what those naming conventions derive*
> Everyone is saying that because H(D,D) did need to abort its simulation
> to prevent D(D) from infinite execution that this proves that it never
> needed to abort its simulation because it can rely on the fact that it
> already aborted its simulation thus never needed to abort it.
>

So, you can't define what you SET is defined as?

If not, then how can you complain that I don't get the members right?

That is just part of your deception.

And, you seem to have a confusion about identities.

The calling of H by D is a distinct computation from the H called by
main that is trying to simulate the input given to it

After all D(D) is DEFINED to be a seperate Computation that H is
supposed to decide on.

Seperate things are separate things,

THIS H didn't "already abort it", it was THAT OTHER H that did,

Somethibg distinct from it.

At a different level of "Simulation"

You don't seem to understand that each level of simulation is something
distinct.

Otherwise, when H abort, it would be aborting "itself" and thus stop
running.

On 3/18/2024 6:10 PM, immibis wrote:
> On 18/03/24 23:50, olcott wrote:
>> On 3/18/2024 5:49 AM, Mikko wrote:
>>> 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:
>>>>>>>> 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.
>>>
>>> You have presented nothing that even looks like proof, let alone is.
>>
>> That you don't understand that this is proof does not
>> entail that it is not proof.
>> [execution trace removed]
>
> The execution trace of H(D,D) only proves that H(D,D) returns 0 and does
> not prove that 0 is the correct return value of a halt decider. Actually
> 1 is the correct return value of a halt decider. Therefore, H isn't a
> halt decider.

It is only because H(D,D) sees that it must intervene and force
D(D) to stop running that D(D) ever 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/18/2024 6:11 PM, immibis wrote:
> On 18/03/24 23:49, olcott wrote:
>> On 3/18/2024 5:37 PM, Fred. Zwarts wrote:
>>> Op 18.mrt.2024 om 23:25 schreef olcott:
>>>> On 3/18/2024 4:56 PM, Fred. Zwarts wrote:
>>>>> Op 18.mrt.2024 om 22:48 schreef olcott:
>>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 18.mrt.2024 om 21:40 schreef olcott:
>>>>>>>>>> On 3/18/2024 3:30 PM, immibis wrote:
>>>>>>>>>>> On 18/03/24 21:20, olcott wrote:
>>>>>>>>>>>> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>>>>>>>>>>>>> On 3/18/2024 10:11 AM, 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.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident
>>>>>>>>>>>>>> truth--]
>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Be clear in the naming. Is it Dan that is considered, or
>>>>>>>>>>>>> Dss? Dss must be aborted, because is does not halt, but Dan
>>>>>>>>>>>>> does halt and does not need to be aborted.
>>>>>>>>>>>>
>>>>>>>>>>>> *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.
>>>>>>>>>>>>
>>>>>>>>>>>> (a) If simulating abort decider H correctly simulates its
>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>> would never stop running unless aborted...
>>>>>>>>>>>>
>>>>>>>>>>>> *Therefore*
>>>>>>>>>>>> *Every element of (1) is incorrect and every element of (2)
>>>>>>>>>>>> is correct*
>>>>>>>>>>>> *Pathological thinking to make them both seem incorrect is
>>>>>>>>>>>> incorrect*
>>>>>>>>>>>>
>>>>>>>>>>>>> So, Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and
>>>>>>>>>>>>> the Han that does not meet its abort criteria does abort.
>>>>>>>>>>>>> So, both are wrong.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Is it Dan that is considered, or Dss? Dss must be aborted,
>>>>>>>>>>> because is does not halt, but Dan does halt and does not need
>>>>>>>>>>> to be aborted.
>>>>>>>>>>
>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>>>>>>> simulation
>>>>>>>>>> to prevent D(D) from infinite execution that this proves that
>>>>>>>>>> it never
>>>>>>>>>> needed to abort its simulation because it can rely on the fact
>>>>>>>>>> that it
>>>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You are almost there. If you stop naming all different H which
>>>>>>>>> the same name and all different D with the same name, your
>>>>>>>>> confusion may disappear.
>>>>>>>>
>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>>
>>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>> The Hss that meets the abort criteria does not abort and the Han
>>>>>>>>> that does not meet its abort criteria does abort. So, both are
>>>>>>>>> wrong.
>>>>>>>>>
>>>>>>>
>>>>>>> Olcott does not understand that if the H in the simulated D
>>>>>>> aborts, then the simulating H should not abort
>>>>>>
>>>>>> *You are confused*
>>>>>> If the H in the simulated D aborts then the directly executed H did
>>>>>> not abort. Since the directly executed H sees one more execution
>>>>>> trace then the simulated H then the H in the simulated D never
>>>>>> aborts.
>>>>>>
>>>>>
>>>>> No, Olcott told us that the simulating H aborts before it sees that
>>>>> the simulated D halts. It only sees that D calls H, but it does not
>>>>> see that the called H aborts, because the simulation stops at the
>>>>> call, which is too early.
>>>>>
>>>>
>>>> DD correctly simulated by HH cannot possibly reach past its
>>>> own first line, thus cannot possibly halt.
>>>
>>> Olcott does not understand that if the call to HH were correctly
>>> simulated, then this HH would abort its simulation and return and
>>> therefore DD would continue
>>
>> *When HH aborts its simulation DD immediately becomes 100%
>> totally dead along with the entire simulation chain. I don't
>> think that Richard understands this either.
>>
>
> What happens when the simulation is aborted is irrelevant to what would
> happens if the simulation were not aborted.

On 3/18/2024 6:16 PM, Richard Damon wrote:
> On 3/18/24 1:41 PM, olcott wrote:
>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>> On 3/18/24 12:39 PM, olcott wrote:
>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>> *We are only looking at this*
>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident truth--]
>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>
>>>>>> (a) If *simulating abort decider H* correctly simulates its input
>>>>>> D until H correctly determines that its simulated D would never
>>>>>> stop running unless aborted then
>>>>>
>>>>> So, it needs to simulate UNTIL it ACTUALLY CORRECTLY DETERMINES
>>>>> that its D will never stop running, unless THIS H aborts it.
>>>>>
>>>>
>>>> You never seemed to get the idea that X is a member of set Y
>>>> otherwise X is not a member of set Y.
>>>>
>>>
>>> And what are you defining X and set Y to be?
>>>
>>> That seems to be your problem, you are listing TWO distinct sets,
>>> which hae two distinct set of Deciders and two distince to of inputs.
>>>
>>> You can't argue about an input built on a different decider tells you
>>> anything about the input built on THIS decider.
>>
>> *This is what those naming conventions derive*
>> Everyone is saying that because H(D,D) did need to abort its simulation
>> to prevent D(D) from infinite execution that this proves that it never
>> needed to abort its simulation because it can rely on the fact that it
>> already aborted its simulation thus never needed to abort it.
>>
>
> So, you can't define what you SET is defined as?
>

∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))

Did you notice that I said that at least once now?

> If not, then how can you complain that I don't get the members right?
>
> That is just part of your deception.
>
> And, you seem to have a confusion about identities.
>
> The calling of H by D is a distinct computation from the H called by
> main that is trying to simulate the input given to it
>

This is all a part of the exact same computation.
H(D,D) behaves exactly the same way no matter who calls it.

> After all D(D) is DEFINED to be a seperate Computation that H is
> supposed to decide on.
>
> Seperate things are separate things,
>
>
> THIS H didn't "already abort it", it was THAT OTHER H that did,
>

Therefore proving that from the POV of H(D,D) no matter whether
main() calls it or D(D) calls it own D(D) never halts.

This proves that H(D,D)==0 was always a correct halt status
decision for its own D(D).

> Somethibg distinct from it.
>
> At a different level of "Simulation"
>
> You don't seem to understand that each level of simulation is something
> distinct.
>
I am causing you to see this.

> Otherwise, when H abort, it would be aborting "itself" and thus stop
> 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 19/03/24 00:23, olcott wrote:
> On 3/18/2024 6:11 PM, immibis wrote:
>> On 18/03/24 23:49, olcott wrote:
>>> On 3/18/2024 5:37 PM, Fred. Zwarts wrote:
>>>> Op 18.mrt.2024 om 23:25 schreef olcott:
>>>>> On 3/18/2024 4:56 PM, Fred. Zwarts wrote:
>>>>>> Op 18.mrt.2024 om 22:48 schreef olcott:
>>>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>>>> You are almost there. If you stop naming all different H which
>>>>>>>>>> the same name and all different D with the same name, your
>>>>>>>>>> confusion may disappear.
>>>>>>>>>
>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>>>
>>>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>> The Hss that meets the abort criteria does not abort and the Han
>>>>>>>>>> that does not meet its abort criteria does abort. So, both are
>>>>>>>>>> wrong.
>>>>>>>>>>
>>>>>>>>
>>>>>>>> Olcott does not understand that if the H in the simulated D
>>>>>>>> aborts, then the simulating H should not abort
>>>>>>>
>>>>>>> *You are confused*
>>>>>>> If the H in the simulated D aborts then the directly executed H did
>>>>>>> not abort. Since the directly executed H sees one more execution
>>>>>>> trace then the simulated H then the H in the simulated D never
>>>>>>> aborts.
>>>>>>>
>>>>>>
>>>>>> No, Olcott told us that the simulating H aborts before it sees
>>>>>> that the simulated D halts. It only sees that D calls H, but it
>>>>>> does not see that the called H aborts, because the simulation
>>>>>> stops at the call, which is too early.
>>>>>>
>>>>>
>>>>> DD correctly simulated by HH cannot possibly reach past its
>>>>> own first line, thus cannot possibly halt.
>>>>
>>>> Olcott does not understand that if the call to HH were correctly
>>>> simulated, then this HH would abort its simulation and return and
>>>> therefore DD would continue
>>>
>>> *When HH aborts its simulation DD immediately becomes 100%
>>> totally dead along with the entire simulation chain. I don't
>>> think that Richard understands this either.
>>>
>>
>> What happens when the simulation is aborted is irrelevant to what
>> would happens if the simulation were not aborted.
>
> You did not pay close enough attention to see that Fred said
> that the aborted DD keeps running after it has been aborted.
>

No, he is talking about what WOULD happen if the outer simulation was
not aborted. According to you, this is the basis on which H must make it
decision.

On 19/03/24 00:20, olcott wrote:
> On 3/18/2024 6:10 PM, immibis wrote:
>> On 18/03/24 23:50, olcott wrote:
>>> On 3/18/2024 5:49 AM, Mikko wrote:
>>>> 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:
>>>>>>>>> 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.
>>>>
>>>> You have presented nothing that even looks like proof, let alone is.
>>>
>>> That you don't understand that this is proof does not
>>> entail that it is not proof.
>>> [execution trace removed]
>>
>> The execution trace of H(D,D) only proves that H(D,D) returns 0 and
>> does not prove that 0 is the correct return value of a halt decider.
>> Actually 1 is the correct return value of a halt decider. Therefore, H
>> isn't a halt decider.
>
> It is only because H(D,D) sees that it must intervene and force
> D(D) to stop running that D(D) ever stops running.
>

If the outer simulation was forced not to abort, by skipping the abort
instruction every time the program counter reaches the abort
instruction, you would find that it did not need to abort because the
simulation ends normally.

On 19/03/24 00:13, olcott wrote:
> On 3/18/2024 11:18 AM, immibis wrote:
>> 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.
>
> If you can't even understand that H is a correct abort decider then
> you can't understand anything else that requires the prerequisite
> knowledge that H is a correct abort decider.
>

Strawman deception. It is the halting problem, not the Olcott abort problem.

On 3/18/2024 6:32 PM, immibis wrote:
> On 19/03/24 00:23, olcott wrote:
>> On 3/18/2024 6:11 PM, immibis wrote:
>>> On 18/03/24 23:49, olcott wrote:
>>>> On 3/18/2024 5:37 PM, Fred. Zwarts wrote:
>>>>> Op 18.mrt.2024 om 23:25 schreef olcott:
>>>>>> On 3/18/2024 4:56 PM, Fred. Zwarts wrote:
>>>>>>> Op 18.mrt.2024 om 22:48 schreef olcott:
>>>>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>>>>> You are almost there. If you stop naming all different H
>>>>>>>>>>> which the same name and all different D with the same name,
>>>>>>>>>>> your confusion may disappear.
>>>>>>>>>>
>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls
>>>>>>>>>> H(D,D))
>>>>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>>>>
>>>>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>> The Hss that meets the abort criteria does not abort and the Han
>>>>>>>>>>> that does not meet its abort criteria does abort. So, both
>>>>>>>>>>> are wrong.
>>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Olcott does not understand that if the H in the simulated D
>>>>>>>>> aborts, then the simulating H should not abort
>>>>>>>>
>>>>>>>> *You are confused*
>>>>>>>> If the H in the simulated D aborts then the directly executed H did
>>>>>>>> not abort. Since the directly executed H sees one more execution
>>>>>>>> trace then the simulated H then the H in the simulated D never
>>>>>>>> aborts.
>>>>>>>>
>>>>>>>
>>>>>>> No, Olcott told us that the simulating H aborts before it sees
>>>>>>> that the simulated D halts. It only sees that D calls H, but it
>>>>>>> does not see that the called H aborts, because the simulation
>>>>>>> stops at the call, which is too early.
>>>>>>>
>>>>>>
>>>>>> DD correctly simulated by HH cannot possibly reach past its
>>>>>> own first line, thus cannot possibly halt.
>>>>>
>>>>> Olcott does not understand that if the call to HH were correctly
>>>>> simulated, then this HH would abort its simulation and return and
>>>>> therefore DD would continue
>>>>
>>>> *When HH aborts its simulation DD immediately becomes 100%
>>>> totally dead along with the entire simulation chain. I don't
>>>> think that Richard understands this either.
>>>>
>>>
>>> What happens when the simulation is aborted is irrelevant to what
>>> would happens if the simulation were not aborted.
>>
>> You did not pay close enough attention to see that Fred said
>> that the aborted DD keeps running after it has been aborted.
>>
>
> No, he is talking about what WOULD happen if the outer simulation was
> not aborted. According to you, this is the basis on which H must make it
> decision.

It is simplest to always abort as soon as the abort criteria
is met. If the outer HH waits for the inner HH then it is
waiting on its inner HH on and on forever...

--
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/18/2024 6:33 PM, immibis wrote:
> On 19/03/24 00:20, olcott wrote:
>> On 3/18/2024 6:10 PM, immibis wrote:
>>> On 18/03/24 23:50, olcott wrote:
>>>> On 3/18/2024 5:49 AM, Mikko wrote:
>>>>> 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:
>>>>>>>>>> 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.
>>>>>
>>>>> You have presented nothing that even looks like proof, let alone is.
>>>>
>>>> That you don't understand that this is proof does not
>>>> entail that it is not proof.
>>>> [execution trace removed]
>>>
>>> The execution trace of H(D,D) only proves that H(D,D) returns 0 and
>>> does not prove that 0 is the correct return value of a halt decider.
>>> Actually 1 is the correct return value of a halt decider. Therefore,
>>> H isn't a halt decider.
>>
>> It is only because H(D,D) sees that it must intervene and force
>> D(D) to stop running that D(D) ever stops running.
>>
>
> If the outer simulation was forced not to abort, by skipping the abort
> instruction every time the program counter reaches the abort
> instruction, you would find that it did not need to abort because the
> simulation ends normally.

That merely cheats the foundational assumption that the outer one
and the inner one have the exact same algorithm. I was going to
comment on Mike post about this yet deciding that it made my reply
more complex thus harder to understand.

As it is now I have to focus on the exact same point thousands
of times before anyone ever gets it. It took Richard two years
to notice that H(D,D) and H1(D,D) really do get a different result.

For two years he simply assumed that this was impossible thus
never bothered to look at the execution trace that proved I
was correct all along.

--
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/18/2024 6:34 PM, immibis wrote:
> On 19/03/24 00:13, olcott wrote:
>> On 3/18/2024 11:18 AM, immibis wrote:
>>> 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.
>>
>> If you can't even understand that H is a correct abort decider then
>> you can't understand anything else that requires the prerequisite
>> knowledge that H is a correct abort decider.
>>
>
> Strawman deception. It is the halting problem, not the Olcott abort
> problem.

You can learn calculus without the basis of algebra. You can't learn
simulating halt deciders without the basis of simulating abort deciders.

--
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/18/24 3:50 PM, olcott wrote:
> On 3/18/2024 5:49 AM, Mikko wrote:
>> 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.
>>
>> You have presented nothing that even looks like proof, let alone is.
>>
>
> That you don't understand that this is proof does not
> entail that it is not proof.

On 3/18/24 4:20 PM, olcott wrote:
> On 3/18/2024 6:10 PM, immibis wrote:
>> On 18/03/24 23:50, olcott wrote:
>>> On 3/18/2024 5:49 AM, Mikko wrote:
>>>> 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:
>>>>>>>>> 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.
>>>>
>>>> You have presented nothing that even looks like proof, let alone is.
>>>
>>> That you don't understand that this is proof does not
>>> entail that it is not proof.
>>> [execution trace removed]
>>
>> The execution trace of H(D,D) only proves that H(D,D) returns 0 and
>> does not prove that 0 is the correct return value of a halt decider.
>> Actually 1 is the correct return value of a halt decider. Therefore, H
>> isn't a halt decider.
>
> It is only because H(D,D) sees that it must intervene and force
> D(D) to stop running that D(D) ever stops running.
>

You mean it THINKS that it must intervene.

Turns out that this instance of H doesn't need to.

So, it is wrong.

On 3/18/24 4:42 PM, olcott wrote:
> On 3/18/2024 6:33 PM, immibis wrote:
>> On 19/03/24 00:20, olcott wrote:
>>> On 3/18/2024 6:10 PM, immibis wrote:
>>>> On 18/03/24 23:50, olcott wrote:
>>>>> On 3/18/2024 5:49 AM, Mikko wrote:
>>>>>> 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:
>>>>>>>>>>> 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.
>>>>>>
>>>>>> You have presented nothing that even looks like proof, let alone is.
>>>>>
>>>>> That you don't understand that this is proof does not
>>>>> entail that it is not proof.
>>>>> [execution trace removed]
>>>>
>>>> The execution trace of H(D,D) only proves that H(D,D) returns 0 and
>>>> does not prove that 0 is the correct return value of a halt decider.
>>>> Actually 1 is the correct return value of a halt decider. Therefore,
>>>> H isn't a halt decider.
>>>
>>> It is only because H(D,D) sees that it must intervene and force
>>> D(D) to stop running that D(D) ever stops running.
>>>
>>
>> If the outer simulation was forced not to abort, by skipping the abort
>> instruction every time the program counter reaches the abort
>> instruction, you would find that it did not need to abort because the
>> simulation ends normally.
>
> That merely cheats the foundational assumption that the outer one
> and the inner one have the exact same algorithm. I was going to
> comment on Mike post about this yet deciding that it made my reply
> more complex thus harder to understand.
>
> As it is now I have to focus on the exact same point thousands
> of times before anyone ever gets it. It took Richard two years
> to notice that H(D,D) and H1(D,D) really do get a different result.
>
> For two years he simply assumed that this was impossible thus
> never bothered to look at the execution trace that proved I
> was correct all along.
>

No, your problem is that you have LIED about what you claim to be doing.

You have established that your goal is to apply your work to the Halting
Problem and Turing machines.

YOu have also establihsed that you are not above MISQUOTING people e to
try to use it to get support for things the people didn't say.

Your decider/input structure is TOTALLY not congruent with what would be
needed to actually be a Turing Equivalent of the system, this has been
pointed out, and you ignore it.

You USE this incongruency to do things that you could not do in an
actual Turing Equivalent system.

It turns out that, YES, in your system you are actually asking a truely
invalid question, but it is not the one asked in the Halting Problem,
and in fact, your question could NOT actually be asked of a decider, as
you can't make an input do what you specify.

I will point out that you continue to LIE.

Your CLAIM was initially that H and H1 were the same computation, and in
that condition, they can not do what you claim.

You claim that "Hidden" inputs were not "Hidden" because you could look
for them, when that isn't was defined inputs mean.

If you want to say I lie about this, SHOW WHERE I SAIND that H and H1
couldn't do that by being different computations.

YOU ARE JUST A MORONIC PATHETIC IGNORANT HYPOCRITICAL PATHOOLGOICAL
DAMNED LYING PEDOPHILIC IDIOT.

On 3/18/24 4:02 PM, olcott wrote:
> On 3/18/2024 6:26 AM, Mikko wrote:
>> 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.
>>
>
> I do yet so far everyone says that they believe this is impossible
> so I have to go back a few steps and prove that it is possible.

On 3/18/24 4:13 PM, olcott wrote:
> On 3/18/2024 11:18 AM, immibis wrote:
>> 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.
>
> If you can't even understand that H is a correct abort decider then
> you can't understand anything else that requires the prerequisite
> knowledge that H is a correct abort decider.
>

But by the definition YOU agreed to:

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.

H isn't a correct abort decider.

Since D(D) Halts thus H can't correctly abort it simulaition of it.

On 3/18/24 2:16 PM, olcott wrote:
> On 3/18/2024 3:56 PM, Richard Damon wrote:
>> On 3/18/24 1:41 PM, olcott wrote:
>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>> *We are only looking at this*
>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident truth--]
>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>
>>>>>>> (a) If *simulating abort decider H* correctly simulates its input
>>>>>>> D until H correctly determines that its simulated D would never
>>>>>>> stop running unless aborted then
>>>>>>
>>>>>> So, it needs to simulate UNTIL it ACTUALLY CORRECTLY DETERMINES
>>>>>> that its D will never stop running, unless THIS H aborts it.
>>>>>>
>>>>>
>>>>> You never seemed to get the idea that X is a member of set Y
>>>>> otherwise X is not a member of set Y.
>>>>>
>>>>
>>>> And what are you defining X and set Y to be?
>>>>
>>>> That seems to be your problem, you are listing TWO distinct sets,
>>>> which hae two distinct set of Deciders and two distince to of inputs.
>>>>
>>>> You can't argue about an input built on a different decider tells
>>>> you anything about the input built on THIS decider.
>>>
>>> *This is what those naming conventions derive*
>>> Everyone is saying that because H(D,D) did need to abort its simulation
>>> to prevent D(D) from infinite execution that this proves that it never
>>> needed to abort its simulation because it can rely on the fact that it
>>> already aborted its simulation thus never needed to abort it.
>>>
>>
>> So, you can't define what you SET is defined as?
>>
>
> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))

So, ONLY the D that calls that PARTICULAR H.

>
>
>> If not, then how can you complain that I don't get the members right?
>>
>> That is just part of your deception.
>>
>> And, you seem to have a confusion about identities.
>>
>> The calling of H by D is a distinct computation from the H called by
>> main that is trying to simulate the input given to it
>>
> That is counter-factual.

Nope.

Until you renounce that your work is in the shadows of computaiton
theory, you are working under its definitons.

And thus each level of simulation is of a INDEPENDENT machine.

How do you say they are the same?

What ACTUAL ACCEPTED DEFINITIONS?

>
>> After all D(D) is DEFINED to be a seperate Computation that H is
>> supposed to decide on.
>>
>> Seperate things are separate things,
>>
>>
>> THIS H didn't "already abort it", it was THAT OTHER H that did,
>>
>> Somethibg distinct from it.
>>
> Richard cannot seem to understand that.

???

The copy of H that aborted WAS a seperate instance from the one that is
running in the call from main.

>
>> At a different level of "Simulation"
>>
> main() { D(D); }   // directly invokes H(D,D)
> main() { H(D,D); } // directly invokes H(D,D)

But you are looking at the SIMULATION of the first by the second.

Thus, it IS a level down in simulation.

You are just LYING again, (Like always)

>
>
>> You don't seem to understand that each level of simulation is
>> something distinct.
>>
> main() { D(D); }   // only stops running because H(D,D) aborted
> the recursive simulation that this directly invoked D(D) specifies.

But it DIDN'T abort that directly executed D(D), as that halted without
being aborted.

You are just unable to see the difference between "Same Thing" and
"Different Things"

That is your insanity.

>
>> Otherwise, when H abort, it would be aborting "itself" and thus stop
>> running.
>

On 19/03/24 00:31, olcott wrote:
> On 3/18/2024 6:16 PM, Richard Damon wrote:
>> On 3/18/24 1:41 PM, olcott wrote:
>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>> *We are only looking at this*
>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident truth--]
>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>
>>>>>>> (a) If *simulating abort decider H* correctly simulates its input
>>>>>>> D until H correctly determines that its simulated D would never
>>>>>>> stop running unless aborted then
>>>>>>
>>>>>> So, it needs to simulate UNTIL it ACTUALLY CORRECTLY DETERMINES
>>>>>> that its D will never stop running, unless THIS H aborts it.
>>>>>>
>>>>>
>>>>> You never seemed to get the idea that X is a member of set Y
>>>>> otherwise X is not a member of set Y.
>>>>>
>>>>
>>>> And what are you defining X and set Y to be?
>>>>
>>>> That seems to be your problem, you are listing TWO distinct sets,
>>>> which hae two distinct set of Deciders and two distince to of inputs.
>>>>
>>>> You can't argue about an input built on a different decider tells
>>>> you anything about the input built on THIS decider.
>>>
>>> *This is what those naming conventions derive*
>>> Everyone is saying that because H(D,D) did need to abort its simulation
>>> to prevent D(D) from infinite execution that this proves that it never
>>> needed to abort its simulation because it can rely on the fact that it
>>> already aborted its simulation thus never needed to abort it.
>>>
>>
>> So, you can't define what you SET is defined as?
>>
>
> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))

This doesn't define a set, it is a statement which says all Turing
machines simulate their input and all Turing machines D (whatever that
means) call H(D,D). It is obviously false because some Turing machines
don't simulate their input.

> This is all a part of the exact same computation.
> H(D,D) behaves exactly the same way no matter who calls it.

So when D(D) calls it, it aborts and D(D) halts even if outer D(D) is
not aborted?

> Therefore proving that from the POV of H(D,D) no matter whether > main() calls it or D(D) calls it own D(D) never halts.

Wrong, blatant lie, why do you keep lying? It is obvious that D(D)
halts. Just run it for a few milliseconds and see.