On 3/16/2024 11:56 PM, Richard Damon wrote:
> On 3/16/24 9:44 PM, olcott wrote:
>> On 3/16/2024 11:33 PM, Richard Damon wrote:
>>> On 3/16/24 9:26 PM, olcott wrote:
>>>> On 3/16/2024 11:21 PM, Richard Damon wrote:
>>>>> On 3/16/24 9:14 PM, olcott wrote:
>>>>>> On 3/16/2024 11:12 PM, Richard Damon wrote:
>>>>>>> On 3/16/24 9:08 PM, olcott wrote:
>>>>>>>> On 3/16/2024 10:50 PM, Richard Damon wrote:
>>>>>>>>> On 3/16/24 7:54 PM, olcott wrote:
>>>>>>>>>> On 3/16/2024 9:50 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>>>> So, are you admitting that you "Halt Deciders" are
>>>>>>>>>>
>>>>>>>>>> Not being discussed. We are only looking at this:
>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Then why do you call them Halt Deciders?
>>>>>>>>
>>>>>>>> In this thread we must focus on the single point
>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>> Or we will never ever get closure on this single point.
>>>>>>>>
>>>>>>>
>>>>>>> So, is this criteria supposed to be a Halt Deciding criteria?
>>>>>>>
>>>>>>
>>>>>> 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"?
>>>>>
>>>>> Note, if H is an algorithm, we can't talk of "changing" it, or it
>>>>> looses its identity.
>>>>>
>>>>
>>>> It is the set of every implementation of its spec:
>>>
>>> But it was an algorithm, not a set. Make up your mind.
>>>
>>>> (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 how do you determine NEED.
>>>
>>
>> Determine if it needs to stop simulating its input
>> *to prevent the simulated D(D) from never halting*
>>
>
> But H already does what it does.
>
We never validated that it is definitely correct.

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

And we can't "change" H to do that, since each H does what it does, and
since each H generates a DIFFERENT input, we need to verify each
individually.

For that Hs that Halt, we will see that all of them abort. The only way
to see if that abort was needed, we need to hypothectically look at the
correct simulation of that input to see if it halts, which it does, and
thus H didn't NEED to abort, so those elements failed to meet the
requirements.

WE then seem to end up with an empty set of Hs

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?

--
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/16/24 9:59 PM, olcott wrote:
> On 3/16/2024 11:56 PM, Richard Damon wrote:
>> On 3/16/24 9:44 PM, olcott wrote:
>>> On 3/16/2024 11:33 PM, Richard Damon wrote:
>>>> On 3/16/24 9:26 PM, olcott wrote:
>>>>> On 3/16/2024 11:21 PM, Richard Damon wrote:
>>>>>> On 3/16/24 9:14 PM, olcott wrote:
>>>>>>> On 3/16/2024 11:12 PM, Richard Damon wrote:
>>>>>>>> On 3/16/24 9:08 PM, olcott wrote:
>>>>>>>>> On 3/16/2024 10:50 PM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 7:54 PM, olcott wrote:
>>>>>>>>>>> On 3/16/2024 9:50 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>>>> So, are you admitting that you "Halt Deciders" are
>>>>>>>>>>>
>>>>>>>>>>> Not being discussed. We are only looking at this:
>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Then why do you call them Halt Deciders?
>>>>>>>>>
>>>>>>>>> In this thread we must focus on the single point
>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>> Or we will never ever get closure on this single point.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, is this criteria supposed to be a Halt Deciding criteria?
>>>>>>>>
>>>>>>>
>>>>>>> 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"?
>>>>>>
>>>>>> Note, if H is an algorithm, we can't talk of "changing" it, or it
>>>>>> looses its identity.
>>>>>>
>>>>>
>>>>> It is the set of every implementation of its spec:
>>>>
>>>> But it was an algorithm, not a set. Make up your mind.
>>>>
>>>>> (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 how do you determine NEED.
>>>>
>>>
>>> Determine if it needs to stop simulating its input
>>> *to prevent the simulated D(D) from never halting*
>>>
>>
>> But H already does what it does.
>>
> We never validated that it is definitely correct.
>

How do we know?

Your "algorithm" included a non-algorithmic step, so how do you intend
to perform that step?

Best you can do is try all possiblities are remove those that fail.

Which removes them all.

You need to define how to determine NEED as an algorithm.

That mean the decision is based just on what it knows already.

Then the results can be compared to the specification to determine it is
correct.

You can't just "assume" a given algorithm meets a specificaiton, unless
the specification is itself an algorithm, which this isnt.

As you said, we can't ask H to look into the future, so it can't base
its actions on what WILL (or will not) happen in the future.

We also can't imagine CHANGING H, as it is what it is, we can imagine
something else acting in its stead (but that doesn't affect the
definition of H) and H can't act on the imagining, we can only use that
to show if it was correct or not.

On 3/17/2024 12:05 AM, Richard Damon wrote:
> On 3/16/24 9:59 PM, olcott wrote:
>> On 3/16/2024 11:56 PM, Richard Damon wrote:
>>> On 3/16/24 9:44 PM, olcott wrote:
>>>> On 3/16/2024 11:33 PM, Richard Damon wrote:
>>>>> On 3/16/24 9:26 PM, olcott wrote:
>>>>>> On 3/16/2024 11:21 PM, Richard Damon wrote:
>>>>>>> On 3/16/24 9:14 PM, olcott wrote:
>>>>>>>> On 3/16/2024 11:12 PM, Richard Damon wrote:
>>>>>>>>> On 3/16/24 9:08 PM, olcott wrote:
>>>>>>>>>> On 3/16/2024 10:50 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/16/24 7:54 PM, olcott wrote:
>>>>>>>>>>>> On 3/16/2024 9:50 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>>>> So, are you admitting that you "Halt Deciders" are
>>>>>>>>>>>>
>>>>>>>>>>>> Not being discussed. We are only looking at this:
>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Then why do you call them Halt Deciders?
>>>>>>>>>>
>>>>>>>>>> In this thread we must focus on the single point
>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>> Or we will never ever get closure on this single point.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, is this criteria supposed to be a Halt Deciding criteria?
>>>>>>>>>
>>>>>>>>
>>>>>>>> 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"?
>>>>>>>
>>>>>>> Note, if H is an algorithm, we can't talk of "changing" it, or it
>>>>>>> looses its identity.
>>>>>>>
>>>>>>
>>>>>> It is the set of every implementation of its spec:
>>>>>
>>>>> But it was an algorithm, not a set. Make up your mind.
>>>>>
>>>>>> (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 how do you determine NEED.
>>>>>
>>>>
>>>> Determine if it needs to stop simulating its input
>>>> *to prevent the simulated D(D) from never halting*
>>>>
>>>
>>> But H already does what it does.
>>>
>> We never validated that it is definitely correct.
>>
>
> How do we know?
>

(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

Do you understand that spec?

> Your "algorithm" included a non-algorithmic step, so how do you intend
> to perform that step?
>
> Best you can do is try all possiblities are remove those that fail.
>
> Which removes them all.
>
> You need to define how to determine NEED as an algorithm.
>
> That mean the decision is based just on what it knows already.
>
> Then the results can be compared to the specification to determine it is
> correct.
>
> You can't just "assume" a given algorithm meets a specificaiton, unless
> the specification is itself an algorithm, which this isnt.
>
> As you said, we can't ask H to look into the future, so it can't base
> its actions on what WILL (or will not) happen in the future.
>
> We also can't imagine CHANGING H, as it is what it is, we can imagine
> something else acting in its stead (but that doesn't affect the
> definition of H) and H can't act on the imagining, we can only use that
> to show if it was correct or not.

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

I say this isn't the way you do, as I have shown that H fails to meet
this specification.

You can't seem to actually define it the way you want, likely because
you don't actually understand what you are doing.

This seems clear as your "implementation" isn't actually an
implementation as it includes non-algorithmic steps.

There is no "Get the right answer" instruction, or look into the future
(or even look into an alternate future) instruction.

On 3/16/24 10:08 PM, olcott wrote:
> On 3/17/2024 12:05 AM, Richard Damon wrote:
>> On 3/16/24 9:59 PM, olcott wrote:
>>> On 3/16/2024 11:56 PM, Richard Damon wrote:
>>>> On 3/16/24 9:44 PM, olcott wrote:
>>>>> On 3/16/2024 11:33 PM, Richard Damon wrote:
>>>>>> On 3/16/24 9:26 PM, olcott wrote:
>>>>>>> On 3/16/2024 11:21 PM, Richard Damon wrote:
>>>>>>>> On 3/16/24 9:14 PM, olcott wrote:
>>>>>>>>> On 3/16/2024 11:12 PM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 9:08 PM, olcott wrote:
>>>>>>>>>>> On 3/16/2024 10:50 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 7:54 PM, olcott wrote:
>>>>>>>>>>>>> On 3/16/2024 9:50 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>>> So, are you admitting that you "Halt Deciders" are
>>>>>>>>>>>>>
>>>>>>>>>>>>> Not being discussed. We are only looking at this:
>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Then why do you call them Halt Deciders?
>>>>>>>>>>>
>>>>>>>>>>> In this thread we must focus on the single point
>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>> Or we will never ever get closure on this single point.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, is this criteria supposed to be a Halt Deciding criteria?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> 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"?
>>>>>>>>
>>>>>>>> Note, if H is an algorithm, we can't talk of "changing" it, or
>>>>>>>> it looses its identity.
>>>>>>>>
>>>>>>>
>>>>>>> It is the set of every implementation of its spec:
>>>>>>
>>>>>> But it was an algorithm, not a set. Make up your mind.
>>>>>>
>>>>>>> (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 how do you determine NEED.
>>>>>>
>>>>>
>>>>> Determine if it needs to stop simulating its input
>>>>> *to prevent the simulated D(D) from never halting*
>>>>>
>>>>
>>>> But H already does what it does.
>>>>
>>> We never validated that it is definitely correct.
>>>
>>
>> How do we know?
>>
>
> (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
>
> Do you understand that spec?

Yes, but you don't seem to agree with my understanding, and can not
actualy define it in any other way.

(a) is NOT a algorithm, but a specification, so something we need to
check AFTER we have defined H.

because, it include words requiring it to know the right answer before
it can act on them.

You have shown he algorithm you THINK meets this spec, but it fails the
test.

To test if a given machine needed to abort a simulation that it aborted,
you give that input to an actual pure simulator and see if it stop. If
it does, then the machine did not NEED to abort its simulation, and thus
failed to meet the specification.

We can't "change" H to test it, as that changes the question being asked
of it, we can only give its input to something else related, that by
doing so we don't change the input, or the H itself.

Remember, Machines do what they do and only what they do and don't do
anything else.

And, Get the right answer is not an algorithmic step.

>
>> Your "algorithm" included a non-algorithmic step, so how do you intend
>> to perform that step?
>>
>> Best you can do is try all possiblities are remove those that fail.
>>
>> Which removes them all.
>>
>> You need to define how to determine NEED as an algorithm.
>>
>> That mean the decision is based just on what it knows already.
>>
>> Then the results can be compared to the specification to determine it
>> is correct.
>>
>> You can't just "assume" a given algorithm meets a specificaiton,
>> unless the specification is itself an algorithm, which this isnt.
>>
>> As you said, we can't ask H to look into the future, so it can't base
>> its actions on what WILL (or will not) happen in the future.
>>
>> We also can't imagine CHANGING H, as it is what it is, we can imagine
>> something else acting in its stead (but that doesn't affect the
>> definition of H) and H can't act on the imagining, we can only use
>> that to show if it was correct or not.
>

On 2024-03-16 15:09:42 +0000, olcott said:

> https://philarchive.org/archive/OLCRTSv1

Before the C code for Sipser_D that page should should say
that all return values are encoded so that Sipser's reject
is enoded as 0 and Sipser's accept as 1.

There should also be a proof that your C programs satisfy
Sipser's definitions of D and H.

--
Mikko

On 2024-03-16 19:19:50 +0000, olcott said:

> On 3/16/2024 12:31 PM, immibis wrote:
>> On 16/03/24 15:51, olcott wrote:
>>> I keep posting the same point until it gets a complete and correct
>>> review. This has proved to be very effective in that I am finally
>>> getting complete closure on some of these points.
>>>
>>> There cannot possibly exist any H(D,D) that is called by
>>> D where H(D,D) simulates its input and D(D) stops running
>>> and H never aborts its simulation.
>>>
>>
>> These words don't mean anything.
>
> Since all words always mean something why lie?

I wouldn't zyggy about that.

--
Mikko

On 2024-03-16 14:48:51 +0000, olcott said:

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

The set from wich such H could be chosen is so small that
it is no surprise that any H that simulates D(D) to its
termination is not in that set.

--
Mikko

On 2024-03-16 19:03:58 +0000, olcott said:

> On 3/16/2024 12:32 PM, immibis wrote:
>> On 16/03/24 17:56, olcott wrote:
>>> On 3/16/2024 11:45 AM, Richard Damon wrote:
>>>> On 3/16/24 9:31 AM, olcott wrote:
>>>>> On 3/16/2024 11:22 AM, Richard Damon wrote:
>>>>>> On 3/16/24 7:48 AM, olcott wrote:
>>>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>>>> On 3/15/2024 1:45 PM, immibis wrote:
>>>>>>>>>>>> On 15/03/24 19:39, olcott wrote:
>>>>>>>>>>>>> On 3/15/2024 1:38 PM, immibis wrote:
>>>>>>>>>>>>>> On 15/03/24 18:52, olcott wrote:
>>>>>>>>>>>>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>>>>>>>>>>>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates its input D until
>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would never stop running
>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>>>>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp ; begin main()
>>>>>>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp ; enter D(D)
>>>>>>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax ; push D
>>>>>>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx ; push D
>>>>>>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called with its same
>>>>>>>>>>>>>>>>> inputs and there are no conditional branch instructions between the
>>>>>>>>>>>>>>>>> invocation of D(D) and its call to H(D,D).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except that D calling H(D,D) does NOT prove the required (a), since the
>>>>>>>>>>>>>>>> simulated D WILL stop running because *ITS* H will abort *ITS*
>>>>>>>>>>>>>>>> simulation and returm 0 so that simulated D will halt.
>>>>>>>>>>>>>>> You keep saying that H(D,D) never really needs to abort the
>>>>>>>>>>>>>>> simulation of its input because after H(D,D) has aborted the
>>>>>>>>>>>>>>> simulation of this input it no longer needs to be aborted.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You keep thinking there is more than one H(D,D) and then when it's
>>>>>>>>>>>>>> convenient for you you think there is only one H(D,D). Why is that?
>>>>>>>>>>>>>
>>>>>>>>>>>>> The first H(D,D) to see that the abort criteria has been met
>>>>>>>>>>>>> (the outermost one) must abort the simulation of its input or
>>>>>>>>>>>>> none of them ever abort.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> that's wrong. They all abort,
>>>>>>>>>>>
>>>>>>>>>>> I was baffled by this for three days when I first investigated this.
>>>>>>>>>>> Because every H has the exact same code, if the first one to see that
>>>>>>>>>>> the abort criteria has been met does not abort then none of them abort.
>>>>>>>>>>
>>>>>>>>>> And thus you look at a strawman. A case where H isn't the H that we
>>>>>>>>>> started with.
>>>>>>>>>>
>>>>>>>>>> If you change the H used by D, you change the quesition being asked.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> We cannot reference the behavior of what D(D) does after H(D,D)
>>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure
>>>>>>>>> for this H(D,D).
>>>>>>>>
>>>>>>>> Then you cannot prove that H is a halting decider, as that is what
>>>>>>>> you need to reference in the proof.
>>>>>>>>
>>>>>>>
>>>>>>> I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
>>>>>>> that H correctly determined that it had to abort the simulation
>>>>>>> of its input to prevent the infinite execution of this input.
>>>>>>>
>>>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>>>> and H never aborts its simulation.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Except that it THIS H actually DID need to abort its simulation, then
>>>>>> when we run the input, it should not halt.
>>>>>>
>>>>>
>>>>>  >>>Except that it THIS H actually DID need to abort its simulation<<<
>>>>> Then it aborts its simulation.
>>>>>
>>>>> Wrong
>>>>>  >>>then when we run the input, it should not halt.<<<
>>>>>
>>>>> then when we run the input, (after H aborts its simulation)
>>>>> it should halt.
>>>>>
>>>>>
>>>>>
>>>>
>>>> WRONG.
>>>>
>>>> Is the call to H from main the same function invocation as the call to
>>>> H from D?
>>>>
>>>> NO, They are different stack frames and thus DIFFERENT invocations.
>>>>
>>>
>>> *The timing is different*
>>> In both cases H(D,D) must abort the simulation of its input to prevent
>>> the infinite execution of this input.
>>>
>>> void main() { D(D); };
>>> reaps the benefit of this correct decision by H(D,D).
>>>
>>> void main() { H(D,D); };
>>> cannot reap this same benefit because of the difference in timing.
>>>
>>> The behavior of D(D) before H(D,D) has aborted its simulation is
>>> different than the behavior of D(D) after H(D,D) has aborted its
>>> simulation.
>>>
>>>> Thus, the invocation from main didn't NEED to abort, because the
>>>> function is it simulating will terminate.
>>>>
>>>> The problem is your altered definition has actually created the LIAR'S
>>>> PARADOX that you claim the original version has (which it doesn't).
>>>>
>>>> THAT makes the input not have a correct answer.
>>>>
>>>> To look at a changed H and call it H is just INCORRECT LOGIC, and a LIE
>>>> to perform.
>>>
>>
>> Turing machines don't have timing
>
> Sure they do.
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets a different result than Ĥ ⟨Ĥ⟩

On 2024-03-17 00:25:08 +0000, immibis said:

> On 17/03/24 00:38, olcott wrote:
>> On 3/16/2024 6:31 PM, Richard Damon wrote:
>>> On 3/16/24 12:03 PM, olcott wrote:
>>>> On 3/16/2024 12:32 PM, immibis wrote:
>>>>> On 16/03/24 17:56, olcott wrote:
>>>>>> On 3/16/2024 11:45 AM, Richard Damon wrote:
>>>>>>> On 3/16/24 9:31 AM, olcott wrote:
>>>>>>>> On 3/16/2024 11:22 AM, Richard Damon wrote:
>>>>>>>>> On 3/16/24 7:48 AM, olcott wrote:
>>>>>>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/15/2024 1:45 PM, immibis wrote:
>>>>>>>>>>>>>>> On 15/03/24 19:39, olcott wrote:
>>>>>>>>>>>>>>>> On 3/15/2024 1:38 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 15/03/24 18:52, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>>>>>>>>>>>>>>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates its input D until
>>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would never stop running
>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp ; begin main()
>>>>>>>>>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>>>>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>>>>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp ; enter D(D)
>>>>>>>>>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax ; push D
>>>>>>>>>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx ; push D
>>>>>>>>>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called with its same
>>>>>>>>>>>>>>>>>>>> inputs and there are no conditional branch instructions between the
>>>>>>>>>>>>>>>>>>>> invocation of D(D) and its call to H(D,D).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Except that D calling H(D,D) does NOT prove the required (a), since the
>>>>>>>>>>>>>>>>>>> simulated D WILL stop running because *ITS* H will abort *ITS*
>>>>>>>>>>>>>>>>>>> simulation and returm 0 so that simulated D will halt.
>>>>>>>>>>>>>>>>>> You keep saying that H(D,D) never really needs to abort the
>>>>>>>>>>>>>>>>>> simulation of its input because after H(D,D) has aborted the
>>>>>>>>>>>>>>>>>> simulation of this input it no longer needs to be aborted.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You keep thinking there is more than one H(D,D) and then when it's
>>>>>>>>>>>>>>>>> convenient for you you think there is only one H(D,D). Why is that?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The first H(D,D) to see that the abort criteria has been met
>>>>>>>>>>>>>>>> (the outermost one) must abort the simulation of its input or
>>>>>>>>>>>>>>>> none of them ever abort.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> that's wrong. They all abort,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I was baffled by this for three days when I first investigated this.
>>>>>>>>>>>>>> Because every H has the exact same code, if the first one to see that
>>>>>>>>>>>>>> the abort criteria has been met does not abort then none of them abort.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And thus you look at a strawman. A case where H isn't the H that we
>>>>>>>>>>>>> started with.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you change the H used by D, you change the quesition being asked.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> We cannot reference the behavior of what D(D) does after H(D,D)
>>>>>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure
>>>>>>>>>>>> for this H(D,D).
>>>>>>>>>>>
>>>>>>>>>>> Then you cannot prove that H is a halting decider, as that is what
>>>>>>>>>>> you need to reference in the proof.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
>>>>>>>>>> that H correctly determined that it had to abort the simulation
>>>>>>>>>> of its input to prevent the infinite execution of this input.
>>>>>>>>>>
>>>>>>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>>>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>>>>>>> and H never aborts its simulation.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Except that it THIS H actually DID need to abort its simulation, then
>>>>>>>>> when we run the input, it should not halt.
>>>>>>>>>
>>>>>>>>
>>>>>>>>  >>>Except that it THIS H actually DID need to abort its simulation<<<
>>>>>>>> Then it aborts its simulation.
>>>>>>>>
>>>>>>>> Wrong
>>>>>>>>  >>>then when we run the input, it should not halt.<<<
>>>>>>>>
>>>>>>>> then when we run the input, (after H aborts its simulation)
>>>>>>>> it should halt.
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> WRONG.
>>>>>>>
>>>>>>> Is the call to H from main the same function invocation as the call to
>>>>>>> H from D?
>>>>>>>
>>>>>>> NO, They are different stack frames and thus DIFFERENT invocations.
>>>>>>>
>>>>>>
>>>>>> *The timing is different*
>>>>>> In both cases H(D,D) must abort the simulation of its input to prevent
>>>>>> the infinite execution of this input.
>>>>>>
>>>>>> void main() { D(D); };
>>>>>> reaps the benefit of this correct decision by H(D,D).
>>>>>>
>>>>>> void main() { H(D,D); };
>>>>>> cannot reap this same benefit because of the difference in timing.
>>>>>>
>>>>>> The behavior of D(D) before H(D,D) has aborted its simulation is
>>>>>> different than the behavior of D(D) after H(D,D) has aborted its
>>>>>> simulation.
>>>>>>
>>>>>>> Thus, the invocation from main didn't NEED to abort, because the
>>>>>>> function is it simulating will terminate.
>>>>>>>
>>>>>>> The problem is your altered definition has actually created the LIAR'S
>>>>>>> PARADOX that you claim the original version has (which it doesn't).
>>>>>>>
>>>>>>> THAT makes the input not have a correct answer.
>>>>>>>
>>>>>>> To look at a changed H and call it H is just INCORRECT LOGIC, and a LIE
>>>>>>> to perform.
>>>>>>
>>>>>
>>>>> Turing machines don't have timing
>>>>
>>>> Sure they do.
>>>>
>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets a different result than Ĥ ⟨Ĥ⟩
>>>> because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is executed :
>>>> BEFORE it has aborted its simulation and Ĥ ⟨Ĥ⟩ is executed
>>>> AFTER Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ has aborted its simulation.
>>>>
>>>
>>> Nope.
>>>
>>> Show an example as an actual Turing Machine, or you are just a liar.
>>
>> *I said that incorrectly*
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets a different result than [THE BEHAVIOR OF] Ĥ ⟨Ĥ⟩
>> because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is executed:
>> BEFORE it has aborted its simulation and Ĥ ⟨Ĥ⟩ [ONLY TERMINATES]
>> AFTER Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ has aborted its simulation.
>>
>> When a deposit is made to you bank account is it larger
>> AFTER the deposit or immediately BEFORE this same deposit?
>>
>>
> Strawman deception rejected. A bank deposit is not a Turing machine.

On 2024-03-17 00:06:18 +0000, olcott said:

> *logically impossible* never places any actual limit on anyone
> or anything even though it superficially seems to.

So the fact a square circle is logically impossible does not
prevet you (or at least someone) from drawing one?

Likwise, the tact that a halting decider is logcally impossible
does not prevent you (or at least someone) from constructing one?

--
Mikko

On 2024-03-17 00:06:18 +0000, olcott said:

> Likewise is seems to be a reasonable question to ask if a
> simple sentence is true or false.
> (a) 2 + 3 = 5.
> (b) What time is it?
> (c) This sentence is not true.

Note that logicians use the word "sentence" in a more restricted
meaning than grammarians. In the former meaning, which is nore
relevant here, (b) is not a sentence and (c) hardly either.

--
Mikko

On 2024-03-17 00:10:08 +0000, olcott said:

> On 3/16/2024 7:04 PM, Richard Damon wrote:
>> On 3/16/24 9:38 AM, olcott wrote:
>>> On 3/16/2024 11:35 AM, immibis wrote:
>>
>>>> ERROR is not the exact same result as the conventional halting criteria.
>>>
>>> Because the conventional criteria requires:
>>>
>>> (a) Halt deciders to correctly answer incorrect questions.
>>
>> Nope, and you can't show a reason it is invalid.
>>
>
> The you persistently ignore the verified fact that that discourse
> context of who is asked is the determining factor of whether
> the very same answer to the same word-for-word question is
> correct or incorrect *IS YOUR ERROR NOT MINE*

You equally persistently ignore the verified fact that the discourse
context of who is asked is irrelevant in the cases discussed here,
which "IS YOUE ERROR*.

--
Mikko

On 3/17/2024 4:02 AM, Mikko wrote:
> On 2024-03-16 15:09:42 +0000, olcott said:
>
>> https://philarchive.org/archive/OLCRTSv1
>
> Before the C code for Sipser_D that page should should say
> that all return values are encoded so that Sipser's reject
> is enoded as 0 and Sipser's accept as 1.
>

It already says that.
//
// H returns 1 when its input would halt and return 1.
// otherwise H returns 0
//
int Sipser_D(ptr2 M)
{ if ( Sipser_H(M, M) )
return 0;
return 1;
}

> There should also be a proof that your C programs satisfy
> Sipser's definitions of D and H.
>
*He didn't have time to look at that much of it*

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001d22][00102fc9][00000000] 55 push ebp
[00001d23][00102fc9][00000000] 8bec mov ebp,esp
[00001d25][00102fc5][00001b32] 68321b0000 push 00001b32 ; push Sipser_D
[00001d2a][00102fc1][00001b32] 68321b0000 push 00001b32 ; push Sipser_D
[00001d2f][00102fbd][00001d34] e8eef8ffff call 00001622 ; call Sipser_H

Sipser_H: Begin Simulation Execution Trace Stored at:113075
Address_of_Sipser_H:1622
[00001b32][00113061][00113065] 55 push ebp
[00001b33][00113061][00113065] 8bec mov ebp,esp
[00001b35][00113061][00113065] 8b4508 mov eax,[ebp+08]
[00001b38][0011305d][00001b32] 50 push eax ; push Sipser_D
[00001b39][0011305d][00001b32] 8b4d08 mov ecx,[ebp+08]
[00001b3c][00113059][00001b32] 51 push ecx ; push Sipser_D
[00001b3d][00113055][00001b42] e8e0faffff call 00001622 ; call Sipser_H
Sipser_H: Recursive Simulation Detected Simulation Stopped

[00001d34][00102fc9][00000000] 83c408 add esp,+08
[00001d37][00102fc5][00000000] 50 push eax
[00001d38][00102fc1][00000743] 6843070000 push 00000743
[00001d3d][00102fc1][00000743] e820eaffff call 00000762
Input_Halts = 0
[00001d42][00102fc9][00000000] 83c408 add esp,+08
[00001d45][00102fc9][00000000] 33c0 xor eax,eax
[00001d47][00102fcd][00000018] 5d pop ebp
[00001d48][00102fd1][00000000] c3 ret
Number of Instructions Executed(868) == 13 Pages

We can see that Sipser_D(Sipser_D) cannot stop running unless
Sipser_H(Sipser_D, Sipser_D) aborts its simulation.

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

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

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.

> I say this isn't the way you do, as I have shown that H fails to meet
> this specification.
>
(a) If abort halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then

This is the way that I do it and you have never shown otherwise.

> You can't seem to actually define it the way you want, likely because
> you don't actually understand what you are doing.
>
It seems to me that the issue is your persistence in remaining in
rebuttal mode even when this contradicts the verified facts.

> This seems clear as your "implementation" isn't actually an
> implementation as it includes non-algorithmic steps.
>
My C code provably does do this and I can show a TM equivalent.

> There is no "Get the right answer" instruction, or look into the future
> (or even look into an alternate future) instruction.

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001d22][00102fc9][00000000] 55 push ebp
[00001d23][00102fc9][00000000] 8bec mov ebp,esp
[00001d25][00102fc5][00001b32] 68321b0000 push 00001b32 ; push Sipser_D
[00001d2a][00102fc1][00001b32] 68321b0000 push 00001b32 ; push Sipser_D
[00001d2f][00102fbd][00001d34] e8eef8ffff call 00001622 ; call Sipser_H

Sipser_H: Begin Simulation Execution Trace Stored at:113075
Address_of_Sipser_H:1622
[00001b32][00113061][00113065] 55 push ebp
[00001b33][00113061][00113065] 8bec mov ebp,esp
[00001b35][00113061][00113065] 8b4508 mov eax,[ebp+08]
[00001b38][0011305d][00001b32] 50 push eax ; push Sipser_D
[00001b39][0011305d][00001b32] 8b4d08 mov ecx,[ebp+08]
[00001b3c][00113059][00001b32] 51 push ecx ; push Sipser_D
[00001b3d][00113055][00001b42] e8e0faffff call 00001622 ; call Sipser_H
Sipser_H: Recursive Simulation Detected Simulation Stopped

[00001d34][00102fc9][00000000] 83c408 add esp,+08
[00001d37][00102fc5][00000000] 50 push eax
[00001d38][00102fc1][00000743] 6843070000 push 00000743
[00001d3d][00102fc1][00000743] e820eaffff call 00000762
Input_Halts = 0
[00001d42][00102fc9][00000000] 83c408 add esp,+08
[00001d45][00102fc9][00000000] 33c0 xor eax,eax
[00001d47][00102fcd][00000018] 5d pop ebp
[00001d48][00102fd1][00000000] c3 ret
Number of Instructions Executed(868) == 13 Pages

We can see that Sipser_D(Sipser_D) cannot stop running unless
Sipser_H(Sipser_D, Sipser_D) aborts its simulation.

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

On 3/17/24 6:02 AM, olcott wrote:
> On 3/17/2024 4:02 AM, Mikko wrote:
>> On 2024-03-16 15:09:42 +0000, olcott said:
>>
>>> https://philarchive.org/archive/OLCRTSv1
>>
>> Before the C code for Sipser_D that page should should say
>> that all return values are encoded so that Sipser's reject
>> is enoded as 0 and Sipser's accept as 1.
>>
>
> It already says that.
> //
> // H returns 1 when its input would halt and return 1.
> // otherwise H returns 0
> //
> int Sipser_D(ptr2 M)
> {
>  if ( Sipser_H(M, M) )
>    return 0;
>  return 1;
> }
>
>> There should also be a proof that your C programs satisfy
>> Sipser's definitions of D and H.
>>
> *He didn't have time to look at that much of it*
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [00001d22][00102fc9][00000000] 55         push ebp
> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
> [00001d25][00102fc5][00001b32] 68321b0000 push 00001b32 ; push Sipser_D
> [00001d2a][00102fc1][00001b32] 68321b0000 push 00001b32 ; push Sipser_D
> [00001d2f][00102fbd][00001d34] e8eef8ffff call 00001622 ; call Sipser_H
>
> Sipser_H: Begin Simulation   Execution Trace Stored at:113075
> Address_of_Sipser_H:1622
> [00001b32][00113061][00113065] 55         push ebp
> [00001b33][00113061][00113065] 8bec       mov ebp,esp
> [00001b35][00113061][00113065] 8b4508     mov eax,[ebp+08]
> [00001b38][0011305d][00001b32] 50         push eax      ; push Sipser_D
> [00001b39][0011305d][00001b32] 8b4d08     mov ecx,[ebp+08]
> [00001b3c][00113059][00001b32] 51         push ecx      ; push Sipser_D
> [00001b3d][00113055][00001b42] e8e0faffff call 00001622 ; call Sipser_H
> Sipser_H: Recursive Simulation Detected Simulation Stopped
>
> [00001d34][00102fc9][00000000] 83c408     add esp,+08
> [00001d37][00102fc5][00000000] 50         push eax
> [00001d38][00102fc1][00000743] 6843070000 push 00000743
> [00001d3d][00102fc1][00000743] e820eaffff call 00000762
> Input_Halts = 0
> [00001d42][00102fc9][00000000] 83c408     add esp,+08
> [00001d45][00102fc9][00000000] 33c0       xor eax,eax
> [00001d47][00102fcd][00000018] 5d         pop ebp
> [00001d48][00102fd1][00000000] c3         ret
> Number of Instructions Executed(868) == 13 Pages
>
> We can see that Sipser_D(Sipser_D) cannot stop running unless
> Sipser_H(Sipser_D, Sipser_D) aborts its simulation.
>

Nope, wrong definiton of unless it aborts.

Your Sipser_H is just incapable of handling inputs that call itself with
some sets of parameters.

Make Sipser_B return the same value on both branches, then it is clear
by inspection what the answer that a correct Sipser_H should return, and
in fact what a smarter Sipser_H could return (using the method discussed
here a year or so back).

THus H just aborting when it sees "recursive calling" is just incorrect.

And shows its author is just using defective reasoning.

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

> On 3/16/2024 11:32 AM, immibis wrote:
>> On 16/03/24 05:23, olcott wrote:
>>> On 3/15/2024 10:55 PM, immibis wrote:
>>>> On 16/03/24 04:14, olcott wrote:
>>>>> On 3/15/2024 6:26 PM, Richard Damon wrote:
>>>>>> On 3/15/24 3:41 PM, olcott wrote:
>>>>>>> On 3/15/2024 5:10 PM, Richard Damon wrote:
>>>>>>>> On 3/15/24 2:13 PM, olcott wrote:
>>>>>>>>> On 3/15/2024 3:27 PM, Richard Damon wrote:
>>>>>>>>>> On 3/15/24 12:38 PM, olcott wrote:
>>>>>>>>>>> On 3/15/2024 2:30 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/15/24 12:14 PM, olcott wrote:
>>>>>>>>>>>>> On 3/15/2024 2:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/15/24 11:39 AM, olcott wrote:
>>>>>>>>>>>>>>> On 3/15/2024 1:38 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 15/03/24 18:52, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>>>>>>>>>>>>>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates its input D until
>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would never stop running
>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>>>>>>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp ; begin main()
>>>>>>>>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>>>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>>>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp ; enter D(D)
>>>>>>>>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax ; push D
>>>>>>>>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx ; push D
>>>>>>>>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called with its same
>>>>>>>>>>>>>>>>>>> inputs and there are no conditional branch instructions between the
>>>>>>>>>>>>>>>>>>> invocation of D(D) and its call to H(D,D).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Except that D calling H(D,D) does NOT prove the required (a), since the
>>>>>>>>>>>>>>>>>> simulated D WILL stop running because *ITS* H will abort *ITS*
>>>>>>>>>>>>>>>>>> simulation and returm 0 so that simulated D will halt.
>>>>>>>>>>>>>>>>> You keep saying that H(D,D) never really needs to abort the
>>>>>>>>>>>>>>>>> simulation of its input because after H(D,D) has aborted the
>>>>>>>>>>>>>>>>> simulation of this input it no longer needs to be aborted.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You keep thinking there is more than one H(D,D) and then when it's
>>>>>>>>>>>>>>>> convenient for you you think there is only one H(D,D). Why is that?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The first H(D,D) to see that the abort criteria has been met
>>>>>>>>>>>>>>> (the outermost one) must abort the simulation of its input or
>>>>>>>>>>>>>>> none of them ever abort.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But since it does, which is your definition of H, the others
>>>>>>>>>>>>>
>>>>>>>>>>>>> never begin to be simulated.
>>>>>>>>>>>>
>>>>>>>>>>>> But D(D) started to be simulated, and we can know what D(D) actually
>>>>>>>>>>>> does, which includes it using its version of H.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> We cannot reference the behavior of what D(D) does after H(D,D)
>>>>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure
>>>>>>>>>>> for this H(D,D).
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> WHy not?
>>>>>>>>>>
>>>>>>>>>> That is what Correct Simulation refers to.
>>>>>>>>>>
>>>>>>>>>> I guess you are just admiting to being a LIAR (or stupid).
>>>>>>>>>
>>>>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>>>>
>>>>>>>> So, do you admit that the definition of a "Correct Simulation" for the
>>>>>>>> purposes of that criteria are the complete not-aborted simulation done
>>>>>>>> by possibly some other simulator?
>>>>>>>>
>>>>>>>
>>>>>>> (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
>>>>>>>
>>>>>>> Not at all the words don't say anything like that.
>>>>>>> "H correctly simulates its input D until"
>>>>>>> specifically means a partial simulation.
>>>>>>>
>>>>>>
>>>>>> Means H uses a partial simulation to make its decision.
>>>>>>
>>>>>
>>>>> Finally you get this.
>>>>>
>>>>>> The correctness of the decision is measured by the full simulation,
>>>>>> even past where H simulated. Thus, is based on things H might not know.
>>>>>>
>>>>>
>>>>> No. the correctness of the decision is essentially anchored
>>>>> in something like mathematical induction that correctly
>>>>> predicts that complete simulation would never end.
>>>>
>>>> The correctness of the decision is anchored in whether D(D) halts or not.
>>>
>>> A termination analyzer must have some way to predicate this.
>>> H(D,D) can only predict what it actually sees and H(D,D)
>>> sees that it must abort the simulation of its input.
>>>
>> A termination analyzer cannot always correctly predict this. Every time
>> you make a termination analyzer it is easy to demonstrate one program
>> which it predicts incorrectly.
>
> 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.
>
> To the best of my knowledge no one here has ever shown that
> the above criteria is impossible to always meet.

On 2024-03-16 14:49:31 +0000, olcott said:

> On 3/16/2024 3:51 AM, Mikko wrote:
>> On 2024-03-15 18:38:23 +0000, immibis said:
>>
>>> On 15/03/24 18:52, olcott wrote:
>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>
>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>> (a) If simulating halt decider H correctly simulates its input D until
>>>>>> H correctly determines that its simulated D would never stop running
>>>>>> unless aborted then
>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>> specifies a non-halting sequence of configurations.
>>>>>>
>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>> Will you halt if you never abort your simulation?
>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>
>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>
>>>>>> int D(int (*x)())
>>>>>> {
>>>>>>    int Halt_Status = H(x, x);
>>>>>>    if (Halt_Status)
>>>>>>      HERE: goto HERE;
>>>>>>    return Halt_Status;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>> }
>>>>>>
>>>>>>   machine   stack     stack     machine    assembly
>>>>>>   address   address   data      code       language
>>>>>>   ========  ========  ========  =========  =============
>>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>
>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>> Address_of_H:1522
>>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>                            H(D,D) returns 0 to main()
>>>>>>
>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>> H(D,D) correctly determines that itself is being called with its same
>>>>>> inputs and there are no conditional branch instructions between the
>>>>>> invocation of D(D) and its call to H(D,D).
>>>>>>
>>>>>>
>>>>>
>>>>> Except that D calling H(D,D) does NOT prove the required (a), since the
>>>>> simulated D WILL stop running because *ITS* H will abort *ITS*
>>>>> simulation and returm 0 so that simulated D will halt.
>>>> You keep saying that H(D,D) never really needs to abort the
>>>> simulation of its input because after H(D,D) has aborted the
>>>> simulation of this input it no longer needs to be aborted.
>>>>
>>> You keep thinking there is more than one H(D,D) and then when it's
>>> convenient for you you think there is only one H(D,D). Why is that?
>>
>> Counting to two is not as trivial as some people think.
>>
>
> There cannot possibly exist any H(D,D) that is called by
> D where H(D,D) simulates its input and D(D) stops running
> and H never aborts its simulation.

However there is a H' not called by D where H'(D,D) simulates
its input and D(D) stops running and H' never aborts its simulation.

--
Mikko

On 3/17/2024 8:30 AM, Mikko wrote:
> On 2024-03-16 16:44:35 +0000, olcott said:
>
>> On 3/16/2024 11:32 AM, immibis wrote:
>>> On 16/03/24 05:23, olcott wrote:
>>>> On 3/15/2024 10:55 PM, immibis wrote:
>>>>> On 16/03/24 04:14, olcott wrote:
>>>>>> On 3/15/2024 6:26 PM, Richard Damon wrote:
>>>>>>> On 3/15/24 3:41 PM, olcott wrote:
>>>>>>>> On 3/15/2024 5:10 PM, Richard Damon wrote:
>>>>>>>>> On 3/15/24 2:13 PM, olcott wrote:
>>>>>>>>>> On 3/15/2024 3:27 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/15/24 12:38 PM, olcott wrote:
>>>>>>>>>>>> On 3/15/2024 2:30 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/15/24 12:14 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/15/2024 2:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/15/24 11:39 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/15/2024 1:38 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 15/03/24 18:52, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by
>>>>>>>>>>>>>>>>>>>> sipser*
>>>>>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim
>>>>>>>>>>>>>>>>>>>> paragraph is correct*
>>>>>>>>>>>>>>>>>>>> (He has neither reviewed nor agreed to anything else
>>>>>>>>>>>>>>>>>>>> in this paper)
>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates
>>>>>>>>>>>>>>>>>>>> its input D until H correctly determines that its
>>>>>>>>>>>>>>>>>>>> simulated D would never stop running unless aborted
>>>>>>>>>>>>>>>>>>>> then
>>>>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly
>>>>>>>>>>>>>>>>>>>> report that D specifies a non-halting sequence of
>>>>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>>>>>>>>   ========  ========  ========  =========
>>>>>>>>>>>>>>>>>>>> =============
>>>>>>>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp ;
>>>>>>>>>>>>>>>>>>>> begin main()
>>>>>>>>>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push
>>>>>>>>>>>>>>>>>>>> 00001cf2 ; push DD
>>>>>>>>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push
>>>>>>>>>>>>>>>>>>>> 00001cf2 ; push D
>>>>>>>>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call
>>>>>>>>>>>>>>>>>>>> 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp ;
>>>>>>>>>>>>>>>>>>>> enter D(D)
>>>>>>>>>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov
>>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax ;
>>>>>>>>>>>>>>>>>>>> push D
>>>>>>>>>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov
>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx ;
>>>>>>>>>>>>>>>>>>>> push D
>>>>>>>>>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call
>>>>>>>>>>>>>>>>>>>> 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being
>>>>>>>>>>>>>>>>>>>> called with its same inputs and there are no
>>>>>>>>>>>>>>>>>>>> conditional branch instructions between the
>>>>>>>>>>>>>>>>>>>> invocation of D(D) and its call to H(D,D).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Except that D calling H(D,D) does NOT prove the
>>>>>>>>>>>>>>>>>>> required (a), since the simulated D WILL stop running
>>>>>>>>>>>>>>>>>>> because *ITS* H will abort *ITS* simulation and
>>>>>>>>>>>>>>>>>>> returm 0 so that simulated D will halt.
>>>>>>>>>>>>>>>>>> You keep saying that H(D,D) never really needs to
>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>> simulation of its input because after H(D,D) has
>>>>>>>>>>>>>>>>>> aborted the
>>>>>>>>>>>>>>>>>> simulation of this input it no longer needs to be
>>>>>>>>>>>>>>>>>> aborted.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You keep thinking there is more than one H(D,D) and
>>>>>>>>>>>>>>>>> then when it's convenient for you you think there is
>>>>>>>>>>>>>>>>> only one H(D,D). Why is that?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The first H(D,D) to see that the abort criteria has been
>>>>>>>>>>>>>>>> met
>>>>>>>>>>>>>>>> (the outermost one) must abort the simulation of its
>>>>>>>>>>>>>>>> input or
>>>>>>>>>>>>>>>> none of them ever abort.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But since it does, which is your definition of H, the others
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> never begin to be simulated.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But D(D) started to be simulated, and we can know what D(D)
>>>>>>>>>>>>> actually does, which includes it using its version of H.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> We cannot reference the behavior of what D(D) does after H(D,D)
>>>>>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure
>>>>>>>>>>>> for this H(D,D).
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> WHy not?
>>>>>>>>>>>
>>>>>>>>>>> That is what Correct Simulation refers to.
>>>>>>>>>>>
>>>>>>>>>>> I guess you are just admiting to being a LIAR (or stupid).
>>>>>>>>>>
>>>>>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>>>>>> *I am not a liar or stupid and you admitted your mistake*
>>>>>>>>>
>>>>>>>>> So, do you admit that the definition of a "Correct Simulation"
>>>>>>>>> for the purposes of that criteria are the complete not-aborted
>>>>>>>>> simulation done by possibly some other simulator?
>>>>>>>>>
>>>>>>>>
>>>>>>>> (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
>>>>>>>>
>>>>>>>> Not at all the words don't say anything like that.
>>>>>>>> "H correctly simulates its input D until"
>>>>>>>> specifically means a partial simulation.
>>>>>>>>
>>>>>>>
>>>>>>> Means H uses a partial simulation to make its decision.
>>>>>>>
>>>>>>
>>>>>> Finally you get this.
>>>>>>
>>>>>>> The correctness of the decision is measured by the full
>>>>>>> simulation, even past where H simulated. Thus, is based on things
>>>>>>> H might not know.
>>>>>>>
>>>>>>
>>>>>> No. the correctness of the decision is essentially anchored
>>>>>> in something like mathematical induction that correctly
>>>>>> predicts that complete simulation would never end.
>>>>>
>>>>> The correctness of the decision is anchored in whether D(D) halts
>>>>> or not.
>>>>
>>>> A termination analyzer must have some way to predicate this.
>>>> H(D,D) can only predict what it actually sees and H(D,D)
>>>> sees that it must abort the simulation of its input.
>>>>
>>> A termination analyzer cannot always correctly predict this. Every
>>> time you make a termination analyzer it is easy to demonstrate one
>>> program which it predicts incorrectly.
>>
>> 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.
>>
>> To the best of my knowledge no one here has ever shown that
>> the above criteria is impossible to always meet.
>
> You haven't shown that it is possible to meet it once, let alone always.
>

On 3/17/2024 8:33 AM, Mikko wrote:
> On 2024-03-16 14:49:31 +0000, olcott said:
>
>> On 3/16/2024 3:51 AM, Mikko wrote:
>>> On 2024-03-15 18:38:23 +0000, immibis said:
>>>
>>>> On 15/03/24 18:52, olcott wrote:
>>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>
>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>>>>> correct*
>>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>>> (a) If simulating halt decider H correctly simulates its input D
>>>>>>> until H correctly determines that its simulated D would never
>>>>>>> stop running unless aborted then
>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>
>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>> Will you halt if you never abort your simulation?
>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>
>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>
>>>>>>> int D(int (*x)())
>>>>>>> {
>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>    if (Halt_Status)
>>>>>>>      HERE: goto HERE;
>>>>>>>    return Halt_Status;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>> }
>>>>>>>
>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>   address   address   data      code       language
>>>>>>>   ========  ========  ========  =========  =============
>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin
>>>>>>> main()
>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call
>>>>>>> H(D,D)
>>>>>>>
>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>> Address_of_H:1522
>>>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter
>>>>>>> D(D)
>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call
>>>>>>> H(D,D)
>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>
>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>> H(D,D) correctly determines that itself is being called with its
>>>>>>> same inputs and there are no conditional branch instructions
>>>>>>> between the invocation of D(D) and its call to H(D,D).
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Except that D calling H(D,D) does NOT prove the required (a),
>>>>>> since the simulated D WILL stop running because *ITS* H will abort
>>>>>> *ITS* simulation and returm 0 so that simulated D will halt.
>>>>> You keep saying that H(D,D) never really needs to abort the
>>>>> simulation of its input because after H(D,D) has aborted the
>>>>> simulation of this input it no longer needs to be aborted.
>>>>>
>>>> You keep thinking there is more than one H(D,D) and then when it's
>>>> convenient for you you think there is only one H(D,D). Why is that?
>>>
>>> Counting to two is not as trivial as some people think.
>>>
>>
>> There cannot possibly exist any H(D,D) that is called by
>> D where H(D,D) simulates its input and D(D) stops running
>> and H never aborts its simulation.
>
> However there is a H' not called by D where H'(D,D) simulates
> its input and D(D) stops running and H' never aborts its simulation.
>

That exists as H1(D,D) yet only works because H(D,D) aborts its simulation.

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

On 3/17/2024 8:16 AM, Richard Damon wrote:
> On 3/17/24 6:02 AM, olcott wrote:
>> On 3/17/2024 4:02 AM, Mikko wrote:
>>> On 2024-03-16 15:09:42 +0000, olcott said:
>>>
>>>> https://philarchive.org/archive/OLCRTSv1
>>>
>>> Before the C code for Sipser_D that page should should say
>>> that all return values are encoded so that Sipser's reject
>>> is enoded as 0 and Sipser's accept as 1.
>>>
>>
>> It already says that.
>> //
>> // H returns 1 when its input would halt and return 1.
>> // otherwise H returns 0
>> //
>> int Sipser_D(ptr2 M)
>> {
>>   if ( Sipser_H(M, M) )
>>     return 0;
>>   return 1;
>> }
>>
>>> There should also be a proof that your C programs satisfy
>>> Sipser's definitions of D and H.
>>>
>> *He didn't have time to look at that much of it*
>>
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [00001d22][00102fc9][00000000] 55         push ebp
>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>> [00001d25][00102fc5][00001b32] 68321b0000 push 00001b32 ; push Sipser_D
>> [00001d2a][00102fc1][00001b32] 68321b0000 push 00001b32 ; push Sipser_D
>> [00001d2f][00102fbd][00001d34] e8eef8ffff call 00001622 ; call Sipser_H
>>
>> Sipser_H: Begin Simulation   Execution Trace Stored at:113075
>> Address_of_Sipser_H:1622
>> [00001b32][00113061][00113065] 55         push ebp
>> [00001b33][00113061][00113065] 8bec       mov ebp,esp
>> [00001b35][00113061][00113065] 8b4508     mov eax,[ebp+08]
>> [00001b38][0011305d][00001b32] 50         push eax      ; push Sipser_D
>> [00001b39][0011305d][00001b32] 8b4d08     mov ecx,[ebp+08]
>> [00001b3c][00113059][00001b32] 51         push ecx      ; push Sipser_D
>> [00001b3d][00113055][00001b42] e8e0faffff call 00001622 ; call Sipser_H
>> Sipser_H: Recursive Simulation Detected Simulation Stopped
>>
>> [00001d34][00102fc9][00000000] 83c408     add esp,+08
>> [00001d37][00102fc5][00000000] 50         push eax
>> [00001d38][00102fc1][00000743] 6843070000 push 00000743
>> [00001d3d][00102fc1][00000743] e820eaffff call 00000762
>> Input_Halts = 0
>> [00001d42][00102fc9][00000000] 83c408     add esp,+08
>> [00001d45][00102fc9][00000000] 33c0       xor eax,eax
>> [00001d47][00102fcd][00000018] 5d         pop ebp
>> [00001d48][00102fd1][00000000] c3         ret
>> Number of Instructions Executed(868) == 13 Pages
>>
>> We can see that Sipser_D(Sipser_D) cannot stop running unless
>> Sipser_H(Sipser_D, Sipser_D) aborts its simulation.
>>
>
>
> Nope, wrong definiton of unless it aborts.

For pathological thinking H(D,D) is incorrect to abort and
incorrect not to abort. For factual thinking I proved that
Sipser_H(Sipser_D, Sipser_D) was correct to abort.

>
> Your Sipser_H is just incapable of handling inputs that call itself with
> some sets of parameters.
>
> Make Sipser_B return the same value on both branches, then it is clear
> by inspection what the answer that a correct Sipser_H should return, and
> in fact what a smarter Sipser_H could return (using the method discussed
> here a year or so back).
>
> THus H just aborting when it sees "recursive calling" is just incorrect.
>
> And shows its author is just using defective reasoning.

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

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.

> Requiring H to be clairvoyant is an unreasonable requirement.
> *The criteria shown below eliminate the requirement of clairvoyance*

You can call it unreasonable but it is what it is.

--
Mikko