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.
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.
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.
In the study of problem solving, any problem in which the initial
state or starting position, the allowable operations, and the goal
state are clearly specified, and a unique solution can be shown to
exist.
*a unique solution can be shown to exist*
or the problem itself is ill-defined
https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947
*I have been saying this for decades*
Every undecidable decision problem is necessarily erroneous.
*Finally www.oxfordreference.com agrees*
When we redefine the problem from arbitrary pairs of finite strings to arbitrary pairs of finite string inputs to a decider then the liar
paradox issue goes away. H(D,D) does correctly determine that its
correct simulation of its input would never stop running unless aborted.
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:Not so fast! Remember that PO is often fractally wrong. Not only >>>>> is he
...
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! >>>>>
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.
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
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:Not so fast! Remember that PO is often fractally wrong. Not only >>>>>> is he
...
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! >>>>>>
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.
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.
You still have not provided any counter example that shows that my
definition of correct simulation is incorrect:
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.
ALL OF THE ARGUMENTS AGAINST MY POSITION HAVE PROVEN TO BE COUNTER-FACTUAL
(a) The simulation of the input to H(D,D) by H is correct.
(b) D correctly simulated by H would never stop running unless aborted.
(c) Therefore H is necessarily correct to abort its simulation of D and
reject D as non-halting.
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
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:Not so fast! Remember that PO is often fractally wrong. Not
...
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! >>>>>>>
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.
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.
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:Not by just defining that sets can't contain themselves, but by
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. >>>>>
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.
P(P), its call H will go through the exact same set of states when
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) 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.
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:Not by just defining that sets can't contain themselves, but by
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. >>>>>>
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*
If this is impossible then my standard of correct simulation is proven
to be 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:call H
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:Not by just defining that sets can't contain themselves, but by
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. >>>>>>>
limiting the kind of things that sets can contain.
That a set cannot contain itself is what eliminates Russell's
Paradox.
When we define a machine that correctly determines whether or not
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 >>>>>>
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. >>>
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: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.
When we define a machine that correctly determines whether or not >>>>>>> pairs
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 >>>>>>>
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: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.
When we define a machine that correctly determines whether or
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 >>>>>>>>
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:
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.
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.
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));
}
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.
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));
}
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.
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.
On 1/27/2023 10:21 PM, Richard Damon wrote:
On 1/27/23 11:14 PM, olcott wrote:
H does a correct simulation of the first seven lines of D and upon
encountering the 8th line of D correctly determines that D would never
stop running unless aborted.
Nope, that is an INCORRECT conclusion, because the actual behavior of
that call to H by D(D) will be to abort ITS simulation (which is a
different instance, which is also an incorrect action) and return 0.
Thus H gets the wrong answer because it presumes that H will not get
the wrong answer when it does.
Until you provide the instruction in that direct execution of D(D)
that differs from the execution of H(D,D) when called by main, you are
just admitting that you are a Hypocritical Patholgical Lying Ignorant
Idiot.
In other words you are trying to get away with the counter-factual claim
that D correctly simulated by H would eventually reach its own final
state and terminate normally.
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.
If I was wrong you could point to a mistake.
Because you know that I am correct you cannot point to any mistake.
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.
In other words you have no rebuttal to my claim because you know that I
just proved that I am correct.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 297 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 99:51:23 |
| Calls: | 6,659 |
| Calls today: | 1 |
| Files: | 12,208 |
| Messages: | 5,334,676 |