On 1/29/23 8:43 PM, olcott wrote:
> On 1/29/2023 7:39 PM, Richard Damon wrote:
>> On 1/29/23 8:23 PM, olcott wrote:
>>> On 1/29/2023 7:04 PM, Richard Damon wrote:
>>>> On 1/29/23 7:15 PM, olcott wrote:
>>>>> On 1/28/2023 9:44 PM, Richard Damon wrote:
>>>>>> On 1/28/23 6:29 PM, olcott wrote:
>>>>>>> On 1/27/2023 10:21 PM, Richard Damon wrote:
>>>>>>>> On 1/27/23 11:14 PM, olcott wrote:
>>>>>>>>> H does a correct simulation of the first seven lines of D and upon
>>>>>>>>> encountering the 8th line of D correctly determines that D
>>>>>>>>> would never
>>>>>>>>> stop running unless aborted.
>>>>>>>>
>>>>>>>> Nope, that is an INCORRECT conclusion, because the actual
>>>>>>>> behavior of that call to H by D(D) will be to abort ITS
>>>>>>>> simulation (which is a different instance, which is also an
>>>>>>>> incorrect action) and return 0.
>>>>>>>>
>>>>>>>> Thus H gets the wrong answer because it presumes that H will not
>>>>>>>> get the wrong answer when it does.
>>>>>>>>
>>>>>>>> Until you provide the instruction in that direct execution of
>>>>>>>> D(D) that differs from the execution of H(D,D) when called by
>>>>>>>> main, you are just admitting that you are a Hypocritical
>>>>>>>> Patholgical Lying Ignorant Idiot.
>>>>>>>>
>>>>>>>
>>>>>>> In other words you are trying to get away with the
>>>>>>> counter-factual claim
>>>>>>> that D correctly simulated by H would eventually reach its own final
>>>>>>> state and terminate normally.
>>>>>>
>>>>>> D correctly siumulated will reach its own final state. This is
>>>>>> shown by UTM(D,D).
>>>>> You dishonestly changed the words. Why lie?
>>>>
>>>> No, YOU are o=one making the change,
>>>
>>> When D is CORRECTLY SIMULATED BY H
>>
>> Which doesn't happen if H answers,
>
> Correctly and completely is not the same as correctly.

It is the only definition that lest you replace the behavior of the
actual machine with a simulation.

Since D(D) Halts, H(D,D) must return 1

If you claim 0- is the correct answer, you question must be different
and you have been lying all the time/.

>
> It one instruction of D is correctly simulated then this one instruction
> <is> correctly simulated, likewise with more than one.

H, being a computation, must do the same thing for every invocation of
it with the same parameter. Thus either ALL invocations to a "correct
simulation" that doesn't abort (ad thus never answers), or NONE do so it
can answer and you don't have a correct simulation to claim to base you
answer on.

You are just basing you logic an mythical magic fairy dust powered
unicorns, which doesn't work to give consistent answers.

>
> *THIS IS PROVEN TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
> As long as H correctly simulates D until H has a correct basis to
> determine that D would never reach the final state of D then H has
> correctly determined that D is non-halting.
>

But not the Technical meaning of the wornds.

By the "Meaning of the words" since we can say:

If this sentence is correct, Peter Olcott is a Hypocritical Pathological
Lying Ignorat Idiot

And since that sentence is true under the same use of meaning of the
words as you are using.

You are admitting that you ARE a Hypocritical Pathological Lying Ignornt
Idiot.

The problem is you are basing your "proof" on an assumption of a premise
that can only be proven by assuming it to be true, This leads to a
system subject to Curry's Paradox.

Thus, your logic system is invalid.

The fact that you repeat these same claims actually gives us the
independent proof of the second clause, so we CAN logically say that you
ARE a Hypocritical Pathological Lying Ignorant Idiot.

On 1/29/23 8:48 PM, olcott wrote:
> On 1/29/2023 7:41 PM, Richard Damon wrote:
>> On 1/29/23 8:28 PM, olcott wrote:
>>> On 1/29/2023 7:10 PM, Richard Damon wrote:
>>>> On 1/29/23 7:28 PM, olcott wrote:
>>>>> On 1/28/2023 9:47 PM, Richard Damon wrote:
>>>>>> On 1/28/23 4:29 PM, olcott wrote:
>>>>>>> On 1/28/2023 3:13 PM, Richard Damon wrote:
>>>>>>>> On 1/28/23 3:59 PM, olcott wrote:
>>>>>>>>> On 1/28/2023 2:42 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>>>> Yes, you can build SOME Deciders from a Sumation.
>>>>>>>>>>
>>>>>>>>>> Not All Deciders can be built from a Sumation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> One TM is *ALL* deciders.
>>>>>>>>
>>>>>>>> Really?
>>>>>>>>
>>>>>>>> It can be both a is_prime and is_perfect decider?
>>>>>>>>
>>>>>>>> Maybe your problem is you don't understand at all what a decider
>>>>>>>> is?
>>>>>>>>
>>>>>>>>>
>>>>>>>>>> You just don't understand the basics of category theory, and
>>>>>>>>>> just fall into the fallacy of Proof by Example.
>>>>>>>>>>
>>>>>>>>>> Just because one subset of a set happens to have a property
>>>>>>>>>> doesn't mean that property applies to the whole class.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Try and provide a single counter-example where IS_SUM gets the
>>>>>>>>> wrong answer.
>>>>>>>>
>>>>>>>> If the question is Is the number prime?
>>>>>>>>
>>>>>>>>>
>>>>>>>>> If there are no counter-examples that prove that IS_SUM gets
>>>>>>>>> the wrong
>>>>>>>>> answer then this logically entails that IS_SUM always gets the
>>>>>>>>> correct
>>>>>>>>> answer.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> But only to the one question it was built for.
>>>>>>>>
>>>>>>>
>>>>>>> Likewise for DOES_HALT, there are zero countability issues with
>>>>>>> DOES_HALT. DOES_HALT merely needs to compute the mapping from any
>>>>>>> arbitrary input pair of finite strings to its accept or reject
>>>>>>> state.
>>>>>>>
>>>>>>
>>>>>> Can you PROVE that this is doable?
>>>>>>
>>>>>
>>>>> We can change IS_SUM to allow any arbitrary finite set of finite
>>>>> string
>>>>> inputs. If any of these finite strings contains a character that is
>>>>> not
>>>>> an ASCII digit then IS_SUM rejects, otherwise IS_SUM is as it was
>>>>> previously specified.
>>>>
>>>> Ok, how do you use IS_SUM to answer the IS_PRIME question?
>>>>
>>>
>>> IS_PRIME would have a single finite string of ASCII digits as its
>>> only input and you already know this is computable.
>>>
>>>> IS_SUM takes the countably infinite number of inputs
>>>
>>> IS_SUM takes a finite set of finite string inputs
>>> IS_SUM takes a finite set of finite string inputs
>>> IS_SUM takes a finite set of finite string inputs
>>> IS_SUM takes a finite set of finite string inputs
>>> IS_SUM takes a finite set of finite string inputs
>>
>> And computes ONE mapping, out of the uncountable infinte many mappings
>> of strings -> the set of answers for each input.
> IS_SUM need not ever count any uncountable set. All that IS_SUM must do
> is compute each mapping that it is presented with, one finite set of
> finite strings at a time.
>

So????

We aren't talking about IS_SUM being non-computable, we are talking
about most of the uncountable infinte number of possible mappings being
uncountable.

Do you even know what is meant by "a mapping"?

ONE Turing Machine, ONE Mapping of input to output.

Countable infinite possible Turing Machine, can generate a countable
infinte number of possible mappings.

The actual number of possible mappings is an UNCOUNTABLE infinite, thus
most of the possible mappings are not computed by any Turing Machine.

On 1/29/2023 7:54 PM, Richard Damon wrote:
> On 1/29/23 8:43 PM, olcott wrote:
>> On 1/29/2023 7:39 PM, Richard Damon wrote:
>>> On 1/29/23 8:23 PM, olcott wrote:
>>>> On 1/29/2023 7:04 PM, Richard Damon wrote:
>>>>> On 1/29/23 7:15 PM, olcott wrote:
>>>>>> On 1/28/2023 9:44 PM, Richard Damon wrote:
>>>>>>> On 1/28/23 6:29 PM, olcott wrote:
>>>>>>>> On 1/27/2023 10:21 PM, Richard Damon wrote:
>>>>>>>>> On 1/27/23 11:14 PM, olcott wrote:
>>>>>>>>>> H does a correct simulation of the first seven lines of D and
>>>>>>>>>> upon
>>>>>>>>>> encountering the 8th line of D correctly determines that D
>>>>>>>>>> would never
>>>>>>>>>> stop running unless aborted.
>>>>>>>>>
>>>>>>>>> Nope, that is an INCORRECT conclusion, because the actual
>>>>>>>>> behavior of that call to H by D(D) will be to abort ITS
>>>>>>>>> simulation (which is a different instance, which is also an
>>>>>>>>> incorrect action) and return 0.
>>>>>>>>>
>>>>>>>>> Thus H gets the wrong answer because it presumes that H will
>>>>>>>>> not get the wrong answer when it does.
>>>>>>>>>
>>>>>>>>> Until you provide the instruction in that direct execution of
>>>>>>>>> D(D) that differs from the execution of H(D,D) when called by
>>>>>>>>> main, you are just admitting that you are a Hypocritical
>>>>>>>>> Patholgical Lying Ignorant Idiot.
>>>>>>>>>
>>>>>>>>
>>>>>>>> In other words you are trying to get away with the
>>>>>>>> counter-factual claim
>>>>>>>> that D correctly simulated by H would eventually reach its own
>>>>>>>> final
>>>>>>>> state and terminate normally.
>>>>>>>
>>>>>>> D correctly siumulated will reach its own final state. This is
>>>>>>> shown by UTM(D,D).
>>>>>> You dishonestly changed the words. Why lie?
>>>>>
>>>>> No, YOU are o=one making the change,
>>>>
>>>> When D is CORRECTLY SIMULATED BY H
>>>
>>> Which doesn't happen if H answers,
>>
>> Correctly and completely is not the same as correctly.
>
> It is the only definition that lest you replace the behavior of the
> actual machine with a simulation.
>
> Since D(D) Halts, H(D,D) must return 1
>
> If you claim 0- is the correct answer, you question must be different
> and you have been lying all the time/.
>
>>
>> It one instruction of D is correctly simulated then this one instruction
>> <is> correctly simulated, likewise with more than one.
>
> H, being a computation, must do the same thing for every invocation of
> it with the same parameter.

None-the-less we can both see that in the exhaustive set of possibilities:
(a) H aborts the simulation of its input
(b) H does not abort the simulation of its input
D never reaches its final state, thus D never halts.

I don't see what your thrill is to lie about this.

--
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/29/2023 8:06 PM, Richard Damon wrote:
> On 1/29/23 8:48 PM, olcott wrote:
>> On 1/29/2023 7:41 PM, Richard Damon wrote:
>>> On 1/29/23 8:28 PM, olcott wrote:
>>>> On 1/29/2023 7:10 PM, Richard Damon wrote:
>>>>> On 1/29/23 7:28 PM, olcott wrote:
>>>>>> On 1/28/2023 9:47 PM, Richard Damon wrote:
>>>>>>> On 1/28/23 4:29 PM, olcott wrote:
>>>>>>>> On 1/28/2023 3:13 PM, Richard Damon wrote:
>>>>>>>>> On 1/28/23 3:59 PM, olcott wrote:
>>>>>>>>>> On 1/28/2023 2:42 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>>>> Yes, you can build SOME Deciders from a Sumation.
>>>>>>>>>>>
>>>>>>>>>>> Not All Deciders can be built from a Sumation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> One TM is *ALL* deciders.
>>>>>>>>>
>>>>>>>>> Really?
>>>>>>>>>
>>>>>>>>> It can be both a is_prime and is_perfect decider?
>>>>>>>>>
>>>>>>>>> Maybe your problem is you don't understand at all what a
>>>>>>>>> decider is?
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> You just don't understand the basics of category theory, and
>>>>>>>>>>> just fall into the fallacy of Proof by Example.
>>>>>>>>>>>
>>>>>>>>>>> Just because one subset of a set happens to have a property
>>>>>>>>>>> doesn't mean that property applies to the whole class.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Try and provide a single counter-example where IS_SUM gets the
>>>>>>>>>> wrong answer.
>>>>>>>>>
>>>>>>>>> If the question is Is the number prime?
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If there are no counter-examples that prove that IS_SUM gets
>>>>>>>>>> the wrong
>>>>>>>>>> answer then this logically entails that IS_SUM always gets the
>>>>>>>>>> correct
>>>>>>>>>> answer.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But only to the one question it was built for.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Likewise for DOES_HALT, there are zero countability issues with
>>>>>>>> DOES_HALT. DOES_HALT merely needs to compute the mapping from any
>>>>>>>> arbitrary input pair of finite strings to its accept or reject
>>>>>>>> state.
>>>>>>>>
>>>>>>>
>>>>>>> Can you PROVE that this is doable?
>>>>>>>
>>>>>>
>>>>>> We can change IS_SUM to allow any arbitrary finite set of finite
>>>>>> string
>>>>>> inputs. If any of these finite strings contains a character that
>>>>>> is not
>>>>>> an ASCII digit then IS_SUM rejects, otherwise IS_SUM is as it was
>>>>>> previously specified.
>>>>>
>>>>> Ok, how do you use IS_SUM to answer the IS_PRIME question?
>>>>>
>>>>
>>>> IS_PRIME would have a single finite string of ASCII digits as its
>>>> only input and you already know this is computable.
>>>>
>>>>> IS_SUM takes the countably infinite number of inputs
>>>>
>>>> IS_SUM takes a finite set of finite string inputs
>>>> IS_SUM takes a finite set of finite string inputs
>>>> IS_SUM takes a finite set of finite string inputs
>>>> IS_SUM takes a finite set of finite string inputs
>>>> IS_SUM takes a finite set of finite string inputs
>>>
>>> And computes ONE mapping, out of the uncountable infinte many
>>> mappings of strings -> the set of answers for each input.
>> IS_SUM need not ever count any uncountable set. All that IS_SUM must
>> do is compute each mapping that it is presented with, one finite set
>> of finite strings at a time.
>>
>
>
> So????
>
>
> We aren't talking about IS_SUM being non-computable,

Then the "you" of "we" is off topic. Countability was supposed to be an
alternate proof that halting is undecidable.

--
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/29/23 9:24 PM, olcott wrote:
> On 1/29/2023 7:54 PM, Richard Damon wrote:
>> On 1/29/23 8:43 PM, olcott wrote:
>>> On 1/29/2023 7:39 PM, Richard Damon wrote:
>>>> On 1/29/23 8:23 PM, olcott wrote:
>>>>> On 1/29/2023 7:04 PM, Richard Damon wrote:
>>>>>> On 1/29/23 7:15 PM, olcott wrote:
>>>>>>> On 1/28/2023 9:44 PM, Richard Damon wrote:
>>>>>>>> On 1/28/23 6:29 PM, olcott wrote:
>>>>>>>>> On 1/27/2023 10:21 PM, Richard Damon wrote:
>>>>>>>>>> On 1/27/23 11:14 PM, olcott wrote:
>>>>>>>>>>> H does a correct simulation of the first seven lines of D and
>>>>>>>>>>> upon
>>>>>>>>>>> encountering the 8th line of D correctly determines that D
>>>>>>>>>>> would never
>>>>>>>>>>> stop running unless aborted.
>>>>>>>>>>
>>>>>>>>>> Nope, that is an INCORRECT conclusion, because the actual
>>>>>>>>>> behavior of that call to H by D(D) will be to abort ITS
>>>>>>>>>> simulation (which is a different instance, which is also an
>>>>>>>>>> incorrect action) and return 0.
>>>>>>>>>>
>>>>>>>>>> Thus H gets the wrong answer because it presumes that H will
>>>>>>>>>> not get the wrong answer when it does.
>>>>>>>>>>
>>>>>>>>>> Until you provide the instruction in that direct execution of
>>>>>>>>>> D(D) that differs from the execution of H(D,D) when called by
>>>>>>>>>> main, you are just admitting that you are a Hypocritical
>>>>>>>>>> Patholgical Lying Ignorant Idiot.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> In other words you are trying to get away with the
>>>>>>>>> counter-factual claim
>>>>>>>>> that D correctly simulated by H would eventually reach its own
>>>>>>>>> final
>>>>>>>>> state and terminate normally.
>>>>>>>>
>>>>>>>> D correctly siumulated will reach its own final state. This is
>>>>>>>> shown by UTM(D,D).
>>>>>>> You dishonestly changed the words. Why lie?
>>>>>>
>>>>>> No, YOU are o=one making the change,
>>>>>
>>>>> When D is CORRECTLY SIMULATED BY H
>>>>
>>>> Which doesn't happen if H answers,
>>>
>>> Correctly and completely is not the same as correctly.
>>
>> It is the only definition that lest you replace the behavior of the
>> actual machine with a simulation.
>>
>> Since D(D) Halts, H(D,D) must return 1
>>
>> If you claim 0- is the correct answer, you question must be different
>> and you have been lying all the time/.
>>
>>>
>>> It one instruction of D is correctly simulated then this one instruction
>>> <is> correctly simulated, likewise with more than one.
>>
>> H, being a computation, must do the same thing for every invocation of
>> it with the same parameter.
>
> None-the-less we can both see that in the exhaustive set of possibilities:

None-the-less: Translate, Peter Olcott will avoid valid logic and make
an fabricated statement.

> (a) H aborts the simulation of its input
(Which it does)
> (b) H does not abort the simulation of its input
> D never reaches its final state, thus D never halts.

Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches its
final state.

Remember, the question is NOT "Does H simulate to the final state" but
does the machine represented by the input reach a final state.

Also, if H doesn't abort its simulation, it isn't the machine you are
thinking of, as it never returns an answer, and thus fails to be the
decider needed. Since you are talking about an H that DOES abort its
simulation, case (b) is not available as a possible behavior for the H
that D calls.

At least until you show the instruction of different behavior on the two
paths of direct execution, which you haven't so you have admitted to
being the Hypocritical Pathological Lying Ignorant Idiot.

>
> I don't see what your thrill is to lie about this.
>
>
So, you are caught in your lie again.

D(D) will Halt because H(D,D) WILL return 0, thus H(D,D) returning 0 is
an incorrecxt answer for the ACTUAL Halting problem which asks about
that direct exectuion, not your fantasy condition of "a correct
simulation by H".

Your repeating this statement just proves you are that Hypocritical
Pathological Lying Ignorant Idiot.

On 1/29/23 9:27 PM, olcott wrote:
> On 1/29/2023 8:06 PM, Richard Damon wrote:
>> On 1/29/23 8:48 PM, olcott wrote:
>>> On 1/29/2023 7:41 PM, Richard Damon wrote:
>>>> On 1/29/23 8:28 PM, olcott wrote:
>>>>> On 1/29/2023 7:10 PM, Richard Damon wrote:
>>>>>> On 1/29/23 7:28 PM, olcott wrote:
>>>>>>> On 1/28/2023 9:47 PM, Richard Damon wrote:
>>>>>>>> On 1/28/23 4:29 PM, olcott wrote:
>>>>>>>>> On 1/28/2023 3:13 PM, Richard Damon wrote:
>>>>>>>>>> On 1/28/23 3:59 PM, olcott wrote:
>>>>>>>>>>> On 1/28/2023 2:42 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>>>> Yes, you can build SOME Deciders from a Sumation.
>>>>>>>>>>>>
>>>>>>>>>>>> Not All Deciders can be built from a Sumation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> One TM is *ALL* deciders.
>>>>>>>>>>
>>>>>>>>>> Really?
>>>>>>>>>>
>>>>>>>>>> It can be both a is_prime and is_perfect decider?
>>>>>>>>>>
>>>>>>>>>> Maybe your problem is you don't understand at all what a
>>>>>>>>>> decider is?
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> You just don't understand the basics of category theory, and
>>>>>>>>>>>> just fall into the fallacy of Proof by Example.
>>>>>>>>>>>>
>>>>>>>>>>>> Just because one subset of a set happens to have a property
>>>>>>>>>>>> doesn't mean that property applies to the whole class.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Try and provide a single counter-example where IS_SUM gets
>>>>>>>>>>> the wrong answer.
>>>>>>>>>>
>>>>>>>>>> If the question is Is the number prime?
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If there are no counter-examples that prove that IS_SUM gets
>>>>>>>>>>> the wrong
>>>>>>>>>>> answer then this logically entails that IS_SUM always gets
>>>>>>>>>>> the correct
>>>>>>>>>>> answer.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But only to the one question it was built for.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Likewise for DOES_HALT, there are zero countability issues with
>>>>>>>>> DOES_HALT. DOES_HALT merely needs to compute the mapping from any
>>>>>>>>> arbitrary input pair of finite strings to its accept or reject
>>>>>>>>> state.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Can you PROVE that this is doable?
>>>>>>>>
>>>>>>>
>>>>>>> We can change IS_SUM to allow any arbitrary finite set of finite
>>>>>>> string
>>>>>>> inputs. If any of these finite strings contains a character that
>>>>>>> is not
>>>>>>> an ASCII digit then IS_SUM rejects, otherwise IS_SUM is as it was
>>>>>>> previously specified.
>>>>>>
>>>>>> Ok, how do you use IS_SUM to answer the IS_PRIME question?
>>>>>>
>>>>>
>>>>> IS_PRIME would have a single finite string of ASCII digits as its
>>>>> only input and you already know this is computable.
>>>>>
>>>>>> IS_SUM takes the countably infinite number of inputs
>>>>>
>>>>> IS_SUM takes a finite set of finite string inputs
>>>>> IS_SUM takes a finite set of finite string inputs
>>>>> IS_SUM takes a finite set of finite string inputs
>>>>> IS_SUM takes a finite set of finite string inputs
>>>>> IS_SUM takes a finite set of finite string inputs
>>>>
>>>> And computes ONE mapping, out of the uncountable infinte many
>>>> mappings of strings -> the set of answers for each input.
>>> IS_SUM need not ever count any uncountable set. All that IS_SUM must
>>> do is compute each mapping that it is presented with, one finite set
>>> of finite strings at a time.
>>>
>>
>>
>> So????
>>
>>
>> We aren't talking about IS_SUM being non-computable,
>
> Then the "you" of "we" is off topic. Countability was supposed to be an
> alternate proof that halting is undecidable.
>
Right, countablility of mappings.

The computability of a single mapping show nothing about the
countability arguement.

No one says that NO mappings are computable, just that most are not.

You clearly don't understand categorical logic.

Again, your use of the fallacy of proof by example.

On 1/29/2023 8:52 PM, Richard Damon wrote:
> On 1/29/23 9:27 PM, olcott wrote:
>> On 1/29/2023 8:06 PM, Richard Damon wrote:
>>> On 1/29/23 8:48 PM, olcott wrote:
>>>> On 1/29/2023 7:41 PM, Richard Damon wrote:
>>>>> On 1/29/23 8:28 PM, olcott wrote:
>>>>>> On 1/29/2023 7:10 PM, Richard Damon wrote:
>>>>>>> On 1/29/23 7:28 PM, olcott wrote:
>>>>>>>> On 1/28/2023 9:47 PM, Richard Damon wrote:
>>>>>>>>> On 1/28/23 4:29 PM, olcott wrote:
>>>>>>>>>> On 1/28/2023 3:13 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/28/23 3:59 PM, olcott wrote:
>>>>>>>>>>>> On 1/28/2023 2:42 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>>>> Yes, you can build SOME Deciders from a Sumation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Not All Deciders can be built from a Sumation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> One TM is *ALL* deciders.
>>>>>>>>>>>
>>>>>>>>>>> Really?
>>>>>>>>>>>
>>>>>>>>>>> It can be both a is_prime and is_perfect decider?
>>>>>>>>>>>
>>>>>>>>>>> Maybe your problem is you don't understand at all what a
>>>>>>>>>>> decider is?
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>> You just don't understand the basics of category theory,
>>>>>>>>>>>>> and just fall into the fallacy of Proof by Example.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Just because one subset of a set happens to have a property
>>>>>>>>>>>>> doesn't mean that property applies to the whole class.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Try and provide a single counter-example where IS_SUM gets
>>>>>>>>>>>> the wrong answer.
>>>>>>>>>>>
>>>>>>>>>>> If the question is Is the number prime?
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If there are no counter-examples that prove that IS_SUM gets
>>>>>>>>>>>> the wrong
>>>>>>>>>>>> answer then this logically entails that IS_SUM always gets
>>>>>>>>>>>> the correct
>>>>>>>>>>>> answer.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But only to the one question it was built for.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Likewise for DOES_HALT, there are zero countability issues with
>>>>>>>>>> DOES_HALT. DOES_HALT merely needs to compute the mapping from any
>>>>>>>>>> arbitrary input pair of finite strings to its accept or reject
>>>>>>>>>> state.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Can you PROVE that this is doable?
>>>>>>>>>
>>>>>>>>
>>>>>>>> We can change IS_SUM to allow any arbitrary finite set of finite
>>>>>>>> string
>>>>>>>> inputs. If any of these finite strings contains a character that
>>>>>>>> is not
>>>>>>>> an ASCII digit then IS_SUM rejects, otherwise IS_SUM is as it was
>>>>>>>> previously specified.
>>>>>>>
>>>>>>> Ok, how do you use IS_SUM to answer the IS_PRIME question?
>>>>>>>
>>>>>>
>>>>>> IS_PRIME would have a single finite string of ASCII digits as its
>>>>>> only input and you already know this is computable.
>>>>>>
>>>>>>> IS_SUM takes the countably infinite number of inputs
>>>>>>
>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>
>>>>> And computes ONE mapping, out of the uncountable infinte many
>>>>> mappings of strings -> the set of answers for each input.
>>>> IS_SUM need not ever count any uncountable set. All that IS_SUM must
>>>> do is compute each mapping that it is presented with, one finite set
>>>> of finite strings at a time.
>>>>
>>>
>>>
>>> So????
>>>
>>>
>>> We aren't talking about IS_SUM being non-computable,
>>
>> Then the "you" of "we" is off topic. Countability was supposed to be
>> an alternate proof that halting is undecidable.
>>
> Right, countablility of mappings.
>
> The computability of a single mapping show nothing about the
> countability arguement.
>
> No one says that NO mappings are computable, just that most are not.
>

No one can show even one mapping of a finite set of string inputs to
IS_SUM that is not computable, thus the conclusion that there are more
than one counter-example is totally refuted.

> You clearly don't understand categorical logic.
>

Categorically exhaustive reasoning is my key innovation it utterly
eliminates the error of omission.

If it is impossible to show as many as a single counter-example then we
can correctly generalize this to say that more than one counter example
also does not exist.

> Again, your use of the fallacy of proof by example.

--
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/29/2023 8:48 PM, Richard Damon wrote:
> On 1/29/23 9:24 PM, olcott wrote:
>> On 1/29/2023 7:54 PM, Richard Damon wrote:
>>> On 1/29/23 8:43 PM, olcott wrote:
>>>> On 1/29/2023 7:39 PM, Richard Damon wrote:
>>>>> On 1/29/23 8:23 PM, olcott wrote:
>>>>>> On 1/29/2023 7:04 PM, Richard Damon wrote:
>>>>>>> On 1/29/23 7:15 PM, olcott wrote:
>>>>>>>> On 1/28/2023 9:44 PM, Richard Damon wrote:
>>>>>>>>> On 1/28/23 6:29 PM, olcott wrote:
>>>>>>>>>> On 1/27/2023 10:21 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/27/23 11:14 PM, olcott wrote:
>>>>>>>>>>>> H does a correct simulation of the first seven lines of D
>>>>>>>>>>>> and upon
>>>>>>>>>>>> encountering the 8th line of D correctly determines that D
>>>>>>>>>>>> would never
>>>>>>>>>>>> stop running unless aborted.
>>>>>>>>>>>
>>>>>>>>>>> Nope, that is an INCORRECT conclusion, because the actual
>>>>>>>>>>> behavior of that call to H by D(D) will be to abort ITS
>>>>>>>>>>> simulation (which is a different instance, which is also an
>>>>>>>>>>> incorrect action) and return 0.
>>>>>>>>>>>
>>>>>>>>>>> Thus H gets the wrong answer because it presumes that H will
>>>>>>>>>>> not get the wrong answer when it does.
>>>>>>>>>>>
>>>>>>>>>>> Until you provide the instruction in that direct execution of
>>>>>>>>>>> D(D) that differs from the execution of H(D,D) when called by
>>>>>>>>>>> main, you are just admitting that you are a Hypocritical
>>>>>>>>>>> Patholgical Lying Ignorant Idiot.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> In other words you are trying to get away with the
>>>>>>>>>> counter-factual claim
>>>>>>>>>> that D correctly simulated by H would eventually reach its own
>>>>>>>>>> final
>>>>>>>>>> state and terminate normally.
>>>>>>>>>
>>>>>>>>> D correctly siumulated will reach its own final state. This is
>>>>>>>>> shown by UTM(D,D).
>>>>>>>> You dishonestly changed the words. Why lie?
>>>>>>>
>>>>>>> No, YOU are o=one making the change,
>>>>>>
>>>>>> When D is CORRECTLY SIMULATED BY H
>>>>>
>>>>> Which doesn't happen if H answers,
>>>>
>>>> Correctly and completely is not the same as correctly.
>>>
>>> It is the only definition that lest you replace the behavior of the
>>> actual machine with a simulation.
>>>
>>> Since D(D) Halts, H(D,D) must return 1
>>>
>>> If you claim 0- is the correct answer, you question must be different
>>> and you have been lying all the time/.
>>>
>>>>
>>>> It one instruction of D is correctly simulated then this one
>>>> instruction
>>>> <is> correctly simulated, likewise with more than one.
>>>
>>> H, being a computation, must do the same thing for every invocation
>>> of it with the same parameter.
>>
>> None-the-less we can both see that in the exhaustive set of
>> possibilities:
>
> None-the-less: Translate, Peter Olcott will avoid valid logic and make
> an fabricated statement.
>
>> (a) H aborts the simulation of its input
> (Which it does)
>> (b) H does not abort the simulation of its input
>> D never reaches its final state, thus D never halts.
>
> Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches its
> final state.
>

You know that D correctly simulated by H cannot possibly reach the final
state of D and lie about this because you think that lying is funny.

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

Le 30/01/2023 à 06:11, olcott a écrit :
> On 1/29/2023 8:48 PM, Richard Damon wrote:
>> On 1/29/23 9:24 PM, olcott wrote:
>>> On 1/29/2023 7:54 PM, Richard Damon wrote:
>>>> On 1/29/23 8:43 PM, olcott wrote:
>>>>> On 1/29/2023 7:39 PM, Richard Damon wrote:
>>>>>> On 1/29/23 8:23 PM, olcott wrote:
>>>>>>> On 1/29/2023 7:04 PM, Richard Damon wrote:
>>>>>>>> On 1/29/23 7:15 PM, olcott wrote:
>>>>>>>>> On 1/28/2023 9:44 PM, Richard Damon wrote:
>>>>>>>>>> On 1/28/23 6:29 PM, olcott wrote:
>>>>>>>>>>> On 1/27/2023 10:21 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/27/23 11:14 PM, olcott wrote:
>>>>>>>>>>>>> H does a correct simulation of the first seven lines of D
>>>>>>>>>>>>> and upon
>>>>>>>>>>>>> encountering the 8th line of D correctly determines that D
>>>>>>>>>>>>> would never
>>>>>>>>>>>>> stop running unless aborted.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, that is an INCORRECT conclusion, because the actual
>>>>>>>>>>>> behavior of that call to H by D(D) will be to abort ITS
>>>>>>>>>>>> simulation (which is a different instance, which is also an
>>>>>>>>>>>> incorrect action) and return 0.
>>>>>>>>>>>>
>>>>>>>>>>>> Thus H gets the wrong answer because it presumes that H will
>>>>>>>>>>>> not get the wrong answer when it does.
>>>>>>>>>>>>
>>>>>>>>>>>> Until you provide the instruction in that direct execution
>>>>>>>>>>>> of D(D) that differs from the execution of H(D,D) when
>>>>>>>>>>>> called by main, you are just admitting that you are a
>>>>>>>>>>>> Hypocritical Patholgical Lying Ignorant Idiot.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> In other words you are trying to get away with the
>>>>>>>>>>> counter-factual claim
>>>>>>>>>>> that D correctly simulated by H would eventually reach its
>>>>>>>>>>> own final
>>>>>>>>>>> state and terminate normally.
>>>>>>>>>>
>>>>>>>>>> D correctly siumulated will reach its own final state. This is
>>>>>>>>>> shown by UTM(D,D).
>>>>>>>>> You dishonestly changed the words. Why lie?
>>>>>>>>
>>>>>>>> No, YOU are o=one making the change,
>>>>>>>
>>>>>>> When D is CORRECTLY SIMULATED BY H
>>>>>>
>>>>>> Which doesn't happen if H answers,
>>>>>
>>>>> Correctly and completely is not the same as correctly.
>>>>
>>>> It is the only definition that lest you replace the behavior of the
>>>> actual machine with a simulation.
>>>>
>>>> Since D(D) Halts, H(D,D) must return 1
>>>>
>>>> If you claim 0- is the correct answer, you question must be
>>>> different and you have been lying all the time/.
>>>>
>>>>>
>>>>> It one instruction of D is correctly simulated then this one
>>>>> instruction
>>>>> <is> correctly simulated, likewise with more than one.
>>>>
>>>> H, being a computation, must do the same thing for every invocation
>>>> of it with the same parameter.
>>>
>>> None-the-less we can both see that in the exhaustive set of
>>> possibilities:
>>
>> None-the-less: Translate, Peter Olcott will avoid valid logic and make
>> an fabricated statement.
>>
>>> (a) H aborts the simulation of its input
>> (Which it does)
>>> (b) H does not abort the simulation of its input
>>> D never reaches its final state, thus D never halts.
>>
>> Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches its
>> final state.
>>
>
> You know that D correctly simulated by H cannot possibly reach the final
> state of D and lie about this because you think that lying is funny.

You are the one lying, and it is not funny.

On 1/29/2023 11:27 PM, Python wrote:
> Le 30/01/2023 à 06:11, olcott a écrit :
>> On 1/29/2023 8:48 PM, Richard Damon wrote:
>>> On 1/29/23 9:24 PM, olcott wrote:
>>>> On 1/29/2023 7:54 PM, Richard Damon wrote:
>>>>> On 1/29/23 8:43 PM, olcott wrote:
>>>>>> On 1/29/2023 7:39 PM, Richard Damon wrote:
>>>>>>> On 1/29/23 8:23 PM, olcott wrote:
>>>>>>>> On 1/29/2023 7:04 PM, Richard Damon wrote:
>>>>>>>>> On 1/29/23 7:15 PM, olcott wrote:
>>>>>>>>>> On 1/28/2023 9:44 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/28/23 6:29 PM, olcott wrote:
>>>>>>>>>>>> On 1/27/2023 10:21 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/27/23 11:14 PM, olcott wrote:
>>>>>>>>>>>>>> H does a correct simulation of the first seven lines of D
>>>>>>>>>>>>>> and upon
>>>>>>>>>>>>>> encountering the 8th line of D correctly determines that D
>>>>>>>>>>>>>> would never
>>>>>>>>>>>>>> stop running unless aborted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, that is an INCORRECT conclusion, because the actual
>>>>>>>>>>>>> behavior of that call to H by D(D) will be to abort ITS
>>>>>>>>>>>>> simulation (which is a different instance, which is also an
>>>>>>>>>>>>> incorrect action) and return 0.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus H gets the wrong answer because it presumes that H
>>>>>>>>>>>>> will not get the wrong answer when it does.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Until you provide the instruction in that direct execution
>>>>>>>>>>>>> of D(D) that differs from the execution of H(D,D) when
>>>>>>>>>>>>> called by main, you are just admitting that you are a
>>>>>>>>>>>>> Hypocritical Patholgical Lying Ignorant Idiot.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> In other words you are trying to get away with the
>>>>>>>>>>>> counter-factual claim
>>>>>>>>>>>> that D correctly simulated by H would eventually reach its
>>>>>>>>>>>> own final
>>>>>>>>>>>> state and terminate normally.
>>>>>>>>>>>
>>>>>>>>>>> D correctly siumulated will reach its own final state. This
>>>>>>>>>>> is shown by UTM(D,D).
>>>>>>>>>> You dishonestly changed the words. Why lie?
>>>>>>>>>
>>>>>>>>> No, YOU are o=one making the change,
>>>>>>>>
>>>>>>>> When D is CORRECTLY SIMULATED BY H
>>>>>>>
>>>>>>> Which doesn't happen if H answers,
>>>>>>
>>>>>> Correctly and completely is not the same as correctly.
>>>>>
>>>>> It is the only definition that lest you replace the behavior of the
>>>>> actual machine with a simulation.
>>>>>
>>>>> Since D(D) Halts, H(D,D) must return 1
>>>>>
>>>>> If you claim 0- is the correct answer, you question must be
>>>>> different and you have been lying all the time/.
>>>>>
>>>>>>
>>>>>> It one instruction of D is correctly simulated then this one
>>>>>> instruction
>>>>>> <is> correctly simulated, likewise with more than one.
>>>>>
>>>>> H, being a computation, must do the same thing for every invocation
>>>>> of it with the same parameter.
>>>>
>>>> None-the-less we can both see that in the exhaustive set of
>>>> possibilities:
>>>
>>> None-the-less: Translate, Peter Olcott will avoid valid logic and
>>> make an fabricated statement.
>>>
>>>> (a) H aborts the simulation of its input
>>> (Which it does)
>>>> (b) H does not abort the simulation of its input
>>>> D never reaches its final state, thus D never halts.
>>>
>>> Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
>>> its final state.
>>>
>>
>> You know that D correctly simulated by H cannot possibly reach the final
>> state of D and lie about this because you think that lying is funny.
>
> You are the one lying, and it is not funny.

Anyone that knows these things knows that I am correct.
You cannot point out any mistake because there are none.

--
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/30/23 12:11 AM, olcott wrote:
> On 1/29/2023 8:48 PM, Richard Damon wrote:

>> Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches its
>> final state.
>>
>
> You know that D correctly simulated by H cannot possibly reach the final
> state of D and lie about this because you think that lying is funny.
>

Sincd H doesn't correctlyh simu.ate D(D), that sentence is like "Have
you stopped beating your wife?"

H is a DEFINIED function, you H ALWAYS aborts this D when it simulates,
so it NEVER does a complete and correct simulation of the input.

Also, you are asking the wrong queztion, it isn't if the simulation done
by H can reach the final state, but does D(D) when run reach its final
state.

The fact that H aborts its simulation says the question of did its
simulation reach the final state is just moot. That is like claimin you
can measure how long a road is by driving the first mile and then
getting off.

You are showing that you fundamentally don't understand ANY of the logic
theory, or how computers work, either you are totally ignorant, or you
are just a pathological liar (because you know the right answer but
won't accept it) or both.

Since you have AGREED that D(D) when dirrectly run will return, then the
correct answer to the question of the Halting Program for D(D), "Will
this input when directly run Halt?" is yes.

The fact that you try to claim that No could be a correct answer just
shows how much you don't care about what it true.

You are just a pitiful hypociritcal pathological lying ignorant idiot
that has doomed himself for all eternity to be remembered for the dolt
he his.

On 1/30/23 12:43 AM, olcott wrote:
> On 1/29/2023 11:27 PM, Python wrote:
>> Le 30/01/2023 à 06:11, olcott a écrit :
>>> On 1/29/2023 8:48 PM, Richard Damon wrote:
>>>> On 1/29/23 9:24 PM, olcott wrote:
>>>>> D never reaches its final state, thus D never halts.
>>>>
>>>> Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
>>>> its final state.
>>>>
>>>
>>> You know that D correctly simulated by H cannot possibly reach the final
>>> state of D and lie about this because you think that lying is funny.
>>
>> You are the one lying, and it is not funny.
>
> Anyone that knows these things knows that I am correct.
> You cannot point out any mistake because there are none.
>

No, EVERYONE who knows even the littlest bit of the theory knows you are
just wrong.

On 1/30/23 12:08 AM, olcott wrote:
> On 1/29/2023 8:52 PM, Richard Damon wrote:
>> On 1/29/23 9:27 PM, olcott wrote:
>>> On 1/29/2023 8:06 PM, Richard Damon wrote:
>>>> On 1/29/23 8:48 PM, olcott wrote:
>>>>> On 1/29/2023 7:41 PM, Richard Damon wrote:
>>>>>> On 1/29/23 8:28 PM, olcott wrote:
>>>>>>> On 1/29/2023 7:10 PM, Richard Damon wrote:
>>>>>>>> On 1/29/23 7:28 PM, olcott wrote:
>>>>>>>>> On 1/28/2023 9:47 PM, Richard Damon wrote:
>>>>>>>>>> On 1/28/23 4:29 PM, olcott wrote:
>>>>>>>>>>> On 1/28/2023 3:13 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/28/23 3:59 PM, olcott wrote:
>>>>>>>>>>>>> On 1/28/2023 2:42 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, you can build SOME Deciders from a Sumation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Not All Deciders can be built from a Sumation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> One TM is *ALL* deciders.
>>>>>>>>>>>>
>>>>>>>>>>>> Really?
>>>>>>>>>>>>
>>>>>>>>>>>> It can be both a is_prime and is_perfect decider?
>>>>>>>>>>>>
>>>>>>>>>>>> Maybe your problem is you don't understand at all what a
>>>>>>>>>>>> decider is?
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>> You just don't understand the basics of category theory,
>>>>>>>>>>>>>> and just fall into the fallacy of Proof by Example.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Just because one subset of a set happens to have a
>>>>>>>>>>>>>> property doesn't mean that property applies to the whole
>>>>>>>>>>>>>> class.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Try and provide a single counter-example where IS_SUM gets
>>>>>>>>>>>>> the wrong answer.
>>>>>>>>>>>>
>>>>>>>>>>>> If the question is Is the number prime?
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> If there are no counter-examples that prove that IS_SUM
>>>>>>>>>>>>> gets the wrong
>>>>>>>>>>>>> answer then this logically entails that IS_SUM always gets
>>>>>>>>>>>>> the correct
>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But only to the one question it was built for.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Likewise for DOES_HALT, there are zero countability issues with
>>>>>>>>>>> DOES_HALT. DOES_HALT merely needs to compute the mapping from
>>>>>>>>>>> any
>>>>>>>>>>> arbitrary input pair of finite strings to its accept or
>>>>>>>>>>> reject state.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Can you PROVE that this is doable?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> We can change IS_SUM to allow any arbitrary finite set of
>>>>>>>>> finite string
>>>>>>>>> inputs. If any of these finite strings contains a character
>>>>>>>>> that is not
>>>>>>>>> an ASCII digit then IS_SUM rejects, otherwise IS_SUM is as it was
>>>>>>>>> previously specified.
>>>>>>>>
>>>>>>>> Ok, how do you use IS_SUM to answer the IS_PRIME question?
>>>>>>>>
>>>>>>>
>>>>>>> IS_PRIME would have a single finite string of ASCII digits as its
>>>>>>> only input and you already know this is computable.
>>>>>>>
>>>>>>>> IS_SUM takes the countably infinite number of inputs
>>>>>>>
>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>
>>>>>> And computes ONE mapping, out of the uncountable infinte many
>>>>>> mappings of strings -> the set of answers for each input.
>>>>> IS_SUM need not ever count any uncountable set. All that IS_SUM
>>>>> must do is compute each mapping that it is presented with, one
>>>>> finite set of finite strings at a time.
>>>>>
>>>>
>>>>
>>>> So????
>>>>
>>>>
>>>> We aren't talking about IS_SUM being non-computable,
>>>
>>> Then the "you" of "we" is off topic. Countability was supposed to be
>>> an alternate proof that halting is undecidable.
>>>
>> Right, countablility of mappings.
>>
>> The computability of a single mapping show nothing about the
>> countability arguement.
>>
>> No one says that NO mappings are computable, just that most are not.
>>
>
> No one can show even one mapping of a finite set of string inputs to
> IS_SUM that is not computable, thus the conclusion that there are more
> than one counter-example is totally refuted.

????

You seem to think that is_sum computes multiple mappings.

*A* mapping, as being talked about here, is a complete listing of the
required output for every possible input.

IS_SUM computes *ONE* mapping of input to output.

Yes, it can computer the

>
>> You clearly don't understand categorical logic.
>>
>
> Categorically exhaustive reasoning is my key innovation it utterly
> eliminates the error of omission.

No, it is your key fallicy. You seem to think that a detail analysis of
one case tells you all you need about every case that you don't look at.

That is just

>
> If it is impossible to show as many as a single counter-example then we
> can correctly generalize this to say that more than one counter example
> also does not exist.

No, you are just using the fallacy of the Red Herring, because you
demand a counter-example of something that isn't the problem.

How does your "IS_SUM" machine answer both the question of "is 8 the sum
of two primes?" and "is 8 a perfect number?" (assuming the first is what
you are defininig IS_SUM to be, not sure what else you mean, sometime it
seems like IS_SUM is computing the sum of two numbers give to is, which
isn't an "IS" question.

Note, these two question both take the SAME input (8), but have
different outputs,

For IS_SUM_OF_PRIMES, the answer is yes, because 8 = 3 + 5

For IS_PERFECT, the answer is no, because 8 has factors to 1, 2, 4 which
only total to 7, not 8.

You claim same machine, in is the same, output will be the same, thus
must give the wrong answer to one of them.
>
>
>> Again, your use of the fallacy of proof by example.
>

On 1/30/2023 6:10 AM, Richard Damon wrote:
> On 1/30/23 12:08 AM, olcott wrote:
>> On 1/29/2023 8:52 PM, Richard Damon wrote:
>>> On 1/29/23 9:27 PM, olcott wrote:
>>>> On 1/29/2023 8:06 PM, Richard Damon wrote:
>>>>> On 1/29/23 8:48 PM, olcott wrote:
>>>>>> On 1/29/2023 7:41 PM, Richard Damon wrote:
>>>>>>> On 1/29/23 8:28 PM, olcott wrote:
>>>>>>>> On 1/29/2023 7:10 PM, Richard Damon wrote:
>>>>>>>>> On 1/29/23 7:28 PM, olcott wrote:
>>>>>>>>>> On 1/28/2023 9:47 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/28/23 4:29 PM, olcott wrote:
>>>>>>>>>>>> On 1/28/2023 3:13 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/28/23 3:59 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/28/2023 2:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, you can build SOME Deciders from a Sumation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Not All Deciders can be built from a Sumation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> One TM is *ALL* deciders.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Really?
>>>>>>>>>>>>>
>>>>>>>>>>>>> It can be both a is_prime and is_perfect decider?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Maybe your problem is you don't understand at all what a
>>>>>>>>>>>>> decider is?
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You just don't understand the basics of category theory,
>>>>>>>>>>>>>>> and just fall into the fallacy of Proof by Example.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Just because one subset of a set happens to have a
>>>>>>>>>>>>>>> property doesn't mean that property applies to the whole
>>>>>>>>>>>>>>> class.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Try and provide a single counter-example where IS_SUM gets
>>>>>>>>>>>>>> the wrong answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If the question is Is the number prime?
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If there are no counter-examples that prove that IS_SUM
>>>>>>>>>>>>>> gets the wrong
>>>>>>>>>>>>>> answer then this logically entails that IS_SUM always gets
>>>>>>>>>>>>>> the correct
>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But only to the one question it was built for.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Likewise for DOES_HALT, there are zero countability issues with
>>>>>>>>>>>> DOES_HALT. DOES_HALT merely needs to compute the mapping
>>>>>>>>>>>> from any
>>>>>>>>>>>> arbitrary input pair of finite strings to its accept or
>>>>>>>>>>>> reject state.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Can you PROVE that this is doable?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> We can change IS_SUM to allow any arbitrary finite set of
>>>>>>>>>> finite string
>>>>>>>>>> inputs. If any of these finite strings contains a character
>>>>>>>>>> that is not
>>>>>>>>>> an ASCII digit then IS_SUM rejects, otherwise IS_SUM is as it was
>>>>>>>>>> previously specified.
>>>>>>>>>
>>>>>>>>> Ok, how do you use IS_SUM to answer the IS_PRIME question?
>>>>>>>>>
>>>>>>>>
>>>>>>>> IS_PRIME would have a single finite string of ASCII digits as
>>>>>>>> its only input and you already know this is computable.
>>>>>>>>
>>>>>>>>> IS_SUM takes the countably infinite number of inputs
>>>>>>>>
>>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>>
>>>>>>> And computes ONE mapping, out of the uncountable infinte many
>>>>>>> mappings of strings -> the set of answers for each input.
>>>>>> IS_SUM need not ever count any uncountable set. All that IS_SUM
>>>>>> must do is compute each mapping that it is presented with, one
>>>>>> finite set of finite strings at a time.
>>>>>>
>>>>>
>>>>>
>>>>> So????
>>>>>
>>>>>
>>>>> We aren't talking about IS_SUM being non-computable,
>>>>
>>>> Then the "you" of "we" is off topic. Countability was supposed to be
>>>> an alternate proof that halting is undecidable.
>>>>
>>> Right, countablility of mappings.
>>>
>>> The computability of a single mapping show nothing about the
>>> countability arguement.
>>>
>>> No one says that NO mappings are computable, just that most are not.
>>>
>>
>> No one can show even one mapping of a finite set of string inputs to
>> IS_SUM that is not computable, thus the conclusion that there are more
>> than one counter-example is totally refuted.
>
> ????
>
> You seem to think that is_sum computes multiple mappings.
>
> *A* mapping, as being talked about here, is a complete listing of the
> required output for every possible input.
>
> IS_SUM computes *ONE* mapping of input to output.
>
> Yes, it can computer the
>
>>
>>> You clearly don't understand categorical logic.
>>>
>>
>> Categorically exhaustive reasoning is my key innovation it utterly
>> eliminates the error of omission.
>
> No, it is your key fallicy. You seem to think that a detail analysis of
> one case tells you all you need about every case that you don't look at.
>
> That is just
>
>
>>
>> If it is impossible to show as many as a single counter-example then we
>> can correctly generalize this to say that more than one counter example
>> also does not exist.
>
> No, you are just using the fallacy of the Red Herring, because you
> demand a counter-example of something that isn't the problem.
>

If no counter example can be provided that a decision problem is
undecidable then this proves that it is decidable.

> How does your "IS_SUM" machine answer both the question of "is 8 the sum
> of two primes?" and "is 8 a perfect number?" (assuming the first is what
> you are defininig IS_SUM to be, not sure what else you mean, sometime it
> seems like IS_SUM is computing the sum of two numbers give to is, which
> isn't an "IS" question.
>

On 1/30/2023 5:57 AM, Richard Damon wrote:
> On 1/30/23 12:11 AM, olcott wrote:
>> On 1/29/2023 8:48 PM, Richard Damon wrote:
>
>>> Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
>>> its final state.
>>>
>>
>> You know that D correctly simulated by H cannot possibly reach the final
>> state of D and lie about this because you think that lying is funny.
>>
>
> Sincd H doesn't correctlyh simu.ate D(D), that sentence is like "Have
> you stopped beating your wife?"
>

Because HH does faithfully simulate the first 8 instructions of PP we
know that the simulation of these first 8 instructions is correct.

Begin Local Halt Decider Simulation Executio Trace Stored at:112aa9
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001993][00112a95][00112a99] 55 push ebp // begin PP
[00001994][00112a95][00112a99] 8bec mov ebp,esp
[00001996][00112a91][00102a65] 51 push ecx
[00001997][00112a91][00102a65] 8b4508 mov eax,[ebp+08]
[0000199a][00112a8d][00001993] 50 push eax // push PP
[0000199b][00112a8d][00001993] 8b4d08 mov ecx,[ebp+08]
[0000199e][00112a89][00001993] 51 push ecx // push PP
[0000199f][00112a85][000019a4] e8fff7ffff call 000011a3 // call HH
New slave_stack at:14d4c9
[00001993][0015d4bd][0015d4c1] 55 push ebp // begin PP
[00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
[00001996][0015d4b9][0014d48d] 51 push ecx
[00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
[0000199a][0015d4b5][00001993] 50 push eax // push PP
[0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08]
[0000199e][0015d4b1][00001993] 51 push ecx // push PP
[0000199f][0015d4ad][000019a4] e8fff7ffff call 000011a3 // call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Everyone can see that this does cause the same 8 instructions of PP to
be repeated and everyone can see that there are no instructions in PP
that would prevent this from infinitely repeating.

That you lie about this is despicable.

--
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/30/2023 5:58 AM, Richard Damon wrote:
> On 1/30/23 12:43 AM, olcott wrote:
>> On 1/29/2023 11:27 PM, Python wrote:
>>> Le 30/01/2023 à 06:11, olcott a écrit :
>>>> On 1/29/2023 8:48 PM, Richard Damon wrote:
>>>>> On 1/29/23 9:24 PM, olcott wrote:
>>>>>> D never reaches its final state, thus D never halts.
>>>>>
>>>>> Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
>>>>> its final state.
>>>>>
>>>>
>>>> You know that D correctly simulated by H cannot possibly reach the
>>>> final
>>>> state of D and lie about this because you think that lying is funny.
>>>
>>> You are the one lying, and it is not funny.
>>
>> Anyone that knows these things knows that I am correct.
>> You cannot point out any mistake because there are none.
>>
>
> No, EVERYONE who knows even the littlest bit of the theory knows you are
> just wrong.

Everyone that knows a little bit about theory presumes that I am wrong
either without looking at what I say or by looking at what I say and
ignoring it. ChatGPT determined that my argument is valid.

olcott
This first sentence is an established fact: When H(D,D) correctly
simulates its input the execution trace of this simulated input proves
that it would never stop running because D continues to call H in
recursive simulation. Then H aborts its simulation of D and returns 0 to
main, indicating that D would never stop running unless aborted. Is H
correct?

ChatGPT correctly determined that my second sentence follows from my
first sentence by logical necessity. You were unable to comprehend this
elementary rule of logical deduction.

Begin Local Halt Decider Simulation Execution Trace Stored at:112aa9
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001993][00112a95][00112a99] 55 push ebp // begin PP
[00001994][00112a95][00112a99] 8bec mov ebp,esp
[00001996][00112a91][00102a65] 51 push ecx
[00001997][00112a91][00102a65] 8b4508 mov eax,[ebp+08]
[0000199a][00112a8d][00001993] 50 push eax // push PP
[0000199b][00112a8d][00001993] 8b4d08 mov ecx,[ebp+08]
[0000199e][00112a89][00001993] 51 push ecx // push PP
[0000199f][00112a85][000019a4] e8fff7ffff call 000011a3 // call HH
New slave_stack at:14d4c9
[00001993][0015d4bd][0015d4c1] 55 push ebp // begin PP
[00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
[00001996][0015d4b9][0014d48d] 51 push ecx
[00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
[0000199a][0015d4b5][00001993] 50 push eax // push PP
[0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08]
[0000199e][0015d4b1][00001993] 51 push ecx // push PP
[0000199f][0015d4ad][000019a4] e8fff7ffff call 000011a3 // call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Analysis of the above conclusively proves that HH did correctly simulate
PP until HH correctly determined that PP could not possibly reach its
own final state and terminate normally.

--
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/30/23 10:21 AM, olcott wrote:
> On 1/30/2023 6:10 AM, Richard Damon wrote:
>> On 1/30/23 12:08 AM, olcott wrote:
>>> On 1/29/2023 8:52 PM, Richard Damon wrote:
>>>> On 1/29/23 9:27 PM, olcott wrote:
>>>>> On 1/29/2023 8:06 PM, Richard Damon wrote:
>>>>>> On 1/29/23 8:48 PM, olcott wrote:
>>>>>>> On 1/29/2023 7:41 PM, Richard Damon wrote:
>>>>>>>> On 1/29/23 8:28 PM, olcott wrote:
>>>>>>>>> On 1/29/2023 7:10 PM, Richard Damon wrote:
>>>>>>>>>> On 1/29/23 7:28 PM, olcott wrote:
>>>>>>>>>>> On 1/28/2023 9:47 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/28/23 4:29 PM, olcott wrote:
>>>>>>>>>>>>> On 1/28/2023 3:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/28/23 3:59 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/28/2023 2:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes, you can build SOME Deciders from a Sumation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Not All Deciders can be built from a Sumation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> One TM is *ALL* deciders.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Really?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It can be both a is_prime and is_perfect decider?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Maybe your problem is you don't understand at all what a
>>>>>>>>>>>>>> decider is?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You just don't understand the basics of category theory,
>>>>>>>>>>>>>>>> and just fall into the fallacy of Proof by Example.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Just because one subset of a set happens to have a
>>>>>>>>>>>>>>>> property doesn't mean that property applies to the whole
>>>>>>>>>>>>>>>> class.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Try and provide a single counter-example where IS_SUM
>>>>>>>>>>>>>>> gets the wrong answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If the question is Is the number prime?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If there are no counter-examples that prove that IS_SUM
>>>>>>>>>>>>>>> gets the wrong
>>>>>>>>>>>>>>> answer then this logically entails that IS_SUM always
>>>>>>>>>>>>>>> gets the correct
>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But only to the one question it was built for.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Likewise for DOES_HALT, there are zero countability issues
>>>>>>>>>>>>> with
>>>>>>>>>>>>> DOES_HALT. DOES_HALT merely needs to compute the mapping
>>>>>>>>>>>>> from any
>>>>>>>>>>>>> arbitrary input pair of finite strings to its accept or
>>>>>>>>>>>>> reject state.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Can you PROVE that this is doable?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> We can change IS_SUM to allow any arbitrary finite set of
>>>>>>>>>>> finite string
>>>>>>>>>>> inputs. If any of these finite strings contains a character
>>>>>>>>>>> that is not
>>>>>>>>>>> an ASCII digit then IS_SUM rejects, otherwise IS_SUM is as it
>>>>>>>>>>> was
>>>>>>>>>>> previously specified.
>>>>>>>>>>
>>>>>>>>>> Ok, how do you use IS_SUM to answer the IS_PRIME question?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> IS_PRIME would have a single finite string of ASCII digits as
>>>>>>>>> its only input and you already know this is computable.
>>>>>>>>>
>>>>>>>>>> IS_SUM takes the countably infinite number of inputs
>>>>>>>>>
>>>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>>>> IS_SUM takes a finite set of finite string inputs
>>>>>>>>
>>>>>>>> And computes ONE mapping, out of the uncountable infinte many
>>>>>>>> mappings of strings -> the set of answers for each input.
>>>>>>> IS_SUM need not ever count any uncountable set. All that IS_SUM
>>>>>>> must do is compute each mapping that it is presented with, one
>>>>>>> finite set of finite strings at a time.
>>>>>>>
>>>>>>
>>>>>>
>>>>>> So????
>>>>>>
>>>>>>
>>>>>> We aren't talking about IS_SUM being non-computable,
>>>>>
>>>>> Then the "you" of "we" is off topic. Countability was supposed to
>>>>> be an alternate proof that halting is undecidable.
>>>>>
>>>> Right, countablility of mappings.
>>>>
>>>> The computability of a single mapping show nothing about the
>>>> countability arguement.
>>>>
>>>> No one says that NO mappings are computable, just that most are not.
>>>>
>>>
>>> No one can show even one mapping of a finite set of string inputs to
>>> IS_SUM that is not computable, thus the conclusion that there are more
>>> than one counter-example is totally refuted.
>>
>> ????
>>
>> You seem to think that is_sum computes multiple mappings.
>>
>> *A* mapping, as being talked about here, is a complete listing of the
>> required output for every possible input.
>>
>> IS_SUM computes *ONE* mapping of input to output.
>>
>> Yes, it can computer the
>>
>>>
>>>> You clearly don't understand categorical logic.
>>>>
>>>
>>> Categorically exhaustive reasoning is my key innovation it utterly
>>> eliminates the error of omission.
>>
>> No, it is your key fallicy. You seem to think that a detail analysis
>> of one case tells you all you need about every case that you don't
>> look at.
>>
>> That is just
>>
>>
>>>
>>> If it is impossible to show as many as a single counter-example then we
>>> can correctly generalize this to say that more than one counter example
>>> also does not exist.
>>
>> No, you are just using the fallacy of the Red Herring, because you
>> demand a counter-example of something that isn't the problem.
>>
>
> If no counter example can be provided that a decision problem is
> undecidable then this proves that it is decidable.

On 1/30/23 10:31 AM, olcott wrote:
> On 1/30/2023 5:57 AM, Richard Damon wrote:
>> On 1/30/23 12:11 AM, olcott wrote:
>>> On 1/29/2023 8:48 PM, Richard Damon wrote:
>>
>>>> Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
>>>> its final state.
>>>>
>>>
>>> You know that D correctly simulated by H cannot possibly reach the final
>>> state of D and lie about this because you think that lying is funny.
>>>
>>
>> Sincd H doesn't correctlyh simu.ate D(D), that sentence is like "Have
>> you stopped beating your wife?"
>>
>
> Because HH does faithfully simulate the first 8 instructions of PP we
> know that the simulation of these first 8 instructions is correct.
>

SS, the first mile of a road doesn't tell you how long it is.

Also, it is debatable if the 8th instruction was simulated correctly, as
the "machine" state after it doesn't match what actually haooens (the
continued execution of the function HH)

> Begin Local Halt Decider Simulation   Executio Trace Stored at:112aa9
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [00001993][00112a95][00112a99] 55             push ebp      // begin PP
> [00001994][00112a95][00112a99] 8bec           mov ebp,esp
> [00001996][00112a91][00102a65] 51             push ecx
> [00001997][00112a91][00102a65] 8b4508         mov eax,[ebp+08]
> [0000199a][00112a8d][00001993] 50             push eax      // push PP
> [0000199b][00112a8d][00001993] 8b4d08         mov ecx,[ebp+08]
> [0000199e][00112a89][00001993] 51             push ecx      // push PP
> [0000199f][00112a85][000019a4] e8fff7ffff     call 000011a3 // call HH
> New slave_stack at:14d4c9
> [00001993][0015d4bd][0015d4c1] 55             push ebp      // begin PP
> [00001994][0015d4bd][0015d4c1] 8bec           mov ebp,esp
> [00001996][0015d4b9][0014d48d] 51             push ecx
> [00001997][0015d4b9][0014d48d] 8b4508         mov eax,[ebp+08]
> [0000199a][0015d4b5][00001993] 50             push eax      // push PP
> [0000199b][0015d4b5][00001993] 8b4d08         mov ecx,[ebp+08]
> [0000199e][0015d4b1][00001993] 51             push ecx      // push PP
> [0000199f][0015d4ad][000019a4] e8fff7ffff     call 000011a3 // call HH
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> Everyone can see that this does cause the same 8 instructions of PP to
> be repeated and everyone can see that there are no instructions in PP
> that would prevent this from infinitely repeating.
>

But after the call HH should be the instruciton of HH, so the simulation
is incorrect.

> That you lie about this is despicable.
>
>

YOU are the liar

On 1/30/23 10:42 AM, olcott wrote:
> On 1/30/2023 5:58 AM, Richard Damon wrote:
>> On 1/30/23 12:43 AM, olcott wrote:
>>> On 1/29/2023 11:27 PM, Python wrote:
>>>> Le 30/01/2023 à 06:11, olcott a écrit :
>>>>> On 1/29/2023 8:48 PM, Richard Damon wrote:
>>>>>> On 1/29/23 9:24 PM, olcott wrote:
>>>>>>> D never reaches its final state, thus D never halts.
>>>>>>
>>>>>> Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
>>>>>> its final state.
>>>>>>
>>>>>
>>>>> You know that D correctly simulated by H cannot possibly reach the
>>>>> final
>>>>> state of D and lie about this because you think that lying is funny.
>>>>
>>>> You are the one lying, and it is not funny.
>>>
>>> Anyone that knows these things knows that I am correct.
>>> You cannot point out any mistake because there are none.
>>>
>>
>> No, EVERYONE who knows even the littlest bit of the theory knows you
>> are just wrong.
>
> Everyone that knows a little bit about theory presumes that I am wrong
> either without looking at what I say or by looking at what I say and
> ignoring it. ChatGPT determined that my argument is valid.

Well, since you have shown that you know NOTHING about theory, they are
in a better place than you.
ChatGPT can't "prove" your statements as it isn't actually a Theorem prover.

It is just a Natural Language AI that repeats back "reasonable" sounding
statements based on what it

>
> olcott
> This first sentence is an established fact: When H(D,D) correctly
> simulates its input the execution trace of this simulated input proves
> that it would never stop running because D continues to call H in
> recursive simulation. Then H aborts its simulation of D and returns 0 to
> main, indicating that D would never stop running unless aborted. Is H
> correct?
>
> ChatGPT correctly determined that my second sentence follows from my
> first sentence by logical necessity. You were unable to comprehend this
> elementary rule of logical deduction.

No, it is just agreeing with you without thinking.
>
> Begin Local Halt Decider Simulation   Execution Trace Stored at:112aa9
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [00001993][00112a95][00112a99] 55             push ebp      // begin PP
> [00001994][00112a95][00112a99] 8bec           mov ebp,esp
> [00001996][00112a91][00102a65] 51             push ecx
> [00001997][00112a91][00102a65] 8b4508         mov eax,[ebp+08]
> [0000199a][00112a8d][00001993] 50             push eax      // push PP
> [0000199b][00112a8d][00001993] 8b4d08         mov ecx,[ebp+08]
> [0000199e][00112a89][00001993] 51             push ecx      // push PP
> [0000199f][00112a85][000019a4] e8fff7ffff     call 000011a3 // call HH
> New slave_stack at:14d4c9
> [00001993][0015d4bd][0015d4c1] 55             push ebp      // begin PP
> [00001994][0015d4bd][0015d4c1] 8bec           mov ebp,esp
> [00001996][0015d4b9][0014d48d] 51             push ecx
> [00001997][0015d4b9][0014d48d] 8b4508         mov eax,[ebp+08]
> [0000199a][0015d4b5][00001993] 50             push eax      // push PP
> [0000199b][0015d4b5][00001993] 8b4d08         mov ecx,[ebp+08]
> [0000199e][0015d4b1][00001993] 51             push ecx      // push PP
> [0000199f][0015d4ad][000019a4] e8fff7ffff     call 000011a3 // call HH
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> Analysis of the above conclusively proves that HH did correctly simulate
> PP until HH correctly determined that PP could not possibly reach its
> own final state and terminate normally.
>

Nope, I have explaine the problems with your logic.

I have come to the realizeation that maybe the issue is that you got out
of your kiddie porn arrest by being mentally incompetent to stand trial,
and you can't show mental accuity or you could be put on trial and
convicted.

On 1/30/2023 5:43 PM, Richard Damon wrote:
> On 1/30/23 10:31 AM, olcott wrote:
>> On 1/30/2023 5:57 AM, Richard Damon wrote:
>>> On 1/30/23 12:11 AM, olcott wrote:
>>>> On 1/29/2023 8:48 PM, Richard Damon wrote:
>>>
>>>>> Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
>>>>> its final state.
>>>>>
>>>>
>>>> You know that D correctly simulated by H cannot possibly reach the
>>>> final
>>>> state of D and lie about this because you think that lying is funny.
>>>>
>>>
>>> Sincd H doesn't correctlyh simu.ate D(D), that sentence is like "Have
>>> you stopped beating your wife?"
>>>
>>
>> Because HH does faithfully simulate the first 8 instructions of PP we
>> know that the simulation of these first 8 instructions is correct.
>>
>
> SS, the first mile of a road doesn't tell you how long it is.
>
> Also, it is debatable if the 8th instruction was simulated correctly, as
> the "machine" state after it doesn't match what actually haooens (the
> continued execution of the function HH)
>
>> Begin Local Halt Decider Simulation   Executio Trace Stored at:112aa9
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [00001993][00112a95][00112a99] 55             push ebp      // begin PP
>> [00001994][00112a95][00112a99] 8bec           mov ebp,esp
>> [00001996][00112a91][00102a65] 51             push ecx
>> [00001997][00112a91][00102a65] 8b4508         mov eax,[ebp+08]
>> [0000199a][00112a8d][00001993] 50             push eax      // push PP
>> [0000199b][00112a8d][00001993] 8b4d08         mov ecx,[ebp+08]
>> [0000199e][00112a89][00001993] 51             push ecx      // push PP
>> [0000199f][00112a85][000019a4] e8fff7ffff     call 000011a3 // call HH
>> New slave_stack at:14d4c9
>> [00001993][0015d4bd][0015d4c1] 55             push ebp      // begin PP
>> [00001994][0015d4bd][0015d4c1] 8bec           mov ebp,esp
>> [00001996][0015d4b9][0014d48d] 51             push ecx
>> [00001997][0015d4b9][0014d48d] 8b4508         mov eax,[ebp+08]
>> [0000199a][0015d4b5][00001993] 50             push eax      // push PP
>> [0000199b][0015d4b5][00001993] 8b4d08         mov ecx,[ebp+08]
>> [0000199e][0015d4b1][00001993] 51             push ecx      // push PP
>> [0000199f][0015d4ad][000019a4] e8fff7ffff     call 000011a3 // call HH
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> Everyone can see that this does cause the same 8 instructions of PP to
>> be repeated and everyone can see that there are no instructions in PP
>> that would prevent this from infinitely repeating.
>>
>
> But after the call HH should be the instruciton of HH, so the simulation
> is incorrect.
>

It is not that the execution trace is incorrect I simply do not show
the other 251 pages of execution trace. HH knows its own behavior so it
does not look at its simulated self. It still does simulate itself that
is why it takes 251 more pages.

--
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/30/23 11:07 PM, olcott wrote:
> On 1/30/2023 5:43 PM, Richard Damon wrote:
>> On 1/30/23 10:31 AM, olcott wrote:
>>> On 1/30/2023 5:57 AM, Richard Damon wrote:
>>>> On 1/30/23 12:11 AM, olcott wrote:
>>>>> On 1/29/2023 8:48 PM, Richard Damon wrote:
>>>>
>>>>>> Wrong, if H aborts its simulation, then the ACTUAL MACHINE reaches
>>>>>> its final state.
>>>>>>
>>>>>
>>>>> You know that D correctly simulated by H cannot possibly reach the
>>>>> final
>>>>> state of D and lie about this because you think that lying is funny.
>>>>>
>>>>
>>>> Sincd H doesn't correctlyh simu.ate D(D), that sentence is like
>>>> "Have you stopped beating your wife?"
>>>>
>>>
>>> Because HH does faithfully simulate the first 8 instructions of PP we
>>> know that the simulation of these first 8 instructions is correct.
>>>
>>
>> SS, the first mile of a road doesn't tell you how long it is.
>>
>> Also, it is debatable if the 8th instruction was simulated correctly,
>> as the "machine" state after it doesn't match what actually haooens
>> (the continued execution of the function HH)
>>
>>> Begin Local Halt Decider Simulation   Executio Trace Stored at:112aa9
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ========  ========  ========  =========  =============
>>> [00001993][00112a95][00112a99] 55             push ebp      // begin PP
>>> [00001994][00112a95][00112a99] 8bec           mov ebp,esp
>>> [00001996][00112a91][00102a65] 51             push ecx
>>> [00001997][00112a91][00102a65] 8b4508         mov eax,[ebp+08]
>>> [0000199a][00112a8d][00001993] 50             push eax      // push PP
>>> [0000199b][00112a8d][00001993] 8b4d08         mov ecx,[ebp+08]
>>> [0000199e][00112a89][00001993] 51             push ecx      // push PP
>>> [0000199f][00112a85][000019a4] e8fff7ffff     call 000011a3 // call HH
>>> New slave_stack at:14d4c9
>>> [00001993][0015d4bd][0015d4c1] 55             push ebp      // begin PP
>>> [00001994][0015d4bd][0015d4c1] 8bec           mov ebp,esp
>>> [00001996][0015d4b9][0014d48d] 51             push ecx
>>> [00001997][0015d4b9][0014d48d] 8b4508         mov eax,[ebp+08]
>>> [0000199a][0015d4b5][00001993] 50             push eax      // push PP
>>> [0000199b][0015d4b5][00001993] 8b4d08         mov ecx,[ebp+08]
>>> [0000199e][0015d4b1][00001993] 51             push ecx      // push PP
>>> [0000199f][0015d4ad][000019a4] e8fff7ffff     call 000011a3 // call HH
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>
>>> Everyone can see that this does cause the same 8 instructions of PP to
>>> be repeated and everyone can see that there are no instructions in PP
>>> that would prevent this from infinitely repeating.
>>>
>>
>> But after the call HH should be the instruciton of HH, so the
>> simulation is incorrect.
>>
>
> It is not that the execution trace is incorrect I simply do not show
> the other 251 pages of execution trace. HH knows its own behavior so it
> does not look at its simulated self. It still does simulate itself that
> is why it takes 251 more pages.
>

But the actual execution trace never gets into another copy of D, as all
that happens is that H simulates those instruction, they never actually
get executed as an "program"

Even if done via a Step with Debug exception, then every instruction is
seperated by the code of the tracing.

Thus, it is INCORRECT.

You apparently don't understand the difference between a direct
execution and a simulation.