On 3/24/2024 11:42 AM, Mikko wrote:
> On 2024-03-24 03:39:12 +0000, olcott said:
>
>> On 3/23/2024 9:54 PM, immibis wrote:
>>> On 24/03/24 03:40, olcott wrote:
>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>>>
>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>
>>>>>>>>> To be a halt decider it has to give an answer that is the same
>>>>>>>>> as whether the direct execution of its input would halt.
>>>>>>>>
>>>>>>>> That would entail that
>>>>>>>
>>>>>>> Tough shit. That is the requirement.
>>>>>>
>>>>>> I proved otherwise in the parts you erased.
>>>>>
>>>>> You proved that the requirement is not actually the requirement?
>>>>
>>>> I proved that it cannot be a coherent requirement, it can still
>>>> be an incoherent requirement. Try and think it through for yourself.
>>>
>>> Every program/input pair either halts some time, or never halts.
>>> Determining this is a coherent requirement.
>>
>> That part is coherent.
>
> The part that this determination must be done by a Turing machine
> using descriptions of the program and input is coherent, too.
>

Every decider is required by definition to only report on what
this input specifies.

int sum(int x, int y){ return x + y; }
sum(3,4) is not allowed to report on the sum of 5 + 6
even if you really really believe that it should.

--
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/24/2024 9:27 AM, Mikko wrote:
> On 2024-03-24 02:11:34 +0000, olcott said:
>
>> On 3/23/2024 7:31 PM, Richard Damon wrote:
>>> On 3/23/24 7:29 PM, olcott wrote:
>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>      because it would halt and all deciders must always halt.
>>>>>
>>>>> To be a decider it has to give an answer.
>>>>>
>>>>> To be a halt decider it has to give an answer that is the same as
>>>>> whether the direct execution of its input would halt.
>>>>>
>>>>
>>>> That would entail that H must report on different behavior
>>>> than the behavior that H actually sees thus violate the
>>>> definition of a decider that must compute the mapping from
>>>> its inputs...
>>>
>>> Nope.
>>> You are just showing yourself to be a stupid liar.
>>>
>>> Where in the DEFINITION of Compute the Mapping of the Input to the
>>> Mapped Output does it say that the decider has to be able to "see"
>>> that property of the input?
>>>
>>
>> In order to compute the mapping from an input there must be
>> some basis that is directly provided by this input.
>
> If no such basis is in the input the problem has no soution.
>

int sum(int x, int y){ return x + y; }
sum(3,4) is not allowed to report on the sum of 5 + 6
even if you really really believe that it should.

--
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/25/24 11:59 AM, olcott wrote:
> On 3/24/2024 6:31 AM, Richard Damon wrote:
>> On 3/23/24 10:11 PM, olcott wrote:
>>> On 3/23/2024 7:31 PM, Richard Damon wrote:
>>>> On 3/23/24 7:29 PM, olcott wrote:
>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>
>>>>>> To be a decider it has to give an answer.
>>>>>>
>>>>>> To be a halt decider it has to give an answer that is the same as
>>>>>> whether the direct execution of its input would halt.
>>>>>>
>>>>>
>>>>> That would entail that H must report on different behavior
>>>>> than the behavior that H actually sees thus violate the
>>>>> definition of a decider that must compute the mapping from
>>>>> its inputs...
>>>>
>>>> Nope.
>>>> You are just showing yourself to be a stupid liar.
>>>>
>>>> Where in the DEFINITION of Compute the Mapping of the Input to the
>>>> Mapped Output does it say that the decider has to be able to "see"
>>>> that property of the input?
>>>>
>>>
>>> In order to compute the mapping from an input there must be
>>> some basis that is directly provided by this input. The basis
>>> certainly cannot be what you and others simply imagine is the
>>> correct behavior.
>>
>> To be ABLE, yes.
>>
>> To be REQUIRED, No.
>>
>> The mapping just needs a formal definition, that definition might not
>> include how to "calculate" it in finite time.
>>
>
> On 3/22/2024 9:17 PM, Richard Damon wrote:
> >
> > The problem is that even if the "C function" D is
> > the same machine code, the fact that it calls an
> > external H means *the code of H affects its*
> > *behavior, and that must be taken into account*
>
> *Simpler paraphrase*
> *The code of H affects the behavior of D*
> *and this must be taken into account*

Right,

>
> H computes the mapping from its input on the basis of its
> behavior *taking the pathological relationship into account*
> For every possible implementation of H(D,D) where H simulates
> its input D cannot possibly reach its own line 06 and halt.
>

But it doesn't.

Since the H that abort and return 0 have input that by simple
observation will halt.

> Thus when *taking the pathological relationship into account*
> H(D,D) is correct to abort its simulation of D(D) thus meeting
> this criteria:

Nope, that is NOT taking the pathological relationship into account and
assuming a LIE that D is built on an non-aborting H.

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

Right, any H that waits until it KNOWS the right answer, is just
non-halting.

Any H that stops earilesr and tries to guess, will just be wrong, since
to be right, it needs to consider what itself will do. An H that
understands this, knows it is stuck, and can't give a right answer, but
that isn't an option.

On 3/25/24 11:27 AM, olcott wrote:
> On 3/24/2024 6:51 AM, Richard Damon wrote:
>> On 3/23/24 11:57 PM, olcott wrote:
>>> On 3/23/2024 10:05 PM, Richard Damon wrote:
>>>> olcott <polcott2@gmail.com> wrote:
>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>       (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>       because it would halt and all deciders must always halt.
>>>>>>>>>>
>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>
>>>>>>>>>> To be a halt decider it has to give an answer that is the same as
>>>>>>>>>> whether the direct execution of its input would halt.
>>>>>>>>>
>>>>>>>>> That would entail that
>>>>>>>>
>>>>>>>> Tough shit. That is the requirement.
>>>>>>>
>>>>>>> I proved otherwise in the parts you erased.
>>>>>>
>>>>>> You proved that the requirement is not actually the requirement?
>>>>>
>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>> be an incoherent requirement. Try and think it through for yourself.
>>>>>
>>>>> Can it be a legitimate for a TM to be required to compute something
>>>>> that is only in your head?
>>>>>
>>>>
>>>> Yes. If you can DEFINE how you build the Mapping Table, by ANY
>>>> method, you
>>>> can ask a Turing Machine to compute it.
>>>>
>>>
>>> Yet this mapping table only remains in your head and you never
>>> encode it for the TM to see. Can the TM be required to compute
>>> what is ONLY in your head and thus not anywhere on its tape?
>>>
>>
>> If I DEFINE what the mapping is, then it can be asked to be computed.
>>
>
> Not if your just keep it in your head and don't encode it
> for the TM to see.

Don't need to encode it for a TM, just need to describe it so an
intelegent sentient being can understand the definition.

For example, it COULD be given a particular parameterized formula, and a
set of parameters for it, find the zeros.

>
> int sum(int x, int y){ return x + y; }
> sum(3,7) returns the sum of 3 + 4.

That is just not giving it the right inputs.

>
> "The sum of three plus four" (in your head)
> has no return value from sum().

No, YOU lied to it about what the problem is.

>
>> The definition doesn't need to be the actual value, but a method to
>> get the value, but the method need not be "computable" as it can
>> involve infinite work, or only be "checkable".
>>
>> There is NO requirement that I tell you how to compute the value when
>> I ask you to compute it, that is YOUR job, as the programmer.
>>
>> This does lead to some mappings being truly uncomputable, as there is
>> no finite algorithm that can generate all the values in finite time.
>>
>

On 2024-03-25 22:52:18 +0000, olcott said:

> On 3/24/2024 9:27 AM, Mikko wrote:
>> On 2024-03-24 02:11:34 +0000, olcott said:
>>
>>> On 3/23/2024 7:31 PM, Richard Damon wrote:
>>>> On 3/23/24 7:29 PM, olcott wrote:
>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>
>>>>>> To be a decider it has to give an answer.
>>>>>>
>>>>>> To be a halt decider it has to give an answer that is the same as
>>>>>> whether the direct execution of its input would halt.
>>>>>>
>>>>>
>>>>> That would entail that H must report on different behavior
>>>>> than the behavior that H actually sees thus violate the
>>>>> definition of a decider that must compute the mapping from
>>>>> its inputs...
>>>>
>>>> Nope.
>>>> You are just showing yourself to be a stupid liar.
>>>>
>>>> Where in the DEFINITION of Compute the Mapping of the Input to the
>>>> Mapped Output does it say that the decider has to be able to "see" that
>>>> property of the input?
>>>>
>>>
>>> In order to compute the mapping from an input there must be
>>> some basis that is directly provided by this input.
>>
>> If no such basis is in the input the problem has no soution.
>>
>
> int sum(int x, int y){ return x + y; }
> sum(3,4) is not allowed to report on the sum of 5 + 6
> even if you really really believe that it should.

Your and my beliefs don't matter. Testers call the function with
various pairs of inputs and compare the result to the specification.
If the result is not what the specification requires then the function
is wrong and needs be fixed or rejected.

--
Mikko

Op 25.mrt.2024 om 23:50 schreef olcott:
> On 3/24/2024 11:42 AM, Mikko wrote:
>> On 2024-03-24 03:39:12 +0000, olcott said:
>>
>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>> On 24/03/24 03:40, olcott wrote:
>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>>>>
>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>
>>>>>>>>>> To be a halt decider it has to give an answer that is the same
>>>>>>>>>> as whether the direct execution of its input would halt.
>>>>>>>>>
>>>>>>>>> That would entail that
>>>>>>>>
>>>>>>>> Tough shit. That is the requirement.
>>>>>>>
>>>>>>> I proved otherwise in the parts you erased.
>>>>>>
>>>>>> You proved that the requirement is not actually the requirement?
>>>>>
>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>> be an incoherent requirement. Try and think it through for yourself.
>>>>
>>>> Every program/input pair either halts some time, or never halts.
>>>> Determining this is a coherent requirement.
>>>
>>> That part is coherent.
>>
>> The part that this determination must be done by a Turing machine
>> using descriptions of the program and input is coherent, too.
>>
>
> Every decider is required by definition to only report on what
> this input specifies.
>
> int sum(int x, int y){ return x + y; }
> sum(3,4) is not allowed to report on the sum of 5 + 6
> even if you really really believe that it should.
>

Exactly! Therefore H(D,D), where D is based on H that aborts and returns
false, so that D halts, should not return a report about another D that
does not halt, even if you really really believe that it should.
--
Paradoxes in the relation between Creator and creature.
<http://www.wirholt.nl/English>.

On 2024-03-25 22:50:08 +0000, olcott said:

> On 3/24/2024 11:42 AM, Mikko wrote:
>> On 2024-03-24 03:39:12 +0000, olcott said:
>>
>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>> On 24/03/24 03:40, olcott wrote:
>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>>>>
>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>
>>>>>>>>>> To be a halt decider it has to give an answer that is the same as
>>>>>>>>>> whether the direct execution of its input would halt.
>>>>>>>>>
>>>>>>>>> That would entail that
>>>>>>>>
>>>>>>>> Tough shit. That is the requirement.
>>>>>>>
>>>>>>> I proved otherwise in the parts you erased.
>>>>>>
>>>>>> You proved that the requirement is not actually the requirement?
>>>>>
>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>> be an incoherent requirement. Try and think it through for yourself.
>>>>
>>>> Every program/input pair either halts some time, or never halts.
>>>> Determining this is a coherent requirement.
>>>
>>> That part is coherent.
>>
>> The part that this determination must be done by a Turing machine
>> using descriptions of the program and input is coherent, too.
>>
>
> Every decider is required by definition to only report on what
> this input specifies.

Not true. The input is not a specification. Every decider is only
required to halt and either accept or reject, no more. All other
requirements (if any) come from specifications for some type of
deciders and don't apply to other types.

> int sum(int x, int y){ return x + y; }
> sum(3,4) is not allowed to report on the sum of 5 + 6
> even if you really really believe that it should.

It is allowed unless the specification says otherwise. Your beliefs
are irrelevant.

--
Mikko

On 3/26/2024 3:50 AM, Mikko wrote:
> On 2024-03-25 22:52:18 +0000, olcott said:
>
>> On 3/24/2024 9:27 AM, Mikko wrote:
>>> On 2024-03-24 02:11:34 +0000, olcott said:
>>>
>>>> On 3/23/2024 7:31 PM, Richard Damon wrote:
>>>>> On 3/23/24 7:29 PM, olcott wrote:
>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>
>>>>>>> To be a decider it has to give an answer.
>>>>>>>
>>>>>>> To be a halt decider it has to give an answer that is the same as
>>>>>>> whether the direct execution of its input would halt.
>>>>>>>
>>>>>>
>>>>>> That would entail that H must report on different behavior
>>>>>> than the behavior that H actually sees thus violate the
>>>>>> definition of a decider that must compute the mapping from
>>>>>> its inputs...
>>>>>
>>>>> Nope.
>>>>> You are just showing yourself to be a stupid liar.
>>>>>
>>>>> Where in the DEFINITION of Compute the Mapping of the Input to the
>>>>> Mapped Output does it say that the decider has to be able to "see"
>>>>> that property of the input?
>>>>>
>>>>
>>>> In order to compute the mapping from an input there must be
>>>> some basis that is directly provided by this input.
>>>
>>> If no such basis is in the input the problem has no soution.
>>>
>>
>> int sum(int x, int y){ return x + y; }
>> sum(3,4) is not allowed to report on the sum of 5 + 6
>> even if you really really believe that it should.
>
> Your and my beliefs don't matter. Testers call the function with
> various pairs of inputs and compare the result to the specification.
> If the result is not what the specification requires then the function
> is wrong and needs be fixed or rejected.
>

There is enough information for sum(3,4) to compute the sum of 3+4.
There is NOT enough information for sum(3,4) to compute the sum of 5+6.

There is enough information for H1(D,D) to compute Halts(D,D).
There is NOT enough information for H(D,D) to compute Halts(D,D).

--
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/26/2024 3:51 AM, Fred. Zwarts wrote:
> Op 25.mrt.2024 om 23:50 schreef olcott:
>> On 3/24/2024 11:42 AM, Mikko wrote:
>>> On 2024-03-24 03:39:12 +0000, olcott said:
>>>
>>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>>> On 24/03/24 03:40, olcott wrote:
>>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>>>>>
>>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>>
>>>>>>>>>>> To be a halt decider it has to give an answer that is the
>>>>>>>>>>> same as whether the direct execution of its input would halt.
>>>>>>>>>>
>>>>>>>>>> That would entail that
>>>>>>>>>
>>>>>>>>> Tough shit. That is the requirement.
>>>>>>>>
>>>>>>>> I proved otherwise in the parts you erased.
>>>>>>>
>>>>>>> You proved that the requirement is not actually the requirement?
>>>>>>
>>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>>> be an incoherent requirement. Try and think it through for yourself.
>>>>>
>>>>> Every program/input pair either halts some time, or never halts.
>>>>> Determining this is a coherent requirement.
>>>>
>>>> That part is coherent.
>>>
>>> The part that this determination must be done by a Turing machine
>>> using descriptions of the program and input is coherent, too.
>>>
>>
>> Every decider is required by definition to only report on what
>> this input specifies.
>>
>> int sum(int x, int y){ return x + y; }
>> sum(3,4) is not allowed to report on the sum of 5 + 6
>> even if you really really believe that it should.
>>
>
> Exactly! Therefore H(D,D), where D is based on H that aborts and returns
> false, so that D halts, should not return a report about another D that
> does not halt, even if you really really believe that it should.

There is enough information for sum(3,4) to compute the sum of 3+4.
There is NOT enough information for sum(3,4) to compute the sum of 5+6.

There is enough information for H1(D,D) to compute Halts(D,D).
There is NOT enough information for H(D,D) to compute Halts(D,D).

--
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/26/2024 3:57 AM, Mikko wrote:
> On 2024-03-25 22:50:08 +0000, olcott said:
>
>> On 3/24/2024 11:42 AM, Mikko wrote:
>>> On 2024-03-24 03:39:12 +0000, olcott said:
>>>
>>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>>> On 24/03/24 03:40, olcott wrote:
>>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>>>>>
>>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>>
>>>>>>>>>>> To be a halt decider it has to give an answer that is the
>>>>>>>>>>> same as whether the direct execution of its input would halt.
>>>>>>>>>>
>>>>>>>>>> That would entail that
>>>>>>>>>
>>>>>>>>> Tough shit. That is the requirement.
>>>>>>>>
>>>>>>>> I proved otherwise in the parts you erased.
>>>>>>>
>>>>>>> You proved that the requirement is not actually the requirement?
>>>>>>
>>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>>> be an incoherent requirement. Try and think it through for yourself.
>>>>>
>>>>> Every program/input pair either halts some time, or never halts.
>>>>> Determining this is a coherent requirement.
>>>>
>>>> That part is coherent.
>>>
>>> The part that this determination must be done by a Turing machine
>>> using descriptions of the program and input is coherent, too.
>>>
>>
>> Every decider is required by definition to only report on what
>> this input specifies.
>
> Not true.

int sum(int x, int y){ return x + y; }
The show how sum(3,4) reports the sum of 5 + 6.

> The input is not a specification. Every decider is only
> required to halt and either accept or reject, no more. All other
> requirements (if any) come from specifications for some type of
> deciders and don't apply to other types.
>

It is a verified fact that most people here lie about that
unless H(D,D) aborts its simulation neither H(D,D) nor its
simulated D(D) will ever halt.

It is also a verified fact that every value that H(D,D) returns
is contradicted by the behavior of D. This means that if H(D,D)
did report that D(D) halts that answer would be wrong too.

>> int sum(int x, int y){ return x + y; }
>> sum(3,4) is not allowed to report on the sum of 5 + 6
>> even if you really really believe that it should.
>
> It is allowed unless the specification says otherwise. Your beliefs
> are irrelevant.
>

Likewise H(D,D) must abort its simulation to prevent its own infinite
execution. I don't think that there are any actual beliefs to the
contrary, statements to the contrary are intentional lies.

--
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-26 14:41:08 +0000, olcott said:

> On 3/26/2024 3:50 AM, Mikko wrote:
>> On 2024-03-25 22:52:18 +0000, olcott said:
>>
>>> On 3/24/2024 9:27 AM, Mikko wrote:
>>>> On 2024-03-24 02:11:34 +0000, olcott said:
>>>>
>>>>> On 3/23/2024 7:31 PM, Richard Damon wrote:
>>>>>> On 3/23/24 7:29 PM, olcott wrote:
>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>>
>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>
>>>>>>>> To be a halt decider it has to give an answer that is the same as
>>>>>>>> whether the direct execution of its input would halt.
>>>>>>>>
>>>>>>>
>>>>>>> That would entail that H must report on different behavior
>>>>>>> than the behavior that H actually sees thus violate the
>>>>>>> definition of a decider that must compute the mapping from
>>>>>>> its inputs...
>>>>>>
>>>>>> Nope.
>>>>>> You are just showing yourself to be a stupid liar.
>>>>>>
>>>>>> Where in the DEFINITION of Compute the Mapping of the Input to the
>>>>>> Mapped Output does it say that the decider has to be able to "see" that
>>>>>> property of the input?
>>>>>>
>>>>>
>>>>> In order to compute the mapping from an input there must be
>>>>> some basis that is directly provided by this input.
>>>>
>>>> If no such basis is in the input the problem has no soution.
>>>>
>>>
>>> int sum(int x, int y){ return x + y; }
>>> sum(3,4) is not allowed to report on the sum of 5 + 6
>>> even if you really really believe that it should.
>>
>> Your and my beliefs don't matter. Testers call the function with
>> various pairs of inputs and compare the result to the specification.
>> If the result is not what the specification requires then the function
>> is wrong and needs be fixed or rejected.
>>
>
> There is enough information for sum(3,4) to compute the sum of 3+4.
> There is NOT enough information for sum(3,4) to compute the sum of 5+6.
>
> There is enough information for H1(D,D) to compute Halts(D,D).
> There is NOT enough information for H(D,D) to compute Halts(D,D).

There is enough information to determine whether the result is as
required by the specification.

--
Mikko

On 2024-03-26 14:51:18 +0000, olcott said:

> On 3/26/2024 3:57 AM, Mikko wrote:
>> On 2024-03-25 22:50:08 +0000, olcott said:
>>
>>> On 3/24/2024 11:42 AM, Mikko wrote:
>>>> On 2024-03-24 03:39:12 +0000, olcott said:
>>>>
>>>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>>>> On 24/03/24 03:40, olcott wrote:
>>>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>>>>>>
>>>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>>>
>>>>>>>>>>>> To be a halt decider it has to give an answer that is the same as
>>>>>>>>>>>> whether the direct execution of its input would halt.
>>>>>>>>>>>
>>>>>>>>>>> That would entail that
>>>>>>>>>>
>>>>>>>>>> Tough shit. That is the requirement.
>>>>>>>>>
>>>>>>>>> I proved otherwise in the parts you erased.
>>>>>>>>
>>>>>>>> You proved that the requirement is not actually the requirement?
>>>>>>>
>>>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>>>> be an incoherent requirement. Try and think it through for yourself.
>>>>>>
>>>>>> Every program/input pair either halts some time, or never halts.
>>>>>> Determining this is a coherent requirement.
>>>>>
>>>>> That part is coherent.
>>>>
>>>> The part that this determination must be done by a Turing machine
>>>> using descriptions of the program and input is coherent, too.
>>>>
>>>
>>> Every decider is required by definition to only report on what
>>> this input specifies.
>>
>> Not true.
>
> int sum(int x, int y){ return x + y; }
> The show how sum(3,4) reports the sum of 5 + 6.

I needn't show anything as I didn't promise to implement it.

--
Mikko

Op 26.mrt.2024 om 15:43 schreef olcott:
> On 3/26/2024 3:51 AM, Fred. Zwarts wrote:
>> Op 25.mrt.2024 om 23:50 schreef olcott:
>>> On 3/24/2024 11:42 AM, Mikko wrote:
>>>> On 2024-03-24 03:39:12 +0000, olcott said:
>>>>
>>>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>>>> On 24/03/24 03:40, olcott wrote:
>>>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>>>>>>
>>>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>>>
>>>>>>>>>>>> To be a halt decider it has to give an answer that is the
>>>>>>>>>>>> same as whether the direct execution of its input would halt.
>>>>>>>>>>>
>>>>>>>>>>> That would entail that
>>>>>>>>>>
>>>>>>>>>> Tough shit. That is the requirement.
>>>>>>>>>
>>>>>>>>> I proved otherwise in the parts you erased.
>>>>>>>>
>>>>>>>> You proved that the requirement is not actually the requirement?
>>>>>>>
>>>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>>>> be an incoherent requirement. Try and think it through for yourself.
>>>>>>
>>>>>> Every program/input pair either halts some time, or never halts.
>>>>>> Determining this is a coherent requirement.
>>>>>
>>>>> That part is coherent.
>>>>
>>>> The part that this determination must be done by a Turing machine
>>>> using descriptions of the program and input is coherent, too.
>>>>
>>>
>>> Every decider is required by definition to only report on what
>>> this input specifies.
>>>
>>> int sum(int x, int y){ return x + y; }
>>> sum(3,4) is not allowed to report on the sum of 5 + 6
>>> even if you really really believe that it should.
>>>
>>
>> Exactly! Therefore H(D,D), where D is based on H that aborts and
>> returns false, so that D halts, should not return a report about
>> another D that does not halt, even if you really really believe that
>> it should.
>
> There is enough information for sum(3,4) to compute the sum of 3+4.
> There is NOT enough information for sum(3,4) to compute the sum of 5+6.
>
> There is enough information for H1(D,D) to compute Halts(D,D).
> There is NOT enough information for H(D,D) to compute Halts(D,D).
>

But it is possible to create a simulating sum decider that aborts sum
and returns the sum of 5+6 and then claim that it is right, because it
has not enough information to calculate 3+4. It is possible, but wrong.
The only reason it has not enough information, is that it aborts
prematurely. That makes the decision to abort wrong. This holds for H as
well.

Op 26.mrt.2024 om 15:43 schreef olcott:
> On 3/26/2024 3:51 AM, Fred. Zwarts wrote:
>> Op 25.mrt.2024 om 23:50 schreef olcott:
>>> On 3/24/2024 11:42 AM, Mikko wrote:
>>>> On 2024-03-24 03:39:12 +0000, olcott said:
>>>>
>>>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>>>> On 24/03/24 03:40, olcott wrote:
>>>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>>>>>>
>>>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>>>
>>>>>>>>>>>> To be a halt decider it has to give an answer that is the
>>>>>>>>>>>> same as whether the direct execution of its input would halt.
>>>>>>>>>>>
>>>>>>>>>>> That would entail that
>>>>>>>>>>
>>>>>>>>>> Tough shit. That is the requirement.
>>>>>>>>>
>>>>>>>>> I proved otherwise in the parts you erased.
>>>>>>>>
>>>>>>>> You proved that the requirement is not actually the requirement?
>>>>>>>
>>>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>>>> be an incoherent requirement. Try and think it through for yourself.
>>>>>>
>>>>>> Every program/input pair either halts some time, or never halts.
>>>>>> Determining this is a coherent requirement.
>>>>>
>>>>> That part is coherent.
>>>>
>>>> The part that this determination must be done by a Turing machine
>>>> using descriptions of the program and input is coherent, too.
>>>>
>>>
>>> Every decider is required by definition to only report on what
>>> this input specifies.
>>>
>>> int sum(int x, int y){ return x + y; }
>>> sum(3,4) is not allowed to report on the sum of 5 + 6
>>> even if you really really believe that it should.
>>>
>>
>> Exactly! Therefore H(D,D), where D is based on H that aborts and
>> returns false, so that D halts, should not return a report about
>> another D that does not halt, even if you really really believe that
>> it should.
>
> There is enough information for sum(3,4) to compute the sum of 3+4.
> There is NOT enough information for sum(3,4) to compute the sum of 5+6.
>
> There is enough information for H1(D,D) to compute Halts(D,D).
> There is NOT enough information for H(D,D) to compute Halts(D,D).

H and H1 have the same information, because they have the same input!
H and H1 have the same information, because they have the same input!
H and H1 have the same information, because they have the same input!
H and H1 have the same information, because they have the same input!
H and H1 have the same information, because they have the same input!

Te difference is that H does not use the information, because it aborts
prematurely.

On 3/27/2024 4:32 AM, Mikko wrote:
> On 2024-03-26 14:41:08 +0000, olcott said:
>
>> On 3/26/2024 3:50 AM, Mikko wrote:
>>> On 2024-03-25 22:52:18 +0000, olcott said:
>>>
>>>> On 3/24/2024 9:27 AM, Mikko wrote:
>>>>> On 2024-03-24 02:11:34 +0000, olcott said:
>>>>>
>>>>>> On 3/23/2024 7:31 PM, Richard Damon wrote:
>>>>>>> On 3/23/24 7:29 PM, olcott wrote:
>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>>>
>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>
>>>>>>>>> To be a halt decider it has to give an answer that is the same
>>>>>>>>> as whether the direct execution of its input would halt.
>>>>>>>>>
>>>>>>>>
>>>>>>>> That would entail that H must report on different behavior
>>>>>>>> than the behavior that H actually sees thus violate the
>>>>>>>> definition of a decider that must compute the mapping from
>>>>>>>> its inputs...
>>>>>>>
>>>>>>> Nope.
>>>>>>> You are just showing yourself to be a stupid liar.
>>>>>>>
>>>>>>> Where in the DEFINITION of Compute the Mapping of the Input to
>>>>>>> the Mapped Output does it say that the decider has to be able to
>>>>>>> "see" that property of the input?
>>>>>>>
>>>>>>
>>>>>> In order to compute the mapping from an input there must be
>>>>>> some basis that is directly provided by this input.
>>>>>
>>>>> If no such basis is in the input the problem has no soution.
>>>>>
>>>>
>>>> int sum(int x, int y){ return x + y; }
>>>> sum(3,4) is not allowed to report on the sum of 5 + 6
>>>> even if you really really believe that it should.
>>>
>>> Your and my beliefs don't matter. Testers call the function with
>>> various pairs of inputs and compare the result to the specification.
>>> If the result is not what the specification requires then the function
>>> is wrong and needs be fixed or rejected.
>>>
>>
>> There is enough information for sum(3,4) to compute the sum of 3+4.
>> There is NOT enough information for sum(3,4) to compute the sum of 5+6.
>>
>> There is enough information for H1(D,D) to compute Halts(D,D).
>> There is NOT enough information for H(D,D) to compute Halts(D,D).
>
> There is enough information to determine whether the result is as
> required by the specification.
>

This specification only requires a mapping from H(D,D)
to Halts(Simulated_by_H(D,D)) and it gets that one correctly.
D(D) does not halt from the POV of H.

--
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/27/2024 4:35 AM, Mikko wrote:
> On 2024-03-26 14:51:18 +0000, olcott said:
>
>> On 3/26/2024 3:57 AM, Mikko wrote:
>>> On 2024-03-25 22:50:08 +0000, olcott said:
>>>
>>>> On 3/24/2024 11:42 AM, Mikko wrote:
>>>>> On 2024-03-24 03:39:12 +0000, olcott said:
>>>>>
>>>>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>>>>> On 24/03/24 03:40, olcott wrote:
>>>>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To be a halt decider it has to give an answer that is the
>>>>>>>>>>>>> same as whether the direct execution of its input would halt.
>>>>>>>>>>>>
>>>>>>>>>>>> That would entail that
>>>>>>>>>>>
>>>>>>>>>>> Tough shit. That is the requirement.
>>>>>>>>>>
>>>>>>>>>> I proved otherwise in the parts you erased.
>>>>>>>>>
>>>>>>>>> You proved that the requirement is not actually the requirement?
>>>>>>>>
>>>>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>>>>> be an incoherent requirement. Try and think it through for
>>>>>>>> yourself.
>>>>>>>
>>>>>>> Every program/input pair either halts some time, or never halts.
>>>>>>> Determining this is a coherent requirement.
>>>>>>
>>>>>> That part is coherent.
>>>>>
>>>>> The part that this determination must be done by a Turing machine
>>>>> using descriptions of the program and input is coherent, too.
>>>>>
>>>>
>>>> Every decider is required by definition to only report on what
>>>> this input specifies.
>>>
>>> Not true.
>>
>> int sum(int x, int y){ return x + y; }
>> The show how sum(3,4) reports the sum of 5 + 6.
>
> I needn't show anything as I didn't promise to implement it.
>

If implementing the specification is logically impossible
then that makes it an incorrect question instance.

--
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/27/2024 4:55 AM, Fred. Zwarts wrote:
> Op 26.mrt.2024 om 15:43 schreef olcott:
>> On 3/26/2024 3:51 AM, Fred. Zwarts wrote:
>>> Op 25.mrt.2024 om 23:50 schreef olcott:
>>>> On 3/24/2024 11:42 AM, Mikko wrote:
>>>>> On 2024-03-24 03:39:12 +0000, olcott said:
>>>>>
>>>>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>>>>> On 24/03/24 03:40, olcott wrote:
>>>>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To be a halt decider it has to give an answer that is the
>>>>>>>>>>>>> same as whether the direct execution of its input would halt.
>>>>>>>>>>>>
>>>>>>>>>>>> That would entail that
>>>>>>>>>>>
>>>>>>>>>>> Tough shit. That is the requirement.
>>>>>>>>>>
>>>>>>>>>> I proved otherwise in the parts you erased.
>>>>>>>>>
>>>>>>>>> You proved that the requirement is not actually the requirement?
>>>>>>>>
>>>>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>>>>> be an incoherent requirement. Try and think it through for
>>>>>>>> yourself.
>>>>>>>
>>>>>>> Every program/input pair either halts some time, or never halts.
>>>>>>> Determining this is a coherent requirement.
>>>>>>
>>>>>> That part is coherent.
>>>>>
>>>>> The part that this determination must be done by a Turing machine
>>>>> using descriptions of the program and input is coherent, too.
>>>>>
>>>>
>>>> Every decider is required by definition to only report on what
>>>> this input specifies.
>>>>
>>>> int sum(int x, int y){ return x + y; }
>>>> sum(3,4) is not allowed to report on the sum of 5 + 6
>>>> even if you really really believe that it should.
>>>>
>>>
>>> Exactly! Therefore H(D,D), where D is based on H that aborts and
>>> returns false, so that D halts, should not return a report about
>>> another D that does not halt, even if you really really believe that
>>> it should.
>>
>> There is enough information for sum(3,4) to compute the sum of 3+4.
>> There is NOT enough information for sum(3,4) to compute the sum of 5+6.
>>
>> There is enough information for H1(D,D) to compute Halts(D,D).
>> There is NOT enough information for H(D,D) to compute Halts(D,D).
>>
>
> But it is possible to create a simulating sum decider that aborts sum
> and returns the sum of 5+6 and then claim that it is right, because it
> has not enough information to calculate 3+4. It is possible, but wrong.
> The only reason it has not enough information, is that it aborts
> prematurely. That makes the decision to abort wrong. This holds for H as
> well.

Why are you denying reality?

Can D correctly simulated by H terminate normally?
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }

*Execution Trace*
Line 11: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.

--
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/27/2024 5:10 AM, Fred. Zwarts wrote:
> Op 26.mrt.2024 om 15:43 schreef olcott:
>> On 3/26/2024 3:51 AM, Fred. Zwarts wrote:
>>> Op 25.mrt.2024 om 23:50 schreef olcott:
>>>> On 3/24/2024 11:42 AM, Mikko wrote:
>>>>> On 2024-03-24 03:39:12 +0000, olcott said:
>>>>>
>>>>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>>>>> On 24/03/24 03:40, olcott wrote:
>>>>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To be a halt decider it has to give an answer that is the
>>>>>>>>>>>>> same as whether the direct execution of its input would halt.
>>>>>>>>>>>>
>>>>>>>>>>>> That would entail that
>>>>>>>>>>>
>>>>>>>>>>> Tough shit. That is the requirement.
>>>>>>>>>>
>>>>>>>>>> I proved otherwise in the parts you erased.
>>>>>>>>>
>>>>>>>>> You proved that the requirement is not actually the requirement?
>>>>>>>>
>>>>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>>>>> be an incoherent requirement. Try and think it through for
>>>>>>>> yourself.
>>>>>>>
>>>>>>> Every program/input pair either halts some time, or never halts.
>>>>>>> Determining this is a coherent requirement.
>>>>>>
>>>>>> That part is coherent.
>>>>>
>>>>> The part that this determination must be done by a Turing machine
>>>>> using descriptions of the program and input is coherent, too.
>>>>>
>>>>
>>>> Every decider is required by definition to only report on what
>>>> this input specifies.
>>>>
>>>> int sum(int x, int y){ return x + y; }
>>>> sum(3,4) is not allowed to report on the sum of 5 + 6
>>>> even if you really really believe that it should.
>>>>
>>>
>>> Exactly! Therefore H(D,D), where D is based on H that aborts and
>>> returns false, so that D halts, should not return a report about
>>> another D that does not halt, even if you really really believe that
>>> it should.
>>
>> There is enough information for sum(3,4) to compute the sum of 3+4.
>> There is NOT enough information for sum(3,4) to compute the sum of 5+6.
>>
>> There is enough information for H1(D,D) to compute Halts(D,D).
>> There is NOT enough information for H(D,D) to compute Halts(D,D).
>
> H and H1 have the same information, because they have the same input!
> H and H1 have the same information, because they have the same input!
> H and H1 have the same information, because they have the same input!
> H and H1 have the same information, because they have the same input!
> H and H1 have the same information, because they have the same input!

H and H1 DO NOT HAVE the same information,
because they ARE EXAMINING TWO DIFFERENT INSTANCES OF D!

H(D,D) is examining D BEFORE its simulation has been aborted and
H1(D,D) is examining D AFTER its simulation has been aborted

>
> Te difference is that H does not use the information, because it aborts
> prematurely.

--
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/24/2024 7:08 PM, immibis wrote:
> On 24/03/24 04:39, olcott wrote:
>> On 3/23/2024 9:54 PM, immibis wrote:
>>> On 24/03/24 03:40, olcott wrote:
>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>      because it would halt and all deciders must always halt.
>>>>>>>>>
>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>
>>>>>>>>> To be a halt decider it has to give an answer that is the same
>>>>>>>>> as whether the direct execution of its input would halt.
>>>>>>>>
>>>>>>>> That would entail that
>>>>>>>
>>>>>>> Tough shit. That is the requirement.
>>>>>>
>>>>>> I proved otherwise in the parts you erased.
>>>>>
>>>>> You proved that the requirement is not actually the requirement?
>>>>
>>>> I proved that it cannot be a coherent requirement, it can still
>>>> be an incoherent requirement. Try and think it through for yourself.
>>>
>>> Every program/input pair either halts some time, or never halts.
>>> Determining this is a coherent requirement.
>>
>> That part is coherent. The many other details that are
>> not coherent could have never been discovered without
>> actually encoding them in fully operational code that
>> proves that some assumptions are false.
>>
>> Prior to x86utm the answer to the halt status of the pathological
>> input was no one has any idea at all.
>
> This is wrong. The halt status can be different for each decider and its
> pathological input. If x86utm D is actually the pathological input for
> x86utm H (or even if it isn't), the halt status of x86utm D is YES.
>

When any YES/NO question is asked of anyone or anything X
has both answers from X contradicted then this is an incorrect
question instance for X.

>> After the innovation of the x86utm operating system we can clearly
>> see that the input to H(D,D) is non-halting from the point of view of H.
>>
>> *This is the part where honest and competent reviewers would agree*
>>
>> How this pertains to the actual halting problem may have room for
>> differing opinions without error or deception.
>

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

Op 27.mrt.2024 om 15:09 schreef olcott:
> On 3/27/2024 4:55 AM, Fred. Zwarts wrote:
>> Op 26.mrt.2024 om 15:43 schreef olcott:
>>> On 3/26/2024 3:51 AM, Fred. Zwarts wrote:
>>>> Op 25.mrt.2024 om 23:50 schreef olcott:
>>>>> On 3/24/2024 11:42 AM, Mikko wrote:
>>>>>> On 2024-03-24 03:39:12 +0000, olcott said:
>>>>>>
>>>>>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>>>>>> On 24/03/24 03:40, olcott wrote:
>>>>>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>>>>>      because it would halt and all deciders must always
>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To be a halt decider it has to give an answer that is the
>>>>>>>>>>>>>> same as whether the direct execution of its input would halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That would entail that
>>>>>>>>>>>>
>>>>>>>>>>>> Tough shit. That is the requirement.
>>>>>>>>>>>
>>>>>>>>>>> I proved otherwise in the parts you erased.
>>>>>>>>>>
>>>>>>>>>> You proved that the requirement is not actually the requirement?
>>>>>>>>>
>>>>>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>>>>>> be an incoherent requirement. Try and think it through for
>>>>>>>>> yourself.
>>>>>>>>
>>>>>>>> Every program/input pair either halts some time, or never halts.
>>>>>>>> Determining this is a coherent requirement.
>>>>>>>
>>>>>>> That part is coherent.
>>>>>>
>>>>>> The part that this determination must be done by a Turing machine
>>>>>> using descriptions of the program and input is coherent, too.
>>>>>>
>>>>>
>>>>> Every decider is required by definition to only report on what
>>>>> this input specifies.
>>>>>
>>>>> int sum(int x, int y){ return x + y; }
>>>>> sum(3,4) is not allowed to report on the sum of 5 + 6
>>>>> even if you really really believe that it should.
>>>>>
>>>>
>>>> Exactly! Therefore H(D,D), where D is based on H that aborts and
>>>> returns false, so that D halts, should not return a report about
>>>> another D that does not halt, even if you really really believe that
>>>> it should.
>>>
>>> There is enough information for sum(3,4) to compute the sum of 3+4.
>>> There is NOT enough information for sum(3,4) to compute the sum of 5+6.
>>>
>>> There is enough information for H1(D,D) to compute Halts(D,D).
>>> There is NOT enough information for H(D,D) to compute Halts(D,D).
>>>
>>
>> But it is possible to create a simulating sum decider that aborts sum
>> and returns the sum of 5+6 and then claim that it is right, because it
>> has not enough information to calculate 3+4. It is possible, but wrong.
>> The only reason it has not enough information, is that it aborts
>> prematurely. That makes the decision to abort wrong. This holds for H
>> as well.
>
> Why are you denying reality?

Olcott is frustrated, but wrong.

>
> Can D correctly simulated by H terminate normally?
> 01 int D(ptr x)  // ptr is pointer to int function
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> *Execution Trace*
> Line 11: main() invokes H(D,D);
>
> *keeps repeating* (unless aborted)
> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)

Wrong. Should be:
*will return false* (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that aborts and returns
false. So D will continue with line 04 (ubnless aborted)
Why denying verified facts?
D is the D that calls the H that aborts and returns false. That H is
wrong is no reason to assume that D calls another H that keeps simulating.

>
> *Simulation invariant*
> D correctly simulated by H cannot possibly reach past its own line 03.
>

Proven wrong.

Op 27.mrt.2024 om 15:13 schreef olcott:
> On 3/27/2024 5:10 AM, Fred. Zwarts wrote:
>> Op 26.mrt.2024 om 15:43 schreef olcott:
>>> On 3/26/2024 3:51 AM, Fred. Zwarts wrote:
>>>> Op 25.mrt.2024 om 23:50 schreef olcott:
>>>>> On 3/24/2024 11:42 AM, Mikko wrote:
>>>>>> On 2024-03-24 03:39:12 +0000, olcott said:
>>>>>>
>>>>>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>>>>>> On 24/03/24 03:40, olcott wrote:
>>>>>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>>>>>      because it would halt and all deciders must always
>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To be a halt decider it has to give an answer that is the
>>>>>>>>>>>>>> same as whether the direct execution of its input would halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That would entail that
>>>>>>>>>>>>
>>>>>>>>>>>> Tough shit. That is the requirement.
>>>>>>>>>>>
>>>>>>>>>>> I proved otherwise in the parts you erased.
>>>>>>>>>>
>>>>>>>>>> You proved that the requirement is not actually the requirement?
>>>>>>>>>
>>>>>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>>>>>> be an incoherent requirement. Try and think it through for
>>>>>>>>> yourself.
>>>>>>>>
>>>>>>>> Every program/input pair either halts some time, or never halts.
>>>>>>>> Determining this is a coherent requirement.
>>>>>>>
>>>>>>> That part is coherent.
>>>>>>
>>>>>> The part that this determination must be done by a Turing machine
>>>>>> using descriptions of the program and input is coherent, too.
>>>>>>
>>>>>
>>>>> Every decider is required by definition to only report on what
>>>>> this input specifies.
>>>>>
>>>>> int sum(int x, int y){ return x + y; }
>>>>> sum(3,4) is not allowed to report on the sum of 5 + 6
>>>>> even if you really really believe that it should.
>>>>>
>>>>
>>>> Exactly! Therefore H(D,D), where D is based on H that aborts and
>>>> returns false, so that D halts, should not return a report about
>>>> another D that does not halt, even if you really really believe that
>>>> it should.
>>>
>>> There is enough information for sum(3,4) to compute the sum of 3+4.
>>> There is NOT enough information for sum(3,4) to compute the sum of 5+6.
>>>
>>> There is enough information for H1(D,D) to compute Halts(D,D).
>>> There is NOT enough information for H(D,D) to compute Halts(D,D).
>>
>> H and H1 have the same information, because they have the same input!
>> H and H1 have the same information, because they have the same input!
>> H and H1 have the same information, because they have the same input!
>> H and H1 have the same information, because they have the same input!
>> H and H1 have the same information, because they have the same input!
>
> H and H1 DO NOT HAVE the same information,
> because they ARE EXAMINING TWO DIFFERENT INSTANCES OF D!

There is only one D. H and H1 have exactly the same input. So, they have
exactly the same information.
Why denying easily verified facts?

>
>  H(D,D) is examining D BEFORE its simulation has been aborted and
> H1(D,D) is examining D AFTER its simulation has been aborted
It does not matter how H and H1 look at D, it is the same D that they
should examine. If H closes its eyes and misses some details of D, by
aborting too early, it is a problem of H, not a property of D.
Both H and H1 should process their full input, namely the same D, not a
a non-input that consists of only the first part of D, before it was
aborted. Remember that H is part of D and should be examined by the decider.

On 3/27/2024 2:09 PM, Fred. Zwarts wrote:
> Op 27.mrt.2024 om 15:09 schreef olcott:
>> On 3/27/2024 4:55 AM, Fred. Zwarts wrote:
>>> Op 26.mrt.2024 om 15:43 schreef olcott:
>>>> On 3/26/2024 3:51 AM, Fred. Zwarts wrote:
>>>>> Op 25.mrt.2024 om 23:50 schreef olcott:
>>>>>> On 3/24/2024 11:42 AM, Mikko wrote:
>>>>>>> On 2024-03-24 03:39:12 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>>>>>>> On 24/03/24 03:40, olcott wrote:
>>>>>>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>>>>>>      because it would halt and all deciders must always
>>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To be a halt decider it has to give an answer that is the
>>>>>>>>>>>>>>> same as whether the direct execution of its input would
>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That would entail that
>>>>>>>>>>>>>
>>>>>>>>>>>>> Tough shit. That is the requirement.
>>>>>>>>>>>>
>>>>>>>>>>>> I proved otherwise in the parts you erased.
>>>>>>>>>>>
>>>>>>>>>>> You proved that the requirement is not actually the requirement?
>>>>>>>>>>
>>>>>>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>>>>>>> be an incoherent requirement. Try and think it through for
>>>>>>>>>> yourself.
>>>>>>>>>
>>>>>>>>> Every program/input pair either halts some time, or never halts.
>>>>>>>>> Determining this is a coherent requirement.
>>>>>>>>
>>>>>>>> That part is coherent.
>>>>>>>
>>>>>>> The part that this determination must be done by a Turing machine
>>>>>>> using descriptions of the program and input is coherent, too.
>>>>>>>
>>>>>>
>>>>>> Every decider is required by definition to only report on what
>>>>>> this input specifies.
>>>>>>
>>>>>> int sum(int x, int y){ return x + y; }
>>>>>> sum(3,4) is not allowed to report on the sum of 5 + 6
>>>>>> even if you really really believe that it should.
>>>>>>
>>>>>
>>>>> Exactly! Therefore H(D,D), where D is based on H that aborts and
>>>>> returns false, so that D halts, should not return a report about
>>>>> another D that does not halt, even if you really really believe
>>>>> that it should.
>>>>
>>>> There is enough information for sum(3,4) to compute the sum of 3+4.
>>>> There is NOT enough information for sum(3,4) to compute the sum of 5+6.
>>>>
>>>> There is enough information for H1(D,D) to compute Halts(D,D).
>>>> There is NOT enough information for H(D,D) to compute Halts(D,D).
>>>>
>>>
>>> But it is possible to create a simulating sum decider that aborts sum
>>> and returns the sum of 5+6 and then claim that it is right, because
>>> it has not enough information to calculate 3+4. It is possible, but
>>> wrong.
>>> The only reason it has not enough information, is that it aborts
>>> prematurely. That makes the decision to abort wrong. This holds for H
>>> as well.
>>
>> Why are you denying reality?
>
> Olcott is frustrated, but wrong.
>
>>
>> Can D correctly simulated by H terminate normally?
>> 01 int D(ptr x)  // ptr is pointer to int function
>> 02 {
>> 03   int Halt_Status = H(x, x);
>> 04   if (Halt_Status)
>> 05     HERE: goto HERE;
>> 06   return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> *Execution Trace*
>> Line 11: main() invokes H(D,D);
>>
>> *keeps repeating* (unless aborted)
>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
> Wrong. Should be:
> *will return false* (unless aborted)

There is no possible way that D simulated by any H ever
returns false whether its simulation has been aborted or not.
Are you fibbing about your programming skill?

> Line 03: simulated D(D) invokes simulated H(D,D) that aborts and returns
> false. So D will continue with line 04 (ubnless aborted)
> Why denying verified facts?
> D is the D that calls the H that aborts and returns false. That H is
> wrong is no reason to assume that D calls another H that keeps simulating.
>
>>
>> *Simulation invariant*
>> D correctly simulated by H cannot possibly reach past its own line 03.
>>
>
> Proven wrong.

--
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/27/2024 2:18 PM, Fred. Zwarts wrote:
> Op 27.mrt.2024 om 15:13 schreef olcott:
>> On 3/27/2024 5:10 AM, Fred. Zwarts wrote:
>>> Op 26.mrt.2024 om 15:43 schreef olcott:
>>>> On 3/26/2024 3:51 AM, Fred. Zwarts wrote:
>>>>> Op 25.mrt.2024 om 23:50 schreef olcott:
>>>>>> On 3/24/2024 11:42 AM, Mikko wrote:
>>>>>>> On 2024-03-24 03:39:12 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>>>>>>> On 24/03/24 03:40, olcott wrote:
>>>>>>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>>>>>>      because it would halt and all deciders must always
>>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To be a halt decider it has to give an answer that is the
>>>>>>>>>>>>>>> same as whether the direct execution of its input would
>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That would entail that
>>>>>>>>>>>>>
>>>>>>>>>>>>> Tough shit. That is the requirement.
>>>>>>>>>>>>
>>>>>>>>>>>> I proved otherwise in the parts you erased.
>>>>>>>>>>>
>>>>>>>>>>> You proved that the requirement is not actually the requirement?
>>>>>>>>>>
>>>>>>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>>>>>>> be an incoherent requirement. Try and think it through for
>>>>>>>>>> yourself.
>>>>>>>>>
>>>>>>>>> Every program/input pair either halts some time, or never halts.
>>>>>>>>> Determining this is a coherent requirement.
>>>>>>>>
>>>>>>>> That part is coherent.
>>>>>>>
>>>>>>> The part that this determination must be done by a Turing machine
>>>>>>> using descriptions of the program and input is coherent, too.
>>>>>>>
>>>>>>
>>>>>> Every decider is required by definition to only report on what
>>>>>> this input specifies.
>>>>>>
>>>>>> int sum(int x, int y){ return x + y; }
>>>>>> sum(3,4) is not allowed to report on the sum of 5 + 6
>>>>>> even if you really really believe that it should.
>>>>>>
>>>>>
>>>>> Exactly! Therefore H(D,D), where D is based on H that aborts and
>>>>> returns false, so that D halts, should not return a report about
>>>>> another D that does not halt, even if you really really believe
>>>>> that it should.
>>>>
>>>> There is enough information for sum(3,4) to compute the sum of 3+4.
>>>> There is NOT enough information for sum(3,4) to compute the sum of 5+6.
>>>>
>>>> There is enough information for H1(D,D) to compute Halts(D,D).
>>>> There is NOT enough information for H(D,D) to compute Halts(D,D).
>>>
>>> H and H1 have the same information, because they have the same input!
>>> H and H1 have the same information, because they have the same input!
>>> H and H1 have the same information, because they have the same input!
>>> H and H1 have the same information, because they have the same input!
>>> H and H1 have the same information, because they have the same input!
>>
>> H and H1 DO NOT HAVE the same information,
>> because they ARE EXAMINING TWO DIFFERENT INSTANCES OF D!
>
> There is only one D. H and H1 have exactly the same input. So, they have
> exactly the same information.
> Why denying easily verified facts?
>
>>
>>   H(D,D) is examining D BEFORE its simulation has been aborted and
>> H1(D,D) is examining D AFTER its simulation has been aborted
> It does not matter

Are you fibbing about your programming skill?

> how H and H1 look at D, it is the same D that they
> should examine. If H closes its eyes and misses some details of D, by
> aborting too early, it is a problem of H, not a property of D.
> Both H and H1 should process their full input, namely the same D, not a
> a non-input that consists of only the first part of D, before it was
> aborted. Remember that H is part of D and should be examined by the
> decider.

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

Op 27.mrt.2024 om 20:36 schreef olcott:
> On 3/27/2024 2:09 PM, Fred. Zwarts wrote:
>> Op 27.mrt.2024 om 15:09 schreef olcott:
>>> On 3/27/2024 4:55 AM, Fred. Zwarts wrote:
>>>> Op 26.mrt.2024 om 15:43 schreef olcott:
>>>>> On 3/26/2024 3:51 AM, Fred. Zwarts wrote:
>>>>>> Op 25.mrt.2024 om 23:50 schreef olcott:
>>>>>>> On 3/24/2024 11:42 AM, Mikko wrote:
>>>>>>>> On 2024-03-24 03:39:12 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>>>>>>>> On 24/03/24 03:40, olcott wrote:
>>>>>>>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>>>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>>>>>>>      because it would halt and all deciders must always
>>>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> To be a halt decider it has to give an answer that is
>>>>>>>>>>>>>>>> the same as whether the direct execution of its input
>>>>>>>>>>>>>>>> would halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That would entail that
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Tough shit. That is the requirement.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I proved otherwise in the parts you erased.
>>>>>>>>>>>>
>>>>>>>>>>>> You proved that the requirement is not actually the
>>>>>>>>>>>> requirement?
>>>>>>>>>>>
>>>>>>>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>>>>>>>> be an incoherent requirement. Try and think it through for
>>>>>>>>>>> yourself.
>>>>>>>>>>
>>>>>>>>>> Every program/input pair either halts some time, or never halts.
>>>>>>>>>> Determining this is a coherent requirement.
>>>>>>>>>
>>>>>>>>> That part is coherent.
>>>>>>>>
>>>>>>>> The part that this determination must be done by a Turing machine
>>>>>>>> using descriptions of the program and input is coherent, too.
>>>>>>>>
>>>>>>>
>>>>>>> Every decider is required by definition to only report on what
>>>>>>> this input specifies.
>>>>>>>
>>>>>>> int sum(int x, int y){ return x + y; }
>>>>>>> sum(3,4) is not allowed to report on the sum of 5 + 6
>>>>>>> even if you really really believe that it should.
>>>>>>>
>>>>>>
>>>>>> Exactly! Therefore H(D,D), where D is based on H that aborts and
>>>>>> returns false, so that D halts, should not return a report about
>>>>>> another D that does not halt, even if you really really believe
>>>>>> that it should.
>>>>>
>>>>> There is enough information for sum(3,4) to compute the sum of 3+4.
>>>>> There is NOT enough information for sum(3,4) to compute the sum of
>>>>> 5+6.
>>>>>
>>>>> There is enough information for H1(D,D) to compute Halts(D,D).
>>>>> There is NOT enough information for H(D,D) to compute Halts(D,D).
>>>>>
>>>>
>>>> But it is possible to create a simulating sum decider that aborts
>>>> sum and returns the sum of 5+6 and then claim that it is right,
>>>> because it has not enough information to calculate 3+4. It is
>>>> possible, but wrong.
>>>> The only reason it has not enough information, is that it aborts
>>>> prematurely. That makes the decision to abort wrong. This holds for
>>>> H as well.
>>>
>>> Why are you denying reality?
>>
>> Olcott is frustrated, but wrong.
>>
>>>
>>> Can D correctly simulated by H terminate normally?
>>> 01 int D(ptr x)  // ptr is pointer to int function
>>> 02 {
>>> 03   int Halt_Status = H(x, x);
>>> 04   if (Halt_Status)
>>> 05     HERE: goto HERE;
>>> 06   return Halt_Status;
>>> 07 }
>>> 08
>>> 09 void main()
>>> 10 {
>>> 11   H(D,D);
>>> 12 }
>>>
>>> *Execution Trace*
>>> Line 11: main() invokes H(D,D);
>>>
>>> *keeps repeating* (unless aborted)
>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>
>> Wrong. Should be:
>> *will return false* (unless aborted)
>
> There is no possible way that D simulated by any H ever
> returns false whether its simulation has been aborted or not.
> Are you fibbing about your programming  skill?

Why denying easily verified facts?

>
>> Line 03: simulated D(D) invokes simulated H(D,D) that aborts and
>> returns false. So D will continue with line 04 (ubnless aborted)
>> Why denying verified facts?
>> D is the D that calls the H that aborts and returns false. That H is
>> wrong is no reason to assume that D calls another H that keeps
>> simulating.
>>
>>>
>>> *Simulation invariant*
>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>
>>
>> Proven wrong.
>

On 3/27/2024 2:39 PM, Fred. Zwarts wrote:
> Op 27.mrt.2024 om 20:36 schreef olcott:
>> On 3/27/2024 2:09 PM, Fred. Zwarts wrote:
>>> Op 27.mrt.2024 om 15:09 schreef olcott:
>>>> On 3/27/2024 4:55 AM, Fred. Zwarts wrote:
>>>>> Op 26.mrt.2024 om 15:43 schreef olcott:
>>>>>> On 3/26/2024 3:51 AM, Fred. Zwarts wrote:
>>>>>>> Op 25.mrt.2024 om 23:50 schreef olcott:
>>>>>>>> On 3/24/2024 11:42 AM, Mikko wrote:
>>>>>>>>> On 2024-03-24 03:39:12 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/23/2024 9:54 PM, immibis wrote:
>>>>>>>>>>> On 24/03/24 03:40, olcott wrote:
>>>>>>>>>>>> On 3/23/2024 9:34 PM, immibis wrote:
>>>>>>>>>>>>> On 24/03/24 03:15, olcott wrote:
>>>>>>>>>>>>>> On 3/23/2024 8:40 PM, immibis wrote:
>>>>>>>>>>>>>>> On 24/03/24 00:29, olcott wrote:
>>>>>>>>>>>>>>>> On 3/23/2024 5:58 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 23/03/24 16:02, olcott wrote:
>>>>>>>>>>>>>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>>>>>>>>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>>>>>>>>>>>>>      because it would halt and all deciders must
>>>>>>>>>>>>>>>>>> always halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> To be a decider it has to give an answer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> To be a halt decider it has to give an answer that is
>>>>>>>>>>>>>>>>> the same as whether the direct execution of its input
>>>>>>>>>>>>>>>>> would halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That would entail that
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Tough shit. That is the requirement.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I proved otherwise in the parts you erased.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You proved that the requirement is not actually the
>>>>>>>>>>>>> requirement?
>>>>>>>>>>>>
>>>>>>>>>>>> I proved that it cannot be a coherent requirement, it can still
>>>>>>>>>>>> be an incoherent requirement. Try and think it through for
>>>>>>>>>>>> yourself.
>>>>>>>>>>>
>>>>>>>>>>> Every program/input pair either halts some time, or never halts.
>>>>>>>>>>> Determining this is a coherent requirement.
>>>>>>>>>>
>>>>>>>>>> That part is coherent.
>>>>>>>>>
>>>>>>>>> The part that this determination must be done by a Turing machine
>>>>>>>>> using descriptions of the program and input is coherent, too.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Every decider is required by definition to only report on what
>>>>>>>> this input specifies.
>>>>>>>>
>>>>>>>> int sum(int x, int y){ return x + y; }
>>>>>>>> sum(3,4) is not allowed to report on the sum of 5 + 6
>>>>>>>> even if you really really believe that it should.
>>>>>>>>
>>>>>>>
>>>>>>> Exactly! Therefore H(D,D), where D is based on H that aborts and
>>>>>>> returns false, so that D halts, should not return a report about
>>>>>>> another D that does not halt, even if you really really believe
>>>>>>> that it should.
>>>>>>
>>>>>> There is enough information for sum(3,4) to compute the sum of 3+4.
>>>>>> There is NOT enough information for sum(3,4) to compute the sum of
>>>>>> 5+6.
>>>>>>
>>>>>> There is enough information for H1(D,D) to compute Halts(D,D).
>>>>>> There is NOT enough information for H(D,D) to compute Halts(D,D).
>>>>>>
>>>>>
>>>>> But it is possible to create a simulating sum decider that aborts
>>>>> sum and returns the sum of 5+6 and then claim that it is right,
>>>>> because it has not enough information to calculate 3+4. It is
>>>>> possible, but wrong.
>>>>> The only reason it has not enough information, is that it aborts
>>>>> prematurely. That makes the decision to abort wrong. This holds for
>>>>> H as well.
>>>>
>>>> Why are you denying reality?
>>>
>>> Olcott is frustrated, but wrong.
>>>
>>>>
>>>> Can D correctly simulated by H terminate normally?
>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>> 02 {
>>>> 03   int Halt_Status = H(x, x);
>>>> 04   if (Halt_Status)
>>>> 05     HERE: goto HERE;
>>>> 06   return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 void main()
>>>> 10 {
>>>> 11   H(D,D);
>>>> 12 }
>>>>
>>>> *Execution Trace*
>>>> Line 11: main() invokes H(D,D);
>>>>
>>>> *keeps repeating* (unless aborted)
>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> Wrong. Should be:
>>> *will return false* (unless aborted)
>>
>> There is no possible way that D simulated by any H ever
>> returns false whether its simulation has been aborted or not.
>> Are you fibbing about your programming  skill?
>
> Why denying easily verified facts?
>

Oh you are just flat out lying, I get it.

>>
>>> Line 03: simulated D(D) invokes simulated H(D,D) that aborts and
>>> returns false. So D will continue with line 04 (ubnless aborted)
>>> Why denying verified facts?
>>> D is the D that calls the H that aborts and returns false. That H is
>>> wrong is no reason to assume that D calls another H that keeps
>>> simulating.
>>>
>>>>
>>>> *Simulation invariant*
>>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>>
>>>
>>> Proven wrong.
>>
>
>

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