On 3/18/2024 11:31 PM, Richard Damon wrote:
> 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 found a bug in my words* (I will start consistently reporting this)

H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says YES this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says NO this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
No matter what any H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says it does not correspond to Halts(Ĥ ⟨Ĥ⟩)

So we are back to both YES and NO are the wrong answer for every
element in this template:

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

All of the elements that reported NO had to abort their simulation
or they could not have reported NO thus have no corresponding YES
element that reports at all.

All of the elements that took the YES path failed to report because
they either did not abort their simulation or got stuck in the infinite
loop thus have no corresponding NO element.

--
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/19/24 9:43 AM, olcott wrote:
> On 3/18/2024 11:31 PM, Richard Damon wrote:
>> 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 found a bug in my words* (I will start consistently reporting this)
>
> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says YES this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says  NO this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
> No matter what any H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says it does not correspond to Halts(Ĥ ⟨Ĥ⟩)

Right, but only because you restrict yourself to looking at the H^ based
on you, and the two lines are different Hs looking at different H^s.

So, not a contradiction.
when we clarify the differences we get:

H1.Ĥ1 ⟨Ĥ1⟩ ⟨Ĥ1⟩ says YES this does not correspond to Halts(Ĥ1 ⟨Ĥ1⟩)
H2.Ĥ2 ⟨Ĥ2⟩ ⟨Ĥ2⟩ says NO this does not correspond to Halts(Ĥ2 ⟨Ĥ2⟩)

since Halts(Ĥ1 ⟨Ĥ1⟩) != Halts(Ĥ2 ⟨Ĥ2⟩) this isn't a problem.

>
> So we are back to both YES and NO are the wrong answer for every
> element in this template:

Nope,
No was the right answer for H1, and YES was the right answer for H2

>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> All of the elements that reported NO had to abort their simulation
> or they could not have reported NO thus have no corresponding YES
> element that reports at all.
>
> All of the elements that took the YES path failed to report because
> they either did not abort their simulation or got stuck in the infinite
> loop thus have no corresponding NO element.
>

In other words, you need to use broken logic to try to assert your lie.

Yes, All the H1s needed to abort but didn't

All the H2s needs to continue to sumulate but didn't

So, all did the wrong thing.

On 19/03/24 03:46, 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.
>
>
Thus the halting problem is unsolvable -- abort deciders cannot be
extended to solve the halting problem instead of just the abort problem.

On 3/19/2024 11:35 AM, Richard Damon wrote:
> On 3/19/24 7:56 AM, olcott wrote:
>> On 3/19/2024 4:05 AM, Fred. Zwarts wrote:
>>> 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*
>>>>
>>>
>>> But H(D,D) cannot be allowed to choose what it want to see and what
>>> it does not want to see. By aborting, it chooses to close it eyes and
>>> therefore it does not see that D calls H, which aborts and returns.
>>> It is not a matter of 'cannot see', but 'chooses to be blind for the
>>> facts'.
>>>
>>
>> Can D correctly simulated by H terminate normally?
>> 01 int D(ptr x)  // ptr is pointer to int function
>> 02 {
>> 03   int Halt_Status = H(x, x);
>> 04   if (Halt_Status)
>> 05     HERE: goto HERE;
>> 06   return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> *Execution Trace*
>> Line 11: main() invokes H(D,D);
>>
>> *keeps repeating* (unless aborted)
>
> No, Stops because the H that D uses aborts ITS simulation and returns.
>
> YOUR H just doesn't know what that is, or is lying about who it is.
>
>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>
>> *Simulation invariant*
>> D correctly simulated by H cannot possibly reach past its own line 03.
>
> Incorrect. LIE.
>

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

If Ĥ is your x86utm function D, then "yes" is the correct answer to all
entities.

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

On 19/03/24 05:37, olcott wrote:
> You are just getting nutty now. You are tossing out the sequence,
> selection, iteration model of computation.

aren't you tossing out the turing machine model of computation?

On 19/03/24 15:37, olcott wrote:
> On 3/19/2024 4:24 AM, Mikko wrote:
>> 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*
>>
>> A requirement is correct if it is possible to determine
>> whether the requirement is satisfied in a particular case.
>>
>
> Any requirement that ever requires the logically impossible is never
> correct in these cases where it requires the logically impossible.
>
So in other words you can draw a square circle.

On 19/03/24 16:23, olcott wrote:
> On 3/19/2024 3:54 AM, Fred. Zwarts wrote:
>> 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.
>>>
>>
>> Olcott does not understand that we are talking about a DD that
>> contains a HH that aborts. He is constructing a problem, that does not
>> exists,
>
> It is fully operational code, thus physically exists.
>
>> because he names all programs with the same names. This causes his
>> confusion. His DD is the Dan, which is based on Han. When changing the
>> decider from Han to Hss, we should still consider the same Dan. But in
>> his mind this can only be done by also changing Dan into Dss. He is
>> unable to see that Han(Dan,Dan) does not need to abort, but it does
>> and Hss(Dss,Dss) needs to abort, but it doesn't. Han and Hss are
>> different deciders. Dan and Dss are different programs. So, we cannot
>> talk about them with the same name. He seems to understand that both
>> Han(Dan,Dan) and Hss(Dss,Dss) are wrong, but by assuming that Dan and
>> Dss are equivalent, he thinks that it is right to claim that
>> Han(Dan,Dan) is still correct. He seems to be unable to see that Dan
>> and Dss are not equivalent. It is impossible to talk about them as if
>> they were the same programs.
>>
>
> The following is true for every element of the set no matter how
> these elements are named. If naming them somehow makes it seem that
> any of these elements do not have their stipulated property then
> naming causes misconception.
>
> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
> When H(D,D) does not abort its simulation then
> this causes the simulated D(D) to never stop running.

On 3/19/2024 4:00 AM, Mikko wrote:
> 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.
>

*counter-factual* The H called by the directly executed D(D)
cannot be aborted because it is directly executed.

The H called by the simulated D(D) is also never directly
aborted only the simulated D(D) that calls it is aborted.

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

On 19/03/24 17:43, olcott wrote:
> On 3/18/2024 11:31 PM, Richard Damon wrote:
>> 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 found a bug in my words* (I will start consistently reporting this)
>
> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says YES this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says  NO this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
> No matter what any H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says it does not correspond to Halts(Ĥ ⟨Ĥ⟩)
>
> So we are back to both YES and NO are the wrong answer for every
> element in this template:
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> All of the elements that reported NO had to abort their simulation
> or they could not have reported NO thus have no corresponding YES
> element that reports at all.
>
> All of the elements that took the YES path failed to report because
> they either did not abort their simulation or got stuck in the infinite
> loop thus have no corresponding NO element.
>
>
>

He asked for an actual H and Ĥ not a copy-pasta.

On 3/19/2024 11:33 AM, Mikko wrote:
> On 2024-03-19 14:35:03 +0000, olcott said:
>
>> On 3/19/2024 4:37 AM, Mikko wrote:
>>> 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.
>>>
>>
>> ∀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.
>
> Seems the best I can do is to assume.
>

On 3/19/2024 11:21 AM, Mikko wrote:
> On 2024-03-19 15:06:05 +0000, olcott said:
>
>> On 3/19/2024 4:05 AM, Mikko wrote:
>>> 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.
>>>
>>
>> *Counter factual*
>> My syntax is intended to specify the universe of H/D pairs such that
>> (H(D,D) simulates its input and D calls H(D,D))
>
> Then you should quantify over those pairs with a simgle quantifier.
>
That wold not allow H and D to vary independently.

> Anyway, every pair has a different D.
>

*I proved otherwise below*
In infinite number of different H
(all having a different number of NOP padding)
all operate on the exact same D.

In infinite number of different D
(all having a different number of NOP padding)
are all input to the exact same H.

>> That there can be multiple H for every unique D and multiple D for
>> every unique H becomes more obvious when understand that we can pad
>> either H or D with an arbitrary number of NOP opcodes.
>> https://en.wikipedia.org/wiki/NOP_(code)
>

--
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/19/2024 12:46 PM, immibis wrote:
> On 19/03/24 17:43, olcott wrote:
>> On 3/18/2024 11:31 PM, Richard Damon wrote:
>>> 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 found a bug in my words* (I will start consistently reporting this)
>>
>> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says YES this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
>> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says  NO this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
>> No matter what any H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says it does not correspond to Halts(Ĥ
>> ⟨Ĥ⟩)
>>
>> So we are back to both YES and NO are the wrong answer for every
>> element in this template:
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> All of the elements that reported NO had to abort their simulation
>> or they could not have reported NO thus have no corresponding YES
>> element that reports at all.
>>
>> All of the elements that took the YES path failed to report because
>> they either did not abort their simulation or got stuck in the infinite
>> loop thus have no corresponding NO element.
>>
>>
>>
>
> He asked for an actual H and Ĥ not a copy-pasta.

Those are brand new words that address the glitch that Richard
found in the words he was responding to.

*There is no corresponding Ĥ.H that gets the correct answer on the*
*same input by providing the opposite answer to this same input*
*Every machine the gets the correct answer is outside of the above set*

--
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/19/2024 10:37 AM, Fred. Zwarts wrote:
> Op 19.mrt.2024 om 15:56 schreef olcott:
>> On 3/19/2024 4:05 AM, Fred. Zwarts wrote:
>>> 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*
>>>>
>>>
>>> But H(D,D) cannot be allowed to choose what it want to see and what
>>> it does not want to see. By aborting, it chooses to close it eyes and
>>> therefore it does not see that D calls H, which aborts and returns.
>>> It is not a matter of 'cannot see', but 'chooses to be blind for the
>>> facts'.
>>>
>>
>> Can D correctly simulated by H terminate normally?
>> 01 int D(ptr x)  // ptr is pointer to int function
>> 02 {
>> 03   int Halt_Status = H(x, x);
>> 04   if (Halt_Status)
>> 05     HERE: goto HERE;
>> 06   return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> *Execution Trace*
>> Line 11: main() invokes H(D,D);
>>
>> *keeps repeating* (unless aborted)
>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>
>> *Simulation invariant*
>> D correctly simulated by H cannot possibly reach past its own line 03.
>>
>> H: Begin Simulation   Execution Trace Stored at:113075
>> Address_of_H:1522
>>
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [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()
>>
>> It is the case that the simulated D(D) can't possibly reach its
>> final instruction and terminate normally, thus can't possibly halt.
>>
>> Unless H(D,D) sees that its input can't possibly halt and aborts
>> its simulation on that basis then the executed D(D) also never halts.
>>
>
> Olcott keeps naming all different H and D with the same name. This is
> very confusing. Maybe he himself is the most confused one. He seems to
> think that Dan is equivalent to Dss, so that he can claim both: that it
> can keep running and halts. So that it both needs to be aborted and
> halts of its own after aborting its simulation.
> If he only would use appropriate naming, so that we know whether he is
> talking about Dss or Dan, then he himself could also be freed from his
> confusion.
> It is an easily verified fact that Dan can reach past its own line 03,
> but Dss cannot. But Dss does not abort, so the corresponding Hss does
> not halt. He seems to be very confused.

On 3/19/2024 12:45 PM, immibis wrote:
> On 19/03/24 16:23, olcott wrote:
>> On 3/19/2024 3:54 AM, Fred. Zwarts wrote:
>>> 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.
>>>>
>>>
>>> Olcott does not understand that we are talking about a DD that
>>> contains a HH that aborts. He is constructing a problem, that does
>>> not exists,
>>
>> It is fully operational code, thus physically exists.
>>
>>> because he names all programs with the same names. This causes his
>>> confusion. His DD is the Dan, which is based on Han. When changing
>>> the decider from Han to Hss, we should still consider the same Dan.
>>> But in his mind this can only be done by also changing Dan into Dss.
>>> He is unable to see that Han(Dan,Dan) does not need to abort, but it
>>> does and Hss(Dss,Dss) needs to abort, but it doesn't. Han and Hss are
>>> different deciders. Dan and Dss are different programs. So, we cannot
>>> talk about them with the same name. He seems to understand that both
>>> Han(Dan,Dan) and Hss(Dss,Dss) are wrong, but by assuming that Dan and
>>> Dss are equivalent, he thinks that it is right to claim that
>>> Han(Dan,Dan) is still correct. He seems to be unable to see that Dan
>>> and Dss are not equivalent. It is impossible to talk about them as if
>>> they were the same programs.
>>>
>>
>> The following is true for every element of the set no matter how
>> these elements are named. If naming them somehow makes it seem that
>> any of these elements do not have their stipulated property then
>> naming causes misconception.
>>
>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>> When H(D,D) does not abort its simulation then
>> this causes the simulated D(D) to never stop running.
>
> this sentence doesn't even make sense
>

On 3/19/2024 12:42 PM, immibis wrote:
> On 19/03/24 05:37, olcott wrote:
>> You are just getting nutty now. You are tossing out the sequence,
>> selection, iteration model of computation.
>
> aren't you tossing out the turing machine model of computation?
>

I am only tossing out the halting problem specification.
I am not saying (like Richard is saying) that sequential
code can be executed out-of-sequence.

--
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/19/2024 12:41 PM, immibis wrote:
> On 19/03/24 05:11, 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.
>
> If Ĥ is your x86utm function D, then "yes" is the correct answer to all
> entities.

*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩

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

--
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/19/2024 12:40 PM, immibis wrote:
> On 19/03/24 03:46, 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.
>>
>>
> Thus the halting problem is unsolvable -- abort deciders cannot be
> extended to solve the halting problem instead of just the abort problem.

Undecidable decision problem instances that are isomorphic to
incorrect questions are tossed out as having an incorrect problem
specification. This is a generalization and simplification of
professor Hehner's and Stoddart's view.

E C R Hehner. *Objective and Subjective Specifications*
WST Workshop on Termination, Oxford. 2018 July 18.
See https://www.cs.toronto.edu/~hehner/OSS.pdf

Bill Stoddart. *The Halting Paradox*
20 December 2017
https://arxiv.org/abs/1906.05340
arXiv:1906.05340 [cs.LO]

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

On 19/03/24 18:54, olcott wrote:
> On 3/19/2024 11:21 AM, Mikko wrote:
>> Then you should quantify over those pairs with a simgle quantifier.
>>
> That wold not allow H and D to vary independently.

Don't you keep saying that you are only interested in the D which calls H?

>
>> Anyway, every pair has a different D.
>>
>
> *I proved otherwise below*
> In infinite number of different H
> (all having a different number of NOP padding)
> all operate on the exact same D.
>
> In infinite number of different D
> (all having a different number of NOP padding)
> are all input to the exact same H.

Nobody is arguing on the basis of NOPs, and it's still true that every
pair has a different D. Adding NOPs to a D does not change which H is
called by that D.

>>> That there can be multiple H for every unique D and multiple D for
>>> every unique H becomes more obvious when understand that we can pad
>>> either H or D with an arbitrary number of NOP opcodes.
>>> https://en.wikipedia.org/wiki/NOP_(code)

There can only be one H for each D. Changing the H also changes the D
because D is considered as a complete self-contained program.

On 19/03/24 19:03, olcott wrote:
> On 3/19/2024 12:46 PM, immibis wrote:
>> On 19/03/24 17:43, olcott wrote:
>>> On 3/18/2024 11:31 PM, Richard Damon wrote:
>>>> 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 found a bug in my words* (I will start consistently reporting this)
>>>
>>> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says YES this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
>>> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says  NO this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
>>> No matter what any H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says it does not correspond to Halts(Ĥ
>>> ⟨Ĥ⟩)
>>>
>>> So we are back to both YES and NO are the wrong answer for every
>>> element in this template:
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> All of the elements that reported NO had to abort their simulation
>>> or they could not have reported NO thus have no corresponding YES
>>> element that reports at all.
>>>
>>> All of the elements that took the YES path failed to report because
>>> they either did not abort their simulation or got stuck in the infinite
>>> loop thus have no corresponding NO element.
>>>
>>>
>>>
>>
>> He asked for an actual H and Ĥ not a copy-pasta.
>
> Those are brand new words that address the glitch that Richard
> found in the words he was responding to.
>
> *There is no corresponding Ĥ.H that gets the correct answer on the*
> *same input by providing the opposite answer to this same input*
> *Every machine the gets the correct answer is outside of the above set*

Every possible Ĥ.H is in the above set so all of them are incorrect.
Anyway, he asked for an actual H and Ĥ not a copy-pasta.

On 19/03/24 19:07, olcott wrote:
> On 3/19/2024 10:37 AM, Fred. Zwarts wrote:
>> Op 19.mrt.2024 om 15:56 schreef olcott:
>>> On 3/19/2024 4:05 AM, Fred. Zwarts wrote:
>>>> 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*
>>>>>
>>>>
>>>> But H(D,D) cannot be allowed to choose what it want to see and what
>>>> it does not want to see. By aborting, it chooses to close it eyes
>>>> and therefore it does not see that D calls H, which aborts and
>>>> returns. It is not a matter of 'cannot see', but 'chooses to be
>>>> blind for the facts'.
>>>>
>>>
>>> Can D correctly simulated by H terminate normally?
>>> 01 int D(ptr x)  // ptr is pointer to int function
>>> 02 {
>>> 03   int Halt_Status = H(x, x);
>>> 04   if (Halt_Status)
>>> 05     HERE: goto HERE;
>>> 06   return Halt_Status;
>>> 07 }
>>> 08
>>> 09 void main()
>>> 10 {
>>> 11   H(D,D);
>>> 12 }
>>>
>>> *Execution Trace*
>>> Line 11: main() invokes H(D,D);
>>>
>>> *keeps repeating* (unless aborted)
>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> *Simulation invariant*
>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>
>>> H: Begin Simulation   Execution Trace Stored at:113075
>>> Address_of_H:1522
>>>
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ========  ========  ========  =========  =============
>>> [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()
>>>
>>> It is the case that the simulated D(D) can't possibly reach its
>>> final instruction and terminate normally, thus can't possibly halt.
>>>
>>> Unless H(D,D) sees that its input can't possibly halt and aborts
>>> its simulation on that basis then the executed D(D) also never halts.
>>>
>>
>> Olcott keeps naming all different H and D with the same name. This is
>> very confusing. Maybe he himself is the most confused one. He seems to
>> think that Dan is equivalent to Dss, so that he can claim both: that
>> it can keep running and halts. So that it both needs to be aborted and
>> halts of its own after aborting its simulation.
>> If he only would use appropriate naming, so that we know whether he is
>> talking about Dss or Dan, then he himself could also be freed from his
>> confusion.
>> It is an easily verified fact that Dan can reach past its own line 03,
>> but Dss cannot. But Dss does not abort, so the corresponding Hss does
>> not halt. He seems to be very confused.
>
> No D correctly simulated by any H(D,D) such that D calls H(D,D)
> can possibly reach past its own line 03.

On 19/03/24 19:11, olcott wrote:
> On 3/19/2024 12:45 PM, immibis wrote:
>> On 19/03/24 16:23, olcott wrote:
>>> On 3/19/2024 3:54 AM, Fred. Zwarts wrote:
>>>> 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.
>>>>>
>>>>
>>>> Olcott does not understand that we are talking about a DD that
>>>> contains a HH that aborts. He is constructing a problem, that does
>>>> not exists,
>>>
>>> It is fully operational code, thus physically exists.
>>>
>>>> because he names all programs with the same names. This causes his
>>>> confusion. His DD is the Dan, which is based on Han. When changing
>>>> the decider from Han to Hss, we should still consider the same Dan.
>>>> But in his mind this can only be done by also changing Dan into Dss.
>>>> He is unable to see that Han(Dan,Dan) does not need to abort, but it
>>>> does and Hss(Dss,Dss) needs to abort, but it doesn't. Han and Hss
>>>> are different deciders. Dan and Dss are different programs. So, we
>>>> cannot talk about them with the same name. He seems to understand
>>>> that both Han(Dan,Dan) and Hss(Dss,Dss) are wrong, but by assuming
>>>> that Dan and Dss are equivalent, he thinks that it is right to claim
>>>> that Han(Dan,Dan) is still correct. He seems to be unable to see
>>>> that Dan and Dss are not equivalent. It is impossible to talk about
>>>> them as if they were the same programs.
>>>>
>>>
>>> The following is true for every element of the set no matter how
>>> these elements are named. If naming them somehow makes it seem that
>>> any of these elements do not have their stipulated property then
>>> naming causes misconception.
>>>
>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>> When H(D,D) does not abort its simulation then
>>> this causes the simulated D(D) to never stop running.
>>
>> this sentence doesn't even make sense
>>
>
> ∀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)
> therefore: simulated D(D) never stops running.
>
>

On 19/03/24 19:15, olcott wrote:
> On 3/19/2024 12:41 PM, immibis wrote:
>> On 19/03/24 05:11, 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.
>>
>> If Ĥ is your x86utm function D, then "yes" is the correct answer to
>> all entities.
>
> *counter factual*
> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩

no it is not

"yes" is the correct answer to all entities.

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

On 19/03/24 19:23, olcott wrote:
> On 3/19/2024 12:40 PM, immibis wrote:
>> On 19/03/24 03:46, 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.
>>>
>>>
>> Thus the halting problem is unsolvable -- abort deciders cannot be
>> extended to solve the halting problem instead of just the abort problem.
>
> Undecidable decision problem instances that are isomorphic to
> incorrect questions are tossed out as having an incorrect problem
> specification. This is a generalization and simplification of
> professor Hehner's and Stoddart's view.
>
> E C R Hehner. *Objective and Subjective Specifications*
> WST Workshop on Termination, Oxford.  2018 July 18.
> See https://www.cs.toronto.edu/~hehner/OSS.pdf
>
> Bill Stoddart. *The Halting Paradox*
> 20 December 2017
> https://arxiv.org/abs/1906.05340
> arXiv:1906.05340 [cs.LO]

who cares? they're still undecidable

On 19/03/24 19:14, olcott wrote:
> On 3/19/2024 12:42 PM, immibis wrote:
>> On 19/03/24 05:37, olcott wrote:
>>> You are just getting nutty now. You are tossing out the sequence,
>>> selection, iteration model of computation.
>>
>> aren't you tossing out the turing machine model of computation?
>>
>
> I am only tossing out the halting problem specification.
> I am not saying (like Richard is saying) that sequential
> code can be executed out-of-sequence.
>

in other words you accept the halting problem is unsolvable and want to
work on a different problem instead.