On 1/26/2023 5:37 PM, Richard Damon wrote:
> On 1/26/23 10:43 AM, olcott wrote:
>> On 1/26/2023 6:22 AM, Ben Bacarisse wrote:
>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>
>>>> On 1/25/23 10:54 PM, Ben Bacarisse wrote:
>>>>> Python <python@invalid.org> writes:
>>>>>
>>>>>> Le 26/01/2023 à 01:33, Richard Damon a écrit :
>>>>>>> One simple comment that comes to mind that points out the error
>>>>>>> in your
>>>>>>> thinking:
>>>>>>> The number of possible computing machines is a countable infinite,
>>>>>>> because we can express every such machine as a finite string of a
>>>>>>> finite symbol set.
>>>>>>> The number of possible deciders that can be defined is an
>>>>>>> UNCOUNTABLE
>>>>>>> infinite.
>>>>> Ooh, I would not say that.  For any reasonable meaning of "can be
>>>>> defined" the set is countable, isn't it?
>>>>
>>>> Right, I meant FUNCTIONS is an uncountable set.
>>>
>>> Yes, it can also be framed in terms of functions.  For any countably
>>> infinite set X, the set X->{0,1} is uncountable, so most of those
>>> functions are not TM computable.
>>>
>>
>> The sum of every element of the set of all finite subsets of finite
>> strings of of ASCII digits can be computed because we can define a TM
>> that takes an arbitrary number of space delimited finite strings.
>
> Red herring as we are not talking about functions that are just a "sum".
>
>>
>> Infinite input to a TM is uncomputable because the TM would never halt,
>> thus the set of subsets of finite strings of ASCII digits must exclude
>> infinite subsets.
>
> We are not talking about any subset that has an infinte number of
> members, but the number of finite subsets of the Natural Numbers.
>
> The count of this is an uncountable infinity, an order of infinity
> bigger than the count of the Natural Numbers.
>

The set of all finite subsets of the natural numbers is countable
https://en.wikipedia.org/wiki/Countable_set

https://proofwiki.org/wiki/Set_of_Finite_Subsets_of_Countable_Set_is_Countable

https://proofwiki.org/wiki/Set_of_Finite_Subsets_of_Countable_Set_is_Countable

Thus the set of all finite subsets of finite strings is countable.

Thus the set all finite string pairs is countable because all of these
pairs are subsets having two elements thus finite length,

>>
>> The same thing would apply to a halt decider that takes arbitrary pairs
>> of finite strings. We know this because we know that a TM that computes
>> the sum of arbitrary pairs of finite strings of ASCII digits can be
>> defined: This is merely a simpler case of the above.
>>
>
> Wrong, and using a Red Herring and the fallacy of proof by examole,
>
>
> You are just showing how IGNORANT you are of what you are talking about.
>
>

--
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/26/2023 5:37 PM, Richard Damon wrote:
> On 1/26/23 12:04 PM, olcott wrote:
>> On 1/25/2023 10:37 PM, Richard Damon wrote:
>>> On 1/25/23 10:58 PM, olcott wrote:
>>>> On 1/25/2023 9:35 PM, Ben Bacarisse wrote:
>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>
>>>>>> On 1/25/23 8:06 PM, Ben Bacarisse wrote:
>>>>>>> Python <python@invalid.org> writes:
>>>>>>>
>>>>>>>> Peter Olcott wrote:
>>>>>>>> ...
>>>>>>>>> No machine can possibly be defined that divides all pairs of
>>>>>>>>> finite
>>>>>>>>> strings into those that represent machines would halt on their
>>>>>>>>> input
>>>>>>>>> when directly executed and those that do not
>>>>>>>>
>>>>>>>> So at least you admit that there no program can be written that
>>>>>>>> is an halt decider! It took time for you to abandon your delusions!
>>>>>>>
>>>>>>> Not so fast!  Remember that PO is often fractally wrong.  Not
>>>>>>> only is he
>>>>>>> usually wrong about the big picture he's usually wrong about all the
>>>>>>> details too.  In this case, he's having trouble expressing what he
>>>>>>> means.  This is actually just another iteration of his "it's an
>>>>>>> invalid
>>>>>>> question" stance, badly phrased.
>>>>>>
>>>>>> Meaning some times he just admits he is wrong because he fails to
>>>>>> fashion a good enough lie and slips up and tells the truth that he
>>>>>> doesn't beleive.
>>>>>
>>>>> Not quite.  Python cut off the end of the sentence.  The "...because"
>>>>> text is what shows it's the same old "some instances have no correct
>>>>> answer" in new clothing.  PO almost certainly does not stand by what
>>>>> Python quoted without the because clause.
>>>>>
>>>>
>>>> It is the case that ZFC did eliminate Russell's Paradox by eliminating
>>>> its basis of a set containing itself. Under the original definition of
>>>> the problem within naive set theory Russell's Paradox still exists.
>>>
>>> Not by just defining that sets can't contain themselves, but by
>>> limiting the kind of things that sets can contain.
>>
>> That a set cannot contain itself is what eliminates Russell's Paradox.
>>
>>>>
>>>> The halting problem proof begins with the correct basis that arbitrary
>>>> pairs of finite strings either represent a computation that halts on
>>>> its
>>>> input or not.
>>>>
>>>> The proof that no machine can correctly determine this set is analogous
>>>> to the Liar Paradox in that the input is specifically defined to do the
>>>> opposite of whatever the halt decider determines. This transforms the
>>>> halting problem into an ill-formed problem.
>>>
>>> Nope. Since the input is part of the domain of machine/inputs, the
>>
>> When we define a machine that correctly determines whether or not pairs
>> of arbitrary finite sting inputs would reach the final state of the
>> first element of this input then halting is computable.
>>
>
> But you need to show that you CAN do that. YOu haven't
>
> H(P,P) says that P(P) will not halt when it does, so it fails.
>
>> Because the pathological input actually has different behavior when it
>> is correctly simulated by its corresponding halt decider and the halt
>> decider must base its halt status decision on the actual behavior of
>> this input then the halt decider is necessarily correct to reject its
>> pathological input as non-halting.
>
> No, it doesn't
>
> You have been asked to point what point in the actual execution of
> H(P,P) called by P(P) call by main differs from the execution of H(P,P)
> calledd by main diverege.
>
> You have failed to point that out, becaue it doesn't exist, because you
> ar a  LIAR and an IDOIT.
>
> As stated before, your failure to even attempt to indicate this is taken
> as your admission that your claim is a LIE, and you can not actually
> prove your claim, also making you a damned hypocrite.
>
>>
>> You still have not provided any counter example that shows that my
>> definition of correct simulation is incorrect:
>
> LIE.
>
> P(P) is the counter example.
>
>>
>> Try and provide a 100% specific counter-example where you show a line
>> of machine code such as [mov eax, 1] and the simulator simulates another
>> different line instead such as [push ebx] and the simulator is correct.
>
> P(P), its call H will go through the exact same set of states when P(P)
> call s as when main calls it, thus since H(P,P) returns 0 when called by
> main, we know it does the same thing when called by P (or it just fails
> to be the "pure function"/computation you have claimex it to be)
>
> Since H simulats that call the H(P,P) as something that will never
> returm, H has done an incorrect simulation.
>
> Your inability to understand this just shows your STUPIDITY.
>
>>
>> If no such counter-example exists then it is proven that the ultimate
>> measure of correct simulation is that the simulator simulates line-by-
>> line exactly what the machine code specifies.
>>
>> ALL OF THE ARGUMENTS AGAINST MY POSITION HAVE PROVEN TO BE
>> COUNTER-FACTUAL
>
> Nope, YOUR statements, have been shown to be "counter-factual" and your
> reasoning ab
>>
>> (a) The simulation of the input to H(D,D) by H is correct.
>
> Nope, because it says H(P,P) will never return, when it doesn.

Try and provide a 100% specific counter-example where you show a line
of machine code such as [mov eax, 1] and the simulator simulates another
different line instead such as [push ebx] and the simulator is correct.

If no such counter-example exists then it is proven that the ultimate
measure of correct simulation is that the simulator simulates line-by-
line exactly what the machine code specifies.

Because your main tactic of rebuttal is the dishonest dodge I will stay
focused on the point until you meet the challenge.

--
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/26/23 7:31 PM, olcott wrote:
> On 1/26/2023 5:37 PM, Richard Damon wrote:
>> On 1/26/23 12:04 PM, olcott wrote:
>>> On 1/25/2023 10:37 PM, Richard Damon wrote:
>>>> On 1/25/23 10:58 PM, olcott wrote:
>>>>> On 1/25/2023 9:35 PM, Ben Bacarisse wrote:
>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>
>>>>>>> On 1/25/23 8:06 PM, Ben Bacarisse wrote:
>>>>>>>> Python <python@invalid.org> writes:
>>>>>>>>
>>>>>>>>> Peter Olcott wrote:
>>>>>>>>> ...
>>>>>>>>>> No machine can possibly be defined that divides all pairs of
>>>>>>>>>> finite
>>>>>>>>>> strings into those that represent machines would halt on their
>>>>>>>>>> input
>>>>>>>>>> when directly executed and those that do not
>>>>>>>>>
>>>>>>>>> So at least you admit that there no program can be written that
>>>>>>>>> is an halt decider! It took time for you to abandon your
>>>>>>>>> delusions!
>>>>>>>>
>>>>>>>> Not so fast!  Remember that PO is often fractally wrong.  Not
>>>>>>>> only is he
>>>>>>>> usually wrong about the big picture he's usually wrong about all
>>>>>>>> the
>>>>>>>> details too.  In this case, he's having trouble expressing what he
>>>>>>>> means.  This is actually just another iteration of his "it's an
>>>>>>>> invalid
>>>>>>>> question" stance, badly phrased.
>>>>>>>
>>>>>>> Meaning some times he just admits he is wrong because he fails to
>>>>>>> fashion a good enough lie and slips up and tells the truth that he
>>>>>>> doesn't beleive.
>>>>>>
>>>>>> Not quite.  Python cut off the end of the sentence.  The "...because"
>>>>>> text is what shows it's the same old "some instances have no correct
>>>>>> answer" in new clothing.  PO almost certainly does not stand by what
>>>>>> Python quoted without the because clause.
>>>>>>
>>>>>
>>>>> It is the case that ZFC did eliminate Russell's Paradox by eliminating
>>>>> its basis of a set containing itself. Under the original definition of
>>>>> the problem within naive set theory Russell's Paradox still exists.
>>>>
>>>> Not by just defining that sets can't contain themselves, but by
>>>> limiting the kind of things that sets can contain.
>>>
>>> That a set cannot contain itself is what eliminates Russell's Paradox.
>>>
>>>>>
>>>>> The halting problem proof begins with the correct basis that arbitrary
>>>>> pairs of finite strings either represent a computation that halts
>>>>> on its
>>>>> input or not.
>>>>>
>>>>> The proof that no machine can correctly determine this set is
>>>>> analogous
>>>>> to the Liar Paradox in that the input is specifically defined to do
>>>>> the
>>>>> opposite of whatever the halt decider determines. This transforms the
>>>>> halting problem into an ill-formed problem.
>>>>
>>>> Nope. Since the input is part of the domain of machine/inputs, the
>>>
>>> When we define a machine that correctly determines whether or not pairs
>>> of arbitrary finite sting inputs would reach the final state of the
>>> first element of this input then halting is computable.
>>>
>>
>> But you need to show that you CAN do that. YOu haven't
>>
>> H(P,P) says that P(P) will not halt when it does, so it fails.
>>
>>> Because the pathological input actually has different behavior when it
>>> is correctly simulated by its corresponding halt decider and the halt
>>> decider must base its halt status decision on the actual behavior of
>>> this input then the halt decider is necessarily correct to reject its
>>> pathological input as non-halting.
>>
>> No, it doesn't
>>
>> You have been asked to point what point in the actual execution of
>> H(P,P) called by P(P) call by main differs from the execution of
>> H(P,P) calledd by main diverege.
>>
>> You have failed to point that out, becaue it doesn't exist, because
>> you ar a  LIAR and an IDOIT.
>>
>> As stated before, your failure to even attempt to indicate this is
>> taken as your admission that your claim is a LIE, and you can not
>> actually prove your claim, also making you a damned hypocrite.
>>
>>>
>>> You still have not provided any counter example that shows that my
>>> definition of correct simulation is incorrect:
>>
>> LIE.
>>
>> P(P) is the counter example.
>>
>>>
>>> Try and provide a 100% specific counter-example where you show a line
>>> of machine code such as [mov eax, 1] and the simulator simulates another
>>> different line instead such as [push ebx] and the simulator is correct.
>>
>> P(P), its call H will go through the exact same set of states when
>> P(P) call s as when main calls it, thus since H(P,P) returns 0 when
>> called by main, we know it does the same thing when called by P (or it
>> just fails to be the "pure function"/computation you have claimex it
>> to be)
>>
>> Since H simulats that call the H(P,P) as something that will never
>> returm, H has done an incorrect simulation.
>>
>> Your inability to understand this just shows your STUPIDITY.
>>
>>>
>>> If no such counter-example exists then it is proven that the ultimate
>>> measure of correct simulation is that the simulator simulates line-by-
>>> line exactly what the machine code specifies.
>>>
>>> ALL OF THE ARGUMENTS AGAINST MY POSITION HAVE PROVEN TO BE
>>> COUNTER-FACTUAL
>>
>> Nope, YOUR statements, have been shown to be "counter-factual" and
>> your reasoning ab
>>>
>>> (a) The simulation of the input to H(D,D) by H is correct.
>>
>> Nope, because it says H(P,P) will never return, when it doesn.
>
> Try and provide a 100% specific counter-example where you show a line
> of machine code such as [mov eax, 1] and the simulator simulates another
> different line instead such as [push ebx] and the simulator is correct.

call H

in actuality, it goes into H which will eventually returns.

H "simulates" that as something that doesn't return, and doesn't
actually simulate into the function.

Remeber, "Correct Simulation" means fully determining the behavior of
the machine, and BY DEFINITION if the machine halts and the simulation
says it doesn't, the simulation is INCORRECT.

>
> If no such counter-example exists then it is proven that the ultimate
> measure of correct simulation is that the simulator simulates line-by-
> line exactly what the machine code specifies.
>
> Because your main tactic of rebuttal is the dishonest dodge I will stay
> focused on the point until you meet the challenge.
>

I have, multiple times, but you are too stup[id to undrstand.

You ADMIT that P(P) halts (at least most of the time) but somehow try to
justify that the correct answer for H, which is being asked if P(P)
Halts, is to say "No". You say H's simulation must be correct, as each
of the instructions it has simulated completed were done correctly, even
though it interprests what a call H instruction will end up doing
incorrectly as it "guesses" the behavior of H to not be what H actually
does (maybe because H doesn't actually do what you think it is "defined"
to do)

This is like saying you can determine how long a road is by following it
exactly till the first exit and then getting off, saying the road past
the exit look just like the road before, so the road must be infinitely
long.

On 1/26/23 7:27 PM, olcott wrote:
> On 1/26/2023 5:37 PM, Richard Damon wrote:
>> On 1/26/23 10:43 AM, olcott wrote:
>>> On 1/26/2023 6:22 AM, Ben Bacarisse wrote:
>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>
>>>>> On 1/25/23 10:54 PM, Ben Bacarisse wrote:
>>>>>> Python <python@invalid.org> writes:
>>>>>>
>>>>>>> Le 26/01/2023 à 01:33, Richard Damon a écrit :
>>>>>>>> One simple comment that comes to mind that points out the error
>>>>>>>> in your
>>>>>>>> thinking:
>>>>>>>> The number of possible computing machines is a countable infinite,
>>>>>>>> because we can express every such machine as a finite string of a
>>>>>>>> finite symbol set.
>>>>>>>> The number of possible deciders that can be defined is an
>>>>>>>> UNCOUNTABLE
>>>>>>>> infinite.
>>>>>> Ooh, I would not say that.  For any reasonable meaning of "can be
>>>>>> defined" the set is countable, isn't it?
>>>>>
>>>>> Right, I meant FUNCTIONS is an uncountable set.
>>>>
>>>> Yes, it can also be framed in terms of functions.  For any countably
>>>> infinite set X, the set X->{0,1} is uncountable, so most of those
>>>> functions are not TM computable.
>>>>
>>>
>>> The sum of every element of the set of all finite subsets of finite
>>> strings of of ASCII digits can be computed because we can define a TM
>>> that takes an arbitrary number of space delimited finite strings.
>>
>> Red herring as we are not talking about functions that are just a "sum".
>>
>>>
>>> Infinite input to a TM is uncomputable because the TM would never halt,
>>> thus the set of subsets of finite strings of ASCII digits must exclude
>>> infinite subsets.
>>
>> We are not talking about any subset that has an infinte number of
>> members, but the number of finite subsets of the Natural Numbers.
>>
>> The count of this is an uncountable infinity, an order of infinity
>> bigger than the count of the Natural Numbers.
>>
>
> The set of all finite subsets of the natural numbers is countable
> https://en.wikipedia.org/wiki/Countable_set

Side note, read on this page about total order:

> In both examples of well orders here, any subset has a least element; and in both examples of non-well orders, some subsets do not have a least element. This is the key definition that determines whether a total order is also a well order.
>

Note, the rationals "in usual order" are a non-well ordered set, and
thus some subsets (like the open interval) do not have a least member.
This is why the intervale (0, 1] doesn't have a "lowest" value.

>
> https://proofwiki.org/wiki/Set_of_Finite_Subsets_of_Countable_Set_is_Countable
>
> https://proofwiki.org/wiki/Set_of_Finite_Subsets_of_Countable_Set_is_Countable
>
> Thus the set of all finite subsets of finite strings is countable.
>
> Thus the set all finite string pairs is countable because all of these
> pairs are subsets having two elements thus finite length,

Note, MY claim was the number of FUNCTIONS was uncountable, not the
number of subsets, thus not all Functions F(N) -> N are computable, as
there are more functions than computations.

This also applies to the set of Functions F(N) -> {0,1}, which is the
set of all deciders

The subset problem is different. While the number of FINITE subsets is
countably infinite, the number of partitions of N into S and S' can
result in both S and S' being infinte, and thus none of those proofs
show that the number of partiosns to be countable, thus more than the
number of possible deciders which must be countable.

From what I remember, the set of Halting Machines/Input pairs is
countably infinte, and the number of Non-Halting pairs is Uncountable,
so a Halting RECOGNIZER is possible, that is a machine that WILL Halt in
finite time and say Halting for ALL Halting Machine/Inputs combinations,
but might not halt on all Non-Halting combinations, which isn't much
better than we could get by just running the machines (it might be able
to detect that SOME non-halting machines are non-halting)

>
>>>
>>> The same thing would apply to a halt decider that takes arbitrary pairs
>>> of finite strings. We know this because we know that a TM that computes
>>> the sum of arbitrary pairs of finite strings of ASCII digits can be
>>> defined: This is merely a simpler case of the above.
>>>
>>
>> Wrong, and using a Red Herring and the fallacy of proof by examole,
>>
>>
>> You are just showing how IGNORANT you are of what you are talking about.
>>
>>
>

On 1/26/2023 9:25 PM, Richard Damon wrote:
> On 1/26/23 7:27 PM, olcott wrote:
>> On 1/26/2023 5:37 PM, Richard Damon wrote:
>>> On 1/26/23 10:43 AM, olcott wrote:
>>>> On 1/26/2023 6:22 AM, Ben Bacarisse wrote:
>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>
>>>>>> On 1/25/23 10:54 PM, Ben Bacarisse wrote:
>>>>>>> Python <python@invalid.org> writes:
>>>>>>>
>>>>>>>> Le 26/01/2023 à 01:33, Richard Damon a écrit :
>>>>>>>>> One simple comment that comes to mind that points out the error
>>>>>>>>> in your
>>>>>>>>> thinking:
>>>>>>>>> The number of possible computing machines is a countable infinite,
>>>>>>>>> because we can express every such machine as a finite string of a
>>>>>>>>> finite symbol set.
>>>>>>>>> The number of possible deciders that can be defined is an
>>>>>>>>> UNCOUNTABLE
>>>>>>>>> infinite.
>>>>>>> Ooh, I would not say that.  For any reasonable meaning of "can be
>>>>>>> defined" the set is countable, isn't it?
>>>>>>
>>>>>> Right, I meant FUNCTIONS is an uncountable set.
>>>>>
>>>>> Yes, it can also be framed in terms of functions.  For any countably
>>>>> infinite set X, the set X->{0,1} is uncountable, so most of those
>>>>> functions are not TM computable.
>>>>>
>>>>
>>>> The sum of every element of the set of all finite subsets of finite
>>>> strings of of ASCII digits can be computed because we can define a TM
>>>> that takes an arbitrary number of space delimited finite strings.
>>>
>>> Red herring as we are not talking about functions that are just a "sum".
>>>
>>>>
>>>> Infinite input to a TM is uncomputable because the TM would never halt,
>>>> thus the set of subsets of finite strings of ASCII digits must exclude
>>>> infinite subsets.
>>>
>>> We are not talking about any subset that has an infinte number of
>>> members, but the number of finite subsets of the Natural Numbers.
>>>
>>> The count of this is an uncountable infinity, an order of infinity
>>> bigger than the count of the Natural Numbers.
>>>
>>
>> The set of all finite subsets of the natural numbers is countable
>> https://en.wikipedia.org/wiki/Countable_set
>
> Side note, read on this page about total order:
>
>> In both examples of well orders here, any subset has a least element;
>> and in both examples of non-well orders, some subsets do not have a
>> least element. This is the key definition that determines whether a
>> total order is also a well order.
>>
>
> Note, the rationals "in usual order" are a non-well ordered set, and
> thus some subsets (like the open interval) do not have a least member.
> This is why the intervale (0, 1] doesn't have a "lowest" value.
>
>>
>> https://proofwiki.org/wiki/Set_of_Finite_Subsets_of_Countable_Set_is_Countable
>>
>> https://proofwiki.org/wiki/Set_of_Finite_Subsets_of_Countable_Set_is_Countable
>>
>> Thus the set of all finite subsets of finite strings is countable.
>>
>> Thus the set all finite string pairs is countable because all of these
>> pairs are subsets having two elements thus finite length,
>
> Note, MY claim was the number of FUNCTIONS was uncountable, not the
> number of subsets, thus not all Functions F(N) -> N are computable, as
> there are more functions than computations.
>

There is a single TM can you not count to one?

A single TM can derive the sum of any arbitrary finite set
of finite strings of ASCII digits that are space delimited.

Proving that this cannot be done requires a specific
counter-example finite set of finite strings of ASCII digits
where the sum cannot be computed.

To be correct the TM need not calculate the sum of every finite
set of finite strings of ASCII digits, it merely has to always
compute this sum correctly for any arbitrary element of the
finite set of finite strings.

--
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/26/2023 8:37 PM, Richard Damon wrote:
> On 1/26/23 7:31 PM, olcott wrote:
>> On 1/26/2023 5:37 PM, Richard Damon wrote:
>>> On 1/26/23 12:04 PM, olcott wrote:
>>>> On 1/25/2023 10:37 PM, Richard Damon wrote:
>>>>> On 1/25/23 10:58 PM, olcott wrote:
>>>>>> On 1/25/2023 9:35 PM, Ben Bacarisse wrote:
>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>
>>>>>>>> On 1/25/23 8:06 PM, Ben Bacarisse wrote:
>>>>>>>>> Python <python@invalid.org> writes:
>>>>>>>>>
>>>>>>>>>> Peter Olcott wrote:
>>>>>>>>>> ...
>>>>>>>>>>> No machine can possibly be defined that divides all pairs of
>>>>>>>>>>> finite
>>>>>>>>>>> strings into those that represent machines would halt on
>>>>>>>>>>> their input
>>>>>>>>>>> when directly executed and those that do not
>>>>>>>>>>
>>>>>>>>>> So at least you admit that there no program can be written that
>>>>>>>>>> is an halt decider! It took time for you to abandon your
>>>>>>>>>> delusions!
>>>>>>>>>
>>>>>>>>> Not so fast!  Remember that PO is often fractally wrong.  Not
>>>>>>>>> only is he
>>>>>>>>> usually wrong about the big picture he's usually wrong about
>>>>>>>>> all the
>>>>>>>>> details too.  In this case, he's having trouble expressing what he
>>>>>>>>> means.  This is actually just another iteration of his "it's an
>>>>>>>>> invalid
>>>>>>>>> question" stance, badly phrased.
>>>>>>>>
>>>>>>>> Meaning some times he just admits he is wrong because he fails to
>>>>>>>> fashion a good enough lie and slips up and tells the truth that he
>>>>>>>> doesn't beleive.
>>>>>>>
>>>>>>> Not quite.  Python cut off the end of the sentence.  The
>>>>>>> "...because"
>>>>>>> text is what shows it's the same old "some instances have no correct
>>>>>>> answer" in new clothing.  PO almost certainly does not stand by what
>>>>>>> Python quoted without the because clause.
>>>>>>>
>>>>>>
>>>>>> It is the case that ZFC did eliminate Russell's Paradox by
>>>>>> eliminating
>>>>>> its basis of a set containing itself. Under the original
>>>>>> definition of
>>>>>> the problem within naive set theory Russell's Paradox still exists.
>>>>>
>>>>> Not by just defining that sets can't contain themselves, but by
>>>>> limiting the kind of things that sets can contain.
>>>>
>>>> That a set cannot contain itself is what eliminates Russell's Paradox.
>>>>
>>>>>>
>>>>>> The halting problem proof begins with the correct basis that
>>>>>> arbitrary
>>>>>> pairs of finite strings either represent a computation that halts
>>>>>> on its
>>>>>> input or not.
>>>>>>
>>>>>> The proof that no machine can correctly determine this set is
>>>>>> analogous
>>>>>> to the Liar Paradox in that the input is specifically defined to
>>>>>> do the
>>>>>> opposite of whatever the halt decider determines. This transforms the
>>>>>> halting problem into an ill-formed problem.
>>>>>
>>>>> Nope. Since the input is part of the domain of machine/inputs, the
>>>>
>>>> When we define a machine that correctly determines whether or not pairs
>>>> of arbitrary finite sting inputs would reach the final state of the
>>>> first element of this input then halting is computable.
>>>>
>>>
>>> But you need to show that you CAN do that. YOu haven't
>>>
>>> H(P,P) says that P(P) will not halt when it does, so it fails.
>>>
>>>> Because the pathological input actually has different behavior when it
>>>> is correctly simulated by its corresponding halt decider and the halt
>>>> decider must base its halt status decision on the actual behavior of
>>>> this input then the halt decider is necessarily correct to reject its
>>>> pathological input as non-halting.
>>>
>>> No, it doesn't
>>>
>>> You have been asked to point what point in the actual execution of
>>> H(P,P) called by P(P) call by main differs from the execution of
>>> H(P,P) calledd by main diverege.
>>>
>>> You have failed to point that out, becaue it doesn't exist, because
>>> you ar a  LIAR and an IDOIT.
>>>
>>> As stated before, your failure to even attempt to indicate this is
>>> taken as your admission that your claim is a LIE, and you can not
>>> actually prove your claim, also making you a damned hypocrite.
>>>
>>>>
>>>> You still have not provided any counter example that shows that my
>>>> definition of correct simulation is incorrect:
>>>
>>> LIE.
>>>
>>> P(P) is the counter example.
>>>
>>>>
>>>> Try and provide a 100% specific counter-example where you show a line
>>>> of machine code such as [mov eax, 1] and the simulator simulates
>>>> another
>>>> different line instead such as [push ebx] and the simulator is correct.
>>>
>>> P(P), its call H will go through the exact same set of states when
>>> P(P) call s as when main calls it, thus since H(P,P) returns 0 when
>>> called by main, we know it does the same thing when called by P (or
>>> it just fails to be the "pure function"/computation you have claimex
>>> it to be)
>>>
>>> Since H simulats that call the H(P,P) as something that will never
>>> returm, H has done an incorrect simulation.
>>>
>>> Your inability to understand this just shows your STUPIDITY.
>>>
>>>>
>>>> If no such counter-example exists then it is proven that the ultimate
>>>> measure of correct simulation is that the simulator simulates line-by-
>>>> line exactly what the machine code specifies.
>>>>
>>>> ALL OF THE ARGUMENTS AGAINST MY POSITION HAVE PROVEN TO BE
>>>> COUNTER-FACTUAL
>>>
>>> Nope, YOUR statements, have been shown to be "counter-factual" and
>>> your reasoning ab
>>>>
>>>> (a) The simulation of the input to H(D,D) by H is correct.
>>>
>>> Nope, because it says H(P,P) will never return, when it doesn.
>>
>> Try and provide a 100% specific counter-example where you show a line
>> of machine code such as [mov eax, 1] and the simulator simulates another
>> different line instead such as [push ebx] and the simulator is correct.
>
> call H
>
> in actuality, it goes into H which will eventually returns.
>
> H "simulates" that as something that doesn't return, and doesn't
> actually simulate into the function.
>
> Remeber, "Correct Simulation" means fully determining the behavior of
> the machine, and BY DEFINITION if the machine halts and the simulation
> says it doesn't, the simulation is INCORRECT.
>
>>
>> If no such counter-example exists then it is proven that the ultimate
>> measure of correct simulation is that the simulator simulates line-by-
>> line exactly what the machine code specifies.
>>
>> Because your main tactic of rebuttal is the dishonest dodge I will stay
>> focused on the point until you meet the challenge.
>>
>
> I have, multiple times, but you are too stup[id to undrstand.
>

Show me a specific line of machine code such as [mov eax, 1] where the
simulator simulates some other entirely different specific line of
machine code instead such as [push ebx] *AND THE SIMULATOR IS CORRECT*

On 1/26/23 10:56 PM, olcott wrote:
> On 1/26/2023 8:37 PM, Richard Damon wrote:
>> On 1/26/23 7:31 PM, olcott wrote:
>>> On 1/26/2023 5:37 PM, Richard Damon wrote:
>>>> On 1/26/23 12:04 PM, olcott wrote:
>>>>> On 1/25/2023 10:37 PM, Richard Damon wrote:
>>>>>> On 1/25/23 10:58 PM, olcott wrote:
>>>>>>> On 1/25/2023 9:35 PM, Ben Bacarisse wrote:
>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>
>>>>>>>>> On 1/25/23 8:06 PM, Ben Bacarisse wrote:
>>>>>>>>>> Python <python@invalid.org> writes:
>>>>>>>>>>
>>>>>>>>>>> Peter Olcott wrote:
>>>>>>>>>>> ...
>>>>>>>>>>>> No machine can possibly be defined that divides all pairs of
>>>>>>>>>>>> finite
>>>>>>>>>>>> strings into those that represent machines would halt on
>>>>>>>>>>>> their input
>>>>>>>>>>>> when directly executed and those that do not
>>>>>>>>>>>
>>>>>>>>>>> So at least you admit that there no program can be written that
>>>>>>>>>>> is an halt decider! It took time for you to abandon your
>>>>>>>>>>> delusions!
>>>>>>>>>>
>>>>>>>>>> Not so fast!  Remember that PO is often fractally wrong.  Not
>>>>>>>>>> only is he
>>>>>>>>>> usually wrong about the big picture he's usually wrong about
>>>>>>>>>> all the
>>>>>>>>>> details too.  In this case, he's having trouble expressing
>>>>>>>>>> what he
>>>>>>>>>> means.  This is actually just another iteration of his "it's
>>>>>>>>>> an invalid
>>>>>>>>>> question" stance, badly phrased.
>>>>>>>>>
>>>>>>>>> Meaning some times he just admits he is wrong because he fails to
>>>>>>>>> fashion a good enough lie and slips up and tells the truth that he
>>>>>>>>> doesn't beleive.
>>>>>>>>
>>>>>>>> Not quite.  Python cut off the end of the sentence.  The
>>>>>>>> "...because"
>>>>>>>> text is what shows it's the same old "some instances have no
>>>>>>>> correct
>>>>>>>> answer" in new clothing.  PO almost certainly does not stand by
>>>>>>>> what
>>>>>>>> Python quoted without the because clause.
>>>>>>>>
>>>>>>>
>>>>>>> It is the case that ZFC did eliminate Russell's Paradox by
>>>>>>> eliminating
>>>>>>> its basis of a set containing itself. Under the original
>>>>>>> definition of
>>>>>>> the problem within naive set theory Russell's Paradox still exists.
>>>>>>
>>>>>> Not by just defining that sets can't contain themselves, but by
>>>>>> limiting the kind of things that sets can contain.
>>>>>
>>>>> That a set cannot contain itself is what eliminates Russell's Paradox.
>>>>>
>>>>>>>
>>>>>>> The halting problem proof begins with the correct basis that
>>>>>>> arbitrary
>>>>>>> pairs of finite strings either represent a computation that halts
>>>>>>> on its
>>>>>>> input or not.
>>>>>>>
>>>>>>> The proof that no machine can correctly determine this set is
>>>>>>> analogous
>>>>>>> to the Liar Paradox in that the input is specifically defined to
>>>>>>> do the
>>>>>>> opposite of whatever the halt decider determines. This transforms
>>>>>>> the
>>>>>>> halting problem into an ill-formed problem.
>>>>>>
>>>>>> Nope. Since the input is part of the domain of machine/inputs, the
>>>>>
>>>>> When we define a machine that correctly determines whether or not
>>>>> pairs
>>>>> of arbitrary finite sting inputs would reach the final state of the
>>>>> first element of this input then halting is computable.
>>>>>
>>>>
>>>> But you need to show that you CAN do that. YOu haven't
>>>>
>>>> H(P,P) says that P(P) will not halt when it does, so it fails.
>>>>
>>>>> Because the pathological input actually has different behavior when it
>>>>> is correctly simulated by its corresponding halt decider and the halt
>>>>> decider must base its halt status decision on the actual behavior of
>>>>> this input then the halt decider is necessarily correct to reject its
>>>>> pathological input as non-halting.
>>>>
>>>> No, it doesn't
>>>>
>>>> You have been asked to point what point in the actual execution of
>>>> H(P,P) called by P(P) call by main differs from the execution of
>>>> H(P,P) calledd by main diverege.
>>>>
>>>> You have failed to point that out, becaue it doesn't exist, because
>>>> you ar a  LIAR and an IDOIT.
>>>>
>>>> As stated before, your failure to even attempt to indicate this is
>>>> taken as your admission that your claim is a LIE, and you can not
>>>> actually prove your claim, also making you a damned hypocrite.
>>>>
>>>>>
>>>>> You still have not provided any counter example that shows that my
>>>>> definition of correct simulation is incorrect:
>>>>
>>>> LIE.
>>>>
>>>> P(P) is the counter example.
>>>>
>>>>>
>>>>> Try and provide a 100% specific counter-example where you show a line
>>>>> of machine code such as [mov eax, 1] and the simulator simulates
>>>>> another
>>>>> different line instead such as [push ebx] and the simulator is
>>>>> correct.
>>>>
>>>> P(P), its call H will go through the exact same set of states when
>>>> P(P) call s as when main calls it, thus since H(P,P) returns 0 when
>>>> called by main, we know it does the same thing when called by P (or
>>>> it just fails to be the "pure function"/computation you have claimex
>>>> it to be)
>>>>
>>>> Since H simulats that call the H(P,P) as something that will never
>>>> returm, H has done an incorrect simulation.
>>>>
>>>> Your inability to understand this just shows your STUPIDITY.
>>>>
>>>>>
>>>>> If no such counter-example exists then it is proven that the ultimate
>>>>> measure of correct simulation is that the simulator simulates line-by-
>>>>> line exactly what the machine code specifies.
>>>>>
>>>>> ALL OF THE ARGUMENTS AGAINST MY POSITION HAVE PROVEN TO BE
>>>>> COUNTER-FACTUAL
>>>>
>>>> Nope, YOUR statements, have been shown to be "counter-factual" and
>>>> your reasoning ab
>>>>>
>>>>> (a) The simulation of the input to H(D,D) by H is correct.
>>>>
>>>> Nope, because it says H(P,P) will never return, when it doesn.
>>>
>>> Try and provide a 100% specific counter-example where you show a line
>>> of machine code such as [mov eax, 1] and the simulator simulates another
>>> different line instead such as [push ebx] and the simulator is correct.
>>
>> call H
>>
>> in actuality, it goes into H which will eventually returns.
>>
>> H "simulates" that as something that doesn't return, and doesn't
>> actually simulate into the function.
>>
>> Remeber, "Correct Simulation" means fully determining the behavior of
>> the machine, and BY DEFINITION if the machine halts and the simulation
>> says it doesn't, the simulation is INCORRECT.
>>
>>>
>>> If no such counter-example exists then it is proven that the ultimate
>>> measure of correct simulation is that the simulator simulates line-by-
>>> line exactly what the machine code specifies.
>>>
>>> Because your main tactic of rebuttal is the dishonest dodge I will stay
>>> focused on the point until you meet the challenge.
>>>
>>
>> I have, multiple times, but you are too stup[id to undrstand.
>>
>
> Show me a specific line of machine code such as [mov eax, 1] where the
> simulator simulates some other entirely different specific line of
> machine code instead such as [push ebx] *AND THE SIMULATOR IS CORRECT*

On 1/26/23 10:46 PM, olcott wrote:
> On 1/26/2023 9:25 PM, Richard Damon wrote:
>> On 1/26/23 7:27 PM, olcott wrote:
>>> On 1/26/2023 5:37 PM, Richard Damon wrote:
>>>> On 1/26/23 10:43 AM, olcott wrote:
>>>>> On 1/26/2023 6:22 AM, Ben Bacarisse wrote:
>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>
>>>>>>> On 1/25/23 10:54 PM, Ben Bacarisse wrote:
>>>>>>>> Python <python@invalid.org> writes:
>>>>>>>>
>>>>>>>>> Le 26/01/2023 à 01:33, Richard Damon a écrit :
>>>>>>>>>> One simple comment that comes to mind that points out the
>>>>>>>>>> error in your
>>>>>>>>>> thinking:
>>>>>>>>>> The number of possible computing machines is a countable
>>>>>>>>>> infinite,
>>>>>>>>>> because we can express every such machine as a finite string of a
>>>>>>>>>> finite symbol set.
>>>>>>>>>> The number of possible deciders that can be defined is an
>>>>>>>>>> UNCOUNTABLE
>>>>>>>>>> infinite.
>>>>>>>> Ooh, I would not say that.  For any reasonable meaning of "can be
>>>>>>>> defined" the set is countable, isn't it?
>>>>>>>
>>>>>>> Right, I meant FUNCTIONS is an uncountable set.
>>>>>>
>>>>>> Yes, it can also be framed in terms of functions.  For any countably
>>>>>> infinite set X, the set X->{0,1} is uncountable, so most of those
>>>>>> functions are not TM computable.
>>>>>>
>>>>>
>>>>> The sum of every element of the set of all finite subsets of finite
>>>>> strings of of ASCII digits can be computed because we can define a TM
>>>>> that takes an arbitrary number of space delimited finite strings.
>>>>
>>>> Red herring as we are not talking about functions that are just a
>>>> "sum".
>>>>
>>>>>
>>>>> Infinite input to a TM is uncomputable because the TM would never
>>>>> halt,
>>>>> thus the set of subsets of finite strings of ASCII digits must exclude
>>>>> infinite subsets.
>>>>
>>>> We are not talking about any subset that has an infinte number of
>>>> members, but the number of finite subsets of the Natural Numbers.
>>>>
>>>> The count of this is an uncountable infinity, an order of infinity
>>>> bigger than the count of the Natural Numbers.
>>>>
>>>
>>> The set of all finite subsets of the natural numbers is countable
>>> https://en.wikipedia.org/wiki/Countable_set
>>
>> Side note, read on this page about total order:
>>
>>> In both examples of well orders here, any subset has a least element;
>>> and in both examples of non-well orders, some subsets do not have a
>>> least element. This is the key definition that determines whether a
>>> total order is also a well order.
>>>
>>
>> Note, the rationals "in usual order" are a non-well ordered set, and
>> thus some subsets (like the open interval) do not have a least member.
>> This is why the intervale (0, 1] doesn't have a "lowest" value.
>>
>>>
>>> https://proofwiki.org/wiki/Set_of_Finite_Subsets_of_Countable_Set_is_Countable
>>>
>>> https://proofwiki.org/wiki/Set_of_Finite_Subsets_of_Countable_Set_is_Countable
>>>
>>> Thus the set of all finite subsets of finite strings is countable.
>>>
>>> Thus the set all finite string pairs is countable because all of
>>> these pairs are subsets having two elements thus finite length,
>>
>> Note, MY claim was the number of FUNCTIONS was uncountable, not the
>> number of subsets, thus not all Functions F(N) -> N are computable, as
>> there are more functions than computations.
>>
>
> There is a single TM can you not count to one?

?????

Where do you get that claim?

>
> A single TM can derive the sum of any arbitrary finite set
> of finite strings of ASCII digits that are space delimited.
>

So?

> Proving that this cannot be done requires a specific
> counter-example finite set of finite strings of ASCII digits
> where the sum cannot be computed.
>

Neer said you couldn't compute SOME functions.

> To be correct the TM need not calculate the sum of every finite
> set of finite strings of ASCII digits, it merely has to always
> compute this sum correctly for any arbitrary element of the
> finite set of finite strings.
>

NBot talking about "Sums"

You are just showing you are totally lost about what I am talking about
becaue you are too stupid.

There exist more possibe problems to decide on then possible deciders
(by an order of infinity).

Thus, most decision problems are not computatble.

Maybe most of the uncomputable ones are not interesting, but it shows
that some are not computable.

This happens to include the halting function.

Your Red Herring Comments just show you have no idea what is being
talked about.

On 1/26/2023 10:16 PM, Richard Damon wrote:
> On 1/26/23 10:56 PM, olcott wrote:
>> On 1/26/2023 8:37 PM, Richard Damon wrote:
>>> On 1/26/23 7:31 PM, olcott wrote:
>>>> On 1/26/2023 5:37 PM, Richard Damon wrote:
>>>>> On 1/26/23 12:04 PM, olcott wrote:
>>>>>> On 1/25/2023 10:37 PM, Richard Damon wrote:
>>>>>>> On 1/25/23 10:58 PM, olcott wrote:
>>>>>>>> On 1/25/2023 9:35 PM, Ben Bacarisse wrote:
>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>
>>>>>>>>>> On 1/25/23 8:06 PM, Ben Bacarisse wrote:
>>>>>>>>>>> Python <python@invalid.org> writes:
>>>>>>>>>>>
>>>>>>>>>>>> Peter Olcott wrote:
>>>>>>>>>>>> ...
>>>>>>>>>>>>> No machine can possibly be defined that divides all pairs
>>>>>>>>>>>>> of finite
>>>>>>>>>>>>> strings into those that represent machines would halt on
>>>>>>>>>>>>> their input
>>>>>>>>>>>>> when directly executed and those that do not
>>>>>>>>>>>>
>>>>>>>>>>>> So at least you admit that there no program can be written that
>>>>>>>>>>>> is an halt decider! It took time for you to abandon your
>>>>>>>>>>>> delusions!
>>>>>>>>>>>
>>>>>>>>>>> Not so fast!  Remember that PO is often fractally wrong.  Not
>>>>>>>>>>> only is he
>>>>>>>>>>> usually wrong about the big picture he's usually wrong about
>>>>>>>>>>> all the
>>>>>>>>>>> details too.  In this case, he's having trouble expressing
>>>>>>>>>>> what he
>>>>>>>>>>> means.  This is actually just another iteration of his "it's
>>>>>>>>>>> an invalid
>>>>>>>>>>> question" stance, badly phrased.
>>>>>>>>>>
>>>>>>>>>> Meaning some times he just admits he is wrong because he fails to
>>>>>>>>>> fashion a good enough lie and slips up and tells the truth
>>>>>>>>>> that he
>>>>>>>>>> doesn't beleive.
>>>>>>>>>
>>>>>>>>> Not quite.  Python cut off the end of the sentence.  The
>>>>>>>>> "...because"
>>>>>>>>> text is what shows it's the same old "some instances have no
>>>>>>>>> correct
>>>>>>>>> answer" in new clothing.  PO almost certainly does not stand by
>>>>>>>>> what
>>>>>>>>> Python quoted without the because clause.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is the case that ZFC did eliminate Russell's Paradox by
>>>>>>>> eliminating
>>>>>>>> its basis of a set containing itself. Under the original
>>>>>>>> definition of
>>>>>>>> the problem within naive set theory Russell's Paradox still exists.
>>>>>>>
>>>>>>> Not by just defining that sets can't contain themselves, but by
>>>>>>> limiting the kind of things that sets can contain.
>>>>>>
>>>>>> That a set cannot contain itself is what eliminates Russell's
>>>>>> Paradox.
>>>>>>
>>>>>>>>
>>>>>>>> The halting problem proof begins with the correct basis that
>>>>>>>> arbitrary
>>>>>>>> pairs of finite strings either represent a computation that
>>>>>>>> halts on its
>>>>>>>> input or not.
>>>>>>>>
>>>>>>>> The proof that no machine can correctly determine this set is
>>>>>>>> analogous
>>>>>>>> to the Liar Paradox in that the input is specifically defined to
>>>>>>>> do the
>>>>>>>> opposite of whatever the halt decider determines. This
>>>>>>>> transforms the
>>>>>>>> halting problem into an ill-formed problem.
>>>>>>>
>>>>>>> Nope. Since the input is part of the domain of machine/inputs, the
>>>>>>
>>>>>> When we define a machine that correctly determines whether or not
>>>>>> pairs
>>>>>> of arbitrary finite sting inputs would reach the final state of the
>>>>>> first element of this input then halting is computable.
>>>>>>
>>>>>
>>>>> But you need to show that you CAN do that. YOu haven't
>>>>>
>>>>> H(P,P) says that P(P) will not halt when it does, so it fails.
>>>>>
>>>>>> Because the pathological input actually has different behavior
>>>>>> when it
>>>>>> is correctly simulated by its corresponding halt decider and the halt
>>>>>> decider must base its halt status decision on the actual behavior of
>>>>>> this input then the halt decider is necessarily correct to reject its
>>>>>> pathological input as non-halting.
>>>>>
>>>>> No, it doesn't
>>>>>
>>>>> You have been asked to point what point in the actual execution of
>>>>> H(P,P) called by P(P) call by main differs from the execution of
>>>>> H(P,P) calledd by main diverege.
>>>>>
>>>>> You have failed to point that out, becaue it doesn't exist, because
>>>>> you ar a  LIAR and an IDOIT.
>>>>>
>>>>> As stated before, your failure to even attempt to indicate this is
>>>>> taken as your admission that your claim is a LIE, and you can not
>>>>> actually prove your claim, also making you a damned hypocrite.
>>>>>
>>>>>>
>>>>>> You still have not provided any counter example that shows that my
>>>>>> definition of correct simulation is incorrect:
>>>>>
>>>>> LIE.
>>>>>
>>>>> P(P) is the counter example.
>>>>>
>>>>>>
>>>>>> Try and provide a 100% specific counter-example where you show a line
>>>>>> of machine code such as [mov eax, 1] and the simulator simulates
>>>>>> another
>>>>>> different line instead such as [push ebx] and the simulator is
>>>>>> correct.
>>>>>
>>>>> P(P), its call H will go through the exact same set of states when
>>>>> P(P) call s as when main calls it, thus since H(P,P) returns 0 when
>>>>> called by main, we know it does the same thing when called by P (or
>>>>> it just fails to be the "pure function"/computation you have
>>>>> claimex it to be)
>>>>>
>>>>> Since H simulats that call the H(P,P) as something that will never
>>>>> returm, H has done an incorrect simulation.
>>>>>
>>>>> Your inability to understand this just shows your STUPIDITY.
>>>>>
>>>>>>
>>>>>> If no such counter-example exists then it is proven that the ultimate
>>>>>> measure of correct simulation is that the simulator simulates
>>>>>> line-by-
>>>>>> line exactly what the machine code specifies.
>>>>>>
>>>>>> ALL OF THE ARGUMENTS AGAINST MY POSITION HAVE PROVEN TO BE
>>>>>> COUNTER-FACTUAL
>>>>>
>>>>> Nope, YOUR statements, have been shown to be "counter-factual" and
>>>>> your reasoning ab
>>>>>>
>>>>>> (a) The simulation of the input to H(D,D) by H is correct.
>>>>>
>>>>> Nope, because it says H(P,P) will never return, when it doesn.
>>>>
>>>> Try and provide a 100% specific counter-example where you show a line
>>>> of machine code such as [mov eax, 1] and the simulator simulates
>>>> another
>>>> different line instead such as [push ebx] and the simulator is correct.
>>>
>>> call H
>>>
>>> in actuality, it goes into H which will eventually returns.
>>>
>>> H "simulates" that as something that doesn't return, and doesn't
>>> actually simulate into the function.
>>>
>>> Remeber, "Correct Simulation" means fully determining the behavior of
>>> the machine, and BY DEFINITION if the machine halts and the
>>> simulation says it doesn't, the simulation is INCORRECT.
>>>
>>>>
>>>> If no such counter-example exists then it is proven that the ultimate
>>>> measure of correct simulation is that the simulator simulates line-by-
>>>> line exactly what the machine code specifies.
>>>>
>>>> Because your main tactic of rebuttal is the dishonest dodge I will stay
>>>> focused on the point until you meet the challenge.
>>>>
>>>
>>> I have, multiple times, but you are too stup[id to undrstand.
>>>
>>
>> Show me a specific line of machine code such as [mov eax, 1] where the
>> simulator simulates some other entirely different specific line of
>> machine code instead such as [push ebx] *AND THE SIMULATOR IS CORRECT*
>
> ????
>
> Why are you asking me to show that the simulator was correct????
>

On 1/26/2023 10:16 PM, Richard Damon wrote:
> On 1/26/23 10:46 PM, olcott wrote:
>> On 1/26/2023 9:25 PM, Richard Damon wrote:
>>> On 1/26/23 7:27 PM, olcott wrote:
>>>> On 1/26/2023 5:37 PM, Richard Damon wrote:
>>>>> On 1/26/23 10:43 AM, olcott wrote:
>>>>>> On 1/26/2023 6:22 AM, Ben Bacarisse wrote:
>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>
>>>>>>>> On 1/25/23 10:54 PM, Ben Bacarisse wrote:
>>>>>>>>> Python <python@invalid.org> writes:
>>>>>>>>>
>>>>>>>>>> Le 26/01/2023 à 01:33, Richard Damon a écrit :
>>>>>>>>>>> One simple comment that comes to mind that points out the
>>>>>>>>>>> error in your
>>>>>>>>>>> thinking:
>>>>>>>>>>> The number of possible computing machines is a countable
>>>>>>>>>>> infinite,
>>>>>>>>>>> because we can express every such machine as a finite string
>>>>>>>>>>> of a
>>>>>>>>>>> finite symbol set.
>>>>>>>>>>> The number of possible deciders that can be defined is an
>>>>>>>>>>> UNCOUNTABLE
>>>>>>>>>>> infinite.
>>>>>>>>> Ooh, I would not say that.  For any reasonable meaning of "can be
>>>>>>>>> defined" the set is countable, isn't it?
>>>>>>>>
>>>>>>>> Right, I meant FUNCTIONS is an uncountable set.
>>>>>>>
>>>>>>> Yes, it can also be framed in terms of functions.  For any countably
>>>>>>> infinite set X, the set X->{0,1} is uncountable, so most of those
>>>>>>> functions are not TM computable.
>>>>>>>
>>>>>>
>>>>>> The sum of every element of the set of all finite subsets of finite
>>>>>> strings of of ASCII digits can be computed because we can define a TM
>>>>>> that takes an arbitrary number of space delimited finite strings.
>>>>>
>>>>> Red herring as we are not talking about functions that are just a
>>>>> "sum".
>>>>>
>>>>>>
>>>>>> Infinite input to a TM is uncomputable because the TM would never
>>>>>> halt,
>>>>>> thus the set of subsets of finite strings of ASCII digits must
>>>>>> exclude
>>>>>> infinite subsets.
>>>>>
>>>>> We are not talking about any subset that has an infinte number of
>>>>> members, but the number of finite subsets of the Natural Numbers.
>>>>>
>>>>> The count of this is an uncountable infinity, an order of infinity
>>>>> bigger than the count of the Natural Numbers.
>>>>>
>>>>
>>>> The set of all finite subsets of the natural numbers is countable
>>>> https://en.wikipedia.org/wiki/Countable_set
>>>
>>> Side note, read on this page about total order:
>>>
>>>> In both examples of well orders here, any subset has a least
>>>> element; and in both examples of non-well orders, some subsets do
>>>> not have a least element. This is the key definition that determines
>>>> whether a total order is also a well order.
>>>>
>>>
>>> Note, the rationals "in usual order" are a non-well ordered set, and
>>> thus some subsets (like the open interval) do not have a least
>>> member. This is why the intervale (0, 1] doesn't have a "lowest" value.
>>>
>>>>
>>>> https://proofwiki.org/wiki/Set_of_Finite_Subsets_of_Countable_Set_is_Countable
>>>>
>>>> https://proofwiki.org/wiki/Set_of_Finite_Subsets_of_Countable_Set_is_Countable
>>>>
>>>> Thus the set of all finite subsets of finite strings is countable.
>>>>
>>>> Thus the set all finite string pairs is countable because all of
>>>> these pairs are subsets having two elements thus finite length,
>>>
>>> Note, MY claim was the number of FUNCTIONS was uncountable, not the
>>> number of subsets, thus not all Functions F(N) -> N are computable,
>>> as there are more functions than computations.
>>>
>>
>> There is a single TM can you not count to one?
>
> ?????
>
> Where do you get that claim?
>
>>
>> A single TM can derive the sum of any arbitrary finite set
>> of finite strings of ASCII digits that are space delimited.
>>
>
> So?
>
>> Proving that this cannot be done requires a specific
>> counter-example finite set of finite strings of ASCII digits
>> where the sum cannot be computed.
>>
>
> Neer said you couldn't compute SOME functions.
>
>> To be correct the TM need not calculate the sum of every finite
>> set of finite strings of ASCII digits, it merely has to always
>> compute this sum correctly for any arbitrary element of the
>> finite set of finite strings.
>>
>
> NBot talking about "Sums"
>
>

I just proved that there are no countability issues with the
computability of halting on the basis that there are no countability
issues with the computation of sums.

--
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/27/23 8:50 PM, olcott wrote:
> On 1/26/2023 10:16 PM, Richard Damon wrote:
>> On 1/26/23 10:56 PM, olcott wrote:
>>> On 1/26/2023 8:37 PM, Richard Damon wrote:
>>>> On 1/26/23 7:31 PM, olcott wrote:
>>>>> On 1/26/2023 5:37 PM, Richard Damon wrote:
>>>>>> On 1/26/23 12:04 PM, olcott wrote:
>>>>>>> On 1/25/2023 10:37 PM, Richard Damon wrote:
>>>>>>>> On 1/25/23 10:58 PM, olcott wrote:
>>>>>>>>> On 1/25/2023 9:35 PM, Ben Bacarisse wrote:
>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>>
>>>>>>>>>>> On 1/25/23 8:06 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> Python <python@invalid.org> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> Peter Olcott wrote:
>>>>>>>>>>>>> ...
>>>>>>>>>>>>>> No machine can possibly be defined that divides all pairs
>>>>>>>>>>>>>> of finite
>>>>>>>>>>>>>> strings into those that represent machines would halt on
>>>>>>>>>>>>>> their input
>>>>>>>>>>>>>> when directly executed and those that do not
>>>>>>>>>>>>>
>>>>>>>>>>>>> So at least you admit that there no program can be written
>>>>>>>>>>>>> that
>>>>>>>>>>>>> is an halt decider! It took time for you to abandon your
>>>>>>>>>>>>> delusions!
>>>>>>>>>>>>
>>>>>>>>>>>> Not so fast!  Remember that PO is often fractally wrong.
>>>>>>>>>>>> Not only is he
>>>>>>>>>>>> usually wrong about the big picture he's usually wrong about
>>>>>>>>>>>> all the
>>>>>>>>>>>> details too.  In this case, he's having trouble expressing
>>>>>>>>>>>> what he
>>>>>>>>>>>> means.  This is actually just another iteration of his "it's
>>>>>>>>>>>> an invalid
>>>>>>>>>>>> question" stance, badly phrased.
>>>>>>>>>>>
>>>>>>>>>>> Meaning some times he just admits he is wrong because he
>>>>>>>>>>> fails to
>>>>>>>>>>> fashion a good enough lie and slips up and tells the truth
>>>>>>>>>>> that he
>>>>>>>>>>> doesn't beleive.
>>>>>>>>>>
>>>>>>>>>> Not quite.  Python cut off the end of the sentence.  The
>>>>>>>>>> "...because"
>>>>>>>>>> text is what shows it's the same old "some instances have no
>>>>>>>>>> correct
>>>>>>>>>> answer" in new clothing.  PO almost certainly does not stand
>>>>>>>>>> by what
>>>>>>>>>> Python quoted without the because clause.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is the case that ZFC did eliminate Russell's Paradox by
>>>>>>>>> eliminating
>>>>>>>>> its basis of a set containing itself. Under the original
>>>>>>>>> definition of
>>>>>>>>> the problem within naive set theory Russell's Paradox still
>>>>>>>>> exists.
>>>>>>>>
>>>>>>>> Not by just defining that sets can't contain themselves, but by
>>>>>>>> limiting the kind of things that sets can contain.
>>>>>>>
>>>>>>> That a set cannot contain itself is what eliminates Russell's
>>>>>>> Paradox.
>>>>>>>
>>>>>>>>>
>>>>>>>>> The halting problem proof begins with the correct basis that
>>>>>>>>> arbitrary
>>>>>>>>> pairs of finite strings either represent a computation that
>>>>>>>>> halts on its
>>>>>>>>> input or not.
>>>>>>>>>
>>>>>>>>> The proof that no machine can correctly determine this set is
>>>>>>>>> analogous
>>>>>>>>> to the Liar Paradox in that the input is specifically defined
>>>>>>>>> to do the
>>>>>>>>> opposite of whatever the halt decider determines. This
>>>>>>>>> transforms the
>>>>>>>>> halting problem into an ill-formed problem.
>>>>>>>>
>>>>>>>> Nope. Since the input is part of the domain of machine/inputs, the
>>>>>>>
>>>>>>> When we define a machine that correctly determines whether or not
>>>>>>> pairs
>>>>>>> of arbitrary finite sting inputs would reach the final state of the
>>>>>>> first element of this input then halting is computable.
>>>>>>>
>>>>>>
>>>>>> But you need to show that you CAN do that. YOu haven't
>>>>>>
>>>>>> H(P,P) says that P(P) will not halt when it does, so it fails.
>>>>>>
>>>>>>> Because the pathological input actually has different behavior
>>>>>>> when it
>>>>>>> is correctly simulated by its corresponding halt decider and the
>>>>>>> halt
>>>>>>> decider must base its halt status decision on the actual behavior of
>>>>>>> this input then the halt decider is necessarily correct to reject
>>>>>>> its
>>>>>>> pathological input as non-halting.
>>>>>>
>>>>>> No, it doesn't
>>>>>>
>>>>>> You have been asked to point what point in the actual execution of
>>>>>> H(P,P) called by P(P) call by main differs from the execution of
>>>>>> H(P,P) calledd by main diverege.
>>>>>>
>>>>>> You have failed to point that out, becaue it doesn't exist,
>>>>>> because you ar a  LIAR and an IDOIT.
>>>>>>
>>>>>> As stated before, your failure to even attempt to indicate this is
>>>>>> taken as your admission that your claim is a LIE, and you can not
>>>>>> actually prove your claim, also making you a damned hypocrite.
>>>>>>
>>>>>>>
>>>>>>> You still have not provided any counter example that shows that
>>>>>>> my definition of correct simulation is incorrect:
>>>>>>
>>>>>> LIE.
>>>>>>
>>>>>> P(P) is the counter example.
>>>>>>
>>>>>>>
>>>>>>> Try and provide a 100% specific counter-example where you show a
>>>>>>> line
>>>>>>> of machine code such as [mov eax, 1] and the simulator simulates
>>>>>>> another
>>>>>>> different line instead such as [push ebx] and the simulator is
>>>>>>> correct.
>>>>>>
>>>>>> P(P), its call H will go through the exact same set of states when
>>>>>> P(P) call s as when main calls it, thus since H(P,P) returns 0
>>>>>> when called by main, we know it does the same thing when called by
>>>>>> P (or it just fails to be the "pure function"/computation you have
>>>>>> claimex it to be)
>>>>>>
>>>>>> Since H simulats that call the H(P,P) as something that will never
>>>>>> returm, H has done an incorrect simulation.
>>>>>>
>>>>>> Your inability to understand this just shows your STUPIDITY.
>>>>>>
>>>>>>>
>>>>>>> If no such counter-example exists then it is proven that the
>>>>>>> ultimate
>>>>>>> measure of correct simulation is that the simulator simulates
>>>>>>> line-by-
>>>>>>> line exactly what the machine code specifies.
>>>>>>>
>>>>>>> ALL OF THE ARGUMENTS AGAINST MY POSITION HAVE PROVEN TO BE
>>>>>>> COUNTER-FACTUAL
>>>>>>
>>>>>> Nope, YOUR statements, have been shown to be "counter-factual" and
>>>>>> your reasoning ab
>>>>>>>
>>>>>>> (a) The simulation of the input to H(D,D) by H is correct.
>>>>>>
>>>>>> Nope, because it says H(P,P) will never return, when it doesn.
>>>>>
>>>>> Try and provide a 100% specific counter-example where you show a line
>>>>> of machine code such as [mov eax, 1] and the simulator simulates
>>>>> another
>>>>> different line instead such as [push ebx] and the simulator is
>>>>> correct.
>>>>
>>>> call H
>>>>
>>>> in actuality, it goes into H which will eventually returns.
>>>>
>>>> H "simulates" that as something that doesn't return, and doesn't
>>>> actually simulate into the function.
>>>>
>>>> Remeber, "Correct Simulation" means fully determining the behavior
>>>> of the machine, and BY DEFINITION if the machine halts and the
>>>> simulation says it doesn't, the simulation is INCORRECT.
>>>>
>>>>>
>>>>> If no such counter-example exists then it is proven that the ultimate
>>>>> measure of correct simulation is that the simulator simulates line-by-
>>>>> line exactly what the machine code specifies.
>>>>>
>>>>> Because your main tactic of rebuttal is the dishonest dodge I will
>>>>> stay
>>>>> focused on the point until you meet the challenge.
>>>>>
>>>>
>>>> I have, multiple times, but you are too stup[id to undrstand.
>>>>
>>>
>>> Show me a specific line of machine code such as [mov eax, 1] where
>>> the simulator simulates some other entirely different specific line
>>> of machine code instead such as [push ebx] *AND THE SIMULATOR IS
>>> CORRECT*
>>
>> ????
>>
>> Why are you asking me to show that the simulator was correct????
>>
>
> You have repeatedly claimed that the simulation of D by H is incorrect
> yet cannot point our a single line of code that was simulated incorrectly.
>

On 1/27/23 8:56 PM, olcott wrote:
> On 1/26/2023 10:16 PM, Richard Damon wrote:
>> On 1/26/23 10:46 PM, olcott wrote:
>>> To be correct the TM need not calculate the sum of every finite
>>> set of finite strings of ASCII digits, it merely has to always
>>> compute this sum correctly for any arbitrary element of the
>>> finite set of finite strings.
>>>
>>
>> NBot talking about "Sums"
>>
>>
>
> I just proved that there are no countability issues with the
> computability of halting on the basis that there are no countability
> issues with the computation of sums.
>

Nope. Falllicy of proof byt example.

Not all computations are "sums"

You are just proving your stupidity.

What does the "Countability of Sums" have to do with the question of an
arbitrary machine halting on a given inputy?

You are just showing you are totally out of touch with what you are saying.

On 1/27/2023 9:19 PM, Richard Damon wrote:
> On 1/27/23 8:50 PM, olcott wrote:
>> On 1/26/2023 10:16 PM, Richard Damon wrote:
>>> On 1/26/23 10:56 PM, olcott wrote:
>>>> On 1/26/2023 8:37 PM, Richard Damon wrote:
>>>>> On 1/26/23 7:31 PM, olcott wrote:
>>>>>> On 1/26/2023 5:37 PM, Richard Damon wrote:
>>>>>>> On 1/26/23 12:04 PM, olcott wrote:
>>>>>>>> On 1/25/2023 10:37 PM, Richard Damon wrote:
>>>>>>>>> On 1/25/23 10:58 PM, olcott wrote:
>>>>>>>>>> On 1/25/2023 9:35 PM, Ben Bacarisse wrote:
>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 1/25/23 8:06 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> Python <python@invalid.org> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Peter Olcott wrote:
>>>>>>>>>>>>>> ...
>>>>>>>>>>>>>>> No machine can possibly be defined that divides all pairs
>>>>>>>>>>>>>>> of finite
>>>>>>>>>>>>>>> strings into those that represent machines would halt on
>>>>>>>>>>>>>>> their input
>>>>>>>>>>>>>>> when directly executed and those that do not
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So at least you admit that there no program can be written
>>>>>>>>>>>>>> that
>>>>>>>>>>>>>> is an halt decider! It took time for you to abandon your
>>>>>>>>>>>>>> delusions!
>>>>>>>>>>>>>
>>>>>>>>>>>>> Not so fast!  Remember that PO is often fractally wrong.
>>>>>>>>>>>>> Not only is he
>>>>>>>>>>>>> usually wrong about the big picture he's usually wrong
>>>>>>>>>>>>> about all the
>>>>>>>>>>>>> details too.  In this case, he's having trouble expressing
>>>>>>>>>>>>> what he
>>>>>>>>>>>>> means.  This is actually just another iteration of his
>>>>>>>>>>>>> "it's an invalid
>>>>>>>>>>>>> question" stance, badly phrased.
>>>>>>>>>>>>
>>>>>>>>>>>> Meaning some times he just admits he is wrong because he
>>>>>>>>>>>> fails to
>>>>>>>>>>>> fashion a good enough lie and slips up and tells the truth
>>>>>>>>>>>> that he
>>>>>>>>>>>> doesn't beleive.
>>>>>>>>>>>
>>>>>>>>>>> Not quite.  Python cut off the end of the sentence.  The
>>>>>>>>>>> "...because"
>>>>>>>>>>> text is what shows it's the same old "some instances have no
>>>>>>>>>>> correct
>>>>>>>>>>> answer" in new clothing.  PO almost certainly does not stand
>>>>>>>>>>> by what
>>>>>>>>>>> Python quoted without the because clause.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is the case that ZFC did eliminate Russell's Paradox by
>>>>>>>>>> eliminating
>>>>>>>>>> its basis of a set containing itself. Under the original
>>>>>>>>>> definition of
>>>>>>>>>> the problem within naive set theory Russell's Paradox still
>>>>>>>>>> exists.
>>>>>>>>>
>>>>>>>>> Not by just defining that sets can't contain themselves, but by
>>>>>>>>> limiting the kind of things that sets can contain.
>>>>>>>>
>>>>>>>> That a set cannot contain itself is what eliminates Russell's
>>>>>>>> Paradox.
>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The halting problem proof begins with the correct basis that
>>>>>>>>>> arbitrary
>>>>>>>>>> pairs of finite strings either represent a computation that
>>>>>>>>>> halts on its
>>>>>>>>>> input or not.
>>>>>>>>>>
>>>>>>>>>> The proof that no machine can correctly determine this set is
>>>>>>>>>> analogous
>>>>>>>>>> to the Liar Paradox in that the input is specifically defined
>>>>>>>>>> to do the
>>>>>>>>>> opposite of whatever the halt decider determines. This
>>>>>>>>>> transforms the
>>>>>>>>>> halting problem into an ill-formed problem.
>>>>>>>>>
>>>>>>>>> Nope. Since the input is part of the domain of machine/inputs, the
>>>>>>>>
>>>>>>>> When we define a machine that correctly determines whether or
>>>>>>>> not pairs
>>>>>>>> of arbitrary finite sting inputs would reach the final state of the
>>>>>>>> first element of this input then halting is computable.
>>>>>>>>
>>>>>>>
>>>>>>> But you need to show that you CAN do that. YOu haven't
>>>>>>>
>>>>>>> H(P,P) says that P(P) will not halt when it does, so it fails.
>>>>>>>
>>>>>>>> Because the pathological input actually has different behavior
>>>>>>>> when it
>>>>>>>> is correctly simulated by its corresponding halt decider and the
>>>>>>>> halt
>>>>>>>> decider must base its halt status decision on the actual
>>>>>>>> behavior of
>>>>>>>> this input then the halt decider is necessarily correct to
>>>>>>>> reject its
>>>>>>>> pathological input as non-halting.
>>>>>>>
>>>>>>> No, it doesn't
>>>>>>>
>>>>>>> You have been asked to point what point in the actual execution
>>>>>>> of H(P,P) called by P(P) call by main differs from the execution
>>>>>>> of H(P,P) calledd by main diverege.
>>>>>>>
>>>>>>> You have failed to point that out, becaue it doesn't exist,
>>>>>>> because you ar a  LIAR and an IDOIT.
>>>>>>>
>>>>>>> As stated before, your failure to even attempt to indicate this
>>>>>>> is taken as your admission that your claim is a LIE, and you can
>>>>>>> not actually prove your claim, also making you a damned hypocrite.
>>>>>>>
>>>>>>>>
>>>>>>>> You still have not provided any counter example that shows that
>>>>>>>> my definition of correct simulation is incorrect:
>>>>>>>
>>>>>>> LIE.
>>>>>>>
>>>>>>> P(P) is the counter example.
>>>>>>>
>>>>>>>>
>>>>>>>> Try and provide a 100% specific counter-example where you show a
>>>>>>>> line
>>>>>>>> of machine code such as [mov eax, 1] and the simulator simulates
>>>>>>>> another
>>>>>>>> different line instead such as [push ebx] and the simulator is
>>>>>>>> correct.
>>>>>>>
>>>>>>> P(P), its call H will go through the exact same set of states
>>>>>>> when P(P) call s as when main calls it, thus since H(P,P) returns
>>>>>>> 0 when called by main, we know it does the same thing when called
>>>>>>> by P (or it just fails to be the "pure function"/computation you
>>>>>>> have claimex it to be)
>>>>>>>
>>>>>>> Since H simulats that call the H(P,P) as something that will
>>>>>>> never returm, H has done an incorrect simulation.
>>>>>>>
>>>>>>> Your inability to understand this just shows your STUPIDITY.
>>>>>>>
>>>>>>>>
>>>>>>>> If no such counter-example exists then it is proven that the
>>>>>>>> ultimate
>>>>>>>> measure of correct simulation is that the simulator simulates
>>>>>>>> line-by-
>>>>>>>> line exactly what the machine code specifies.
>>>>>>>>
>>>>>>>> ALL OF THE ARGUMENTS AGAINST MY POSITION HAVE PROVEN TO BE
>>>>>>>> COUNTER-FACTUAL
>>>>>>>
>>>>>>> Nope, YOUR statements, have been shown to be "counter-factual"
>>>>>>> and your reasoning ab
>>>>>>>>
>>>>>>>> (a) The simulation of the input to H(D,D) by H is correct.
>>>>>>>
>>>>>>> Nope, because it says H(P,P) will never return, when it doesn.
>>>>>>
>>>>>> Try and provide a 100% specific counter-example where you show a line
>>>>>> of machine code such as [mov eax, 1] and the simulator simulates
>>>>>> another
>>>>>> different line instead such as [push ebx] and the simulator is
>>>>>> correct.
>>>>>
>>>>> call H
>>>>>
>>>>> in actuality, it goes into H which will eventually returns.
>>>>>
>>>>> H "simulates" that as something that doesn't return, and doesn't
>>>>> actually simulate into the function.
>>>>>
>>>>> Remeber, "Correct Simulation" means fully determining the behavior
>>>>> of the machine, and BY DEFINITION if the machine halts and the
>>>>> simulation says it doesn't, the simulation is INCORRECT.
>>>>>
>>>>>>
>>>>>> If no such counter-example exists then it is proven that the ultimate
>>>>>> measure of correct simulation is that the simulator simulates
>>>>>> line-by-
>>>>>> line exactly what the machine code specifies.
>>>>>>
>>>>>> Because your main tactic of rebuttal is the dishonest dodge I will
>>>>>> stay
>>>>>> focused on the point until you meet the challenge.
>>>>>>
>>>>>
>>>>> I have, multiple times, but you are too stup[id to undrstand.
>>>>>
>>>>
>>>> Show me a specific line of machine code such as [mov eax, 1] where
>>>> the simulator simulates some other entirely different specific line
>>>> of machine code instead such as [push ebx] *AND THE SIMULATOR IS
>>>> CORRECT*
>>>
>>> ????
>>>
>>> Why are you asking me to show that the simulator was correct????
>>>
>>
>> You have repeatedly claimed that the simulation of D by H is incorrect
>> yet cannot point our a single line of code that was simulated
>> incorrectly.
>>
>
> No, I have repeatedly TOLD you the error, H presumes the wrong behavior
> for a call to H.
>

On 1/27/2023 9:19 PM, Richard Damon wrote:
> On 1/27/23 8:56 PM, olcott wrote:
>> On 1/26/2023 10:16 PM, Richard Damon wrote:
>>> On 1/26/23 10:46 PM, olcott wrote:
>>>> To be correct the TM need not calculate the sum of every finite
>>>> set of finite strings of ASCII digits, it merely has to always
>>>> compute this sum correctly for any arbitrary element of the
>>>> finite set of finite strings.
>>>>
>>>
>>> NBot talking about "Sums"
>>>
>>>
>>
>> I just proved that there are no countability issues with the
>> computability of halting on the basis that there are no countability
>> issues with the computation of sums.
>>
>
> Nope. Falllicy of proof byt example.
>

None-the-less if sum has no countability issue with any finite set of
finite strings then H cannot have any countability issue with any
finite pair of finite strings.

--
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/27/23 10:32 PM, olcott wrote:
> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>
>> No, I have repeatedly TOLD you the error, H presumes the wrong
>> behavior for a call to H.
>>
>
> When D calls H this is D calling H.
> If H did not abort its simulation of D then D would never stop running.
>

But it DOES abort its simulation and returns 0 to D, because that is
what it does.

IF not, what is the first instruction in Main -> D(D) -> H(D,D) that
acts differently than the path main -> H(D,D) to allow it to return 0
from second call and not from the first.

You have been asked this before, and have DUCKED, because you don't have
an answer.

Until you answer this, your claim is just a LIE made up out of fairy dust.

PUT UP or STFU.

On 1/27/23 10:34 PM, olcott wrote:
> On 1/27/2023 9:19 PM, Richard Damon wrote:
>> On 1/27/23 8:56 PM, olcott wrote:
>>> On 1/26/2023 10:16 PM, Richard Damon wrote:
>>>> On 1/26/23 10:46 PM, olcott wrote:
>>>>> To be correct the TM need not calculate the sum of every finite
>>>>> set of finite strings of ASCII digits, it merely has to always
>>>>> compute this sum correctly for any arbitrary element of the
>>>>> finite set of finite strings.
>>>>>
>>>>
>>>> NBot talking about "Sums"
>>>>
>>>>
>>>
>>> I just proved that there are no countability issues with the
>>> computability of halting on the basis that there are no countability
>>> issues with the computation of sums.
>>>
>>
>> Nope. Falllicy of proof byt example.
>>
>
> None-the-less if sum has no countability issue with any finite set of
> finite strings then H cannot have any countability issue with any
> finite pair of finite strings.
>

How do you make a countable infinite number of machine make an
uncountable number of maps.

You non-sequitur about summing just shows you don't know what you are
talking about, and you dismissing of the fallacy says you don't
understand that basics of logic. "Summing" has NOTHING to do with the
problem, except as a trivial example that shows that the decider can get
a few answers right.

All you are proving is that anyone who trust your ideas has a blind man
as a guide, who will lead them into a pit.

On 1/27/2023 9:37 PM, Richard Damon wrote:
> On 1/27/23 10:32 PM, olcott wrote:
>> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>>
>>> No, I have repeatedly TOLD you the error, H presumes the wrong
>>> behavior for a call to H.
>>>
>>
>> When D calls H this is D calling H.
>> If H did not abort its simulation of D then D would never stop running.
>>
>
> But it DOES abort its simulation and returns 0 to D, because that is
> what it does.
>

*THIS IS A TAUTOLOGY DISAGREEMENT IS DISHONEST*
Anytime that H correctly determines that its correct simulation of its
input D would never stop running unless aborted H is always correct to
abort this simulation and reject this input as non-halting.

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

int main()
{ Output("Input_Halts = ", H(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 1/27/2023 9:47 PM, Richard Damon wrote:
> On 1/27/23 10:34 PM, olcott wrote:
>> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>> On 1/27/23 8:56 PM, olcott wrote:
>>>> On 1/26/2023 10:16 PM, Richard Damon wrote:
>>>>> On 1/26/23 10:46 PM, olcott wrote:
>>>>>> To be correct the TM need not calculate the sum of every finite
>>>>>> set of finite strings of ASCII digits, it merely has to always
>>>>>> compute this sum correctly for any arbitrary element of the
>>>>>> finite set of finite strings.
>>>>>>
>>>>>
>>>>> NBot talking about "Sums"
>>>>>
>>>>>
>>>>
>>>> I just proved that there are no countability issues with the
>>>> computability of halting on the basis that there are no countability
>>>> issues with the computation of sums.
>>>>
>>>
>>> Nope. Falllicy of proof byt example.
>>>
>>
>> None-the-less if sum has no countability issue with any finite set of
>> finite strings then H cannot have any countability issue with any
>> finite pair of finite strings.
>>
>
> How do you make a countable infinite number of machine make an
> uncountable number of maps.
>

I ask you again can you count to one?

There is only one machine that always has a finite number of inputs.
We don't need any maps we only need one set of inputs deriving a single
output for any arbitrary set of inputs. When we think of this as sums
then it is obvious that countability is not an issue.

Is there any finite set of finite strings of ASCII digits that cannot be
summed by a TM? No, therefore computability is proven.

--
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/27/23 10:51 PM, olcott wrote:
> On 1/27/2023 9:37 PM, Richard Damon wrote:
>> On 1/27/23 10:32 PM, olcott wrote:
>>> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>>>
>>>> No, I have repeatedly TOLD you the error, H presumes the wrong
>>>> behavior for a call to H.
>>>>
>>>
>>> When D calls H this is D calling H.
>>> If H did not abort its simulation of D then D would never stop running.
>>>
>>
>> But it DOES abort its simulation and returns 0 to D, because that is
>> what it does.
>>
>
> *THIS IS A TAUTOLOGY DISAGREEMENT IS DISHONEST*

No, it is a LIE just like the LIARs paradox.

Your "Claim" that it is a Tautology is just a LIE, becaue it is based on
a false premise.

The fact that you haven't answered my question just proves that you are
admitting to being a Hypociritcal Pathological Lying Idiot.

> Anytime that H correctly determines that its correct simulation of its
> input D would never stop running unless aborted H is always correct to
> abort this simulation and reject this input as non-halting.

Except that the H you have provided never DOES a correct simulation so
it is illogical to make a decision based on it doing one. PERIOD.

You H LIES because it INCORRECTLY presumes that the H that D calls does
something that it doesn't do, because H doesn't meet its own requirements.

>
> void D(void (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(D, D));
> }
>
>

Thanks for proving and admitting that you are just a Hypocritical
Pathological Lying Idiot.

You Baseless lies are exosed.

On 1/27/23 10:59 PM, olcott wrote:
> On 1/27/2023 9:47 PM, Richard Damon wrote:
>> On 1/27/23 10:34 PM, olcott wrote:
>>> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>>> On 1/27/23 8:56 PM, olcott wrote:
>>>>> On 1/26/2023 10:16 PM, Richard Damon wrote:
>>>>>> On 1/26/23 10:46 PM, olcott wrote:
>>>>>>> To be correct the TM need not calculate the sum of every finite
>>>>>>> set of finite strings of ASCII digits, it merely has to always
>>>>>>> compute this sum correctly for any arbitrary element of the
>>>>>>> finite set of finite strings.
>>>>>>>
>>>>>>
>>>>>> NBot talking about "Sums"
>>>>>>
>>>>>>
>>>>>
>>>>> I just proved that there are no countability issues with the
>>>>> computability of halting on the basis that there are no countability
>>>>> issues with the computation of sums.
>>>>>
>>>>
>>>> Nope. Falllicy of proof byt example.
>>>>
>>>
>>> None-the-less if sum has no countability issue with any finite set of
>>> finite strings then H cannot have any countability issue with any
>>> finite pair of finite strings.
>>>
>>
>> How do you make a countable infinite number of machine make an
>> uncountable number of maps.
>>
>
> I ask you again can you count to one?

YTes, SO WHAT.

>
> There is only one machine that always has a finite number of inputs.
> We don't need any maps we only need one set of inputs deriving a single
> output for any arbitrary set of inputs. When we think of this as sums
> then it is obvious that countability is not an issue.

So you are saying that the machine that computes the prime factors of
its input it the same machine that computes its inputs factorial?

You DO understand that a Turing Machine can be treated as a computation
that computes a specific mapping of inputs to outputs?

Maybe not, as you are too stupid.

>
> Is there any finite set of finite strings of ASCII digits that cannot be
> summed by a TM? No, therefore computability is proven.
>

But summing isn't the only operation that a TM can do.

You are just proving you are totally ignorant of what you are talking about.

On 1/27/2023 10:02 PM, Richard Damon wrote:
> On 1/27/23 10:51 PM, olcott wrote:
>> On 1/27/2023 9:37 PM, Richard Damon wrote:
>>> On 1/27/23 10:32 PM, olcott wrote:
>>>> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>>>>
>>>>> No, I have repeatedly TOLD you the error, H presumes the wrong
>>>>> behavior for a call to H.
>>>>>
>>>>
>>>> When D calls H this is D calling H.
>>>> If H did not abort its simulation of D then D would never stop running.
>>>>
>>>
>>> But it DOES abort its simulation and returns 0 to D, because that is
>>> what it does.
>>>
>>
>> *THIS IS A TAUTOLOGY DISAGREEMENT IS DISHONEST*
>
> No, it is a LIE just like the LIARs paradox.
>
> Your "Claim" that it is a Tautology is just a LIE, becaue it is based on
> a false premise.
>
> The fact that you haven't answered my question just proves that you are
> admitting to being a Hypociritcal Pathological Lying Idiot.
>
>> Anytime that H correctly determines that its correct simulation of its
>> input D would never stop running unless aborted H is always correct to
>> abort this simulation and reject this input as non-halting.
>
> Except that the H you have provided never DOES a correct simulation so
> it is illogical to make a decision based on it doing one. PERIOD.

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.

H: Begin Simulation Execution Trace Stored at:112ae5
Address_of_H:1383
[000019b3][00112ad1][00112ad5] 55 push ebp // begin D
[000019b4][00112ad1][00112ad5] 8bec mov ebp,esp
[000019b6][00112acd][00102aa1] 51 push ecx
[000019b7][00112acd][00102aa1] 8b4508 mov eax,[ebp+08]
[000019ba][00112ac9][000019b3] 50 push eax // push D
[000019bb][00112ac9][000019b3] 8b4d08 mov ecx,[ebp+08]
[000019be][00112ac5][000019b3] 51 push ecx // push D
[000019bf][00112ac1][000019c4] e8bff9ffff call 00001383 // call H
H: Infinitely Recursive Simulation Detected Simulation Stopped

It is easier to see that the correct simulation of PP by HH would never
stop running unless aborted.

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

If H or HH were to wait for their nested simulations to abort their
simulation then the input would never be aborted because each H or HH
would wait for the next one ad infinitum.

--
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/27/23 11:14 PM, olcott wrote:
> On 1/27/2023 10:02 PM, Richard Damon wrote:
>> On 1/27/23 10:51 PM, olcott wrote:
>>> On 1/27/2023 9:37 PM, Richard Damon wrote:
>>>> On 1/27/23 10:32 PM, olcott wrote:
>>>>> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>>>>>
>>>>>> No, I have repeatedly TOLD you the error, H presumes the wrong
>>>>>> behavior for a call to H.
>>>>>>
>>>>>
>>>>> When D calls H this is D calling H.
>>>>> If H did not abort its simulation of D then D would never stop
>>>>> running.
>>>>>
>>>>
>>>> But it DOES abort its simulation and returns 0 to D, because that is
>>>> what it does.
>>>>
>>>
>>> *THIS IS A TAUTOLOGY DISAGREEMENT IS DISHONEST*
>>
>> No, it is a LIE just like the LIARs paradox.
>>
>> Your "Claim" that it is a Tautology is just a LIE, becaue it is based
>> on a false premise.
>>
>> The fact that you haven't answered my question just proves that you
>> are admitting to being a Hypociritcal Pathological Lying Idiot.
>>
>>> Anytime that H correctly determines that its correct simulation of its
>>> input D would never stop running unless aborted H is always correct to
>>> abort this simulation and reject this input as non-halting.
>>
>> Except that the H you have provided never DOES a correct simulation so
>> it is illogical to make a decision based on it doing one. PERIOD.
>
> 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.

>
> H: Begin Simulation   Execution Trace Stored at:112ae5
> Address_of_H:1383
> [000019b3][00112ad1][00112ad5] 55         push ebp       // begin D
> [000019b4][00112ad1][00112ad5] 8bec       mov ebp,esp
> [000019b6][00112acd][00102aa1] 51         push ecx
> [000019b7][00112acd][00102aa1] 8b4508     mov eax,[ebp+08]
> [000019ba][00112ac9][000019b3] 50         push eax       // push D
> [000019bb][00112ac9][000019b3] 8b4d08     mov ecx,[ebp+08]
> [000019be][00112ac5][000019b3] 51         push ecx       // push D
> [000019bf][00112ac1][000019c4] e8bff9ffff call 00001383  // call H
> H: Infinitely Recursive Simulation Detected Simulation Stopped

And H is wrong about ths.

>
> It is easier to see that the correct simulation of PP by HH would never
> stop running unless aborted.

So, H is seeing a call to H as a call to HH?

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

And this is the point the trace is incorrect as the CORRECT tracing of a
call to HH should be showing the code of HH executing,

> [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
>
> If H or HH were to wait for their nested simulations to abort their
> simulation then the input would never be aborted because each H or HH
> would wait for the next one ad infinitum.
>
>

Thank you again for confirming that you are just a Hypocirtical
Pathological Lying Ignorant Idiot.

This is an establish fact until you answer the question put to you of
wher the paths of D(D) -> H(D,D) and main -> H(D,D) differ, as that is
needed to show that H can be correct to simulate D(D)'s call to H(D,D)
as doing something different than H(D,D) does.

On 1/27/23 10:51 PM, olcott wrote:
> On 1/27/2023 9:37 PM, Richard Damon wrote:
>> On 1/27/23 10:32 PM, olcott wrote:
>>> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>>>
>>>> No, I have repeatedly TOLD you the error, H presumes the wrong
>>>> behavior for a call to H.
>>>>
>>>
>>> When D calls H this is D calling H.
>>> If H did not abort its simulation of D then D would never stop running.
>>>
>>
>> But it DOES abort its simulation and returns 0 to D, because that is
>> what it does.
>>
>
> *THIS IS A TAUTOLOGY DISAGREEMENT IS DISHONEST*
> Anytime that H correctly determines that its correct simulation of its
> input D would never stop running unless aborted H is always correct to
> abort this simulation and reject this input as non-halting.
>
> void D(void (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(D, D));
> }
>
>

I will also point out that this seems to be using the exact same logic
as the statement:

If this statement is true, Peter Olcott is a Hypocritical Pathological
Lying Ignorant Idiot.

A statment that makes a claim based on itself being true is not allowed
or you can prove ANY statment.

So, if you want to claim yours is a valid statement, so is mine, so you
are admitting that you are uneqivically a Hypocritical Pathological
Lying Ignorant Idiot.

On 1/27/2023 10:05 PM, Richard Damon wrote:
> On 1/27/23 10:59 PM, olcott wrote:
>> On 1/27/2023 9:47 PM, Richard Damon wrote:
>>> On 1/27/23 10:34 PM, olcott wrote:
>>>> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>>>> On 1/27/23 8:56 PM, olcott wrote:
>>>>>> On 1/26/2023 10:16 PM, Richard Damon wrote:
>>>>>>> On 1/26/23 10:46 PM, olcott wrote:
>>>>>>>> To be correct the TM need not calculate the sum of every finite
>>>>>>>> set of finite strings of ASCII digits, it merely has to always
>>>>>>>> compute this sum correctly for any arbitrary element of the
>>>>>>>> finite set of finite strings.
>>>>>>>>
>>>>>>>
>>>>>>> NBot talking about "Sums"
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> I just proved that there are no countability issues with the
>>>>>> computability of halting on the basis that there are no countability
>>>>>> issues with the computation of sums.
>>>>>>
>>>>>
>>>>> Nope. Falllicy of proof byt example.
>>>>>
>>>>
>>>> None-the-less if sum has no countability issue with any finite set of
>>>> finite strings then H cannot have any countability issue with any
>>>> finite pair of finite strings.
>>>>
>>>
>>> How do you make a countable infinite number of machine make an
>>> uncountable number of maps.
>>>
>>
>> I ask you again can you count to one?
>
> YTes, SO WHAT.
>
>>
>> There is only one machine that always has a finite number of inputs.
>> We don't need any maps we only need one set of inputs deriving a single
>> output for any arbitrary set of inputs. When we think of this as sums
>> then it is obvious that countability is not an issue.
>
> So you are saying that the machine that computes the prime factors of
> its input it the same machine that computes its inputs factorial?
>
> You DO understand that a Turing Machine can be treated as a computation
> that computes a specific mapping of inputs to outputs?
>

A TM must only compute the mapping from any arbitrary finite set of
inputs to its finite set of outputs.

> Maybe not, as you are too stupid.
>
>>
>> Is there any finite set of finite strings of ASCII digits that cannot be
>> summed by a TM? No, therefore computability is proven.
>>
>
> But summing isn't the only operation that a TM can do.

That there is never any countability issue in the computing mapping of
one arbitrary finite set of inputs to its corresponding finite set of
outputs with any computation at all proves that there is no such issue
for summing or halt status detection.

If X always works then X always works with Y or Z.

>
> You are just proving you are totally ignorant of what you are talking
> about.

--
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/27/23 11:47 PM, olcott wrote:
> On 1/27/2023 10:05 PM, Richard Damon wrote:
>> On 1/27/23 10:59 PM, olcott wrote:
>>> On 1/27/2023 9:47 PM, Richard Damon wrote:
>>>> On 1/27/23 10:34 PM, olcott wrote:
>>>>> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>>>>> On 1/27/23 8:56 PM, olcott wrote:
>>>>>>> On 1/26/2023 10:16 PM, Richard Damon wrote:
>>>>>>>> On 1/26/23 10:46 PM, olcott wrote:
>>>>>>>>> To be correct the TM need not calculate the sum of every finite
>>>>>>>>> set of finite strings of ASCII digits, it merely has to always
>>>>>>>>> compute this sum correctly for any arbitrary element of the
>>>>>>>>> finite set of finite strings.
>>>>>>>>>
>>>>>>>>
>>>>>>>> NBot talking about "Sums"
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> I just proved that there are no countability issues with the
>>>>>>> computability of halting on the basis that there are no countability
>>>>>>> issues with the computation of sums.
>>>>>>>
>>>>>>
>>>>>> Nope. Falllicy of proof byt example.
>>>>>>
>>>>>
>>>>> None-the-less if sum has no countability issue with any finite set of
>>>>> finite strings then H cannot have any countability issue with any
>>>>> finite pair of finite strings.
>>>>>
>>>>
>>>> How do you make a countable infinite number of machine make an
>>>> uncountable number of maps.
>>>>
>>>
>>> I ask you again can you count to one?
>>
>> YTes, SO WHAT.
>>
>>>
>>> There is only one machine that always has a finite number of inputs.
>>> We don't need any maps we only need one set of inputs deriving a single
>>> output for any arbitrary set of inputs. When we think of this as sums
>>> then it is obvious that countability is not an issue.
>>
>> So you are saying that the machine that computes the prime factors of
>> its input it the same machine that computes its inputs factorial?
>>
>> You DO understand that a Turing Machine can be treated as a
>> computation that computes a specific mapping of inputs to outputs?
>>
>
> A TM must only compute the mapping from any arbitrary finite set of
> inputs to its finite set of outputs.
>
>> Maybe not, as you are too stupid.
>>
>>>
>>> Is there any finite set of finite strings of ASCII digits that cannot be
>>> summed by a TM? No, therefore computability is proven.
>>>
>>
>> But summing isn't the only operation that a TM can do.
>
> That there is never any countability issue in the computing mapping of
> one arbitrary finite set of inputs to its corresponding finite set of
> outputs with any computation at all proves that there is no such issue
> for summing or halt status detection.

So you are claiming that proof by example is true, that if one example
out of a set is true, the statement is true for all?

The fact that ONE machine can be counted, doesn't mean that all can be.

>
> If X always works then X always works with Y or Z.

So if this statement is true, you are a Hypocritical Pathological Lying
Idiot.

That statement must be true, because it only makes an assurtion if it is
true,

Thus you ARE a Hypocritical Pathological Lying Idiot.

You are just proving you like to make all the mistakes that history has
found in logic, because you refuse to learn from it.

>
>>
>> You are just proving you are totally ignorant of what you are talking
>> about.
>