On 5/23/2022 10:16 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 11:08:54 PM UTC-4, olcott wrote:
On 5/23/2022 10:05 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 11:01:56 PM UTC-4, olcott wrote:
On 5/23/2022 9:57 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:48:39 PM UTC-4, olcott wrote:
On 5/23/2022 9:40 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:32:55 PM UTC-4, olcott wrote:
On 5/23/2022 9:23 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:18:37 PM UTC-4, olcott wrote: >>>>>>>>>>> On 5/23/2022 9:09 PM, Dennis Bush wrote:It is just like you are saying that because the dog named Spot >>>>>>>>> is black
On Monday, May 23, 2022 at 9:50:28 PM UTC-4, olcott wrote: >>>>>>>>>>>>> On 5/23/2022 8:40 PM, Richard Damon wrote:No we will not.
Then we'll refer to H as Ha and refer to P as Pa.On 5/23/22 9:34 PM, olcott wrote:I get to decide what is on topic and what is off topic, I >>>>>>>>>>>>> own the topic.
On 5/23/2022 8:29 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 9:24:47 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>>> On 5/23/2022 8:15 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 9:08:54 PM UTC-4, olcott >>>>>>>>>>>>>>>>>> wrote:It not irrelevant jackass it proves that H can detect >>>>>>>>>>>>>>>>> that an infinite
On 5/23/2022 8:05 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 8:57:46 PM UTC-4, olcott >>>>>>>>>>>>>>>>>>>> wrote:
On 5/23/2022 7:44 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 7:50:36 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>> olcott wrote:
On 5/23/2022 6:33 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>But since H has a fixed algorithm, it can't >>>>>>>>>>>>>>>>>>>>>> simulate for an
On 5/23/22 3:05 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 1:52 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> A simple multiple choice question for Olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>The C function H correctly determines that there >>>>>>>>>>>>>>>>>>>>>>> are no number
You consider that H(P,P) == 0 is correct when >>>>>>>>>>>>>>>>>>>>>>>> P(P) halts,All things being equal which is more likely: >>>>>>>>>>>>>>>>>>>>>>>>>>
(a) Olcott is correct and everybody else is >>>>>>>>>>>>>>>>>>>>>>>>>> incorrect
(b) Olcott is incorrect and everybody else is >>>>>>>>>>>>>>>>>>>>>>>>>> correct
?
/Flibble
Believability has the word [lie] embedded >>>>>>>>>>>>>>>>>>>>>>>>> directly within
itself.
Instead of the fake measure of credibility one >>>>>>>>>>>>>>>>>>>>>>>>> must employ
actual
validation.
Actual validation conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0
is correct. This means that everyone that >>>>>>>>>>>>>>>>>>>>>>>>> disagrees is either
insufficiently technically competent or a liar. >>>>>>>>>>>>>>>>>>>>>>>>
when that is
the DEFINITION of what H(P,P) is supposed to be >>>>>>>>>>>>>>>>>>>>>>>> answering?
of steps
(0 to infinity) of its correct simulation of its >>>>>>>>>>>>>>>>>>>>>>> input: a pair of
pointers to finite strings of x86 machine >>>>>>>>>>>>>>>>>>>>>>> language that would
ever reach
the last instruction of this input. >>>>>>>>>>>>>>>>>>>>>>
infinite number of steps. It can only simulate P >>>>>>>>>>>>>>>>>>>>>> for some n
number of steps.
None-the-less on the basis of matching known >>>>>>>>>>>>>>>>>>>>> behavior patterns H
can
determine what the behavior of the input would be >>>>>>>>>>>>>>>>>>>>> if it did
simulate an
infinite number of steps.
So because Pn(Pn) does not halt then Ha(Pa,Pa)==0 is >>>>>>>>>>>>>>>>>>>> correct?
No jackass, infinite loop does not halt because >>>>>>>>>>>>>>>>>>> infinite loop is an
infinite loop.
_Infinite_Loop()
[000012c2](01) 55 push ebp
[000012c3](02) 8bec mov ebp,esp
[000012c5](02) ebfe jmp 000012c5
[000012c7](01) 5d pop ebp
[000012c8](01) c3 ret
Size in bytes:(0007) [000012
Irrelevant, because this isn't part of any P. >>>>>>>>>>>>>>>>>>
simulation would never halt without performing an >>>>>>>>>>>>>>>>> infinite simulation.
An infinite loop and the infinite simulation in Pn(Pn) >>>>>>>>>>>>>>>> are different,
It sure is _Infinite_Loop() is on topic and H(P,P) is on >>>>>>>>>>>>>>> topic
and Pn(Pn) is a strawman error intentionally designed to >>>>>>>>>>>>>>> deceive.
If _Infinite_Loop, which isn't at all related to P is on >>>>>>>>>>>>>> topic, then Pn,
which is one of the P's you talk about must be.
Remember, you confusingly talk about a CLASS of H's since >>>>>>>>>>>>>> the H you keepI am referring to one machine language immutable literal >>>>>>>>>>>>> string named H
on mentioning doesn't have a distinct rule (since if >>>>>>>>>>>>>> changes how much is
simulates to be every possible length of simulation), thus >>>>>>>>>>>>>> giving them
distinct names is a reasonable thing to do.
and another immutable machine language literal string named P. >>>>>>>>>>>>
We all know exactly why not. Because by being clear about
which H and which P we're talking about, it exposes the holes >>>>>>>>>> in your argument and makes it clear exactly where the problem >>>>>>>>>> is. So as Ben has said, clarity is your enemy.
So explain exactly what is wrong with the below statement. >>>>>>>>>> Failure to explain in detail why it is wrong in your next post >>>>>>>>>> will be taken as not being able to explain why it is wrong and >>>>>>>>>> an acceptance that it is correct. Stating "strawman" without >>>>>>>>>> an explanation will be taken as a failure to explain.
Simulating the input to Ha(Pa,Pa) up to an infinite number of >>>>>>>>>> steps is done by UTM(Pa,Pa) which halts, so Ha(Pa,Pa)==0 is >>>>>>>>>> wrong. And Hb(Pa,Pa)==1 which also shows that Ha(Pa,Pa)==0 is >>>>>>>>>> wrong. And yes the input to Ha(Pa,Pa) is the same as the input >>>>>>>>>> to Hb(Pa,Pa), and you have no basis to claim otherwise.
and the cat named Fluffy is white therefore the dog named Rover >>>>>>>>> cannot
be brown.
Ha(Pa,Pa)
Hb(Pa,Pa)
They are not identical therefore it is either ridiculously stupid toHow dishonest can you get?P does not call anything besides HSimulate(Pa,Pa)I know that you *claim* they are distinct, but you have nothing >>>>>>>> to back that up. Both Ha and Hb are halt deciders and both are >>>>>>>> given the same exact input.
are computationally distinct at the x86 machine language level >>>>>>>>> and you have always known this therefore you are a damned liar. >>>>>>>>
And because the fixed algorithm of H aborts, then H is the same as >>>>>> Ha and P is therefore the same as Pa.
It is the same as if you claimed that 5 == 6
Because they have entirely different execution traces
They're identical up to the point that Ha aborts,
claim that they should have the same behavior or in your case (because
we know that you are not stupid) it would be dishonest.
If Ha(Pa,Pa) and Hb(Pa,Pa) are not identical because as you claim the
traces differ, then that would also mean that
Since you always knew this: that you are a liar when
you claimed that they are equivalent.
to back that up.I know that you *claim* they are distinct, but you have nothing
I don't think that we are getting anywhere.
All of the recent discussions are simply disagreement with an easily verifiable fact. Any smart software engineer with a sufficient technical background can easily confirm that H(P,P)==0 is correct:
Where H is a C function that correctly emulates its input pair of finite strings of the x86 machine code of function P and criterion for
returning 0 is that the simulated P would never reach its "ret"
instruction.
The only other remaining objection is whether or not a halt decider must compute the mapping of its input finite strings to an accept or reject
state on the basis of the actual behavior actually specified by its
input OR SOME OTHER MEASURE.
Halting problem undecidability and infinitely nested simulation (V5)
https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
That is all that any of you have and good software engineering refutes
the first and good computer science refutes the second.
On 5/23/22 11:47 PM, olcott wrote:
On 5/23/2022 10:16 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 11:08:54 PM UTC-4, olcott wrote:
On 5/23/2022 10:05 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 11:01:56 PM UTC-4, olcott wrote:
On 5/23/2022 9:57 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:48:39 PM UTC-4, olcott wrote:
On 5/23/2022 9:40 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:32:55 PM UTC-4, olcott wrote: >>>>>>>>>> On 5/23/2022 9:23 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:18:37 PM UTC-4, olcott wrote: >>>>>>>>>>>> On 5/23/2022 9:09 PM, Dennis Bush wrote:It is just like you are saying that because the dog named Spot >>>>>>>>>> is black
On Monday, May 23, 2022 at 9:50:28 PM UTC-4, olcott wrote: >>>>>>>>>>>>>> On 5/23/2022 8:40 PM, Richard Damon wrote:No we will not.
On 5/23/22 9:34 PM, olcott wrote:I get to decide what is on topic and what is off topic, I >>>>>>>>>>>>>> own the topic.
On 5/23/2022 8:29 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 9:24:47 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>>>> On 5/23/2022 8:15 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 9:08:54 PM UTC-4, olcott >>>>>>>>>>>>>>>>>>> wrote:It not irrelevant jackass it proves that H can detect >>>>>>>>>>>>>>>>>> that an infinite
On 5/23/2022 8:05 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 8:57:46 PM UTC-4, olcott >>>>>>>>>>>>>>>>>>>>> wrote:
On 5/23/2022 7:44 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 7:50:36 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
On 5/23/2022 6:33 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>But since H has a fixed algorithm, it can't >>>>>>>>>>>>>>>>>>>>>>> simulate for an
On 5/23/22 3:05 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 1:52 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> A simple multiple choice question for Olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>The C function H correctly determines that there >>>>>>>>>>>>>>>>>>>>>>>> are no number
You consider that H(P,P) == 0 is correct when >>>>>>>>>>>>>>>>>>>>>>>>> P(P) halts,All things being equal which is more likely: >>>>>>>>>>>>>>>>>>>>>>>>>>>
(a) Olcott is correct and everybody else is >>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect
(b) Olcott is incorrect and everybody else is >>>>>>>>>>>>>>>>>>>>>>>>>>> correct
?
/Flibble
Believability has the word [lie] embedded >>>>>>>>>>>>>>>>>>>>>>>>>> directly within
itself.
Instead of the fake measure of credibility one >>>>>>>>>>>>>>>>>>>>>>>>>> must employ
actual
validation.
Actual validation conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0
is correct. This means that everyone that >>>>>>>>>>>>>>>>>>>>>>>>>> disagrees is either
insufficiently technically competent or a liar. >>>>>>>>>>>>>>>>>>>>>>>>>
when that is
the DEFINITION of what H(P,P) is supposed to be >>>>>>>>>>>>>>>>>>>>>>>>> answering?
of steps
(0 to infinity) of its correct simulation of its >>>>>>>>>>>>>>>>>>>>>>>> input: a pair of
pointers to finite strings of x86 machine >>>>>>>>>>>>>>>>>>>>>>>> language that would
ever reach
the last instruction of this input. >>>>>>>>>>>>>>>>>>>>>>>
infinite number of steps. It can only simulate P >>>>>>>>>>>>>>>>>>>>>>> for some n
number of steps.
None-the-less on the basis of matching known >>>>>>>>>>>>>>>>>>>>>> behavior patterns H
can
determine what the behavior of the input would be >>>>>>>>>>>>>>>>>>>>>> if it did
simulate an
infinite number of steps.
So because Pn(Pn) does not halt then Ha(Pa,Pa)==0 >>>>>>>>>>>>>>>>>>>>> is correct?
No jackass, infinite loop does not halt because >>>>>>>>>>>>>>>>>>>> infinite loop is an
infinite loop.
_Infinite_Loop()
[000012c2](01) 55 push ebp
[000012c3](02) 8bec mov ebp,esp
[000012c5](02) ebfe jmp 000012c5
[000012c7](01) 5d pop ebp
[000012c8](01) c3 ret
Size in bytes:(0007) [000012
Irrelevant, because this isn't part of any P. >>>>>>>>>>>>>>>>>>>
simulation would never halt without performing an >>>>>>>>>>>>>>>>>> infinite simulation.
An infinite loop and the infinite simulation in Pn(Pn) >>>>>>>>>>>>>>>>> are different,
It sure is _Infinite_Loop() is on topic and H(P,P) is on >>>>>>>>>>>>>>>> topic
and Pn(Pn) is a strawman error intentionally designed to >>>>>>>>>>>>>>>> deceive.
If _Infinite_Loop, which isn't at all related to P is on >>>>>>>>>>>>>>> topic, then Pn,
which is one of the P's you talk about must be.
Remember, you confusingly talk about a CLASS of H's since >>>>>>>>>>>>>>> the H you keepI am referring to one machine language immutable literal >>>>>>>>>>>>>> string named H
on mentioning doesn't have a distinct rule (since if >>>>>>>>>>>>>>> changes how much is
simulates to be every possible length of simulation), >>>>>>>>>>>>>>> thus giving them
distinct names is a reasonable thing to do.
and another immutable machine language literal string >>>>>>>>>>>>>> named P.
Then we'll refer to H as Ha and refer to P as Pa.
We all know exactly why not. Because by being clear about >>>>>>>>>>> which H and which P we're talking about, it exposes the holes >>>>>>>>>>> in your argument and makes it clear exactly where the problem >>>>>>>>>>> is. So as Ben has said, clarity is your enemy.
So explain exactly what is wrong with the below statement. >>>>>>>>>>> Failure to explain in detail why it is wrong in your next >>>>>>>>>>> post will be taken as not being able to explain why it is >>>>>>>>>>> wrong and an acceptance that it is correct. Stating
"strawman" without an explanation will be taken as a failure >>>>>>>>>>> to explain.
Simulating the input to Ha(Pa,Pa) up to an infinite number of >>>>>>>>>>> steps is done by UTM(Pa,Pa) which halts, so Ha(Pa,Pa)==0 is >>>>>>>>>>> wrong. And Hb(Pa,Pa)==1 which also shows that Ha(Pa,Pa)==0 is >>>>>>>>>>> wrong. And yes the input to Ha(Pa,Pa) is the same as the >>>>>>>>>>> input to Hb(Pa,Pa), and you have no basis to claim otherwise. >>>>>>>>>>>
and the cat named Fluffy is white therefore the dog named
Rover cannot
be brown.
Ha(Pa,Pa)
Hb(Pa,Pa)
They are not identical therefore it is either ridiculously stupid toHow dishonest can you get?P does not call anything besides HSimulate(Pa,Pa)I know that you *claim* they are distinct, but you have nothing >>>>>>>>> to back that up. Both Ha and Hb are halt deciders and both are >>>>>>>>> given the same exact input.
are computationally distinct at the x86 machine language level >>>>>>>>>> and you have always known this therefore you are a damned liar. >>>>>>>>>
And because the fixed algorithm of H aborts, then H is the same
as Ha and P is therefore the same as Pa.
It is the same as if you claimed that 5 == 6
Because they have entirely different execution traces
They're identical up to the point that Ha aborts,
claim that they should have the same behavior or in your case (because >>>> we know that you are not stupid) it would be dishonest.
If Ha(Pa,Pa) and Hb(Pa,Pa) are not identical because as you claim the
traces differ, then that would also mean that
Since you always knew this: that you are a liar when
you claimed that they are equivalent.
nothing to back that up.I know that you *claim* they are distinct, but you have
I don't think that we are getting anywhere.
All of the recent discussions are simply disagreement with an easily
verifiable fact. Any smart software engineer with a sufficient
technical background can easily confirm that H(P,P)==0 is correct:
No, they can confirm that it MUST be INCORECT by the requirement of H.
P(P) will Halt if H(P,P) returns 0.
H(P,P) is REQUIRED to return 1 if P(P) halts, that is the DEFINITION of
a Halting Decider, thus H is wrong.
You are NOT allowed to change the Definition of the problem and still
claim to be working on the problem.
That is like you saying it is ok to say "I have no dogs in my house"
when someone asks "Howmany Cats are in your houst?"
Where H is a C function that correctly emulates its input pair of
finite strings of the x86 machine code of function P and criterion for
returning 0 is that the simulated P would never reach its "ret"
instruction.
Except that it DOESN'T correctly emulates its input if it aborts it.
And your finite string that you claim is P doesn't define the program P
as it refers to code outside the string. (PROGRAMS are complete, and
Halting is defined on COMPLETE PROGRAMS).
The only other remaining objection is whether or not a halt decider
must compute the mapping of its input finite strings to an accept or
reject state on the basis of the actual behavior actually specified by
its input OR SOME OTHER MEASURE.
Right, and the BEHAVIOR OF THE INPUT for H(P,P) IS *DEFINED* to be
whether P(P) Halts or not. Any other defintion and you are not working
on the Halting Problem.
Halting problem undecidability and infinitely nested simulation (V5)
https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
Just a bunch of garbage that shows you don't know what you are talking
about. Detail reviews given previously.
That is all that any of you have and good software engineering refutes
the first and good computer science refutes the second.
Nope, GOOD computer science shows that you are not good at computer
science and fail to comprehend even the basics of it.
On 5/23/2022 11:22 PM, Richard Damon wrote:
On 5/23/22 11:47 PM, olcott wrote:
On 5/23/2022 10:16 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 11:08:54 PM UTC-4, olcott wrote:
On 5/23/2022 10:05 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 11:01:56 PM UTC-4, olcott wrote:
On 5/23/2022 9:57 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:48:39 PM UTC-4, olcott wrote:
On 5/23/2022 9:40 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:32:55 PM UTC-4, olcott wrote: >>>>>>>>>>> On 5/23/2022 9:23 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:18:37 PM UTC-4, olcott wrote: >>>>>>>>>>>>> On 5/23/2022 9:09 PM, Dennis Bush wrote:It is just like you are saying that because the dog named >>>>>>>>>>> Spot is black
On Monday, May 23, 2022 at 9:50:28 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>> On 5/23/2022 8:40 PM, Richard Damon wrote:No we will not.
On 5/23/22 9:34 PM, olcott wrote:I get to decide what is on topic and what is off topic, I >>>>>>>>>>>>>>> own the topic.
On 5/23/2022 8:29 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 9:24:47 PM UTC-4, olcott >>>>>>>>>>>>>>>>>> wrote:
On 5/23/2022 8:15 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 9:08:54 PM UTC-4, olcott >>>>>>>>>>>>>>>>>>>> wrote:
It not irrelevant jackass it proves that H can detect >>>>>>>>>>>>>>>>>>> that an infiniteOn 5/23/2022 8:05 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 8:57:46 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>> olcott wrote:
On 5/23/2022 7:44 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 7:50:36 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
On 5/23/2022 6:33 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>But since H has a fixed algorithm, it can't >>>>>>>>>>>>>>>>>>>>>>>> simulate for an
On 5/23/22 3:05 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 1:52 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> A simple multiple choice question for Olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>The C function H correctly determines that >>>>>>>>>>>>>>>>>>>>>>>>> there are no number
You consider that H(P,P) == 0 is correct when >>>>>>>>>>>>>>>>>>>>>>>>>> P(P) halts,All things being equal which is more likely: >>>>>>>>>>>>>>>>>>>>>>>>>>>>
(a) Olcott is correct and everybody else is >>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect
(b) Olcott is incorrect and everybody else >>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct
?
/Flibble
Believability has the word [lie] embedded >>>>>>>>>>>>>>>>>>>>>>>>>>> directly within
itself.
Instead of the fake measure of credibility >>>>>>>>>>>>>>>>>>>>>>>>>>> one must employ
actual
validation.
Actual validation conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0
is correct. This means that everyone that >>>>>>>>>>>>>>>>>>>>>>>>>>> disagrees is either
insufficiently technically competent or a liar. >>>>>>>>>>>>>>>>>>>>>>>>>>
when that is
the DEFINITION of what H(P,P) is supposed to >>>>>>>>>>>>>>>>>>>>>>>>>> be answering?
of steps
(0 to infinity) of its correct simulation of >>>>>>>>>>>>>>>>>>>>>>>>> its input: a pair of
pointers to finite strings of x86 machine >>>>>>>>>>>>>>>>>>>>>>>>> language that would
ever reach
the last instruction of this input. >>>>>>>>>>>>>>>>>>>>>>>>
infinite number of steps. It can only simulate P >>>>>>>>>>>>>>>>>>>>>>>> for some n
number of steps.
None-the-less on the basis of matching known >>>>>>>>>>>>>>>>>>>>>>> behavior patterns H
can
determine what the behavior of the input would be >>>>>>>>>>>>>>>>>>>>>>> if it did
simulate an
infinite number of steps.
So because Pn(Pn) does not halt then Ha(Pa,Pa)==0 >>>>>>>>>>>>>>>>>>>>>> is correct?
No jackass, infinite loop does not halt because >>>>>>>>>>>>>>>>>>>>> infinite loop is an
infinite loop.
_Infinite_Loop()
[000012c2](01) 55 push ebp
[000012c3](02) 8bec mov ebp,esp
[000012c5](02) ebfe jmp 000012c5
[000012c7](01) 5d pop ebp
[000012c8](01) c3 ret
Size in bytes:(0007) [000012
Irrelevant, because this isn't part of any P. >>>>>>>>>>>>>>>>>>>>
simulation would never halt without performing an >>>>>>>>>>>>>>>>>>> infinite simulation.
An infinite loop and the infinite simulation in Pn(Pn) >>>>>>>>>>>>>>>>>> are different,
It sure is _Infinite_Loop() is on topic and H(P,P) is >>>>>>>>>>>>>>>>> on topic
and Pn(Pn) is a strawman error intentionally designed >>>>>>>>>>>>>>>>> to deceive.
If _Infinite_Loop, which isn't at all related to P is on >>>>>>>>>>>>>>>> topic, then Pn,
which is one of the P's you talk about must be. >>>>>>>>>>>>>>>>
Remember, you confusingly talk about a CLASS of H's >>>>>>>>>>>>>>>> since the H you keepI am referring to one machine language immutable literal >>>>>>>>>>>>>>> string named H
on mentioning doesn't have a distinct rule (since if >>>>>>>>>>>>>>>> changes how much is
simulates to be every possible length of simulation), >>>>>>>>>>>>>>>> thus giving them
distinct names is a reasonable thing to do.
and another immutable machine language literal string >>>>>>>>>>>>>>> named P.
Then we'll refer to H as Ha and refer to P as Pa.
We all know exactly why not. Because by being clear about >>>>>>>>>>>> which H and which P we're talking about, it exposes the >>>>>>>>>>>> holes in your argument and makes it clear exactly where the >>>>>>>>>>>> problem is. So as Ben has said, clarity is your enemy. >>>>>>>>>>>>
So explain exactly what is wrong with the below statement. >>>>>>>>>>>> Failure to explain in detail why it is wrong in your next >>>>>>>>>>>> post will be taken as not being able to explain why it is >>>>>>>>>>>> wrong and an acceptance that it is correct. Stating
"strawman" without an explanation will be taken as a failure >>>>>>>>>>>> to explain.
Simulating the input to Ha(Pa,Pa) up to an infinite number >>>>>>>>>>>> of steps is done by UTM(Pa,Pa) which halts, so Ha(Pa,Pa)==0 >>>>>>>>>>>> is wrong. And Hb(Pa,Pa)==1 which also shows that
Ha(Pa,Pa)==0 is wrong. And yes the input to Ha(Pa,Pa) is the >>>>>>>>>>>> same as the input to Hb(Pa,Pa), and you have no basis to >>>>>>>>>>>> claim otherwise.
and the cat named Fluffy is white therefore the dog named >>>>>>>>>>> Rover cannot
be brown.
Ha(Pa,Pa)
Hb(Pa,Pa)
They are not identical therefore it is either ridiculously stupid to >>>>> claim that they should have the same behavior or in your case (because >>>>> we know that you are not stupid) it would be dishonest.How dishonest can you get?P does not call anything besides HSimulate(Pa,Pa)I know that you *claim* they are distinct, but you have
are computationally distinct at the x86 machine language level >>>>>>>>>>> and you have always known this therefore you are a damned liar. >>>>>>>>>>
nothing to back that up. Both Ha and Hb are halt deciders and >>>>>>>>>> both are given the same exact input.
And because the fixed algorithm of H aborts, then H is the same >>>>>>>> as Ha and P is therefore the same as Pa.
It is the same as if you claimed that 5 == 6
Because they have entirely different execution traces
They're identical up to the point that Ha aborts,
If Ha(Pa,Pa) and Hb(Pa,Pa) are not identical because as you claim
the traces differ, then that would also mean that
Since you always knew this: that you are a liar when
you claimed that they are equivalent.
nothing to back that up.I know that you *claim* they are distinct, but you have
I don't think that we are getting anywhere.
All of the recent discussions are simply disagreement with an easily
verifiable fact. Any smart software engineer with a sufficient
technical background can easily confirm that H(P,P)==0 is correct:
No, they can confirm that it MUST be INCORECT by the requirement of H.
P(P) will Halt if H(P,P) returns 0.
H(P,P) is REQUIRED to return 1 if P(P) halts, that is the DEFINITION
of a Halting Decider, thus H is wrong.
You are NOT allowed to change the Definition of the problem and still
claim to be working on the problem.
That is like you saying it is ok to say "I have no dogs in my house"
when someone asks "Howmany Cats are in your houst?"
Where H is a C function that correctly emulates its input pair of
finite strings of the x86 machine code of function P and criterion
for returning 0 is that the simulated P would never reach its "ret"
instruction.
Except that it DOESN'T correctly emulates its input if it aborts it.
And your finite string that you claim is P doesn't define the program
P as it refers to code outside the string. (PROGRAMS are complete, and
Halting is defined on COMPLETE PROGRAMS).
The only other remaining objection is whether or not a halt decider
must compute the mapping of its input finite strings to an accept or
reject state on the basis of the actual behavior actually specified
by its input OR SOME OTHER MEASURE.
Right, and the BEHAVIOR OF THE INPUT for H(P,P) IS *DEFINED* to be
whether P(P) Halts or not. Any other defintion and you are not working
on the Halting Problem.
Halting problem undecidability and infinitely nested simulation (V5)
https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
Just a bunch of garbage that shows you don't know what you are talking
about. Detail reviews given previously.
That is all that any of you have and good software engineering
refutes the first and good computer science refutes the second.
Nope, GOOD computer science shows that you are not good at computer
science and fail to comprehend even the basics of it.
(1) Good software engineering proves that H(P,P)==0 is correct.
(2) Good computer science shows that a halt decider must
compute the mapping from its input finite strings to an accept or
reject state on the basis of the actual behavior actually specified by
its input.
On 5/24/22 12:31 AM, olcott wrote:
On 5/23/2022 11:22 PM, Richard Damon wrote:
On 5/23/22 11:47 PM, olcott wrote:
On 5/23/2022 10:16 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 11:08:54 PM UTC-4, olcott wrote:
On 5/23/2022 10:05 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 11:01:56 PM UTC-4, olcott wrote:
On 5/23/2022 9:57 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:48:39 PM UTC-4, olcott wrote: >>>>>>>>>> On 5/23/2022 9:40 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:32:55 PM UTC-4, olcott wrote: >>>>>>>>>>>> On 5/23/2022 9:23 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:18:37 PM UTC-4, olcott wrote: >>>>>>>>>>>>>> On 5/23/2022 9:09 PM, Dennis Bush wrote:It is just like you are saying that because the dog named >>>>>>>>>>>> Spot is black
On Monday, May 23, 2022 at 9:50:28 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>> On 5/23/2022 8:40 PM, Richard Damon wrote:
On 5/23/22 9:34 PM, olcott wrote:I get to decide what is on topic and what is off topic, >>>>>>>>>>>>>>>> I own the topic.
On 5/23/2022 8:29 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 9:24:47 PM UTC-4, olcott >>>>>>>>>>>>>>>>>>> wrote:
On 5/23/2022 8:15 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 9:08:54 PM UTC-4, olcott >>>>>>>>>>>>>>>>>>>>> wrote:
It not irrelevant jackass it proves that H can >>>>>>>>>>>>>>>>>>>> detect that an infiniteOn 5/23/2022 8:05 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 8:57:46 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
On 5/23/2022 7:44 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 7:50:36 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
On 5/23/2022 6:33 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>But since H has a fixed algorithm, it can't >>>>>>>>>>>>>>>>>>>>>>>>> simulate for an
On 5/23/22 3:05 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 1:52 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> A simple multiple choice question for Olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>The C function H correctly determines that >>>>>>>>>>>>>>>>>>>>>>>>>> there are no number
You consider that H(P,P) == 0 is correct when >>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) halts,All things being equal which is more likely: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(a) Olcott is correct and everybody else is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect
(b) Olcott is incorrect and everybody else >>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct
?
/Flibble
Believability has the word [lie] embedded >>>>>>>>>>>>>>>>>>>>>>>>>>>> directly within
itself.
Instead of the fake measure of credibility >>>>>>>>>>>>>>>>>>>>>>>>>>>> one must employ
actual
validation.
Actual validation conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0
is correct. This means that everyone that >>>>>>>>>>>>>>>>>>>>>>>>>>>> disagrees is either
insufficiently technically competent or a liar. >>>>>>>>>>>>>>>>>>>>>>>>>>>
when that is
the DEFINITION of what H(P,P) is supposed to >>>>>>>>>>>>>>>>>>>>>>>>>>> be answering?
of steps
(0 to infinity) of its correct simulation of >>>>>>>>>>>>>>>>>>>>>>>>>> its input: a pair of
pointers to finite strings of x86 machine >>>>>>>>>>>>>>>>>>>>>>>>>> language that would
ever reach
the last instruction of this input. >>>>>>>>>>>>>>>>>>>>>>>>>
infinite number of steps. It can only simulate >>>>>>>>>>>>>>>>>>>>>>>>> P for some n
number of steps.
None-the-less on the basis of matching known >>>>>>>>>>>>>>>>>>>>>>>> behavior patterns H
can
determine what the behavior of the input would >>>>>>>>>>>>>>>>>>>>>>>> be if it did
simulate an
infinite number of steps.
So because Pn(Pn) does not halt then Ha(Pa,Pa)==0 >>>>>>>>>>>>>>>>>>>>>>> is correct?
No jackass, infinite loop does not halt because >>>>>>>>>>>>>>>>>>>>>> infinite loop is an
infinite loop.
_Infinite_Loop()
[000012c2](01) 55 push ebp
[000012c3](02) 8bec mov ebp,esp
[000012c5](02) ebfe jmp 000012c5
[000012c7](01) 5d pop ebp
[000012c8](01) c3 ret
Size in bytes:(0007) [000012
Irrelevant, because this isn't part of any P. >>>>>>>>>>>>>>>>>>>>>
simulation would never halt without performing an >>>>>>>>>>>>>>>>>>>> infinite simulation.
An infinite loop and the infinite simulation in >>>>>>>>>>>>>>>>>>> Pn(Pn) are different,
It sure is _Infinite_Loop() is on topic and H(P,P) is >>>>>>>>>>>>>>>>>> on topic
and Pn(Pn) is a strawman error intentionally designed >>>>>>>>>>>>>>>>>> to deceive.
If _Infinite_Loop, which isn't at all related to P is >>>>>>>>>>>>>>>>> on topic, then Pn,
which is one of the P's you talk about must be. >>>>>>>>>>>>>>>>>
Remember, you confusingly talk about a CLASS of H's >>>>>>>>>>>>>>>>> since the H you keepI am referring to one machine language immutable literal >>>>>>>>>>>>>>>> string named H
on mentioning doesn't have a distinct rule (since if >>>>>>>>>>>>>>>>> changes how much is
simulates to be every possible length of simulation), >>>>>>>>>>>>>>>>> thus giving them
distinct names is a reasonable thing to do.
and another immutable machine language literal string >>>>>>>>>>>>>>>> named P.
Then we'll refer to H as Ha and refer to P as Pa. >>>>>>>>>>>>>> No we will not.
We all know exactly why not. Because by being clear about >>>>>>>>>>>>> which H and which P we're talking about, it exposes the >>>>>>>>>>>>> holes in your argument and makes it clear exactly where the >>>>>>>>>>>>> problem is. So as Ben has said, clarity is your enemy. >>>>>>>>>>>>>
So explain exactly what is wrong with the below statement. >>>>>>>>>>>>> Failure to explain in detail why it is wrong in your next >>>>>>>>>>>>> post will be taken as not being able to explain why it is >>>>>>>>>>>>> wrong and an acceptance that it is correct. Stating
"strawman" without an explanation will be taken as a >>>>>>>>>>>>> failure to explain.
Simulating the input to Ha(Pa,Pa) up to an infinite number >>>>>>>>>>>>> of steps is done by UTM(Pa,Pa) which halts, so Ha(Pa,Pa)==0 >>>>>>>>>>>>> is wrong. And Hb(Pa,Pa)==1 which also shows that
Ha(Pa,Pa)==0 is wrong. And yes the input to Ha(Pa,Pa) is >>>>>>>>>>>>> the same as the input to Hb(Pa,Pa), and you have no basis >>>>>>>>>>>>> to claim otherwise.
and the cat named Fluffy is white therefore the dog named >>>>>>>>>>>> Rover cannot
be brown.
Ha(Pa,Pa)
Hb(Pa,Pa)
They are not identical therefore it is either ridiculously stupid to >>>>>> claim that they should have the same behavior or in your caseHow dishonest can you get?P does not call anything besides HSimulate(Pa,Pa)I know that you *claim* they are distinct, but you have
are computationally distinct at the x86 machine language level >>>>>>>>>>>> and you have always known this therefore you are a damned liar. >>>>>>>>>>>
nothing to back that up. Both Ha and Hb are halt deciders and >>>>>>>>>>> both are given the same exact input.
And because the fixed algorithm of H aborts, then H is the same >>>>>>>>> as Ha and P is therefore the same as Pa.
It is the same as if you claimed that 5 == 6
Because they have entirely different execution traces
They're identical up to the point that Ha aborts,
(because
we know that you are not stupid) it would be dishonest.
If Ha(Pa,Pa) and Hb(Pa,Pa) are not identical because as you claim
the traces differ, then that would also mean that
Since you always knew this: that you are a liar when
you claimed that they are equivalent.
nothing to back that up.I know that you *claim* they are distinct, but you have
I don't think that we are getting anywhere.
All of the recent discussions are simply disagreement with an easily
verifiable fact. Any smart software engineer with a sufficient
technical background can easily confirm that H(P,P)==0 is correct:
No, they can confirm that it MUST be INCORECT by the requirement of H.
P(P) will Halt if H(P,P) returns 0.
H(P,P) is REQUIRED to return 1 if P(P) halts, that is the DEFINITION
of a Halting Decider, thus H is wrong.
You are NOT allowed to change the Definition of the problem and still
claim to be working on the problem.
That is like you saying it is ok to say "I have no dogs in my house"
when someone asks "Howmany Cats are in your houst?"
Where H is a C function that correctly emulates its input pair of
finite strings of the x86 machine code of function P and criterion
for returning 0 is that the simulated P would never reach its "ret"
instruction.
Except that it DOESN'T correctly emulates its input if it aborts it.
And your finite string that you claim is P doesn't define the program
P as it refers to code outside the string. (PROGRAMS are complete,
and Halting is defined on COMPLETE PROGRAMS).
The only other remaining objection is whether or not a halt decider
must compute the mapping of its input finite strings to an accept or
reject state on the basis of the actual behavior actually specified
by its input OR SOME OTHER MEASURE.
Right, and the BEHAVIOR OF THE INPUT for H(P,P) IS *DEFINED* to be
whether P(P) Halts or not. Any other defintion and you are not
working on the Halting Problem.
Halting problem undecidability and infinitely nested simulation (V5)
https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
Just a bunch of garbage that shows you don't know what you are
talking about. Detail reviews given previously.
That is all that any of you have and good software engineering
refutes the first and good computer science refutes the second.
Nope, GOOD computer science shows that you are not good at computer
science and fail to comprehend even the basics of it.
(1) Good software engineering proves that H(P,P)==0 is correct.
Nope, already explained.
(2) Good computer science shows that a halt decider must
compute the mapping from its input finite strings to an accept or
reject state on the basis of the actual behavior actually specified by
its input.
Right, is CAN only compute an answer from a finite algorithm from its
input, but such an answer doesn't match the definition of the problem,
so a machine that computes the Halting Function can't exist.
Your H may be a successfuly be "A Decider", but it fails to be "A Halt Decider" since H(P,P) doesn't match the halting behavior of P(P).
On 5/24/2022 5:54 AM, Richard Damon wrote:
On 5/24/22 12:31 AM, olcott wrote:
On 5/23/2022 11:22 PM, Richard Damon wrote:
On 5/23/22 11:47 PM, olcott wrote:
On 5/23/2022 10:16 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 11:08:54 PM UTC-4, olcott wrote:
On 5/23/2022 10:05 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 11:01:56 PM UTC-4, olcott wrote:
On 5/23/2022 9:57 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:48:39 PM UTC-4, olcott wrote: >>>>>>>>>>> On 5/23/2022 9:40 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:32:55 PM UTC-4, olcott wrote: >>>>>>>>>>>>> On 5/23/2022 9:23 PM, Dennis Bush wrote:
On Monday, May 23, 2022 at 10:18:37 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>> On 5/23/2022 9:09 PM, Dennis Bush wrote:It is just like you are saying that because the dog named >>>>>>>>>>>>> Spot is black
On Monday, May 23, 2022 at 9:50:28 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>>> On 5/23/2022 8:40 PM, Richard Damon wrote:
On 5/23/22 9:34 PM, olcott wrote:I get to decide what is on topic and what is off topic, >>>>>>>>>>>>>>>>> I own the topic.
On 5/23/2022 8:29 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 9:24:47 PM UTC-4, olcott >>>>>>>>>>>>>>>>>>>> wrote:
On 5/23/2022 8:15 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 9:08:54 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>> olcott wrote:
It not irrelevant jackass it proves that H can >>>>>>>>>>>>>>>>>>>>> detect that an infiniteOn 5/23/2022 8:05 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 8:57:46 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
On 5/23/2022 7:44 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 7:50:36 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
On 5/23/2022 6:33 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>But since H has a fixed algorithm, it can't >>>>>>>>>>>>>>>>>>>>>>>>>> simulate for an
On 5/23/22 3:05 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 1:52 PM, Mr Flibble wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A simple multiple choice question for Olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>The C function H correctly determines that >>>>>>>>>>>>>>>>>>>>>>>>>>> there are no number
All things being equal which is more likely: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(a) Olcott is correct and everybody else >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is incorrect
(b) Olcott is incorrect and everybody else >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct
?
/Flibble
Believability has the word [lie] embedded >>>>>>>>>>>>>>>>>>>>>>>>>>>>> directly within
itself.
Instead of the fake measure of credibility >>>>>>>>>>>>>>>>>>>>>>>>>>>>> one must employ
actual
validation.
Actual validation conclusively proves that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0
is correct. This means that everyone that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagrees is either
insufficiently technically competent or a >>>>>>>>>>>>>>>>>>>>>>>>>>>>> liar.
You consider that H(P,P) == 0 is correct >>>>>>>>>>>>>>>>>>>>>>>>>>>> when P(P) halts,
when that is
the DEFINITION of what H(P,P) is supposed to >>>>>>>>>>>>>>>>>>>>>>>>>>>> be answering?
of steps
(0 to infinity) of its correct simulation of >>>>>>>>>>>>>>>>>>>>>>>>>>> its input: a pair of
pointers to finite strings of x86 machine >>>>>>>>>>>>>>>>>>>>>>>>>>> language that would
ever reach
the last instruction of this input. >>>>>>>>>>>>>>>>>>>>>>>>>>
infinite number of steps. It can only simulate >>>>>>>>>>>>>>>>>>>>>>>>>> P for some n
number of steps.
None-the-less on the basis of matching known >>>>>>>>>>>>>>>>>>>>>>>>> behavior patterns H
can
determine what the behavior of the input would >>>>>>>>>>>>>>>>>>>>>>>>> be if it did
simulate an
infinite number of steps.
So because Pn(Pn) does not halt then >>>>>>>>>>>>>>>>>>>>>>>> Ha(Pa,Pa)==0 is correct?
No jackass, infinite loop does not halt because >>>>>>>>>>>>>>>>>>>>>>> infinite loop is an
infinite loop.
_Infinite_Loop()
[000012c2](01) 55 push ebp
[000012c3](02) 8bec mov ebp,esp
[000012c5](02) ebfe jmp 000012c5 >>>>>>>>>>>>>>>>>>>>>>> [000012c7](01) 5d pop ebp
[000012c8](01) c3 ret
Size in bytes:(0007) [000012
Irrelevant, because this isn't part of any P. >>>>>>>>>>>>>>>>>>>>>>
simulation would never halt without performing an >>>>>>>>>>>>>>>>>>>>> infinite simulation.
An infinite loop and the infinite simulation in >>>>>>>>>>>>>>>>>>>> Pn(Pn) are different,
It sure is _Infinite_Loop() is on topic and H(P,P) is >>>>>>>>>>>>>>>>>>> on topic
and Pn(Pn) is a strawman error intentionally designed >>>>>>>>>>>>>>>>>>> to deceive.
If _Infinite_Loop, which isn't at all related to P is >>>>>>>>>>>>>>>>>> on topic, then Pn,
which is one of the P's you talk about must be. >>>>>>>>>>>>>>>>>>
Remember, you confusingly talk about a CLASS of H's >>>>>>>>>>>>>>>>>> since the H you keepand another immutable machine language literal string >>>>>>>>>>>>>>>>> named P.
on mentioning doesn't have a distinct rule (since if >>>>>>>>>>>>>>>>>> changes how much is
simulates to be every possible length of simulation), >>>>>>>>>>>>>>>>>> thus giving them
distinct names is a reasonable thing to do. >>>>>>>>>>>>>>>>> I am referring to one machine language immutable >>>>>>>>>>>>>>>>> literal string named H
Then we'll refer to H as Ha and refer to P as Pa. >>>>>>>>>>>>>>> No we will not.
We all know exactly why not. Because by being clear about >>>>>>>>>>>>>> which H and which P we're talking about, it exposes the >>>>>>>>>>>>>> holes in your argument and makes it clear exactly where >>>>>>>>>>>>>> the problem is. So as Ben has said, clarity is your enemy. >>>>>>>>>>>>>>
So explain exactly what is wrong with the below statement. >>>>>>>>>>>>>> Failure to explain in detail why it is wrong in your next >>>>>>>>>>>>>> post will be taken as not being able to explain why it is >>>>>>>>>>>>>> wrong and an acceptance that it is correct. Stating >>>>>>>>>>>>>> "strawman" without an explanation will be taken as a >>>>>>>>>>>>>> failure to explain.
Simulating the input to Ha(Pa,Pa) up to an infinite number >>>>>>>>>>>>>> of steps is done by UTM(Pa,Pa) which halts, so
Ha(Pa,Pa)==0 is wrong. And Hb(Pa,Pa)==1 which also shows >>>>>>>>>>>>>> that Ha(Pa,Pa)==0 is wrong. And yes the input to Ha(Pa,Pa) >>>>>>>>>>>>>> is the same as the input to Hb(Pa,Pa), and you have no >>>>>>>>>>>>>> basis to claim otherwise.
and the cat named Fluffy is white therefore the dog named >>>>>>>>>>>>> Rover cannot
be brown.
Ha(Pa,Pa)
Hb(Pa,Pa)
They are not identical therefore it is either ridiculously stupid to >>>>>>> claim that they should have the same behavior or in your caseHow dishonest can you get?P does not call anything besides HSimulate(Pa,Pa)
are computationally distinct at the x86 machine language level >>>>>>>>>>>>> and you have always known this therefore you are a damned >>>>>>>>>>>>> liar.
I know that you *claim* they are distinct, but you have >>>>>>>>>>>> nothing to back that up. Both Ha and Hb are halt deciders >>>>>>>>>>>> and both are given the same exact input.
And because the fixed algorithm of H aborts, then H is the >>>>>>>>>> same as Ha and P is therefore the same as Pa.
It is the same as if you claimed that 5 == 6
Because they have entirely different execution traces
They're identical up to the point that Ha aborts,
(because
we know that you are not stupid) it would be dishonest.
If Ha(Pa,Pa) and Hb(Pa,Pa) are not identical because as you claim
the traces differ, then that would also mean that
Since you always knew this: that you are a liar when
you claimed that they are equivalent.
nothing to back that up.I know that you *claim* they are distinct, but you have
I don't think that we are getting anywhere.
All of the recent discussions are simply disagreement with an
easily verifiable fact. Any smart software engineer with a
sufficient technical background can easily confirm that H(P,P)==0
is correct:
No, they can confirm that it MUST be INCORECT by the requirement of H. >>>>
P(P) will Halt if H(P,P) returns 0.
H(P,P) is REQUIRED to return 1 if P(P) halts, that is the DEFINITION
of a Halting Decider, thus H is wrong.
You are NOT allowed to change the Definition of the problem and
still claim to be working on the problem.
That is like you saying it is ok to say "I have no dogs in my house"
when someone asks "Howmany Cats are in your houst?"
Where H is a C function that correctly emulates its input pair of
finite strings of the x86 machine code of function P and criterion
for returning 0 is that the simulated P would never reach its "ret"
instruction.
Except that it DOESN'T correctly emulates its input if it aborts it.
And your finite string that you claim is P doesn't define the
program P as it refers to code outside the string. (PROGRAMS are
complete, and Halting is defined on COMPLETE PROGRAMS).
The only other remaining objection is whether or not a halt decider
must compute the mapping of its input finite strings to an accept
or reject state on the basis of the actual behavior actually
specified by its input OR SOME OTHER MEASURE.
Right, and the BEHAVIOR OF THE INPUT for H(P,P) IS *DEFINED* to be
whether P(P) Halts or not. Any other defintion and you are not
working on the Halting Problem.
Halting problem undecidability and infinitely nested simulation (V5) >>>>>
https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
Just a bunch of garbage that shows you don't know what you are
talking about. Detail reviews given previously.
That is all that any of you have and good software engineering
refutes the first and good computer science refutes the second.
Nope, GOOD computer science shows that you are not good at computer
science and fail to comprehend even the basics of it.
(1) Good software engineering proves that H(P,P)==0 is correct.
Nope, already explained.
A software engineer with sufficient technical competence would disagree.
(2) Good computer science shows that a halt decider must
compute the mapping from its input finite strings to an accept or
reject state on the basis of the actual behavior actually specified by
its input.
Right, is CAN only compute an answer from a finite algorithm from its
input, but such an answer doesn't match the definition of the problem,
so a machine that computes the Halting Function can't exist.
A computer scientist with sufficient technical competence would disagree.
Your H may be a successfuly be "A Decider", but it fails to be "A Halt
Decider" since H(P,P) doesn't match the halting behavior of P(P).
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 376 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 38:39:18 |
| Calls: | 8,039 |
| Calls today: | 3 |
| Files: | 13,037 |
| Messages: | 5,830,365 |