On 19/03/24 00:42, 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.

Not all inputs to a halt decider have the exact same algorithm as the
halt decider.

On 19/03/24 00:43, olcott wrote:
> 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.

When are you going to extend this theory of simulating abort deciders so
that it solves the halting problem instead of merely solving the Olcott
abort problem?

On 3/18/24 4:31 PM, 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))
> ∀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?

So, where did I confuse something IN that set to something outside that set?

I was just pointing out that the H that abort can't use the behavior of
the D that used the H that doesn't in determining what it does.

I guess you think that if I define a decider that just ALWAYS aborts
(maybe except for a single case so I have something to look at) can just
define ALL those inputs as "Needed to Abort".

>
>> 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.

Nope, H(D,D) is SIMULATING a DISTINCT machine, the D(D) described to it.

It is THAT DIESTINCT machine that has a distinct H that aborts THAT
machies simulation, and thus return 0 and that machine halts.

You are just showing you don't understand what you talking about.

>
>> 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).

Nope.

It isn't a "Subjective" requriement that HAS a "POV".

It seems you just thinking that things are allowed to just lie if they
need to be able to claim to be right.

>
>> 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.

So, are you AGREEING that things in the simulated machine are happening
in a distinct machine from the simulator?

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

On 3/18/24 2:48 PM, olcott wrote:
> 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.

On 3/18/2024 8:45 PM, immibis wrote:
> On 19/03/24 00:43, olcott wrote:
>> 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.
>
> When are you going to extend this theory of simulating abort deciders so
> that it solves the halting problem instead of merely solving the Olcott
> abort problem?

*Here are the two key steps to that*
(1) Abort deciders correctly decide to abort.
(2) The halting problem requires the correct answer to an incorrect
question thus must be redefined.

--
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:25 PM, olcott wrote:
> 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.

On 3/18/24 4:35 PM, olcott wrote:
> 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...
>

But, you need CORRECT abort criteria that means that the correct
simulation of the input would never halt.

Not if the algorithm of H doesn't halt, because that would be logic
based on a false premise, and an H that never aborts is a different
algorithm that an H that does abort.

SO, if, even with the algorithm of H aborting here, would the correct
simulation of this input (with that algorithm) never halt.

THEN you can abort.

H is just stuck between a rock and a hard place, which is why correct
Halt Decider, or correct abort deciding, is non-computable.

On 3/18/24 4:05 PM, olcott wrote:
> 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.
>

But, doesn't the "Meaning" of the function D include the meaning of the
H it calls.

Normally that is true.

On 3/18/24 7:46 PM, olcott wrote:
> On 3/18/2024 8:45 PM, immibis wrote:
>> On 19/03/24 00:43, olcott wrote:
>>> 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.
>>
>> When are you going to extend this theory of simulating abort deciders
>> so that it solves the halting problem instead of merely solving the
>> Olcott abort problem?
>
> *Here are the two key steps to that*
> (1) Abort deciders correctly decide to abort.
> (2) The halting problem requires the correct answer to an incorrect
> question thus must be redefined.
>
>

But (2) is a LIE.

There is nothing "Incorrect" about the Halting Question.

Please show some EXACT input that doesn't have a correct answer.

Remember, that says that (for Linz) H^ is precisely SPECIFIED, as is the
H that it is built on, that means we can know what H (H^) (H^) will
return as an answer. (which will be wrong).

IF every input has a correct answer, then the question is valid.

What definition of "Invalid" are you trying to use?

Your problem is that you don't seem to understand the fundamental nature
of programs, that they WILL do what they are programmed to, and can't do
anything different.

On 3/18/2024 9:44 PM, Richard Damon wrote:
> On 3/18/24 2:48 PM, olcott wrote:
>> 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.
>
> Nope, YOU are confused If the H in the simulated D aborts,

On 3/18/2024 10:11 PM, Richard Damon wrote:
> On 3/18/24 7:46 PM, olcott wrote:
>> On 3/18/2024 8:45 PM, immibis wrote:
>>> On 19/03/24 00:43, olcott wrote:
>>>> 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.
>>>
>>> When are you going to extend this theory of simulating abort deciders
>>> so that it solves the halting problem instead of merely solving the
>>> Olcott abort problem?
>>
>> *Here are the two key steps to that*
>> (1) Abort deciders correctly decide to abort.
>> (2) The halting problem requires the correct answer to an incorrect
>> question thus must be redefined.
>>
>>
>
> But (2) is a LIE.
>
> There is nothing "Incorrect" about the Halting Question.
>

Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
such that YES is a correct answer from one entity
and YES is an incorrect answer from another entity
is an incorrect question when posed to this second entity.

> Please show some EXACT input that doesn't have a correct answer.
>
> Remember, that says that (for Linz) H^ is precisely SPECIFIED, as is the
> H that it is built on, that means we can know what H (H^) (H^) will
> return as an answer. (which will be wrong).
>
> IF every input has a correct answer, then the question is valid.
>
> What definition of "Invalid" are you trying to use?
>
> Your problem is that you don't seem to understand the fundamental nature
> of programs, that they WILL do what they are programmed to, and can't do
> anything different.

--
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 8:53 PM, olcott wrote:
> On 3/18/2024 9:44 PM, Richard Damon wrote:
>> On 3/18/24 2:48 PM, olcott wrote:
>>> 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.
>>
>> Nope, YOU are confused If the H in the simulated D aborts,
>
> Then a dozen square circles are on sale at Walmart right now for $10.99

On 3/18/24 9:11 PM, olcott wrote:
> On 3/18/2024 10:11 PM, Richard Damon wrote:
>> On 3/18/24 7:46 PM, olcott wrote:
>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>> On 19/03/24 00:43, olcott wrote:
>>>>> 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.
>>>>
>>>> When are you going to extend this theory of simulating abort
>>>> deciders so that it solves the halting problem instead of merely
>>>> solving the Olcott abort problem?
>>>
>>> *Here are the two key steps to that*
>>> (1) Abort deciders correctly decide to abort.
>>> (2) The halting problem requires the correct answer to an incorrect
>>> question thus must be redefined.
>>>
>>>
>>
>> But (2) is a LIE.
>>
>> There is nothing "Incorrect" about the Halting Question.
>>
>
> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
> such that YES is a correct answer from one entity
> and YES is an incorrect answer from another entity
> is an incorrect question when posed to this second entity.

So, SHOW ME and ACTUAL H and H^ such that H (H^) (H^) says yess
incorrectly while H1 (H^) (H^) says yes correctly?

You are just proving that you are nothing but a total idiot that doesn't
know what he is talking about and thinks computations have free will and
can give whatever answer they feel like.

Or maybe it is that you can change a program but still keep it the same
program.

Or is the error tosay that two different things can be the same or one
thing can be to distictly different things at the same time.

You are just proving you are an idiot.

>
>> Please show some EXACT input that doesn't have a correct answer.

NOTE, YOU IGNORED THIS BECAUSE YOU KNOW YOU CAN'T DO IT

THIS PROVES YOU ARE JUST A LIAR.

>>
>> Remember, that says that (for Linz) H^ is precisely SPECIFIED, as is
>> the H that it is built on, that means we can know what H (H^) (H^)
>> will return as an answer. (which will be wrong).
>>
>> IF every input has a correct answer, then the question is valid.
>>
>> What definition of "Invalid" are you trying to use?
>>
>> Your problem is that you don't seem to understand the fundamental
>> nature of programs, that they WILL do what they are programmed to, and
>> can't do anything different.
>

On 3/18/2024 11:23 PM, Richard Damon wrote:
> On 3/18/24 8:53 PM, olcott wrote:
>> On 3/18/2024 9:44 PM, Richard Damon wrote:
>>> On 3/18/24 2:48 PM, olcott wrote:
>>>> 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.
>>>
>>> Nope, YOU are confused If the H in the simulated D aborts,
>>
>> Then a dozen square circles are on sale at Walmart right now for $10.99
>
> Interesting, that you retort was to just blantently lie?
>
> When presented with FACTS, you respond with LIES.
>
> That just shows who you are.
>
>>
>>> then the directly executed D MUST abort, or you are agreeing that H's
>>> simulation is not correct.
>>>
>>
>> In other words after we have been over this hundreds and hundreds of
>> times it is still waaaayyy over your head that the executed H always
>> sees exactly one more execution trace than the executed H?
>
> Do you really read your nonsense?
>
> How does x, "the executed H" see one more execution trace than x?
>
> That means you think that 1 + 1 = 1
>
>>
>>> And no, the directed executed vesion of D see no more information
>>> then the machine the simulated D represents,
>>
>> The simulated H can not see its own behavior where as its simulator
>> can thus proving the simulator sees one more execution trace that its
>> simulation.
>
> Nope, it may see one more then at the point the simulation reaches,

On 3/18/24 9:37 PM, olcott wrote:
> On 3/18/2024 11:23 PM, Richard Damon wrote:
>> On 3/18/24 8:53 PM, olcott wrote:
>>> On 3/18/2024 9:44 PM, Richard Damon wrote:
>>>> On 3/18/24 2:48 PM, olcott wrote:
>>>>> 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.
>>>>
>>>> Nope, YOU are confused If the H in the simulated D aborts,
>>>
>>> Then a dozen square circles are on sale at Walmart right now for $10.99
>>
>> Interesting, that you retort was to just blantently lie?
>>
>> When presented with FACTS, you respond with LIES.
>>
>> That just shows who you are.
>>
>>>
>>>> then the directly executed D MUST abort, or you are agreeing that
>>>> H's simulation is not correct.
>>>>
>>>
>>> In other words after we have been over this hundreds and hundreds of
>>> times it is still waaaayyy over your head that the executed H always
>>> sees exactly one more execution trace than the executed H?
>>
>> Do you really read your nonsense?
>>
>> How does x, "the executed H" see one more execution trace than x?
>>
>> That means you think that 1 + 1 = 1
>>
>>>
>>>> And no, the directed executed vesion of D see no more information
>>>> then the machine the simulated D represents,
>>>
>>> The simulated H can not see its own behavior where as its simulator
>>> can thus proving the simulator sees one more execution trace that its
>>> simulation.
>>
>> Nope, it may see one more then at the point the simulation reaches,
>
> Yes, finally. Thus the executed H(D,D) sees its abort criteria before
> any of the simulated ones ever would.

On 3/19/2024 12:23 AM, Richard Damon wrote:
> On 3/18/24 9:37 PM, olcott wrote:
>> On 3/18/2024 11:23 PM, Richard Damon wrote:
>>> On 3/18/24 8:53 PM, olcott wrote:
>>>> On 3/18/2024 9:44 PM, Richard Damon wrote:
>>>>> On 3/18/24 2:48 PM, olcott wrote:
>>>>>> 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.
>>>>>
>>>>> Nope, YOU are confused If the H in the simulated D aborts,
>>>>
>>>> Then a dozen square circles are on sale at Walmart right now for $10.99
>>>
>>> Interesting, that you retort was to just blantently lie?
>>>
>>> When presented with FACTS, you respond with LIES.
>>>
>>> That just shows who you are.
>>>
>>>>
>>>>> then the directly executed D MUST abort, or you are agreeing that
>>>>> H's simulation is not correct.
>>>>>
>>>>
>>>> In other words after we have been over this hundreds and hundreds of
>>>> times it is still waaaayyy over your head that the executed H always
>>>> sees exactly one more execution trace than the executed H?
>>>
>>> Do you really read your nonsense?
>>>
>>> How does x, "the executed H" see one more execution trace than x?
>>>
>>> That means you think that 1 + 1 = 1
>>>
>>>>
>>>>> And no, the directed executed vesion of D see no more information
>>>>> then the machine the simulated D represents,
>>>>
>>>> The simulated H can not see its own behavior where as its simulator
>>>> can thus proving the simulator sees one more execution trace that
>>>> its simulation.
>>>
>>> Nope, it may see one more then at the point the simulation reaches,
>>
>> Yes, finally. Thus the executed H(D,D) sees its abort criteria before
>> any of the simulated ones ever would.
>
> Before the SIMULATION of the SIMULATED one does.
>
> The actual machine has finished before the simulation ever started
> (since it halts)
*H sees that D would keep repeating at machine address* [00001cfe]

On 2024-03-18 23:02:18 +0000, olcott said:

> 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 2024-03-19 02:46:27 +0000, olcott said:

> On 3/18/2024 8:45 PM, immibis wrote:
>> On 19/03/24 00:43, olcott wrote:
>>> 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.
>>
>> When are you going to extend this theory of simulating abort deciders
>> so that it solves the halting problem instead of merely solving the
>> Olcott abort problem?
>
> *Here are the two key steps to that*
> (1) Abort deciders correctly decide to abort.
> (2) The halting problem requires the correct answer to an incorrect
> question thus must be redefined.

If a problem is redefined it must also be renamed. The original name
is already reserved.

--
Mikko

On 2024-03-18 14:44:22 +0000, olcott said:

> 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*

Op 18.mrt.2024 om 23:49 schreef olcott:
> 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 2024-03-18 20:56:38 +0000, Richard Damon said:

> 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.

Actually, the criterion discussed here only aborts H called by D. Another
criterion is needed if the loop at the end of D needs be aborted.

--
Mikko

On 2024-03-18 21:16:42 +0000, olcott said:

> 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))

Use of double quantifiers may be a little confusing as each D calls
only one H.

--
Mikko

Op 19.mrt.2024 om 05:37 schreef olcott:
> On 3/18/2024 11:23 PM, Richard Damon wrote:
>> On 3/18/24 8:53 PM, olcott wrote:
>>> On 3/18/2024 9:44 PM, Richard Damon wrote:
>>>> On 3/18/24 2:48 PM, olcott wrote:
>>>>> 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.
>>>>
>>>> Nope, YOU are confused If the H in the simulated D aborts,
>>>
>>> Then a dozen square circles are on sale at Walmart right now for $10.99
>>
>> Interesting, that you retort was to just blantently lie?
>>
>> When presented with FACTS, you respond with LIES.
>>
>> That just shows who you are.
>>
>>>
>>>> then the directly executed D MUST abort, or you are agreeing that
>>>> H's simulation is not correct.
>>>>
>>>
>>> In other words after we have been over this hundreds and hundreds of
>>> times it is still waaaayyy over your head that the executed H always
>>> sees exactly one more execution trace than the executed H?
>>
>> Do you really read your nonsense?
>>
>> How does x, "the executed H" see one more execution trace than x?
>>
>> That means you think that 1 + 1 = 1
>>
>>>
>>>> And no, the directed executed vesion of D see no more information
>>>> then the machine the simulated D represents,
>>>
>>> The simulated H can not see its own behavior where as its simulator
>>> can thus proving the simulator sees one more execution trace that its
>>> simulation.
>>
>> Nope, it may see one more then at the point the simulation reaches,
>
> Yes, finally. Thus the executed H(D,D) sees its abort criteria before
> any of the simulated ones ever would.
>
>> but the actual machine that is now being simulated did EVERYTHING that
>> it will do as soon as it was created,
>>
> No it is not true that x86 machines are oracle machines.
> https://en.wikipedia.org/wiki/Oracle_machine
>
>> You keep on makeing that mistake, confusing the simulation with what
>> actually happens.
>>
>>>
>>>> if H aborts the simulation before then, then H just doesn't get to
>>>> know what happens after that.
>>>>
>>>> I will point out, you almost NEVER actually look at the direct
>>>> execution of D(D), because it just proves that H isn't a correct
>>>> Halt Decider.
>>>>
>>>
>>> H(D,D) cannot rely on the behavior of D(D) after it has already aborted
>>> its simulation or it would never abort its simulation and D(D) would
>>> never stop running. This means that the executed H(D,D) see non halting
>>> behavior.
>>>
>>
>> Right, H is in a no-win pickle. (or its programmer is).
>
> Not at all. The requirement for clairvoyance is an incorrect
> requirement. H(D,D) cannot be correctly required to report on
> what it cannot see.
>
>> If we wait, we run into the issue that we may never answer. If we
>> abort, we don't know what answer to give.
>
> An abort decider would report on whether it aborted or not.
>
>> That is why the Halting Mapping turns out to be uncomputable.
>>
>
> *H(D,D) cannot be correctly required to report on what it cannot see*
>

On 2024-03-19 04:37:02 +0000, olcott said:

> On 3/18/2024 11:23 PM, Richard Damon wrote:
>> On 3/18/24 8:53 PM, olcott wrote:
>>> On 3/18/2024 9:44 PM, Richard Damon wrote:
>>>> On 3/18/24 2:48 PM, olcott wrote:
>>>>> 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.
>>>>
>>>> Nope, YOU are confused If the H in the simulated D aborts,
>>>
>>> Then a dozen square circles are on sale at Walmart right now for $10.99
>>
>> Interesting, that you retort was to just blantently lie?
>>
>> When presented with FACTS, you respond with LIES.
>>
>> That just shows who you are.
>>
>>>
>>>> then the directly executed D MUST abort, or you are agreeing that H's
>>>> simulation is not correct.
>>>>
>>>
>>> In other words after we have been over this hundreds and hundreds of
>>> times it is still waaaayyy over your head that the executed H always
>>> sees exactly one more execution trace than the executed H?
>>
>> Do you really read your nonsense?
>>
>> How does x, "the executed H" see one more execution trace than x?
>>
>> That means you think that 1 + 1 = 1
>>
>>>
>>>> And no, the directed executed vesion of D see no more information then
>>>> the machine the simulated D represents,
>>>
>>> The simulated H can not see its own behavior where as its simulator
>>> can thus proving the simulator sees one more execution trace that its
>>> simulation.
>>
>> Nope, it may see one more then at the point the simulation reaches,
>
> Yes, finally. Thus the executed H(D,D) sees its abort criteria before
> any of the simulated ones ever would.
>
>> but the actual machine that is now being simulated did EVERYTHING that
>> it will do as soon as it was created,
>>
> No it is not true that x86 machines are oracle machines.
> https://en.wikipedia.org/wiki/Oracle_machine
>
>> You keep on makeing that mistake, confusing the simulation with what
>> actually happens.
>>
>>>
>>>> if H aborts the simulation before then, then H just doesn't get to know
>>>> what happens after that.
>>>>
>>>> I will point out, you almost NEVER actually look at the direct
>>>> execution of D(D), because it just proves that H isn't a correct Halt
>>>> Decider.
>>>>
>>>
>>> H(D,D) cannot rely on the behavior of D(D) after it has already aborted
>>> its simulation or it would never abort its simulation and D(D) would
>>> never stop running. This means that the executed H(D,D) see non halting
>>> behavior.
>>>
>>
>> Right, H is in a no-win pickle. (or its programmer is).
>
> Not at all. The requirement for clairvoyance is an incorrect
> requirement. H(D,D) cannot be correctly required to report on
> what it cannot see.
>
>> If we wait, we run into the issue that we may never answer. If we
>> abort, we don't know what answer to give.
>
> An abort decider would report on whether it aborted or not.
>
>> That is why the Halting Mapping turns out to be uncomputable.
>>
>
> *H(D,D) cannot be correctly required to report on what it cannot see*

On 2024-03-18 23:05:33 +0000, olcott said:

> 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.

What exacly you don't understand? Do you understand the following
phrases:

- "every possibe way that H can be encoded" ?

- "D(D) calls H(D,D)" ?

- "the H(D,D) that D(D) calls" ?

- "H(D,D) aborts its simulation"

Unless you can answer I can only assume that you are too stupid
for this discussion.

--
Mikko