On 12/25/23 05:10, Richard Damon wrote:
> The key is that for a deterministic machine, there may be a right answer
> that it was ALLOWED to give, but didn't as that isn't what its algorithm
> determined, so that machine can't actually give that answer.

Deterministic machines aren't "allowed" to give answers. They give
answers, or they don't.

> His "Identical but different" machines is to try to "magic" volition
> into the machines so the same machine could give different answers to
> the same quesitons.

This is true.

> THe problem being, "get the right answer" isn't a programable
> instruction, but we need to define a actual way to GET that right
> answer, and when working on a problem that gets to reference the
> decider, that might not be possible.

> In his case, when he gets into the details, his H will return the
> "non-halting" answer, which causes D to be halting. H does have a
> correct answer that it is ALLOWED to give, which would be halting, but
> that isn't the answer it DOES give.

There's a mistake here. Nothing "causes" D to be halting, except for the
code of D. H has nothing to do with it. D doesn't magically change
depending on which code is defined as H.

Pete can write a program that he calls H, and I can look at this program
and write a program that I call D. Then D(D) either halts or doesn't
halt. If Pete writes another program and calls it H, this doesn't change
the program I already wrote. I can write another one, of course, and I
can call it D as well, and it either halts or doesn't halt, but has no
relation to the first program that I called D, or the first program that
Pete called H.

On 12/25/23 05:03, olcott wrote:
> On 12/24/2023 7:53 PM, immibis wrote:
>> On 12/24/23 22:24, olcott wrote:
>>>
>>> For any other H with the exact same D
>>> "Does D(D) halt?"
>>>
>>> is a different question that has a different meaning in
>>> the same way that: "Are you a little girl?" is a different
>>> question depending on who you ask.
>>>
>>
>> How can it be a different question when it's the exact same question
>> and makes no reference to subjective pronouns like "you"?
>>
>
> The arguments to the function H(D,D) are asking H about D(D).
> The arguments to the function H1(D,D) are asking H1 about D(D).
>
> When D is intentionally defined to do the opposite of whatever
> value that H returns this proves that the question:
>
> Does the direct execution of D(D) halt?
> is a different question for H than for H1 even
> though D itself is the exact same input.
>

Wrong. The question is the same. There is no subjective reference.

D is a program that I wrote. It bears no relation to H, except that I
saw the source code of H before I wrote D. D does not reference H. D
does not reference "self". D does not reference "you". It's just a
normal program.

On 12/25/23 05:03, olcott wrote:
> On 12/24/2023 7:45 PM, immibis wrote:
>> On 12/24/23 19:37, olcott wrote:
>>> When H is asked: Does the direct execution of D(D) halt?
>>> Both Yes and No are the wrong answer
>>
>> Wrong. D(D) halts or it doesn't halt.
>>
>
> Yet both Yes and No are the wrong answer when the question
> is posed to H because D was intentionally defined to do
> the opposite of whatever Boolean value that H returns.
>
> This is not the case for H1(D,D) thus proving that H and H1
> are being asked a different question even though D is identical
> in both cases.
>

Wrong. D(D) halts or it doesn't halt.

On 12/25/23 7:14 AM, immibis wrote:
> On 12/25/23 05:10, Richard Damon wrote:
>> The key is that for a deterministic machine, there may be a right
>> answer that it was ALLOWED to give, but didn't as that isn't what its
>> algorithm determined, so that machine can't actually give that answer.
>
> Deterministic machines aren't "allowed" to give answers. They give
> answers, or they don't.
>
>> His "Identical but different" machines is to try to "magic" volition
>> into the machines so the same machine could give different answers to
>> the same quesitons.
>
> This is true.
>
>> THe problem being, "get the right answer" isn't a programable
>> instruction, but we need to define a actual way to GET that right
>> answer, and when working on a problem that gets to reference the
>> decider, that might not be possible.
>
>
>
> > In his case, when he gets into the details, his H will return the
> > "non-halting" answer, which causes D to be halting. H does have a
> > correct answer that it is ALLOWED to give, which would be halting, but
> > that isn't the answer it DOES give.
>
> There's a mistake here. Nothing "causes" D to be halting, except for the
> code of D. H has nothing to do with it. D doesn't magically change
> depending on which code is defined as H.

But since D is built on the code to H, changing the INITIAL definition
of H will cause D to be built differently, so the behavior of that
original H "causes" D's behavior.

His confusion is that he thinks H is somehow still variable after that
point, forgetting that it is the fixed point that the proof is based on.

In Logic, you aren't allowed to "change" the "meaning" of a symbol in
the middle of an argument.

>
> Pete can write a program that he calls H, and I can look at this program
> and write a program that I call D. Then D(D) either halts or doesn't
> halt. If Pete writes another program and calls it H, this doesn't change
> the program I already wrote. I can write another one, of course, and I
> can call it D as well, and it either halts or doesn't halt, but has no
> relation to the first program that I called D, or the first program that
> Pete called H.
>
>

Yes, that is the point that PO misses. Programs aren't defined by their
"name" but by their "code". The name is just a label used to convientely
refer to a given set of "code"

On 12/25/2023 6:14 AM, immibis wrote:
> On 12/25/23 05:10, Richard Damon wrote:
>> The key is that for a deterministic machine, there may be a right
>> answer that it was ALLOWED to give, but didn't as that isn't what its
>> algorithm determined, so that machine can't actually give that answer.
>
> Deterministic machines aren't "allowed" to give answers. They give
> answers, or they don't.
>
>> His "Identical but different" machines is to try to "magic" volition
>> into the machines so the same machine could give different answers to
>> the same quesitons.
>
> This is true.
>
>> THe problem being, "get the right answer" isn't a programable
>> instruction, but we need to define a actual way to GET that right
>> answer, and when working on a problem that gets to reference the
>> decider, that might not be possible.
>
>
>
> > In his case, when he gets into the details, his H will return the
> > "non-halting" answer, which causes D to be halting. H does have a
> > correct answer that it is ALLOWED to give, which would be halting, but
> > that isn't the answer it DOES give.
>
> There's a mistake here. Nothing "causes" D to be halting, except for the
> code of D. H has nothing to do with it. D doesn't magically change
> depending on which code is defined as H.
>
> Pete can write a program that he calls H, and I can look at this program
> and write a program that I call D. Then D(D) either halts or doesn't
> halt. If Pete writes another program and calls it H, this doesn't change
> the program I already wrote. I can write another one, of course, and I
> can call it D as well, and it either halts or doesn't halt, but has no
> relation to the first program that I called D, or the first program that
> Pete called H.
>
>

This is no longer hypothetical.
After 18 months of full time development I converted
an excellent open source x86 emulator into a termination
analyzer. https://github.com/plolcott/x86utm
H, D and H1 are fully implemented code.

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

On 12/25/2023 6:16 AM, immibis wrote:
> On 12/25/23 05:03, olcott wrote:
>> On 12/24/2023 7:53 PM, immibis wrote:
>>> On 12/24/23 22:24, olcott wrote:
>>>>
>>>> For any other H with the exact same D
>>>> "Does D(D) halt?"
>>>>
>>>> is a different question that has a different meaning in
>>>> the same way that: "Are you a little girl?" is a different
>>>> question depending on who you ask.
>>>>
>>>
>>> How can it be a different question when it's the exact same question
>>> and makes no reference to subjective pronouns like "you"?
>>>
>>
>> The arguments to the function H(D,D) are asking H about D(D).
>> The arguments to the function H1(D,D) are asking H1 about D(D).
>>
>> When D is intentionally defined to do the opposite of whatever
>> value that H returns this proves that the question:
>>
>> Does the direct execution of D(D) halt?
>> is a different question for H than for H1 even
>> though D itself is the exact same input.
>>
>
> Wrong. The question is the same. There is no subjective reference.
>

When I ask: "Are you a little girl?"
this exact same word-for-word question has a different correct
answer depending on who is asked.

When H is asked: "Does the directly executed D(D) halt?"
this exact same word-for-word question has a different correct
answer depending on who is asked.

When D is intentionally defined to do the opposite of whatever Boolean
value that H returns this is a self-contradictory question for H and is
not a self-contradictory question for H1.

> D is a program that I wrote. It bears no relation to H, except that I
> saw the source code of H before I wrote D. D does not reference H. D
> does not reference "self". D does not reference "you". It's just a
> normal program.

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

On 12/25/2023 6:16 AM, immibis wrote:
> On 12/25/23 05:03, olcott wrote:
>> On 12/24/2023 7:45 PM, immibis wrote:
>>> On 12/24/23 19:37, olcott wrote:
>>>> When H is asked: Does the direct execution of D(D) halt?
>>>> Both Yes and No are the wrong answer
>>>
>>> Wrong. D(D) halts or it doesn't halt.
>>>
>>
>> Yet both Yes and No are the wrong answer when the question
>> is posed to H because D was intentionally defined to do
>> the opposite of whatever Boolean value that H returns.
>>
>> This is not the case for H1(D,D) thus proving that H and H1
>> are being asked a different question even though D is identical
>> in both cases.
>>
>
> Wrong. D(D) halts or it doesn't halt.

Self-contradictory questions have no correct answer.

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

On 12/25/23 4:48 PM, olcott wrote:
> On 12/25/2023 6:14 AM, immibis wrote:
>> On 12/25/23 05:10, Richard Damon wrote:
>>> The key is that for a deterministic machine, there may be a right
>>> answer that it was ALLOWED to give, but didn't as that isn't what its
>>> algorithm determined, so that machine can't actually give that answer.
>>
>> Deterministic machines aren't "allowed" to give answers. They give
>> answers, or they don't.
>>
>>> His "Identical but different" machines is to try to "magic" volition
>>> into the machines so the same machine could give different answers to
>>> the same quesitons.
>>
>> This is true.
>>
>>> THe problem being, "get the right answer" isn't a programable
>>> instruction, but we need to define a actual way to GET that right
>>> answer, and when working on a problem that gets to reference the
>>> decider, that might not be possible.
>>
>>
>>
>>  > In his case, when he gets into the details, his H will return the
>>  > "non-halting" answer, which causes D to be halting. H does have a
>>  > correct answer that it is ALLOWED to give, which would be halting, but
>>  > that isn't the answer it DOES give.
>>
>> There's a mistake here. Nothing "causes" D to be halting, except for
>> the code of D. H has nothing to do with it. D doesn't magically change
>> depending on which code is defined as H.
>>
>> Pete can write a program that he calls H, and I can look at this
>> program and write a program that I call D. Then D(D) either halts or
>> doesn't halt. If Pete writes another program and calls it H, this
>> doesn't change the program I already wrote. I can write another one,
>> of course, and I can call it D as well, and it either halts or doesn't
>> halt, but has no relation to the first program that I called D, or the
>> first program that Pete called H.
>>
>>
>
> This is no longer hypothetical.
> After 18 months of full time development I converted
> an excellent open source x86 emulator into a termination
> analyzer. https://github.com/plolcott/x86utm
> H, D and H1 are fully implemented code.
>

Which shows that H(D,D) claims that D(D) [which it the meaning of
H(D,D)] will not halt, but when you run D(D) it wlll halt.

So, you have proven yourself WRONG.

On 12/25/23 4:52 PM, olcott wrote:
> On 12/25/2023 6:16 AM, immibis wrote:
>> On 12/25/23 05:03, olcott wrote:
>>> On 12/24/2023 7:53 PM, immibis wrote:
>>>> On 12/24/23 22:24, olcott wrote:
>>>>>
>>>>> For any other H with the exact same D
>>>>> "Does D(D) halt?"
>>>>>
>>>>> is a different question that has a different meaning in
>>>>> the same way that: "Are you a little girl?" is a different
>>>>> question depending on who you ask.
>>>>>
>>>>
>>>> How can it be a different question when it's the exact same question
>>>> and makes no reference to subjective pronouns like "you"?
>>>>
>>>
>>> The arguments to the function H(D,D) are asking H about D(D).
>>> The arguments to the function H1(D,D) are asking H1 about D(D).
>>>
>>> When D is intentionally defined to do the opposite of whatever
>>> value that H returns this proves that the question:
>>>
>>> Does the direct execution of D(D) halt?
>>> is a different question for H than for H1 even
>>> though D itself is the exact same input.
>>>
>>
>> Wrong. The question is the same. There is no subjective reference.
>>
>
> When I ask: "Are you a little girl?"
> this exact same word-for-word question has a different correct
> answer depending on who is asked.

Because the question, using a pronoun, refers to different people
depending on who you ask.

>
> When H is asked: "Does the directly executed D(D) halt?"
> this exact same word-for-word question has a different correct
> answer depending on who is asked.
>

Why? What does the machine you question have to do with what the FIXED
code D(D) does.

Remember, by the time you ask the question, D's code has been fixed in
place, and so has the code of H.

> When D is intentionally defined to do the opposite of whatever Boolean
> value that H returns this is a self-contradictory question for H and is
> not a self-contradictory question for H1.

Nope. Remember, D is a specific fixed piece of code.

Now, maybe the bad implemention you did in your "implemention" where D
calls what ever H you are giving it to becomes self-contrradictory
because you didn't build D right and haven't actually made a system that
is an equivalent of the problem presented. (This was pointed out to you
years ago).

Remember, D is supposed to have its own copy of the decider it is
designed to foil, not just call whatever decider is trying to decide it.

You are just showing your ignorance of the problem.

>
>> D is a program that I wrote. It bears no relation to H, except that I
>> saw the source code of H before I wrote D. D does not reference H. D
>> does not reference "self". D does not reference "you". It's just a
>> normal program.
>

On 12/25/23 4:53 PM, olcott wrote:
> On 12/25/2023 6:16 AM, immibis wrote:
>> On 12/25/23 05:03, olcott wrote:
>>> On 12/24/2023 7:45 PM, immibis wrote:
>>>> On 12/24/23 19:37, olcott wrote:
>>>>> When H is asked: Does the direct execution of D(D) halt?
>>>>> Both Yes and No are the wrong answer
>>>>
>>>> Wrong. D(D) halts or it doesn't halt.
>>>>
>>>
>>> Yet both Yes and No are the wrong answer when the question
>>> is posed to H because D was intentionally defined to do
>>> the opposite of whatever Boolean value that H returns.
>>>
>>> This is not the case for H1(D,D) thus proving that H and H1
>>> are being asked a different question even though D is identical
>>> in both cases.
>>>
>>
>> Wrong. D(D) halts or it doesn't halt.
>
> Self-contradictory questions have no correct answer.
>
But the question isn't Self-contradictory.

Any specific D(D) DOES either halt or not.

Your logic system trying to a question with a definite answer
self-contradicory just shows that your logic system has collapsed on its
own inconsistency.

Possibbly, because you can't express the actual correct question.

On 12/25/23 22:52, olcott wrote:
> On 12/25/2023 6:16 AM, immibis wrote:
>> On 12/25/23 05:03, olcott wrote:
>>> On 12/24/2023 7:53 PM, immibis wrote:
>>>> On 12/24/23 22:24, olcott wrote:
>>>>>
>>>>> For any other H with the exact same D
>>>>> "Does D(D) halt?"
>>>>>
>>>>> is a different question that has a different meaning in
>>>>> the same way that: "Are you a little girl?" is a different
>>>>> question depending on who you ask.
>>>>>
>>>>
>>>> How can it be a different question when it's the exact same question
>>>> and makes no reference to subjective pronouns like "you"?
>>>>
>>>
>>> The arguments to the function H(D,D) are asking H about D(D).
>>> The arguments to the function H1(D,D) are asking H1 about D(D).
>>>
>>> When D is intentionally defined to do the opposite of whatever
>>> value that H returns this proves that the question:
>>>
>>> Does the direct execution of D(D) halt?
>>> is a different question for H than for H1 even
>>> though D itself is the exact same input.
>>>
>>
>> Wrong. The question is the same. There is no subjective reference.
>>
>
> When I ask: "Are you a little girl?"
> this exact same word-for-word question has a different correct
> answer depending on who is asked.
>

Because of the subjective reference.

"Does D(D) halt?" has no subjective reference.

> When H is asked: "Does the directly executed D(D) halt?"
> this exact same word-for-word question has a different correct
> answer depending on who is asked.

Wrong.

> When D is intentionally defined to do the opposite of whatever Boolean
> value that H returns this is a self-contradictory question for H and is
> not a self-contradictory question for H1.

D(D) halts or it doesn't halt. There is no subjective reference or
self-contradiction.

>
>> D is a program that I wrote. It bears no relation to H, except that I
>> saw the source code of H before I wrote D. D does not reference H. D
>> does not reference "self". D does not reference "you". It's just a
>> normal program.
>

On 12/25/23 22:53, olcott wrote:
> On 12/25/2023 6:16 AM, immibis wrote:
>> On 12/25/23 05:03, olcott wrote:
>>> On 12/24/2023 7:45 PM, immibis wrote:
>>>> On 12/24/23 19:37, olcott wrote:
>>>>> When H is asked: Does the direct execution of D(D) halt?
>>>>> Both Yes and No are the wrong answer
>>>>
>>>> Wrong. D(D) halts or it doesn't halt.
>>>>
>>>
>>> Yet both Yes and No are the wrong answer when the question
>>> is posed to H because D was intentionally defined to do
>>> the opposite of whatever Boolean value that H returns.
>>>
>>> This is not the case for H1(D,D) thus proving that H and H1
>>> are being asked a different question even though D is identical
>>> in both cases.
>>>
>>
>> Wrong. D(D) halts or it doesn't halt.
>
> Self-contradictory questions have no correct answer.
>
The question isn't self-contradictory. D(D) halts or it doesn't halt.

On 12/31/2023 12:19 PM, immibis wrote:
> On 12/25/23 22:52, olcott wrote:
>> On 12/25/2023 6:16 AM, immibis wrote:
>>> On 12/25/23 05:03, olcott wrote:
>>>> On 12/24/2023 7:53 PM, immibis wrote:
>>>>> On 12/24/23 22:24, olcott wrote:
>>>>>>
>>>>>> For any other H with the exact same D
>>>>>> "Does D(D) halt?"
>>>>>>
>>>>>> is a different question that has a different meaning in
>>>>>> the same way that: "Are you a little girl?" is a different
>>>>>> question depending on who you ask.
>>>>>>
>>>>>
>>>>> How can it be a different question when it's the exact same
>>>>> question and makes no reference to subjective pronouns like "you"?
>>>>>
>>>>
>>>> The arguments to the function H(D,D) are asking H about D(D).
>>>> The arguments to the function H1(D,D) are asking H1 about D(D).
>>>>
>>>> When D is intentionally defined to do the opposite of whatever
>>>> value that H returns this proves that the question:
>>>>
>>>> Does the direct execution of D(D) halt?
>>>> is a different question for H than for H1 even
>>>> though D itself is the exact same input.
>>>>
>>>
>>> Wrong. The question is the same. There is no subjective reference.
>>>
>>
>> When I ask: "Are you a little girl?"
>> this exact same word-for-word question has a different correct
>> answer depending on who is asked.
>>
>
> Because of the subjective reference.
>
> "Does D(D) halt?" has no subjective reference.
>

Does the direct execution of D(D) halt is proven to be a
different question when posed to H than when posed to H1
in that for H both {yes,no} are the wrong answer.

There are now three PhD computer science professor's
that agree with me on this.

>> When H is asked: "Does the directly executed D(D) halt?"
>> this exact same word-for-word question has a different correct
>> answer depending on who is asked.
>
> Wrong.
>
>> When D is intentionally defined to do the opposite of whatever Boolean
>> value that H returns this is a self-contradictory question for H and is
>> not a self-contradictory question for H1.
>
> D(D) halts or it doesn't halt. There is no subjective reference or
> self-contradiction.
>
>>
>>> D is a program that I wrote. It bears no relation to H, except that I
>>> saw the source code of H before I wrote D. D does not reference H. D
>>> does not reference "self". D does not reference "you". It's just a
>>> normal program.
>>
>

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

On 12/31/23 2:34 PM, olcott wrote:

> Does the direct execution of D(D) halt is proven to be a
> different question when posed to H than when posed to H1
> in that for H both {yes,no} are the wrong answer.

Nope, because a given H can only give one of the answers.

It is ALLOWED to give both, but CAN only give one, the one it is
programmed to give.

It turns out, due to the smart design of D, the correct answer is the
opposite of the one given by the one H it was designed to refute.

So, one of the answers IS correct.

You are just showing you don't understand how programs actually work.

You also don't understand how logic or truth works.

>
> There are now three PhD computer science professor's
> that agree with me on this.

And you have been known to lie, so this claim means nothing.

On 12/31/2023 1:34 PM, olcott wrote:
> On 12/31/2023 12:19 PM, immibis wrote:
>> On 12/25/23 22:52, olcott wrote:
>>> On 12/25/2023 6:16 AM, immibis wrote:
>>>> On 12/25/23 05:03, olcott wrote:
>>>>> On 12/24/2023 7:53 PM, immibis wrote:
>>>>>> On 12/24/23 22:24, olcott wrote:
>>>>>>>
>>>>>>> For any other H with the exact same D
>>>>>>> "Does D(D) halt?"
>>>>>>>
>>>>>>> is a different question that has a different meaning in
>>>>>>> the same way that: "Are you a little girl?" is a different
>>>>>>> question depending on who you ask.
>>>>>>>
>>>>>>
>>>>>> How can it be a different question when it's the exact same
>>>>>> question and makes no reference to subjective pronouns like "you"?
>>>>>>
>>>>>
>>>>> The arguments to the function H(D,D) are asking H about D(D).
>>>>> The arguments to the function H1(D,D) are asking H1 about D(D).
>>>>>
>>>>> When D is intentionally defined to do the opposite of whatever
>>>>> value that H returns this proves that the question:
>>>>>
>>>>> Does the direct execution of D(D) halt?
>>>>> is a different question for H than for H1 even
>>>>> though D itself is the exact same input.
>>>>>
>>>>
>>>> Wrong. The question is the same. There is no subjective reference.
>>>>
>>>
>>> When I ask: "Are you a little girl?"
>>> this exact same word-for-word question has a different correct
>>> answer depending on who is asked.
>>>
>>
>> Because of the subjective reference.
>>
>> "Does D(D) halt?" has no subjective reference.
>>
>
> Does the direct execution of D(D) halt is proven to be a
> different question when posed to H than when posed to H1
> in that for H both {yes,no} are the wrong answer.
>
> There are now three PhD computer science professor's
> that agree with me on this.
>
>>> When H is asked: "Does the directly executed D(D) halt?"
>>> this exact same word-for-word question has a different correct
>>> answer depending on who is asked.
>>
>> Wrong.
>>
>>> When D is intentionally defined to do the opposite of whatever Boolean
>>> value that H returns this is a self-contradictory question for H and is
>>> not a self-contradictory question for H1.
>>
>> D(D) halts or it doesn't halt. There is no subjective reference or
>> self-contradiction.
>>
>>>
>>>> D is a program that I wrote. It bears no relation to H, except that
>>>> I saw the source code of H before I wrote D. D does not reference H.
>>>> D does not reference "self". D does not reference "you". It's just a
>>>> normal program.
>>>
>>
>

// The following is written in C
//
typedef int (*ptr)(); // pointer to int function see (x86utm)
int H(ptr x, ptr y) // uses x86 emulator to simulate its input

int D(ptr x)
{ int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

void main()
{ H(D,D);
}

The question:
*Does directly executed D(D) halt? is contradicted by D for every H*

From the above source-code we can see that there cannot possibly exist
any H that can return a value corresponding to the direct execution of
D(D).

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

On 12/31/23 3:08 PM, olcott wrote:
> On 12/31/2023 1:34 PM, olcott wrote:
>> On 12/31/2023 12:19 PM, immibis wrote:
>>> On 12/25/23 22:52, olcott wrote:
>>>> On 12/25/2023 6:16 AM, immibis wrote:
>>>>> On 12/25/23 05:03, olcott wrote:
>>>>>> On 12/24/2023 7:53 PM, immibis wrote:
>>>>>>> On 12/24/23 22:24, olcott wrote:
>>>>>>>>
>>>>>>>> For any other H with the exact same D
>>>>>>>> "Does D(D) halt?"
>>>>>>>>
>>>>>>>> is a different question that has a different meaning in
>>>>>>>> the same way that: "Are you a little girl?" is a different
>>>>>>>> question depending on who you ask.
>>>>>>>>
>>>>>>>
>>>>>>> How can it be a different question when it's the exact same
>>>>>>> question and makes no reference to subjective pronouns like "you"?
>>>>>>>
>>>>>>
>>>>>> The arguments to the function H(D,D) are asking H about D(D).
>>>>>> The arguments to the function H1(D,D) are asking H1 about D(D).
>>>>>>
>>>>>> When D is intentionally defined to do the opposite of whatever
>>>>>> value that H returns this proves that the question:
>>>>>>
>>>>>> Does the direct execution of D(D) halt?
>>>>>> is a different question for H than for H1 even
>>>>>> though D itself is the exact same input.
>>>>>>
>>>>>
>>>>> Wrong. The question is the same. There is no subjective reference.
>>>>>
>>>>
>>>> When I ask: "Are you a little girl?"
>>>> this exact same word-for-word question has a different correct
>>>> answer depending on who is asked.
>>>>
>>>
>>> Because of the subjective reference.
>>>
>>> "Does D(D) halt?" has no subjective reference.
>>>
>>
>> Does the direct execution of D(D) halt is proven to be a
>> different question when posed to H than when posed to H1
>> in that for H both {yes,no} are the wrong answer.
>>
>> There are now three PhD computer science professor's
>> that agree with me on this.
>>
>>>> When H is asked: "Does the directly executed D(D) halt?"
>>>> this exact same word-for-word question has a different correct
>>>> answer depending on who is asked.
>>>
>>> Wrong.
>>>
>>>> When D is intentionally defined to do the opposite of whatever Boolean
>>>> value that H returns this is a self-contradictory question for H and is
>>>> not a self-contradictory question for H1.
>>>
>>> D(D) halts or it doesn't halt. There is no subjective reference or
>>> self-contradiction.
>>>
>>>>
>>>>> D is a program that I wrote. It bears no relation to H, except that
>>>>> I saw the source code of H before I wrote D. D does not reference
>>>>> H. D does not reference "self". D does not reference "you". It's
>>>>> just a normal program.
>>>>
>>>
>>
>
> // The following is written in C
> //
> typedef int (*ptr)(); // pointer to int function  see (x86utm)
> int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>
> int D(ptr x)
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> void main()
> {
>   H(D,D);
> }
>
> The question:
> *Does directly executed D(D) halt? is contradicted by D for every H*
>
> From the above source-code we can see that there cannot possibly exist
> any H that can return a value corresponding to the direct execution of
> D(D).
>
>

So, you agree that the Halting Theorem is True, that it is impossible to
construct a decider that gets every input right, since we have a formula
to build an input that any particular machine will get wrong.

Note, for every H you create, there IS a correct answer, so the question
isn't "self-contradictory".

After-all, for self-contradictory statements the contradictions have to
be to the same "self", not some "split-persooality" like you keep on
proposing.

Or, is that just indicating the state of your own mind?

On 12/31/2023 2:08 PM, olcott wrote:
> On 12/31/2023 1:34 PM, olcott wrote:
>> On 12/31/2023 12:19 PM, immibis wrote:
>>> On 12/25/23 22:52, olcott wrote:
>>>> On 12/25/2023 6:16 AM, immibis wrote:
>>>>> On 12/25/23 05:03, olcott wrote:
>>>>>> On 12/24/2023 7:53 PM, immibis wrote:
>>>>>>> On 12/24/23 22:24, olcott wrote:
>>>>>>>>
>>>>>>>> For any other H with the exact same D
>>>>>>>> "Does D(D) halt?"
>>>>>>>>
>>>>>>>> is a different question that has a different meaning in
>>>>>>>> the same way that: "Are you a little girl?" is a different
>>>>>>>> question depending on who you ask.
>>>>>>>>
>>>>>>>
>>>>>>> How can it be a different question when it's the exact same
>>>>>>> question and makes no reference to subjective pronouns like "you"?
>>>>>>>
>>>>>>
>>>>>> The arguments to the function H(D,D) are asking H about D(D).
>>>>>> The arguments to the function H1(D,D) are asking H1 about D(D).
>>>>>>
>>>>>> When D is intentionally defined to do the opposite of whatever
>>>>>> value that H returns this proves that the question:
>>>>>>
>>>>>> Does the direct execution of D(D) halt?
>>>>>> is a different question for H than for H1 even
>>>>>> though D itself is the exact same input.
>>>>>>
>>>>>
>>>>> Wrong. The question is the same. There is no subjective reference.
>>>>>
>>>>
>>>> When I ask: "Are you a little girl?"
>>>> this exact same word-for-word question has a different correct
>>>> answer depending on who is asked.
>>>>
>>>
>>> Because of the subjective reference.
>>>
>>> "Does D(D) halt?" has no subjective reference.
>>>
>>
>> Does the direct execution of D(D) halt is proven to be a
>> different question when posed to H than when posed to H1
>> in that for H both {yes,no} are the wrong answer.
>>
>> There are now three PhD computer science professor's
>> that agree with me on this.
>>
>>>> When H is asked: "Does the directly executed D(D) halt?"
>>>> this exact same word-for-word question has a different correct
>>>> answer depending on who is asked.
>>>
>>> Wrong.
>>>
>>>> When D is intentionally defined to do the opposite of whatever Boolean
>>>> value that H returns this is a self-contradictory question for H and is
>>>> not a self-contradictory question for H1.
>>>
>>> D(D) halts or it doesn't halt. There is no subjective reference or
>>> self-contradiction.
>>>
>>>>
>>>>> D is a program that I wrote. It bears no relation to H, except that
>>>>> I saw the source code of H before I wrote D. D does not reference
>>>>> H. D does not reference "self". D does not reference "you". It's
>>>>> just a normal program.
>>>>
>>>
>>
>
> // The following is written in C
> //
> typedef int (*ptr)(); // pointer to int function  see (x86utm)
> int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>
> int D(ptr x)
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> void main()
> {
>   H(D,D);
> }
>
> The question:
> *Does directly executed D(D) halt? is contradicted by D for every H*
>
> From the above source-code we can see that there cannot possibly exist
> any H that can return a value corresponding to the direct execution of
> D(D).

Thus when H is asked: Does the directly executed D(D) halt?
this <is> an incorrect question for H because both {yes,no}
are the wrong answer.

It may seem like the same question as the question posed to H1
because it <is> the same word-for-word question about the exact
same input.

The fact that {yes} is the correct answer for H1(D,D) and neither
{yes,no} is the correct answer for H(D,D) proves that these two
questions have different meanings thus are different questions.

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

On 12/31/23 4:27 PM, olcott wrote:
> On 12/31/2023 2:08 PM, olcott wrote:
>> On 12/31/2023 1:34 PM, olcott wrote:
>>> On 12/31/2023 12:19 PM, immibis wrote:
>>>> On 12/25/23 22:52, olcott wrote:
>>>>> On 12/25/2023 6:16 AM, immibis wrote:
>>>>>> On 12/25/23 05:03, olcott wrote:
>>>>>>> On 12/24/2023 7:53 PM, immibis wrote:
>>>>>>>> On 12/24/23 22:24, olcott wrote:
>>>>>>>>>
>>>>>>>>> For any other H with the exact same D
>>>>>>>>> "Does D(D) halt?"
>>>>>>>>>
>>>>>>>>> is a different question that has a different meaning in
>>>>>>>>> the same way that: "Are you a little girl?" is a different
>>>>>>>>> question depending on who you ask.
>>>>>>>>>
>>>>>>>>
>>>>>>>> How can it be a different question when it's the exact same
>>>>>>>> question and makes no reference to subjective pronouns like "you"?
>>>>>>>>
>>>>>>>
>>>>>>> The arguments to the function H(D,D) are asking H about D(D).
>>>>>>> The arguments to the function H1(D,D) are asking H1 about D(D).
>>>>>>>
>>>>>>> When D is intentionally defined to do the opposite of whatever
>>>>>>> value that H returns this proves that the question:
>>>>>>>
>>>>>>> Does the direct execution of D(D) halt?
>>>>>>> is a different question for H than for H1 even
>>>>>>> though D itself is the exact same input.
>>>>>>>
>>>>>>
>>>>>> Wrong. The question is the same. There is no subjective reference.
>>>>>>
>>>>>
>>>>> When I ask: "Are you a little girl?"
>>>>> this exact same word-for-word question has a different correct
>>>>> answer depending on who is asked.
>>>>>
>>>>
>>>> Because of the subjective reference.
>>>>
>>>> "Does D(D) halt?" has no subjective reference.
>>>>
>>>
>>> Does the direct execution of D(D) halt is proven to be a
>>> different question when posed to H than when posed to H1
>>> in that for H both {yes,no} are the wrong answer.
>>>
>>> There are now three PhD computer science professor's
>>> that agree with me on this.
>>>
>>>>> When H is asked: "Does the directly executed D(D) halt?"
>>>>> this exact same word-for-word question has a different correct
>>>>> answer depending on who is asked.
>>>>
>>>> Wrong.
>>>>
>>>>> When D is intentionally defined to do the opposite of whatever Boolean
>>>>> value that H returns this is a self-contradictory question for H
>>>>> and is
>>>>> not a self-contradictory question for H1.
>>>>
>>>> D(D) halts or it doesn't halt. There is no subjective reference or
>>>> self-contradiction.
>>>>
>>>>>
>>>>>> D is a program that I wrote. It bears no relation to H, except
>>>>>> that I saw the source code of H before I wrote D. D does not
>>>>>> reference H. D does not reference "self". D does not reference
>>>>>> "you". It's just a normal program.
>>>>>
>>>>
>>>
>>
>> // The following is written in C
>> //
>> typedef int (*ptr)(); // pointer to int function  see (x86utm)
>> int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>
>> int D(ptr x)
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> void main()
>> {
>>    H(D,D);
>> }
>>
>> The question:
>> *Does directly executed D(D) halt? is contradicted by D for every H*
>>
>>  From the above source-code we can see that there cannot possibly exist
>> any H that can return a value corresponding to the direct execution of
>> D(D).
>
> Thus when H is asked: Does the directly executed D(D) halt?
> this <is> an incorrect question for H because both {yes,no}
> are the wrong answer.
>

Nope. WHich ever anser H DOES give is wrong, and it can only give one
answer because it it limtied by it code.

> It may seem like the same question as the question posed to H1
> because it <is> the same word-for-word question about the exact
> same input.
>

Nope, it IS the same question, because the GIVEN D, which is just a
single program expressed as the input, always will the same thing.

Just like, the GIVEN H will always give the same answer when asked about
a specific input.

H can NOT give both a Yes or No answer about D, because it is LIMITED to
the ONE answer its program gives it.

If you change that programming, you no longer have that H, so need to
call it something else, or just be guilty of LYING in your "proof"

> The fact that {yes} is the correct answer for H1(D,D) and neither
> {yes,no} is the correct answer for H(D,D) proves that these two
> questions have different meanings thus are different questions.
>

No, if YES was the correct answer for H1, then it was also the correct
answer for H, it just that H didn't give it.

You are just proving that you are totally ignorant of the basics of
programming, aand of logic.

You are just proving your STUPIDITY.

On 1/2/2024 9:35 AM, immibis wrote:
> On 1/2/24 04:59, olcott wrote:
>> On 1/1/2024 9:47 PM, immibis wrote:
>>> On 1/2/24 00:42, Richard Damon wrote:
>>>> Part of Olcotts problem seems to be that he thinks that the input
>>>> "D" doesn't change as he mainpulates "the" H.
>>>
>>> It doesn't. You don't change D, you make a new D. Nor do you change H.
>>
>>
>> https://github.com/plolcott/x86utm/blob/master/Halt7out.txt
>> It is always this same D.
>>
>> _D()
>> [00001c72] 55             push ebp
>> [00001c73] 8bec           mov ebp,esp
>> [00001c75] 51             push ecx
>> [00001c76] 8b4508         mov eax,[ebp+08]
>> [00001c79] 50             push eax
>> [00001c7a] 8b4d08         mov ecx,[ebp+08]
>> [00001c7d] 51             push ecx
>> [00001c7e] e8bff8ffff     call 00001542
>> [00001c83] 83c408         add esp,+08
>> [00001c86] 8945fc         mov [ebp-04],eax
>> [00001c89] 837dfc00       cmp dword [ebp-04],+00
>> [00001c8d] 7402           jz 00001c91
>> [00001c8f] ebfe           jmp 00001c8f
>> [00001c91] 8b45fc         mov eax,[ebp-04]
>> [00001c94] 8be5           mov esp,ebp
>> [00001c96] 5d             pop ebp
>> [00001c97] c3             ret
>> Size in bytes:(0038) [00001c97]
>>
>
> This isn't a program. It's only half a program. The address 00001542
> which is part of the program code is missing from the listing.

D correctly simulated by H at machine address 00001542
cannot possibly reach past its own machine address 00001c7e.
The above is verified as completely true entirely on the
basis of the meaning of the above code.

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

On 1/2/2024 9:36 AM, immibis wrote:
> On 1/2/24 05:05, olcott wrote:
>>
>> H Simulates D on input D and as soon as H detects
>> that D is calling H, H correctly determines that D
>> would continue to simulate D without ever terminating
>> normally.
>
> so it infers that H(D,D) doesn't halt
>
> then H(D,D) halts
>
> an incorrect inference
>

H correctly determines that D correctly simulated
by H cannot possibly reach any point in its own
execution trace past D's call to H.

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

On 1/2/2024 9:37 AM, immibis wrote:
> On 1/2/24 05:10, olcott wrote:
>> Everyone here (out of their ignorance) makes sure to
>> ignore the fact that both Boolean return values from H(D,D)
>> are incorrect and the return value of 1 from H1(D,D > correct
>
> if D(D) halts then the return value of 1 from H(D,D) is correct
>

You know that this would cause D to go into an infinite loop
so why lie?

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

On 1/2/24 19:18, olcott wrote:
> On 1/2/2024 9:35 AM, immibis wrote:
>> On 1/2/24 04:59, olcott wrote:
>>> On 1/1/2024 9:47 PM, immibis wrote:
>>>> On 1/2/24 00:42, Richard Damon wrote:
>>>>> Part of Olcotts problem seems to be that he thinks that the input
>>>>> "D" doesn't change as he mainpulates "the" H.
>>>>
>>>> It doesn't. You don't change D, you make a new D. Nor do you change H.
>>>
>>>
>>> https://github.com/plolcott/x86utm/blob/master/Halt7out.txt
>>> It is always this same D.
>>>
>>> _D()
>>> [00001c72] 55             push ebp
>>> [00001c73] 8bec           mov ebp,esp
>>> [00001c75] 51             push ecx
>>> [00001c76] 8b4508         mov eax,[ebp+08]
>>> [00001c79] 50             push eax
>>> [00001c7a] 8b4d08         mov ecx,[ebp+08]
>>> [00001c7d] 51             push ecx
>>> [00001c7e] e8bff8ffff     call 00001542
>>> [00001c83] 83c408         add esp,+08
>>> [00001c86] 8945fc         mov [ebp-04],eax
>>> [00001c89] 837dfc00       cmp dword [ebp-04],+00
>>> [00001c8d] 7402           jz 00001c91
>>> [00001c8f] ebfe           jmp 00001c8f
>>> [00001c91] 8b45fc         mov eax,[ebp-04]
>>> [00001c94] 8be5           mov esp,ebp
>>> [00001c96] 5d             pop ebp
>>> [00001c97] c3             ret
>>> Size in bytes:(0038) [00001c97]
>>>
>>
>> This isn't a program. It's only half a program. The address 00001542
>> which is part of the program code is missing from the listing.
>
> D correctly simulated by H at machine address 00001542
> cannot possibly reach past its own machine address 00001c7e.
> The above is verified as completely true entirely on the
> basis of the meaning of the above code.
>

Rejected due to not addressing the complaint.

This isn't a program. It's only half a program. The address 00001542
which is part of the program code is missing from the listing.

Unless you're proposing that the instruction CALL 00001542 invokes a
halting oracle?

On 1/2/2024 12:27 PM, immibis wrote:
> On 1/2/24 19:18, olcott wrote:
>> On 1/2/2024 9:35 AM, immibis wrote:
>>> On 1/2/24 04:59, olcott wrote:
>>>> On 1/1/2024 9:47 PM, immibis wrote:
>>>>> On 1/2/24 00:42, Richard Damon wrote:
>>>>>> Part of Olcotts problem seems to be that he thinks that the input
>>>>>> "D" doesn't change as he mainpulates "the" H.
>>>>>
>>>>> It doesn't. You don't change D, you make a new D. Nor do you change H.
>>>>
>>>>
>>>> https://github.com/plolcott/x86utm/blob/master/Halt7out.txt
>>>> It is always this same D.
>>>>
>>>> _D()
>>>> [00001c72] 55             push ebp
>>>> [00001c73] 8bec           mov ebp,esp
>>>> [00001c75] 51             push ecx
>>>> [00001c76] 8b4508         mov eax,[ebp+08]
>>>> [00001c79] 50             push eax
>>>> [00001c7a] 8b4d08         mov ecx,[ebp+08]
>>>> [00001c7d] 51             push ecx
>>>> [00001c7e] e8bff8ffff     call 00001542
>>>> [00001c83] 83c408         add esp,+08
>>>> [00001c86] 8945fc         mov [ebp-04],eax
>>>> [00001c89] 837dfc00       cmp dword [ebp-04],+00
>>>> [00001c8d] 7402           jz 00001c91
>>>> [00001c8f] ebfe           jmp 00001c8f
>>>> [00001c91] 8b45fc         mov eax,[ebp-04]
>>>> [00001c94] 8be5           mov esp,ebp
>>>> [00001c96] 5d             pop ebp
>>>> [00001c97] c3             ret
>>>> Size in bytes:(0038) [00001c97]
>>>>
>>>
>>> This isn't a program. It's only half a program. The address 00001542
>>> which is part of the program code is missing from the listing.
>>
>> D correctly simulated by H at machine address 00001542
>> cannot possibly reach past its own machine address 00001c7e.
>> The above is verified as completely true entirely on the
>> basis of the meaning of the above code.
>>
>
> Rejected due to not addressing the complaint.
>
> This isn't a program. It's only half a program. The address 00001542
> which is part of the program code is missing from the listing.

*I never claimed that D is a program, thus strawman error*

It is an easily verified fact that D correctly simulated
by H cannot possibly reach past its own machine address
00001c7e.

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

On 1/2/24 20:11, olcott wrote:
> *I never claimed that D is a program, thus strawman error*

Is D a program?

On 1/2/24 19:20, olcott wrote:
> On 1/2/2024 9:36 AM, immibis wrote:
>> On 1/2/24 05:05, olcott wrote:
>>>
>>> H Simulates D on input D and as soon as H detects
>>> that D is calling H, H correctly determines that D
>>> would continue to simulate D without ever terminating
>>> normally.
>>
>> so it infers that H(D,D) doesn't halt
>>
>> then H(D,D) halts
>>
>> an incorrect inference
>>
>
> H correctly determines that D correctly simulated
> by H cannot possibly reach any point in its own
> execution trace past D's call to H.
>

D(D) reaches a point in its own execution trace past D's call to H,
therefore the simulation is incorrect.