On 3/21/2024 10:14 AM, Mikko wrote:
On 2024-03-21 14:17:04 +0000, olcott said:
On 3/21/2024 4:47 AM, Mikko wrote:
On 2024-03-20 19:30:03 +0000, olcott said:
On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 20:07 schreef olcott:Every H(D,D) that does not abort its simulation is exactly equal in
On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 17:11 schreef olcott:
On 3/20/2024 10:50 AM, Mikko wrote:No. The H that answers 'yes' is a different H.
On 2024-03-20 13:20:51 +0000, olcott said:
On 3/20/2024 3:24 AM, Mikko wrote:
On 2024-03-19 18:15:42 +0000, olcott said:
On 3/19/2024 12:41 PM, immibis wrote:What is true is true even when contradicted by a liar. >>>>>>>>>>>>
On 19/03/24 05:11, olcott wrote:
On 3/18/2024 10:11 PM, Richard Damon wrote:If Ĥ is your x86utm function D, then "yes" is the correct answer to all
On 3/18/24 7:46 PM, olcott wrote:
On 3/18/2024 8:45 PM, immibis wrote:
On 19/03/24 00:43, olcott wrote:
On 3/18/2024 6:34 PM, immibis wrote:
On 19/03/24 00:13, olcott wrote:
On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?Strawman deception. H is a halt decider if it tells whether the direct
*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>
Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>
execution of its input would halt.
If you can't even understand that H is a correct abort decider then
you can't understand anything else that requires the prerequisite
knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>
Strawman deception. It is the halting problem, not the Olcott abort problem.
You can learn calculus without the basis of algebra. You can't learn
simulating halt deciders without the basis of simulating abort deciders.
When are you going to extend this theory of simulating abort deciders
so that it solves the halting problem instead of merely solving the
Olcott abort problem?
*Here are the two key steps to that*
(1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrect
question thus must be redefined.
But (2) is a LIE.
There is nothing "Incorrect" about the Halting Question. >>>>>>>>>>>>>>>>
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
such that YES is a correct answer from one entity >>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>> is an incorrect question when posed to this second entity. >>>>>>>>>>>>>>
entities.
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see.
Therefore the correct answer H(D,D) should give is "yes".
*That would cause D(D) to loop, thus wrong answer*
Can D correctly simulated by H terminate normally?
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never
stops running.
It would be correct for this D. We can build another D, based on the >>>>>>>> new H, but then the question changes, because the input changes. The >>>>>>>> new H does not give the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer*No. The H that answers 'yes' is a different H. It would be correct for >>>>>>>> this D. We can build another D, based on the new H, but then the >>>>>>>> question changes, because the input changes. The new H does not give >>>>>>>> the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer*No. The H that answers 'yes' is a different H. It would be correct for >>>>>>>> this D. We can build another D, based on the new H, but then the >>>>>>>> question changes, because the input changes. The new H does not give >>>>>>>> the correct answer for the new D.
Both questions have a correct answer, but the corresponding H failed to
give it. It seems Olcott is again confused, because he uses the same >>>>>>>> names for different things.
Every H(D,D) that does not abort its simulation input never
stops running.
Trying to refer to a different H than every H is a very lame
attempt to get away with the strawman deception.
Very weak response. I did not say different from every H.
It seems Olcott does not understand that if he speaks about 'every H' >>>>>> then not all these H are equal, but they are different. So two examples >>>>>
that none of them ever stop running.
True but not very relevant as none of them is a halt decider.
We must start with H(D,D) is a correct abort decider
before we move on to the next step of the analysis.
Perhaps you must. Others needn't.
Until this is understood one lacks the sufficient prerequisites to
comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement
must be reached.
I admitted that I was wrong about the details of some things:
H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
exact same H. I was wrong when I said that it could.
*This provides evidence that I want an honest dialogue*
On 3/21/2024 10:14 AM, Mikko wrote:
On 2024-03-21 14:17:04 +0000, olcott said:
On 3/21/2024 4:47 AM, Mikko wrote:
On 2024-03-20 19:30:03 +0000, olcott said:
On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 20:07 schreef olcott:
On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 17:11 schreef olcott:
On 3/20/2024 10:50 AM, Mikko wrote:No. The H that answers 'yes' is a different H.
On 2024-03-20 13:20:51 +0000, olcott said:
On 3/20/2024 3:24 AM, Mikko wrote:
On 2024-03-19 18:15:42 +0000, olcott said:
On 3/19/2024 12:41 PM, immibis wrote:What is true is true even when contradicted by a liar. >>>>>>>>>>>>
On 19/03/24 05:11, olcott wrote:
On 3/18/2024 10:11 PM, Richard Damon wrote:If Ĥ is your x86utm function D, then "yes" is the correct >>>>>>>>>>>>>> answer to all entities.
On 3/18/24 7:46 PM, olcott wrote:
On 3/18/2024 8:45 PM, immibis wrote:
On 19/03/24 00:43, olcott wrote:*Here are the two key steps to that*
On 3/18/2024 6:34 PM, immibis wrote:
On 19/03/24 00:13, olcott wrote:
On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either >>>>>>>>>>>>>>>>>>>>>>>>> abort or fail to abort?Strawman deception. H is a halt decider if it >>>>>>>>>>>>>>>>>>>>>> tells whether the direct execution of its input >>>>>>>>>>>>>>>>>>>>>> would halt.
*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>
Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>
If you can't even understand that H is a correct >>>>>>>>>>>>>>>>>>>>> abort decider then
you can't understand anything else that requires >>>>>>>>>>>>>>>>>>>>> the prerequisite
knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>
Strawman deception. It is the halting problem, not >>>>>>>>>>>>>>>>>>>> the Olcott abort problem.
You can learn calculus without the basis of algebra. >>>>>>>>>>>>>>>>>>> You can't learn
simulating halt deciders without the basis of >>>>>>>>>>>>>>>>>>> simulating abort deciders.
When are you going to extend this theory of simulating >>>>>>>>>>>>>>>>>> abort deciders so that it solves the halting problem >>>>>>>>>>>>>>>>>> instead of merely solving the Olcott abort problem? >>>>>>>>>>>>>>>>>
(1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to >>>>>>>>>>>>>>>>> an incorrect question thus must be redefined. >>>>>>>>>>>>>>>>>
But (2) is a LIE.
There is nothing "Incorrect" about the Halting Question. >>>>>>>>>>>>>>>>
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
such that YES is a correct answer from one entity >>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>> is an incorrect question when posed to this second entity. >>>>>>>>>>>>>>
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see.
Therefore the correct answer H(D,D) should give is "yes".
*That would cause D(D) to loop, thus wrong answer*
Can D correctly simulated by H terminate normally?
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never
stops running.
It would be correct for this D. We can build another D, based on >>>>>>>> the new H, but then the question changes, because the input
changes. The new H does not give the correct answer for the new D. >>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
No. The H that answers 'yes' is a different H. It would be
correct for this D. We can build another D, based on the new H, >>>>>>>> but then the question changes, because the input changes. The
new H does not give the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer*No. The H that answers 'yes' is a different H. It would be
correct for this D. We can build another D, based on the new H, >>>>>>>> but then the question changes, because the input changes. The
new H does not give the correct answer for the new D.
Both questions have a correct answer, but the corresponding H
failed to give it. It seems Olcott is again confused, because he >>>>>>>> uses the same names for different things.
Every H(D,D) that does not abort its simulation input never
stops running.
Trying to refer to a different H than every H is a very lame
attempt to get away with the strawman deception.
Very weak response. I did not say different from every H.
It seems Olcott does not understand that if he speaks about 'every >>>>>> H' then not all these H are equal, but they are different. So two
examples
Every H(D,D) that does not abort its simulation is exactly equal in
that none of them ever stop running.
True but not very relevant as none of them is a halt decider.
We must start with H(D,D) is a correct abort decider
before we move on to the next step of the analysis.
Perhaps you must. Others needn't.
Until this is understood one lacks the sufficient prerequisites to
comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement
must be reached.
On 3/21/2024 12:33 PM, immibis wrote:
... says the person who doesn't understand the correct answer to "Does
D(D) halt?" is only yes if D(D) halts and no if D(D) doesn't halt.
That is the conventional view.
On 3/21/2024 11:29 AM, Mikko wrote:
On 2024-03-21 15:28:13 +0000, olcott said:
On 3/21/2024 10:14 AM, Mikko wrote:
On 2024-03-21 14:17:04 +0000, olcott said:
On 3/21/2024 4:47 AM, Mikko wrote:
On 2024-03-20 19:30:03 +0000, olcott said:
On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 20:07 schreef olcott:
On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 17:11 schreef olcott:
On 3/20/2024 10:50 AM, Mikko wrote:No. The H that answers 'yes' is a different H.
On 2024-03-20 13:20:51 +0000, olcott said:
On 3/20/2024 3:24 AM, Mikko wrote:
On 2024-03-19 18:15:42 +0000, olcott said:
On 3/19/2024 12:41 PM, immibis wrote:What is true is true even when contradicted by a liar. >>>>>>>>>>>>>>
On 19/03/24 05:11, olcott wrote:
On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:If Ĥ is your x86utm function D, then "yes" is the correct answer to all
On 3/18/2024 8:45 PM, immibis wrote:
On 19/03/24 00:43, olcott wrote:
On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
If you can't even understand that H is a correct abort decider thenStrawman deception. H is a halt decider if it tells whether the direct*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>
Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>
execution of its input would halt. >>>>>>>>>>>>>>>>>>>>>>>
you can't understand anything else that requires the prerequisite
knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>>>
Strawman deception. It is the halting problem, not the Olcott abort problem.
You can learn calculus without the basis of algebra. You can't learn
simulating halt deciders without the basis of simulating abort deciders.
When are you going to extend this theory of simulating abort deciders
so that it solves the halting problem instead of merely solving the
Olcott abort problem?
*Here are the two key steps to that*
(1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrect
question thus must be redefined.
But (2) is a LIE.
There is nothing "Incorrect" about the Halting Question. >>>>>>>>>>>>>>>>>>
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>>>> is an incorrect question when posed to this second entity. >>>>>>>>>>>>>>>>
entities.
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see.
Therefore the correct answer H(D,D) should give is "yes". >>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer*
Can D correctly simulated by H terminate normally?
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never
stops running.
It would be correct for this D. We can build another D, based on the >>>>>>>>>> new H, but then the question changes, because the input changes. The >>>>>>>>>> new H does not give the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer*No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the >>>>>>>>>> question changes, because the input changes. The new H does not give >>>>>>>>>> the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer*No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the >>>>>>>>>> question changes, because the input changes. The new H does not give >>>>>>>>>> the correct answer for the new D.
Both questions have a correct answer, but the corresponding H failed to
give it. It seems Olcott is again confused, because he uses the same >>>>>>>>>> names for different things.
Every H(D,D) that does not abort its simulation input never
stops running.
Trying to refer to a different H than every H is a very lame >>>>>>>>> attempt to get away with the strawman deception.
Very weak response. I did not say different from every H.
It seems Olcott does not understand that if he speaks about 'every H' >>>>>>>> then not all these H are equal, but they are different. So two examples
Every H(D,D) that does not abort its simulation is exactly equal in >>>>>>> that none of them ever stop running.
True but not very relevant as none of them is a halt decider.
We must start with H(D,D) is a correct abort decider
before we move on to the next step of the analysis.
Perhaps you must. Others needn't.
Until this is understood one lacks the sufficient prerequisites to
comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement
must be reached.
I admitted that I was wrong about the details of some things:
H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
exact same H. I was wrong when I said that it could.
*This provides evidence that I want an honest dialogue*
In sufficient as you have provided much more contrary evidence.
No honest dialogue can be reasonable expected when you participate.
In other words you misconstrue rhetoric as a kind of reasoning
that can be applied to rebutting logical arguments.
On 3/21/2024 11:29 AM, Mikko wrote:
On 2024-03-21 15:28:13 +0000, olcott said:
On 3/21/2024 10:14 AM, Mikko wrote:
On 2024-03-21 14:17:04 +0000, olcott said:
On 3/21/2024 4:47 AM, Mikko wrote:
On 2024-03-20 19:30:03 +0000, olcott said:
On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 20:07 schreef olcott:
On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 17:11 schreef olcott:
On 3/20/2024 10:50 AM, Mikko wrote:No. The H that answers 'yes' is a different H.
On 2024-03-20 13:20:51 +0000, olcott said:
On 3/20/2024 3:24 AM, Mikko wrote:
On 2024-03-19 18:15:42 +0000, olcott said:
On 3/19/2024 12:41 PM, immibis wrote:What is true is true even when contradicted by a liar. >>>>>>>>>>>>>>
On 19/03/24 05:11, olcott wrote:
On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:If Ĥ is your x86utm function D, then "yes" is the correct answer to all
On 3/18/2024 8:45 PM, immibis wrote:
On 19/03/24 00:43, olcott wrote:
On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
If you can't even understand that H is a correct abort decider thenStrawman deception. H is a halt decider if it tells whether the direct*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>
Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>
execution of its input would halt. >>>>>>>>>>>>>>>>>>>>>>>
you can't understand anything else that requires the prerequisite
knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>>>
Strawman deception. It is the halting problem, not the Olcott abort problem.
You can learn calculus without the basis of algebra. You can't learn
simulating halt deciders without the basis of simulating abort deciders.
When are you going to extend this theory of simulating abort deciders
so that it solves the halting problem instead of merely solving the
Olcott abort problem?
*Here are the two key steps to that*
(1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrect
question thus must be redefined.
But (2) is a LIE.
There is nothing "Incorrect" about the Halting Question. >>>>>>>>>>>>>>>>>>
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>>>> is an incorrect question when posed to this second entity. >>>>>>>>>>>>>>>>
entities.
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see.
Therefore the correct answer H(D,D) should give is "yes". >>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer*
Can D correctly simulated by H terminate normally?
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never
stops running.
It would be correct for this D. We can build another D, based on the >>>>>>>>>> new H, but then the question changes, because the input changes. The >>>>>>>>>> new H does not give the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer*No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the >>>>>>>>>> question changes, because the input changes. The new H does not give >>>>>>>>>> the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer*No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the >>>>>>>>>> question changes, because the input changes. The new H does not give >>>>>>>>>> the correct answer for the new D.
Both questions have a correct answer, but the corresponding H failed to
give it. It seems Olcott is again confused, because he uses the same >>>>>>>>>> names for different things.
Every H(D,D) that does not abort its simulation input never
stops running.
Trying to refer to a different H than every H is a very lame >>>>>>>>> attempt to get away with the strawman deception.
Very weak response. I did not say different from every H.
It seems Olcott does not understand that if he speaks about 'every H' >>>>>>>> then not all these H are equal, but they are different. So two examples
Every H(D,D) that does not abort its simulation is exactly equal in >>>>>>> that none of them ever stop running.
True but not very relevant as none of them is a halt decider.
We must start with H(D,D) is a correct abort decider
before we move on to the next step of the analysis.
Perhaps you must. Others needn't.
Until this is understood one lacks the sufficient prerequisites to
comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement
must be reached.
I admitted that I was wrong about the details of some things:
H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
exact same H. I was wrong when I said that it could.
*This provides evidence that I want an honest dialogue*
In sufficient as you have provided much more contrary evidence.
No honest dialogue can be reasonable expected when you participate.
*See if you can rebut this with reasoning instead of rhetoric*
[Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
On 3/22/2024 2:51 AM, Mikko wrote:
On 2024-03-21 16:39:52 +0000, olcott said:
On 3/21/2024 11:29 AM, Mikko wrote:
On 2024-03-21 15:28:13 +0000, olcott said:
On 3/21/2024 10:14 AM, Mikko wrote:
On 2024-03-21 14:17:04 +0000, olcott said:
On 3/21/2024 4:47 AM, Mikko wrote:
On 2024-03-20 19:30:03 +0000, olcott said:
On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 20:07 schreef olcott:
On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 17:11 schreef olcott:
On 3/20/2024 10:50 AM, Mikko wrote:No. The H that answers 'yes' is a different H.
On 2024-03-20 13:20:51 +0000, olcott said:
On 3/20/2024 3:24 AM, Mikko wrote:
On 2024-03-19 18:15:42 +0000, olcott said:
On 3/19/2024 12:41 PM, immibis wrote:What is true is true even when contradicted by a liar. >>>>>>>>>>>>>>>>
On 19/03/24 05:11, olcott wrote:
On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:If Ĥ is your x86utm function D, then "yes" is the correct answer to all
On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
If you can't even understand that H is a correct abort decider thenStrawman deception. H is a halt decider if it tells whether the direct*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>>>
Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>
execution of its input would halt. >>>>>>>>>>>>>>>>>>>>>>>>>
you can't understand anything else that requires the prerequisite
knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>>>>>
Strawman deception. It is the halting problem, not the Olcott abort problem.
You can learn calculus without the basis of algebra. You can't learn
simulating halt deciders without the basis of simulating abort deciders.
When are you going to extend this theory of simulating abort deciders
so that it solves the halting problem instead of merely solving the
Olcott abort problem?
*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrect
question thus must be redefined.
But (2) is a LIE.
There is nothing "Incorrect" about the Halting Question. >>>>>>>>>>>>>>>>>>>>
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second entity. >>>>>>>>>>>>>>>>>>
entities.
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>>>
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see.
Therefore the correct answer H(D,D) should give is "yes". >>>>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer*
Can D correctly simulated by H terminate normally?
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>> stops running.
It would be correct for this D. We can build another D, based on the
new H, but then the question changes, because the input changes. The
new H does not give the correct answer for the new D. >>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the >>>>>>>>>>>> question changes, because the input changes. The new H does not give
the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer*No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the >>>>>>>>>>>> question changes, because the input changes. The new H does not give
the correct answer for the new D.
Both questions have a correct answer, but the corresponding H failed to
give it. It seems Olcott is again confused, because he uses the same
names for different things.
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>> stops running.
Trying to refer to a different H than every H is a very lame >>>>>>>>>>> attempt to get away with the strawman deception.
Very weak response. I did not say different from every H.
It seems Olcott does not understand that if he speaks about 'every H'
then not all these H are equal, but they are different. So two examples
Every H(D,D) that does not abort its simulation is exactly equal in >>>>>>>>> that none of them ever stop running.
True but not very relevant as none of them is a halt decider.
We must start with H(D,D) is a correct abort decider
before we move on to the next step of the analysis.
Perhaps you must. Others needn't.
Until this is understood one lacks the sufficient prerequisites to
comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement
must be reached.
I admitted that I was wrong about the details of some things:
H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
exact same H. I was wrong when I said that it could.
*This provides evidence that I want an honest dialogue*
In sufficient as you have provided much more contrary evidence.
No honest dialogue can be reasonable expected when you participate.
*See if you can rebut this with reasoning instead of rhetoric*
[Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
I just note that you have rebutted nothing wirh reasoning or rhetoric.
Dogmatic statements do not count as reasoning.
On 3/22/2024 2:50 AM, Mikko wrote:
On 2024-03-21 16:34:02 +0000, olcott said:
On 3/21/2024 11:29 AM, Mikko wrote:
On 2024-03-21 15:28:13 +0000, olcott said:
On 3/21/2024 10:14 AM, Mikko wrote:
On 2024-03-21 14:17:04 +0000, olcott said:
On 3/21/2024 4:47 AM, Mikko wrote:
On 2024-03-20 19:30:03 +0000, olcott said:
On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 20:07 schreef olcott:
On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 17:11 schreef olcott:
On 3/20/2024 10:50 AM, Mikko wrote:No. The H that answers 'yes' is a different H.
On 2024-03-20 13:20:51 +0000, olcott said:
On 3/20/2024 3:24 AM, Mikko wrote:
On 2024-03-19 18:15:42 +0000, olcott said:
On 3/19/2024 12:41 PM, immibis wrote:What is true is true even when contradicted by a liar. >>>>>>>>>>>>>>>>
On 19/03/24 05:11, olcott wrote:
On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:If Ĥ is your x86utm function D, then "yes" is the correct answer to all
On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
If you can't even understand that H is a correct abort decider thenStrawman deception. H is a halt decider if it tells whether the direct*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>>>
Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>
execution of its input would halt. >>>>>>>>>>>>>>>>>>>>>>>>>
you can't understand anything else that requires the prerequisite
knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>>>>>
Strawman deception. It is the halting problem, not the Olcott abort problem.
You can learn calculus without the basis of algebra. You can't learn
simulating halt deciders without the basis of simulating abort deciders.
When are you going to extend this theory of simulating abort deciders
so that it solves the halting problem instead of merely solving the
Olcott abort problem?
*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrect
question thus must be redefined.
But (2) is a LIE.
There is nothing "Incorrect" about the Halting Question. >>>>>>>>>>>>>>>>>>>>
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second entity. >>>>>>>>>>>>>>>>>>
entities.
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>>>
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see.
Therefore the correct answer H(D,D) should give is "yes". >>>>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer*
Can D correctly simulated by H terminate normally?
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>> stops running.
It would be correct for this D. We can build another D, based on the
new H, but then the question changes, because the input changes. The
new H does not give the correct answer for the new D. >>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the >>>>>>>>>>>> question changes, because the input changes. The new H does not give
the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer*No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the >>>>>>>>>>>> question changes, because the input changes. The new H does not give
the correct answer for the new D.
Both questions have a correct answer, but the corresponding H failed to
give it. It seems Olcott is again confused, because he uses the same
names for different things.
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>> stops running.
Trying to refer to a different H than every H is a very lame >>>>>>>>>>> attempt to get away with the strawman deception.
Very weak response. I did not say different from every H.
It seems Olcott does not understand that if he speaks about 'every H'
then not all these H are equal, but they are different. So two examples
Every H(D,D) that does not abort its simulation is exactly equal in >>>>>>>>> that none of them ever stop running.
True but not very relevant as none of them is a halt decider.
We must start with H(D,D) is a correct abort decider
before we move on to the next step of the analysis.
Perhaps you must. Others needn't.
Until this is understood one lacks the sufficient prerequisites to
comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement
must be reached.
I admitted that I was wrong about the details of some things:
H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
exact same H. I was wrong when I said that it could.
*This provides evidence that I want an honest dialogue*
In sufficient as you have provided much more contrary evidence.
No honest dialogue can be reasonable expected when you participate.
In other words you misconstrue rhetoric as a kind of reasoning
that can be applied to rebutting logical arguments.
I misconstrue nothong you say as any kind of reasoning.
Yet can't correctly point out any errors.
On 3/22/2024 1:35 PM, Mikko wrote:
On 2024-03-22 15:43:04 +0000, olcott said:
On 3/22/2024 2:50 AM, Mikko wrote:
On 2024-03-21 16:34:02 +0000, olcott said:
On 3/21/2024 11:29 AM, Mikko wrote:
On 2024-03-21 15:28:13 +0000, olcott said:
On 3/21/2024 10:14 AM, Mikko wrote:
On 2024-03-21 14:17:04 +0000, olcott said:
On 3/21/2024 4:47 AM, Mikko wrote:
On 2024-03-20 19:30:03 +0000, olcott said:
On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 20:07 schreef olcott:
On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 17:11 schreef olcott:
On 3/20/2024 10:50 AM, Mikko wrote:
On 2024-03-20 13:20:51 +0000, olcott said:
On 3/20/2024 3:24 AM, Mikko wrote:Therefore the correct answer H(D,D) should give is "yes". >>>>>>>>>>>>>>>>
On 2024-03-19 18:15:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 3/19/2024 12:41 PM, immibis wrote:What is true is true even when contradicted by a liar. >>>>>>>>>>>>>>>>>>
On 19/03/24 05:11, olcott wrote:
On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either abort or fail to abort? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You can learn calculus without the basis of >>>>>>>>>>>>>>>>>>>>>>>>> algebra. You can't learnStrawman deception. H is a halt decider if >>>>>>>>>>>>>>>>>>>>>>>>>>>> it tells whether the direct execution of its >>>>>>>>>>>>>>>>>>>>>>>>>>>> input would halt.*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
If you can't even understand that H is a >>>>>>>>>>>>>>>>>>>>>>>>>>> correct abort decider then >>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else that >>>>>>>>>>>>>>>>>>>>>>>>>>> requires the prerequisite >>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>
Strawman deception. It is the halting problem, >>>>>>>>>>>>>>>>>>>>>>>>>> not the Olcott abort problem. >>>>>>>>>>>>>>>>>>>>>>>>>
simulating halt deciders without the basis of >>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders.
When are you going to extend this theory of >>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders so that it solves the >>>>>>>>>>>>>>>>>>>>>>>> halting problem instead of merely solving the >>>>>>>>>>>>>>>>>>>>>>>> Olcott abort problem?
*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct >>>>>>>>>>>>>>>>>>>>>>> answer to an incorrect question thus must be >>>>>>>>>>>>>>>>>>>>>>> redefined.
But (2) is a LIE.
There is nothing "Incorrect" about the Halting >>>>>>>>>>>>>>>>>>>>>> Question.
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second >>>>>>>>>>>>>>>>>>>>> entity.
If Ĥ is your x86utm function D, then "yes" is the >>>>>>>>>>>>>>>>>>>> correct answer to all entities.
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
<are>
correctly reporting on what they actually see. >>>>>>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
Can D correctly simulated by H terminate normally?
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>> stops running.
It would be correct for this D. We can build another D, >>>>>>>>>>>>>> based on the new H, but then the question changes, because >>>>>>>>>>>>>> the input changes. The new H does not give the correct >>>>>>>>>>>>>> answer for the new D.
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be >>>>>>>>>>>>>> correct for this D. We can build another D, based on the >>>>>>>>>>>>>> new H, but then the question changes, because the input >>>>>>>>>>>>>> changes. The new H does not give the correct answer for >>>>>>>>>>>>>> the new D.
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be >>>>>>>>>>>>>> correct for this D. We can build another D, based on the >>>>>>>>>>>>>> new H, but then the question changes, because the input >>>>>>>>>>>>>> changes. The new H does not give the correct answer for >>>>>>>>>>>>>> the new D.
Both questions have a correct answer, but the
corresponding H failed to give it. It seems Olcott is >>>>>>>>>>>>>> again confused, because he uses the same names for >>>>>>>>>>>>>> different things.
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>> stops running.
Trying to refer to a different H than every H is a very lame >>>>>>>>>>>>> attempt to get away with the strawman deception.
Very weak response. I did not say different from every H. >>>>>>>>>>>> It seems Olcott does not understand that if he speaks about >>>>>>>>>>>> 'every H' then not all these H are equal, but they are >>>>>>>>>>>> different. So two examples
Every H(D,D) that does not abort its simulation is exactly >>>>>>>>>>> equal in
that none of them ever stop running.
True but not very relevant as none of them is a halt decider. >>>>>>>>>>
We must start with H(D,D) is a correct abort decider
before we move on to the next step of the analysis.
Perhaps you must. Others needn't.
Until this is understood one lacks the sufficient prerequisites to >>>>>>> comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement >>>>>>> must be reached.
I admitted that I was wrong about the details of some things:
H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this >>>>>>> exact same H. I was wrong when I said that it could.
*This provides evidence that I want an honest dialogue*
In sufficient as you have provided much more contrary evidence.
No honest dialogue can be reasonable expected when you participate. >>>>>>
In other words you misconstrue rhetoric as a kind of reasoning
that can be applied to rebutting logical arguments.
I misconstrue nothong you say as any kind of reasoning.
Yet can't correctly point out any errors.
It is sufficient to note that you claim that various proofs are
erroneous without pointing out any errors.
That the various proofs are correct within their false assumptions
provides zero evidence that they are correct.
On 3/22/2024 2:45 PM, immibis wrote:
On 22/03/24 19:46, olcott wrote:
On 3/22/2024 1:35 PM, Mikko wrote:Assumptions such as "every program/input pair either halts or doesn't
On 2024-03-22 15:43:04 +0000, olcott said:
On 3/22/2024 2:50 AM, Mikko wrote:
On 2024-03-21 16:34:02 +0000, olcott said:
On 3/21/2024 11:29 AM, Mikko wrote:
On 2024-03-21 15:28:13 +0000, olcott said:
On 3/21/2024 10:14 AM, Mikko wrote:
On 2024-03-21 14:17:04 +0000, olcott said:
On 3/21/2024 4:47 AM, Mikko wrote:
On 2024-03-20 19:30:03 +0000, olcott said:
On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 20:07 schreef olcott:
On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 17:11 schreef olcott:
On 3/20/2024 10:50 AM, Mikko wrote:
On 2024-03-20 13:20:51 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 3/20/2024 3:24 AM, Mikko wrote:Therefore the correct answer H(D,D) should give is "yes". >>>>>>>>>>>>>>>>>>
On 2024-03-19 18:15:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 3/19/2024 12:41 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either abort or fail to abort? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
When are you going to extend this theory of >>>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders so that it solves >>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem instead of merely solving >>>>>>>>>>>>>>>>>>>>>>>>>> the Olcott abort problem?You can learn calculus without the basis of >>>>>>>>>>>>>>>>>>>>>>>>>>> algebra. You can't learn >>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the basis of >>>>>>>>>>>>>>>>>>>>>>>>>>> simulating abort deciders. >>>>>>>>>>>>>>>>>>>>>>>>>>If you can't even understand that H is a >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct abort decider then >>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> requires the prerequisite >>>>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>Strawman deception. H is a halt decider if >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it tells whether the direct execution of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input would halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Strawman deception. It is the halting >>>>>>>>>>>>>>>>>>>>>>>>>>>> problem, not the Olcott abort problem. >>>>>>>>>>>>>>>>>>>>>>>>>>>
*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct >>>>>>>>>>>>>>>>>>>>>>>>> answer to an incorrect question thus must be >>>>>>>>>>>>>>>>>>>>>>>>> redefined.
But (2) is a LIE.
There is nothing "Incorrect" about the Halting >>>>>>>>>>>>>>>>>>>>>>>> Question.
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this >>>>>>>>>>>>>>>>>>>>>>> second entity.
If Ĥ is your x86utm function D, then "yes" is the >>>>>>>>>>>>>>>>>>>>>> correct answer to all entities.
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
What is true is true even when contradicted by a liar. >>>>>>>>>>>>>>>>>>>>
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩
⟨Ĥ⟩ <are>
correctly reporting on what they actually see. >>>>>>>>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
Can D correctly simulated by H terminate normally? >>>>>>>>>>>>>>> 01 int D(ptr x) // ptr is pointer to int function >>>>>>>>>>>>>>> 02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>>>> stops running.
It would be correct for this D. We can build another D, >>>>>>>>>>>>>>>> based on the new H, but then the question changes, >>>>>>>>>>>>>>>> because the input changes. The new H does not give the >>>>>>>>>>>>>>>> correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would >>>>>>>>>>>>>>>> be correct for this D. We can build another D, based on >>>>>>>>>>>>>>>> the new H, but then the question changes, because the >>>>>>>>>>>>>>>> input changes. The new H does not give the correct >>>>>>>>>>>>>>>> answer for the new D.
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would >>>>>>>>>>>>>>>> be correct for this D. We can build another D, based on >>>>>>>>>>>>>>>> the new H, but then the question changes, because the >>>>>>>>>>>>>>>> input changes. The new H does not give the correct >>>>>>>>>>>>>>>> answer for the new D.
Both questions have a correct answer, but the
corresponding H failed to give it. It seems Olcott is >>>>>>>>>>>>>>>> again confused, because he uses the same names for >>>>>>>>>>>>>>>> different things.
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>>>> stops running.
Trying to refer to a different H than every H is a very lame >>>>>>>>>>>>>>> attempt to get away with the strawman deception.
Very weak response. I did not say different from every H. >>>>>>>>>>>>>> It seems Olcott does not understand that if he speaks >>>>>>>>>>>>>> about 'every H' then not all these H are equal, but they >>>>>>>>>>>>>> are different. So two examples
Every H(D,D) that does not abort its simulation is exactly >>>>>>>>>>>>> equal in
that none of them ever stop running.
True but not very relevant as none of them is a halt decider. >>>>>>>>>>>>
We must start with H(D,D) is a correct abort decider
before we move on to the next step of the analysis.
Perhaps you must. Others needn't.
Until this is understood one lacks the sufficient prerequisites to >>>>>>>>> comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement >>>>>>>>> must be reached.
I admitted that I was wrong about the details of some things: >>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this >>>>>>>>> exact same H. I was wrong when I said that it could.
*This provides evidence that I want an honest dialogue*
In sufficient as you have provided much more contrary evidence. >>>>>>>> No honest dialogue can be reasonable expected when you participate. >>>>>>>>
In other words you misconstrue rhetoric as a kind of reasoning
that can be applied to rebutting logical arguments.
I misconstrue nothong you say as any kind of reasoning.
Yet can't correctly point out any errors.
It is sufficient to note that you claim that various proofs are
erroneous without pointing out any errors.
That the various proofs are correct within their false assumptions
provides zero evidence that they are correct.
halt"?
The false assumption that a halt decider must report on behavior
that is different than the behavior that it actually sees.
On 3/22/2024 3:34 PM, immibis wrote:
On 22/03/24 20:49, olcott wrote:
The false assumption that a halt decider must report on behaviorThat is a true assumption. That is the specification of a halt
that is different than the behavior that it actually sees.
decider. It must report whether a program would ever halt even though
it cannot see whether a program would ever halt.
That contradicts the correct definition of a decider that
must compute the mapping from its input on the basis of a
(in this case semantic) property of this input.
Since D does specify non-halting behavior to H then H(D,D)
is necessarily correct to reject this input as non-halting.
On 3/22/2024 4:17 PM, immibis wrote:
On 22/03/24 22:01, olcott wrote:
On 3/22/2024 3:34 PM, immibis wrote:
On 22/03/24 20:49, olcott wrote:
The false assumption that a halt decider must report on behaviorThat is a true assumption. That is the specification of a halt
that is different than the behavior that it actually sees.
decider. It must report whether a program would ever halt even
though it cannot see whether a program would ever halt.
That contradicts the correct definition of a decider that
must compute the mapping from its input on the basis of a
(in this case semantic) property of this input.
It does not contradict.
Since D does specify non-halting behavior to H then H(D,D)
is necessarily correct to reject this input as non-halting.
D specifies a program which halts when executed.
That the simulation of D must be aborted by H to prevent its own
infinite execution
On 3/22/2024 1:32 PM, Mikko wrote:
On 2024-03-22 15:43:49 +0000, olcott said:
Dogmatic statements do not count as reasoning.
Dgmatic statements likn "Dogmatic statements do not count as reasoning"
do count as rhetoric.
Observation of a fact is does not count as dogmatic.
I call out fake "rebuttals" that lack any correct reasoning basis.
I am correct when I do this.
On 3/22/2024 1:35 PM, Mikko wrote:
It is sufficient to note that you claim that various proofs are
erroneous without pointing out any errors.
That the various proofs are correct within their false assumptions
provides zero evidence that they are correct.
On 3/22/2024 2:45 PM, immibis wrote:
Assumptions such as "every program/input pair either halts or doesn't
halt"?
The false assumption that a halt decider must report on behavior
that is different than the behavior that it actually sees.
On 3/22/2024 7:44 PM, immibis wrote:
On 22/03/24 22:22, olcott wrote:
On 3/22/2024 4:17 PM, immibis wrote:
On 22/03/24 22:01, olcott wrote:
On 3/22/2024 3:34 PM, immibis wrote:
On 22/03/24 20:49, olcott wrote:
The false assumption that a halt decider must report on behavior >>>>>>> that is different than the behavior that it actually sees.That is a true assumption. That is the specification of a halt
decider. It must report whether a program would ever halt even
though it cannot see whether a program would ever halt.
That contradicts the correct definition of a decider that
must compute the mapping from its input on the basis of a
(in this case semantic) property of this input.
It does not contradict.
Since D does specify non-halting behavior to H then H(D,D)
is necessarily correct to reject this input as non-halting.
D specifies a program which halts when executed.
That the simulation of D must be aborted by H to prevent its own
infinite execution
You think this phrase means something different to what everyone else
thinks it means. Therefore I recommend not using it.
On 3/20/2024 6:02 PM, Richard Damon wrote:
On 3/20/24 6:01 PM, olcott wrote:
Every H(D,D) that doesn't abort its simulated input
never stops running.
Yep, shows that H's that don't abort the D built on
them won't be deciders...
On 3/22/2024 4:17 PM, immibis wrote:
On 22/03/24 22:01, olcott wrote:
On 3/22/2024 3:34 PM, immibis wrote:
On 22/03/24 20:49, olcott wrote:
The false assumption that a halt decider must report on behaviorThat is a true assumption. That is the specification of a halt decider. >>>> It must report whether a program would ever halt even though it cannot >>>> see whether a program would ever halt.
that is different than the behavior that it actually sees.
That contradicts the correct definition of a decider that
must compute the mapping from its input on the basis of a
(in this case semantic) property of this input.
It does not contradict.
Since D does specify non-halting behavior to H then H(D,D)
is necessarily correct to reject this input as non-halting.
D specifies a program which halts when executed.
That the simulation of D must be aborted by H to prevent its own
infinite execution conclusively proves that D specifies non-halting
behavior to H. *The only "rebuttals" to this are damned lies*
On 3/22/2024 1:32 PM, Mikko wrote:
On 2024-03-22 15:43:49 +0000, olcott said:
On 3/22/2024 2:51 AM, Mikko wrote:
On 2024-03-21 16:39:52 +0000, olcott said:
On 3/21/2024 11:29 AM, Mikko wrote:
On 2024-03-21 15:28:13 +0000, olcott said:
On 3/21/2024 10:14 AM, Mikko wrote:
On 2024-03-21 14:17:04 +0000, olcott said:
On 3/21/2024 4:47 AM, Mikko wrote:
On 2024-03-20 19:30:03 +0000, olcott said:
On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 20:07 schreef olcott:
On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 17:11 schreef olcott:
On 3/20/2024 10:50 AM, Mikko wrote:
On 2024-03-20 13:20:51 +0000, olcott said:
On 3/20/2024 3:24 AM, Mikko wrote:Therefore the correct answer H(D,D) should give is "yes". >>>>>>>>>>>>>>>>
On 2024-03-19 18:15:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 3/19/2024 12:41 PM, immibis wrote:What is true is true even when contradicted by a liar. >>>>>>>>>>>>>>>>>>
On 19/03/24 05:11, olcott wrote:
On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
If you can't even understand that H is a correct abort decider thenStrawman deception. H is a halt decider if it tells whether the direct*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
execution of its input would halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>
you can't understand anything else that requires the prerequisite
knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>
Strawman deception. It is the halting problem, not the Olcott abort problem.
You can learn calculus without the basis of algebra. You can't learn
simulating halt deciders without the basis of simulating abort deciders.
When are you going to extend this theory of simulating abort deciders
so that it solves the halting problem instead of merely solving the
Olcott abort problem?
*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrect
question thus must be redefined. >>>>>>>>>>>>>>>>>>>>>>>
But (2) is a LIE.
There is nothing "Incorrect" about the Halting Question. >>>>>>>>>>>>>>>>>>>>>>
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second entity.
If Ĥ is your x86utm function D, then "yes" is the correct answer to all
entities.
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see. >>>>>>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
Can D correctly simulated by H terminate normally?
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>> stops running.
It would be correct for this D. We can build another D, based on the
new H, but then the question changes, because the input changes. The
new H does not give the correct answer for the new D. >>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the >>>>>>>>>>>>>> question changes, because the input changes. The new H does not give
the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct forthis D. We can build another D, based on the new H, but then the >>>>>>>>>>>>>> question changes, because the input changes. The new H does not give
the correct answer for the new D.
Both questions have a correct answer, but the corresponding H failed to
give it. It seems Olcott is again confused, because he uses the same
names for different things.
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>> stops running.
Trying to refer to a different H than every H is a very lame >>>>>>>>>>>>> attempt to get away with the strawman deception.
Very weak response. I did not say different from every H. >>>>>>>>>>>> It seems Olcott does not understand that if he speaks about 'every H'
then not all these H are equal, but they are different. So two examples
Every H(D,D) that does not abort its simulation is exactly equal in >>>>>>>>>>> that none of them ever stop running.
True but not very relevant as none of them is a halt decider. >>>>>>>>>>
We must start with H(D,D) is a correct abort decider
before we move on to the next step of the analysis.
Perhaps you must. Others needn't.
Until this is understood one lacks the sufficient prerequisites to >>>>>>> comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement >>>>>>> must be reached.
I admitted that I was wrong about the details of some things:
H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this >>>>>>> exact same H. I was wrong when I said that it could.
*This provides evidence that I want an honest dialogue*
In sufficient as you have provided much more contrary evidence.
No honest dialogue can be reasonable expected when you participate. >>>>>>
*See if you can rebut this with reasoning instead of rhetoric*
[Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
I just note that you have rebutted nothing wirh reasoning or rhetoric. >>>>
Dogmatic statements do not count as reasoning.
Dgmatic statements likn "Dogmatic statements do not count as reasoning"
do count as rhetoric.
Observation of a fact is does not count as dogmatic.
I call out fake "rebuttals" that lack any correct reasoning basis.
I am correct when I do this.
On 3/22/2024 2:45 PM, immibis wrote:
On 22/03/24 19:46, olcott wrote:
On 3/22/2024 1:35 PM, Mikko wrote:Assumptions such as "every program/input pair either halts or doesn't halt"?
On 2024-03-22 15:43:04 +0000, olcott said:
On 3/22/2024 2:50 AM, Mikko wrote:
On 2024-03-21 16:34:02 +0000, olcott said:
On 3/21/2024 11:29 AM, Mikko wrote:
On 2024-03-21 15:28:13 +0000, olcott said:
On 3/21/2024 10:14 AM, Mikko wrote:
On 2024-03-21 14:17:04 +0000, olcott said:
On 3/21/2024 4:47 AM, Mikko wrote:
On 2024-03-20 19:30:03 +0000, olcott said:
On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 20:07 schreef olcott:
On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 17:11 schreef olcott:
On 3/20/2024 10:50 AM, Mikko wrote:
On 2024-03-20 13:20:51 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 3/20/2024 3:24 AM, Mikko wrote:Therefore the correct answer H(D,D) should give is "yes". >>>>>>>>>>>>>>>>>>
On 2024-03-19 18:15:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 3/19/2024 12:41 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
If you can't even understand that H is a correct abort decider thenStrawman deception. H is a halt decider if it tells whether the direct*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
execution of its input would halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
you can't understand anything else that requires the prerequisite
knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Strawman deception. It is the halting problem, not the Olcott abort problem.
You can learn calculus without the basis of algebra. You can't learn
simulating halt deciders without the basis of simulating abort deciders.
When are you going to extend this theory of simulating abort deciders
so that it solves the halting problem instead of merely solving the
Olcott abort problem?
*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrect
question thus must be redefined. >>>>>>>>>>>>>>>>>>>>>>>>>
But (2) is a LIE.
There is nothing "Incorrect" about the Halting Question.
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second entity.
If Ĥ is your x86utm function D, then "yes" is the correct answer to all
entities.
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
What is true is true even when contradicted by a liar. >>>>>>>>>>>>>>>>>>>>
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see. >>>>>>>>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
Can D correctly simulated by H terminate normally? >>>>>>>>>>>>>>> 01 int D(ptr x) // ptr is pointer to int function >>>>>>>>>>>>>>> 02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>>>> stops running.
It would be correct for this D. We can build another D, based on the
new H, but then the question changes, because the input changes. The
new H does not give the correct answer for the new D. >>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the
question changes, because the input changes. The new H does not give
the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct forthis D. We can build another D, based on the new H, but then the
question changes, because the input changes. The new H does not give
the correct answer for the new D.
Both questions have a correct answer, but the corresponding H failed to
give it. It seems Olcott is again confused, because he uses the same
names for different things.
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>>>> stops running.
Trying to refer to a different H than every H is a very lame >>>>>>>>>>>>>>> attempt to get away with the strawman deception.
Very weak response. I did not say different from every H. >>>>>>>>>>>>>> It seems Olcott does not understand that if he speaks about 'every H'
then not all these H are equal, but they are different. So two examples
Every H(D,D) that does not abort its simulation is exactly equal in
that none of them ever stop running.
True but not very relevant as none of them is a halt decider. >>>>>>>>>>>>
We must start with H(D,D) is a correct abort decider
before we move on to the next step of the analysis.
Perhaps you must. Others needn't.
Until this is understood one lacks the sufficient prerequisites to >>>>>>>>> comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement >>>>>>>>> must be reached.
I admitted that I was wrong about the details of some things: >>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this >>>>>>>>> exact same H. I was wrong when I said that it could.
*This provides evidence that I want an honest dialogue*
In sufficient as you have provided much more contrary evidence. >>>>>>>> No honest dialogue can be reasonable expected when you participate. >>>>>>>>
In other words you misconstrue rhetoric as a kind of reasoning
that can be applied to rebutting logical arguments.
I misconstrue nothong you say as any kind of reasoning.
Yet can't correctly point out any errors.
It is sufficient to note that you claim that various proofs are
erroneous without pointing out any errors.
That the various proofs are correct within their false assumptions
provides zero evidence that they are correct.
The false assumption that a halt decider must report on behavior
that is different than the behavior that it actually sees.
On 3/23/2024 6:07 AM, Mikko wrote:
On 2024-03-22 21:22:55 +0000, olcott said:
On 3/22/2024 4:17 PM, immibis wrote:
On 22/03/24 22:01, olcott wrote:
On 3/22/2024 3:34 PM, immibis wrote:
On 22/03/24 20:49, olcott wrote:
The false assumption that a halt decider must report on behavior >>>>>>> that is different than the behavior that it actually sees.That is a true assumption. That is the specification of a halt
decider. It must report whether a program would ever halt even
though it cannot see whether a program would ever halt.
That contradicts the correct definition of a decider that
must compute the mapping from its input on the basis of a
(in this case semantic) property of this input.
It does not contradict.
Since D does specify non-halting behavior to H then H(D,D)
is necessarily correct to reject this input as non-halting.
D specifies a program which halts when executed.
That the simulation of D must be aborted by H to prevent its own
infinite execution conclusively proves that D specifies non-halting
behavior to H. *The only "rebuttals" to this are damned lies*
Linz and many others have proven that there are no halt deciders.
Olcott's only "rebuttals" to this are damned lies.
You can't even found an actual mistake and have the audacity
to call me a liar?
Your last "rebuttal" was anchored in your ignorance about
how deciders are actually defined to work. They must compute
the mapping form their actual inputs.
On 3/23/2024 6:07 AM, Mikko wrote:
On 2024-03-22 21:22:55 +0000, olcott said:
On 3/22/2024 4:17 PM, immibis wrote:
On 22/03/24 22:01, olcott wrote:
On 3/22/2024 3:34 PM, immibis wrote:
On 22/03/24 20:49, olcott wrote:
The false assumption that a halt decider must report on behavior >>>>>>> that is different than the behavior that it actually sees.That is a true assumption. That is the specification of a halt decider. >>>>>> It must report whether a program would ever halt even though it cannot >>>>>> see whether a program would ever halt.
That contradicts the correct definition of a decider that
must compute the mapping from its input on the basis of a
(in this case semantic) property of this input.
It does not contradict.
Since D does specify non-halting behavior to H then H(D,D)
is necessarily correct to reject this input as non-halting.
D specifies a program which halts when executed.
That the simulation of D must be aborted by H to prevent its own
infinite execution conclusively proves that D specifies non-halting
behavior to H. *The only "rebuttals" to this are damned lies*
Linz and many others have proven that there are no halt deciders.
Olcott's only "rebuttals" to this are damned lies.
You can't even found an actual mistake and have the audacity
to call me a liar?
On 3/23/2024 6:11 AM, Mikko wrote:
On 2024-03-22 18:45:01 +0000, olcott said:
On 3/22/2024 1:32 PM, Mikko wrote:
On 2024-03-22 15:43:49 +0000, olcott said:
On 3/22/2024 2:51 AM, Mikko wrote:
On 2024-03-21 16:39:52 +0000, olcott said:
On 3/21/2024 11:29 AM, Mikko wrote:
On 2024-03-21 15:28:13 +0000, olcott said:
On 3/21/2024 10:14 AM, Mikko wrote:
On 2024-03-21 14:17:04 +0000, olcott said:
On 3/21/2024 4:47 AM, Mikko wrote:
On 2024-03-20 19:30:03 +0000, olcott said:
On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 20:07 schreef olcott:
On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 17:11 schreef olcott:
On 3/20/2024 10:50 AM, Mikko wrote:
On 2024-03-20 13:20:51 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 3/20/2024 3:24 AM, Mikko wrote:Therefore the correct answer H(D,D) should give is "yes". >>>>>>>>>>>>>>>>>>
On 2024-03-19 18:15:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 3/19/2024 12:41 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote:
On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
If you can't even understand that H is a correct abort decider thenStrawman deception. H is a halt decider if it tells whether the direct*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
execution of its input would halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
you can't understand anything else that requires the prerequisite
knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Strawman deception. It is the halting problem, not the Olcott abort problem.
You can learn calculus without the basis of algebra. You can't learn
simulating halt deciders without the basis of simulating abort deciders.
When are you going to extend this theory of simulating abort deciders
so that it solves the halting problem instead of merely solving the
Olcott abort problem?
*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrect
question thus must be redefined. >>>>>>>>>>>>>>>>>>>>>>>>>
But (2) is a LIE.
There is nothing "Incorrect" about the Halting Question.
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second entity.
If Ĥ is your x86utm function D, then "yes" is the correct answer to all
entities.
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
What is true is true even when contradicted by a liar. >>>>>>>>>>>>>>>>>>>>
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see. >>>>>>>>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H.
Can D correctly simulated by H terminate normally? >>>>>>>>>>>>>>> 01 int D(ptr x) // ptr is pointer to int function >>>>>>>>>>>>>>> 02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>>>> stops running.
It would be correct for this D. We can build another D, based on the
new H, but then the question changes, because the input changes. The
new H does not give the correct answer for the new D. >>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the
question changes, because the input changes. The new H does not give
the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct forthis D. We can build another D, based on the new H, but then the
question changes, because the input changes. The new H does not give
the correct answer for the new D.
Both questions have a correct answer, but the corresponding H failed to
give it. It seems Olcott is again confused, because he uses the same
names for different things.
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>>>> stops running.
Trying to refer to a different H than every H is a very lame >>>>>>>>>>>>>>> attempt to get away with the strawman deception.
Very weak response. I did not say different from every H. >>>>>>>>>>>>>> It seems Olcott does not understand that if he speaks about 'every H'
then not all these H are equal, but they are different. So two examples
Every H(D,D) that does not abort its simulation is exactly equal in
that none of them ever stop running.
True but not very relevant as none of them is a halt decider. >>>>>>>>>>>>
We must start with H(D,D) is a correct abort decider
before we move on to the next step of the analysis.
Perhaps you must. Others needn't.
Until this is understood one lacks the sufficient prerequisites to >>>>>>>>> comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement >>>>>>>>> must be reached.
I admitted that I was wrong about the details of some things: >>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this >>>>>>>>> exact same H. I was wrong when I said that it could.
*This provides evidence that I want an honest dialogue*
In sufficient as you have provided much more contrary evidence. >>>>>>>> No honest dialogue can be reasonable expected when you participate. >>>>>>>>
*See if you can rebut this with reasoning instead of rhetoric*
[Proof that H(D,D) meets its abort criteria--Mikes-rebuttal--]
I just note that you have rebutted nothing wirh reasoning or rhetoric. >>>>>>
Dogmatic statements do not count as reasoning.
Dgmatic statements likn "Dogmatic statements do not count as reasoning" >>>> do count as rhetoric.
Observation of a fact is does not count as dogmatic.
I call out fake "rebuttals" that lack any correct reasoning basis.
I am correct when I do this.
You usually don't. Moreoften you produce fake "rebuttals" that lack
any correct reasoning basis.
*So far no one has actually shown that*
On 3/23/2024 6:04 AM, Mikko wrote:
On 2024-03-22 19:49:09 +0000, olcott said:
On 3/22/2024 2:45 PM, immibis wrote:
On 22/03/24 19:46, olcott wrote:
On 3/22/2024 1:35 PM, Mikko wrote:Assumptions such as "every program/input pair either halts or doesn't halt"?
On 2024-03-22 15:43:04 +0000, olcott said:
On 3/22/2024 2:50 AM, Mikko wrote:
On 2024-03-21 16:34:02 +0000, olcott said:
On 3/21/2024 11:29 AM, Mikko wrote:
On 2024-03-21 15:28:13 +0000, olcott said:
On 3/21/2024 10:14 AM, Mikko wrote:
On 2024-03-21 14:17:04 +0000, olcott said:
On 3/21/2024 4:47 AM, Mikko wrote:
On 2024-03-20 19:30:03 +0000, olcott said:
On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 20:07 schreef olcott:
On 3/20/2024 1:49 PM, Fred. Zwarts wrote:Very weak response. I did not say different from every H. >>>>>>>>>>>>>>>> It seems Olcott does not understand that if he speaks about 'every H'
Op 20.mrt.2024 om 17:11 schreef olcott:Can D correctly simulated by H terminate normally? >>>>>>>>>>>>>>>>> 01 int D(ptr x) // ptr is pointer to int function >>>>>>>>>>>>>>>>> 02 {
On 3/20/2024 10:50 AM, Mikko wrote:
On 2024-03-20 13:20:51 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 3/20/2024 3:24 AM, Mikko wrote:Therefore the correct answer H(D,D) should give is "yes". >>>>>>>>>>>>>>>>>>>>
On 2024-03-19 18:15:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>
On 3/19/2024 12:41 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
If you can't even understand that H is a correct abort decider thenStrawman deception. H is a halt decider if it tells whether the direct*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
execution of its input would halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
you can't understand anything else that requires the prerequisite
knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Strawman deception. It is the halting problem, not the Olcott abort problem.
You can learn calculus without the basis of algebra. You can't learn
simulating halt deciders without the basis of simulating abort deciders.
When are you going to extend this theory of simulating abort deciders
so that it solves the halting problem instead of merely solving the
Olcott abort problem?
*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrect
question thus must be redefined. >>>>>>>>>>>>>>>>>>>>>>>>>>>
But (2) is a LIE.
There is nothing "Incorrect" about the Halting Question.
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second entity.
If Ĥ is your x86utm function D, then "yes" is the correct answer to all
entities.
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
What is true is true even when contradicted by a liar. >>>>>>>>>>>>>>>>>>>>>>
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see. >>>>>>>>>>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. >>>>>>>>>>>>>>>>>
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>>>>>> stops running.
It would be correct for this D. We can build another D, based on the
new H, but then the question changes, because the input changes. The
new H does not give the correct answer for the new D. >>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the
question changes, because the input changes. The new H does not give
the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct forthis D. We can build another D, based on the new H, but then the
question changes, because the input changes. The new H does not give
the correct answer for the new D.
Both questions have a correct answer, but the corresponding H failed to
give it. It seems Olcott is again confused, because he uses the same
names for different things.
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>>>>>> stops running.
Trying to refer to a different H than every H is a very lame >>>>>>>>>>>>>>>>> attempt to get away with the strawman deception. >>>>>>>>>>>>>>>>
then not all these H are equal, but they are different. So two examples
Every H(D,D) that does not abort its simulation is exactly equal in
that none of them ever stop running.
True but not very relevant as none of them is a halt decider. >>>>>>>>>>>>>>
We must start with H(D,D) is a correct abort decider >>>>>>>>>>>>> before we move on to the next step of the analysis.
Perhaps you must. Others needn't.
Until this is understood one lacks the sufficient prerequisites to >>>>>>>>>>> comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement >>>>>>>>>>> must be reached.
I admitted that I was wrong about the details of some things: >>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this >>>>>>>>>>> exact same H. I was wrong when I said that it could.
*This provides evidence that I want an honest dialogue*
In sufficient as you have provided much more contrary evidence. >>>>>>>>>> No honest dialogue can be reasonable expected when you participate. >>>>>>>>>>
In other words you misconstrue rhetoric as a kind of reasoning >>>>>>>>> that can be applied to rebutting logical arguments.
I misconstrue nothong you say as any kind of reasoning.
Yet can't correctly point out any errors.
It is sufficient to note that you claim that various proofs are
erroneous without pointing out any errors.
That the various proofs are correct within their false assumptions
provides zero evidence that they are correct.
The false assumption that a halt decider must report on behavior
that is different than the behavior that it actually sees.
The false assumption is that a halt decider must report in behaviour
it acutally hallucinates even when that is different from the behaviour
specified by the input.
In other words you had no clue that all deciders must compute the
mapping from their actual inputs. You cannot use your own ignorance
as a correct basis for any rebuttal.
On 3/23/2024 9:18 AM, Richard Damon wrote:
On 3/23/24 10:09 AM, olcott wrote:
On 3/23/2024 6:07 AM, Mikko wrote:
On 2024-03-22 21:22:55 +0000, olcott said:
On 3/22/2024 4:17 PM, immibis wrote:
On 22/03/24 22:01, olcott wrote:
On 3/22/2024 3:34 PM, immibis wrote:
On 22/03/24 20:49, olcott wrote:
The false assumption that a halt decider must report on behavior >>>>>>>>> that is different than the behavior that it actually sees.That is a true assumption. That is the specification of a halt >>>>>>>> decider. It must report whether a program would ever halt even >>>>>>>> though it cannot see whether a program would ever halt.
That contradicts the correct definition of a decider that
must compute the mapping from its input on the basis of a
(in this case semantic) property of this input.
It does not contradict.
Since D does specify non-halting behavior to H then H(D,D)
is necessarily correct to reject this input as non-halting.
D specifies a program which halts when executed.
That the simulation of D must be aborted by H to prevent its own
infinite execution conclusively proves that D specifies non-halting
behavior to H. *The only "rebuttals" to this are damned lies*
Linz and many others have proven that there are no halt deciders.
Olcott's only "rebuttals" to this are damned lies.
You can't even found an actual mistake and have the audacity
to call me a liar?
Your last "rebuttal" was anchored in your ignorance about
how deciders are actually defined to work. They must compute
the mapping form their actual inputs.
Right, and since D,D specifies the program D(D) and that Halts,
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
On 3/23/2024 9:18 AM, Richard Damon wrote:
Right, and since D,D specifies the program D(D) and that Halts,
Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
On 3/23/2024 2:22 AM, immibis wrote:
On 23/03/24 02:31, olcott wrote:
On 3/22/2024 7:44 PM, immibis wrote:How is that a rebuttal to what I said?
On 22/03/24 22:22, olcott wrote:
On 3/22/2024 4:17 PM, immibis wrote:
On 22/03/24 22:01, olcott wrote:
On 3/22/2024 3:34 PM, immibis wrote:
On 22/03/24 20:49, olcott wrote:
The false assumption that a halt decider must report on behavior >>>>>>>>> that is different than the behavior that it actually sees.That is a true assumption. That is the specification of a halt >>>>>>>> decider. It must report whether a program would ever halt even >>>>>>>> though it cannot see whether a program would ever halt.
That contradicts the correct definition of a decider that
must compute the mapping from its input on the basis of a
(in this case semantic) property of this input.
It does not contradict.
Since D does specify non-halting behavior to H then H(D,D)
is necessarily correct to reject this input as non-halting.
D specifies a program which halts when executed.
That the simulation of D must be aborted by H to prevent its own
infinite execution
You think this phrase means something different to what everyone
else thinks it means. Therefore I recommend not using it.
On 3/20/2024 6:02 PM, Richard Damon wrote:
On 3/20/24 6:01 PM, olcott wrote:
Every H(D,D) that doesn't abort its simulated input;
never stops running.
Yep, shows that H's that don't abort the D built on
them won't be deciders...
If you can't tell then you aren't honest.
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether a
Right, and since D,D specifies the program D(D) and that Halts,
Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
"correct simulation" of that program halts.
The halting problem is about computing the mapping from the inputs
to an accept or reject state on the basis of the behavior that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether a
Right, and since D,D specifies the program D(D) and that Halts,
Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
"correct simulation" of that program halts.
The halting problem is about computing the mapping from the inputs
to an accept or reject state on the basis of the behavior that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
On 3/23/2024 8:40 PM, immibis wrote:
On 24/03/24 00:23, olcott wrote:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether a
Right, and since D,D specifies the program D(D) and that Halts,
Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
"correct simulation" of that program halts.
The halting problem is about computing the mapping from the inputs
to an accept or reject state on the basis of the behavior that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
The halting problem is quite simple:
Create a program HaltCheck (or Turing machine) so that:
* the input Prog,Input is another program (or Turing machine) and its
input
* HaltCheck(Prog,Input)==1 if the direct execution of Prog(Input)
would halt
* HaltCheck(Prog,Input)==0 if the direct execution of Prog(Input)
would never halt
The basis for such a computation must be something that H can see
and thus not what you and others simply imagine.
On 3/23/2024 9:19 PM, immibis wrote:
On 24/03/24 03:13, olcott wrote:
On 3/23/2024 8:40 PM, immibis wrote:
On 24/03/24 00:23, olcott wrote:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether a >>>>>> "correct simulation" of that program halts.
Right, and since D,D specifies the program D(D) and that Halts, >>>>>>>Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
The halting problem is about computing the mapping from the inputs
to an accept or reject state on the basis of the behavior that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
The halting problem is quite simple:
Create a program HaltCheck (or Turing machine) so that:
* the input Prog,Input is another program (or Turing machine) and
its input
* HaltCheck(Prog,Input)==1 if the direct execution of Prog(Input)
would halt
* HaltCheck(Prog,Input)==0 if the direct execution of Prog(Input)
would never halt
The basis for such a computation must be something that H can see
and thus not what you and others simply imagine.
"Basis for a computation" is something that you randomly made up and
it doesn't mean anything. Try again.
Try and reason it through for yourself.
Is is legitimate to require a TM to compute
something that is only in your own head?
On 3/23/2024 7:17 PM, Richard Damon wrote:
On 3/23/24 7:23 PM, olcott wrote:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether a
Right, and since D,D specifies the program D(D) and that Halts,
Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
"correct simulation" of that program halts.
The halting problem is about computing the mapping from the inputs
to an accept or reject state on the basis of the behavior that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
No, it doesn't.
It specified the behavior of RUNNING D(D). This is an OBJECTIVE
specficatin
On 3/22/2024 9:17 PM, Richard Damon wrote:
The problem is that even if the "C function" D is
the same machine code, the fact that it calls an
external H means *the code of H affects its*
*behavior, and that must be taken into account*
*You are not taking that into account*
On 3/23/2024 8:40 PM, immibis wrote:
On 24/03/24 00:23, olcott wrote:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether a
Right, and since D,D specifies the program D(D) and that Halts,
Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
"correct simulation" of that program halts.
The halting problem is about computing the mapping from the inputs
to an accept or reject state on the basis of the behavior that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
The halting problem is quite simple:
Create a program HaltCheck (or Turing machine) so that:
* the input Prog,Input is another program (or Turing machine) and its
input
* HaltCheck(Prog,Input)==1 if the direct execution of Prog(Input)
would halt
* HaltCheck(Prog,Input)==0 if the direct execution of Prog(Input)
would never halt
The basis for such a computation must be something that H can see
and thus not what you and others simply imagine.
On 3/23/2024 9:53 PM, immibis wrote:
On 24/03/24 03:38, olcott wrote:
On 3/23/2024 9:19 PM, immibis wrote:
On 24/03/24 03:13, olcott wrote:
On 3/23/2024 8:40 PM, immibis wrote:
On 24/03/24 00:23, olcott wrote:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether >>>>>>>> a "correct simulation" of that program halts.
Right, and since D,D specifies the program D(D) and that Halts, >>>>>>>>>Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
The halting problem is about computing the mapping from the inputs >>>>>>> to an accept or reject state on the basis of the behavior that the >>>>>>> input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
The halting problem is quite simple:
Create a program HaltCheck (or Turing machine) so that:
* the input Prog,Input is another program (or Turing machine) and
its input
* HaltCheck(Prog,Input)==1 if the direct execution of Prog(Input)
would halt
* HaltCheck(Prog,Input)==0 if the direct execution of Prog(Input)
would never halt
The basis for such a computation must be something that H can see
and thus not what you and others simply imagine.
"Basis for a computation" is something that you randomly made up and
it doesn't mean anything. Try again.
Try and reason it through for yourself.
Is is legitimate to require a TM to compute
something that is only in your own head?
"legitimate" for this is something that you randomly made up and it
doesn't mean anything. Try again.
Is is legitimate to require a TM to compute
something that is only in your own head?
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether a
Right, and since D,D specifies the program D(D) and that Halts,
Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
"correct simulation" of that program halts.
The halting problem is about computing the mapping from the inputs
to an accept or reject state on the basis of the behavior that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
On 3/23/2024 11:07 AM, Mikko wrote:
On 2024-03-23 14:05:09 +0000, olcott said:
On 3/23/2024 6:04 AM, Mikko wrote:
On 2024-03-22 19:49:09 +0000, olcott said:
On 3/22/2024 2:45 PM, immibis wrote:
On 22/03/24 19:46, olcott wrote:
On 3/22/2024 1:35 PM, Mikko wrote:Assumptions such as "every program/input pair either halts or doesn't halt"?
On 2024-03-22 15:43:04 +0000, olcott said:
On 3/22/2024 2:50 AM, Mikko wrote:
On 2024-03-21 16:34:02 +0000, olcott said:
On 3/21/2024 11:29 AM, Mikko wrote:
On 2024-03-21 15:28:13 +0000, olcott said:
On 3/21/2024 10:14 AM, Mikko wrote:In sufficient as you have provided much more contrary evidence. >>>>>>>>>>>> No honest dialogue can be reasonable expected when you participate.
On 2024-03-21 14:17:04 +0000, olcott said:
On 3/21/2024 4:47 AM, Mikko wrote:Perhaps you must. Others needn't.
On 2024-03-20 19:30:03 +0000, olcott said:
On 3/20/2024 2:21 PM, Fred. Zwarts wrote:
Op 20.mrt.2024 om 20:07 schreef olcott:
On 3/20/2024 1:49 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>Very weak response. I did not say different from every H. >>>>>>>>>>>>>>>>>> It seems Olcott does not understand that if he speaks about 'every H'
Can D correctly simulated by H terminate normally? >>>>>>>>>>>>>>>>>>> 01 int D(ptr x) // ptr is pointer to int function >>>>>>>>>>>>>>>>>>> 02 {On 3/20/2024 3:24 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>Therefore the correct answer H(D,D) should give is "yes".
On 3/19/2024 12:41 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrectIf you can't even understand that H is a correct abort decider thenStrawman deception. H is a halt decider if it tells whether the direct*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
execution of its input would halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
you can't understand anything else that requires the prerequisite
knowledge that H is a correct abort decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Strawman deception. It is the halting problem, not the Olcott abort problem.
You can learn calculus without the basis of algebra. You can't learn
simulating halt deciders without the basis of simulating abort deciders.
When are you going to extend this theory of simulating abort deciders
so that it solves the halting problem instead of merely solving the
Olcott abort problem? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
question thus must be redefined. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But (2) is a LIE.
There is nothing "Incorrect" about the Halting Question.
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity >>>>>>>>>>>>>>>>>>>>>>>>>>> is an incorrect question when posed to this second entity.
If Ĥ is your x86utm function D, then "yes" is the correct answer to all
entities.
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
What is true is true even when contradicted by a liar. >>>>>>>>>>>>>>>>>>>>>>>>
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see. >>>>>>>>>>>>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. >>>>>>>>>>>>>>>>>>>
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>>>>>>>> stops running.
It would be correct for this D. We can build another D, based on the
new H, but then the question changes, because the input changes. The
new H does not give the correct answer for the new D. >>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the
question changes, because the input changes. The new H does not give
the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct forthis D. We can build another D, based on the new H, but then the
question changes, because the input changes. The new H does not give
the correct answer for the new D.
Both questions have a correct answer, but the corresponding H failed to
give it. It seems Olcott is again confused, because he uses the same
names for different things.
Every H(D,D) that does not abort its simulation input never >>>>>>>>>>>>>>>>>>> stops running.
Trying to refer to a different H than every H is a very lame
attempt to get away with the strawman deception. >>>>>>>>>>>>>>>>>>
then not all these H are equal, but they are different. So two examples
Every H(D,D) that does not abort its simulation is exactly equal in
that none of them ever stop running.
True but not very relevant as none of them is a halt decider. >>>>>>>>>>>>>>>>
We must start with H(D,D) is a correct abort decider >>>>>>>>>>>>>>> before we move on to the next step of the analysis. >>>>>>>>>>>>>>
Until this is understood one lacks the sufficient prerequisites to
comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement >>>>>>>>>>>>> must be reached.
I admitted that I was wrong about the details of some things: >>>>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
exact same H. I was wrong when I said that it could. >>>>>>>>>>>>>
*This provides evidence that I want an honest dialogue* >>>>>>>>>>>>
In other words you misconstrue rhetoric as a kind of reasoning >>>>>>>>>>> that can be applied to rebutting logical arguments.
I misconstrue nothong you say as any kind of reasoning.
Yet can't correctly point out any errors.
It is sufficient to note that you claim that various proofs are >>>>>>>> erroneous without pointing out any errors.
That the various proofs are correct within their false assumptions >>>>>>> provides zero evidence that they are correct.
The false assumption that a halt decider must report on behavior
that is different than the behavior that it actually sees.
The false assumption is that a halt decider must report in behaviour
it acutally hallucinates even when that is different from the behaviour >>>> specified by the input.
In other words you had no clue that all deciders must compute the
mapping from their actual inputs. You cannot use your own ignorance
as a correct basis for any rebuttal.
Not just a mappaing but the one mapping required by the specificaiton
of the particular type of decider.
The mapping that H(D,D) does correctly compute is that D correctly
simulated by H cannot possibly halt.
On 3/23/2024 11:05 AM, Mikko wrote:
On 2024-03-23 14:09:35 +0000, olcott said:
On 3/23/2024 6:07 AM, Mikko wrote:
On 2024-03-22 21:22:55 +0000, olcott said:
On 3/22/2024 4:17 PM, immibis wrote:
On 22/03/24 22:01, olcott wrote:
On 3/22/2024 3:34 PM, immibis wrote:
On 22/03/24 20:49, olcott wrote:
The false assumption that a halt decider must report on behavior >>>>>>>>> that is different than the behavior that it actually sees.That is a true assumption. That is the specification of a halt decider.
It must report whether a program would ever halt even though it cannot >>>>>>>> see whether a program would ever halt.
That contradicts the correct definition of a decider that
must compute the mapping from its input on the basis of a
(in this case semantic) property of this input.
It does not contradict.
Since D does specify non-halting behavior to H then H(D,D)
is necessarily correct to reject this input as non-halting.
D specifies a program which halts when executed.
That the simulation of D must be aborted by H to prevent its own
infinite execution conclusively proves that D specifies non-halting
behavior to H. *The only "rebuttals" to this are damned lies*
Linz and many others have proven that there are no halt deciders.
Olcott's only "rebuttals" to this are damned lies.
You can't even found an actual mistake and have the audacity
to call me a liar?
Both mistakes and lies have been found and pointed out. No need
to repeat.
What matters is that you have't retracted your claim that Linz
made a mistake that you can't point out.
*I think that I remember that we are at this point now*
Linz did not make a mistake within the mistaken notions of the
foundation of computation.
On 3/23/2024 9:19 PM, immibis wrote:
On 24/03/24 03:13, olcott wrote:
On 3/23/2024 8:40 PM, immibis wrote:
On 24/03/24 00:23, olcott wrote:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether a >>>>>> "correct simulation" of that program halts.
Right, and since D,D specifies the program D(D) and that Halts, >>>>>>>Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
The halting problem is about computing the mapping from the inputs
to an accept or reject state on the basis of the behavior that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
The halting problem is quite simple:
Create a program HaltCheck (or Turing machine) so that:
* the input Prog,Input is another program (or Turing machine) and its input
* HaltCheck(Prog,Input)==1 if the direct execution of Prog(Input) would halt
* HaltCheck(Prog,Input)==0 if the direct execution of Prog(Input) would >>>> never halt
The basis for such a computation must be something that H can see
and thus not what you and others simply imagine.
"Basis for a computation" is something that you randomly made up and it
doesn't mean anything. Try again.
Try and reason it through for yourself.
Is is legitimate to require a TM to compute
something that is only in your own head?
On 3/23/2024 9:53 PM, immibis wrote:
On 24/03/24 03:38, olcott wrote:
On 3/23/2024 9:19 PM, immibis wrote:
On 24/03/24 03:13, olcott wrote:
On 3/23/2024 8:40 PM, immibis wrote:
On 24/03/24 00:23, olcott wrote:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether >>>>>>>> a "correct simulation" of that program halts.
Right, and since D,D specifies the program D(D) and that Halts, >>>>>>>>>Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
The halting problem is about computing the mapping from the inputs >>>>>>> to an accept or reject state on the basis of the behavior that the >>>>>>> input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
The halting problem is quite simple:
Create a program HaltCheck (or Turing machine) so that:
* the input Prog,Input is another program (or Turing machine) and
its input
* HaltCheck(Prog,Input)==1 if the direct execution of Prog(Input)
would halt
* HaltCheck(Prog,Input)==0 if the direct execution of Prog(Input)
would never halt
The basis for such a computation must be something that H can see
and thus not what you and others simply imagine.
"Basis for a computation" is something that you randomly made up and
it doesn't mean anything. Try again.
Try and reason it through for yourself.
Is is legitimate to require a TM to compute
something that is only in your own head?
"legitimate" for this is something that you randomly made up and it
doesn't mean anything. Try again.
Is is legitimate to require a TM to compute
something that is only in your own head?
On 3/24/2024 11:51 AM, Mikko wrote:
On 2024-03-23 23:23:32 +0000, olcott said:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether a
Right, and since D,D specifies the program D(D) and that Halts,
Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
"correct simulation" of that program halts.
The halting problem is about computing the mapping from the inputs
to an accept or reject state on the basis of the behavior that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
The input D,D specifies exaclty one behaviour that does not depend
on whom that behaviour is told. Any misinterpretation by H does not
change the specified behaviour.
If that was true then H(D,D) would never need to abort
its simulation or H1(D,D) would need to abort its simulation.
On 3/24/2024 11:51 AM, Mikko wrote:
On 2024-03-23 23:23:32 +0000, olcott said:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether a
Right, and since D,D specifies the program D(D) and that Halts,
Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
"correct simulation" of that program halts.
The halting problem is about computing the mapping from the inputs
to an accept or reject state on the basis of the behavior that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
The input D,D specifies exaclty one behaviour that does not depend
on whom that behaviour is told. Any misinterpretation by H does not
change the specified behaviour.
If that was true then H(D,D) would never need to abort
its simulation or H1(D,D) would need to abort its simulation.
On 3/24/2024 12:07 PM, Mikko wrote:
On 2024-03-23 16:30:35 +0000, olcott said:
On 3/23/2024 11:07 AM, Mikko wrote:
On 2024-03-23 14:05:09 +0000, olcott said:
On 3/23/2024 6:04 AM, Mikko wrote:
On 2024-03-22 19:49:09 +0000, olcott said:
On 3/22/2024 2:45 PM, immibis wrote:
On 22/03/24 19:46, olcott wrote:
On 3/22/2024 1:35 PM, Mikko wrote:Assumptions such as "every program/input pair either halts or doesn't halt"?
On 2024-03-22 15:43:04 +0000, olcott said:
On 3/22/2024 2:50 AM, Mikko wrote:
On 2024-03-21 16:34:02 +0000, olcott said:
On 3/21/2024 11:29 AM, Mikko wrote:
On 2024-03-21 15:28:13 +0000, olcott said:
On 3/21/2024 10:14 AM, Mikko wrote:In sufficient as you have provided much more contrary evidence. >>>>>>>>>>>>>> No honest dialogue can be reasonable expected when you participate.
On 2024-03-21 14:17:04 +0000, olcott said:
On 3/21/2024 4:47 AM, Mikko wrote:Perhaps you must. Others needn't.
On 2024-03-20 19:30:03 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 3/20/2024 2:21 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>
Very weak response. I did not say different from every H. >>>>>>>>>>>>>>>>>>>> It seems Olcott does not understand that if he speaks about 'every H'Can D correctly simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x) // ptr is pointer to int function >>>>>>>>>>>>>>>>>>>>> 02 {On 3/20/2024 3:24 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>Therefore the correct answer H(D,D) should give is "yes".
On 3/19/2024 12:41 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrectIf you can't even understand that H is a correct abort decider thenStrawman deception. H is a halt decider if it tells whether the direct*We are talking about the abort criteria* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
execution of its input would halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
you can't understand anything else that requires the prerequisite
knowledge that H is a correct abort decider.
Strawman deception. It is the halting problem, not the Olcott abort problem.
You can learn calculus without the basis of algebra. You can't learn
simulating halt deciders without the basis of simulating abort deciders.
When are you going to extend this theory of simulating abort deciders
so that it solves the halting problem instead of merely solving the
Olcott abort problem? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
question thus must be redefined. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But (2) is a LIE.
There is nothing "Incorrect" about the Halting Question.
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity >>>>>>>>>>>>>>>>>>>>>>>>>>>>> and YES is an incorrect answer from another entity
is an incorrect question when posed to this second entity.
If Ĥ is your x86utm function D, then "yes" is the correct answer to all
entities.
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
What is true is true even when contradicted by a liar.
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see. >>>>>>>>>>>>>>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. >>>>>>>>>>>>>>>>>>>>>
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never
stops running.
It would be correct for this D. We can build another D, based on the
new H, but then the question changes, because the input changes. The
new H does not give the correct answer for the new D. >>>>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the
question changes, because the input changes. The new H does not give
the correct answer for the new D. >>>>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the
question changes, because the input changes. The new H does not give
the correct answer for the new D.
Both questions have a correct answer, but the corresponding H failed to
give it. It seems Olcott is again confused, because he uses the same
names for different things.
Every H(D,D) that does not abort its simulation input never
stops running.
Trying to refer to a different H than every H is a very lame
attempt to get away with the strawman deception. >>>>>>>>>>>>>>>>>>>>
then not all these H are equal, but they are different. So two examples
Every H(D,D) that does not abort its simulation is exactly equal in
that none of them ever stop running.
True but not very relevant as none of them is a halt decider.
We must start with H(D,D) is a correct abort decider >>>>>>>>>>>>>>>>> before we move on to the next step of the analysis. >>>>>>>>>>>>>>>>
Until this is understood one lacks the sufficient prerequisites to
comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement
must be reached.
I admitted that I was wrong about the details of some things: >>>>>>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
exact same H. I was wrong when I said that it could. >>>>>>>>>>>>>>>
*This provides evidence that I want an honest dialogue* >>>>>>>>>>>>>>
In other words you misconstrue rhetoric as a kind of reasoning >>>>>>>>>>>>> that can be applied to rebutting logical arguments.
I misconstrue nothong you say as any kind of reasoning. >>>>>>>>>>>>
Yet can't correctly point out any errors.
It is sufficient to note that you claim that various proofs are >>>>>>>>>> erroneous without pointing out any errors.
That the various proofs are correct within their false assumptions >>>>>>>>> provides zero evidence that they are correct.
The false assumption that a halt decider must report on behavior >>>>>>> that is different than the behavior that it actually sees.
The false assumption is that a halt decider must report in behaviour >>>>>> it acutally hallucinates even when that is different from the behaviour >>>>>> specified by the input.
In other words you had no clue that all deciders must compute the
mapping from their actual inputs. You cannot use your own ignorance
as a correct basis for any rebuttal.
Not just a mappaing but the one mapping required by the specificaiton
of the particular type of decider.
The mapping that H(D,D) does correctly compute is that D correctly
simulated by H cannot possibly halt.
Which is not the mapping of a halting decider.
It certainly <is> the mapping of an abort decider.
On 3/26/2024 3:27 AM, Mikko wrote:
On 2024-03-25 22:45:37 +0000, olcott said:
On 3/24/2024 11:51 AM, Mikko wrote:
On 2024-03-23 23:23:32 +0000, olcott said:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether a >>>>>> "correct simulation" of that program halts.
Right, and since D,D specifies the program D(D) and that Halts, >>>>>>>Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
The halting problem is about computing the mapping from the inputs
to an accept or reject state on the basis of the behavior that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
The input D,D specifies exaclty one behaviour that does not depend
on whom that behaviour is told. Any misinterpretation by H does not
change the specified behaviour.
If that was true then H(D,D) would never need to abort
its simulation or H1(D,D) would need to abort its simulation.
Right, except that instead of "would" it is better to say "does".
H1(D,D) does not need to abort only because H(D,D) does need to abort.
We can verify that H1(D,D) does not need abort: it does not abortThat is true.
and does not run foreer.
Therefor the only remaining option is
that H(D,D) does not need to abort but aborts anyway because
otherwise it would not be H(D,D).
Unless you are clueless about computer programming I can't see how
you could possibly be not lying about that. If H(D,D) does not abort
then H1(D,D), D(D) and H(D,D) all keep running forever...
On 3/26/2024 3:35 AM, Mikko wrote:
On 2024-03-25 22:42:29 +0000, olcott said:
On 3/24/2024 12:07 PM, Mikko wrote:
On 2024-03-23 16:30:35 +0000, olcott said:
On 3/23/2024 11:07 AM, Mikko wrote:
On 2024-03-23 14:05:09 +0000, olcott said:
On 3/23/2024 6:04 AM, Mikko wrote:
On 2024-03-22 19:49:09 +0000, olcott said:
On 3/22/2024 2:45 PM, immibis wrote:
On 22/03/24 19:46, olcott wrote:
On 3/22/2024 1:35 PM, Mikko wrote:Assumptions such as "every program/input pair either halts or >>>>>>>>>> doesn't halt"?
On 2024-03-22 15:43:04 +0000, olcott said:
On 3/22/2024 2:50 AM, Mikko wrote:
On 2024-03-21 16:34:02 +0000, olcott said:
On 3/21/2024 11:29 AM, Mikko wrote:I misconstrue nothong you say as any kind of reasoning. >>>>>>>>>>>>>>
On 2024-03-21 15:28:13 +0000, olcott said:
On 3/21/2024 10:14 AM, Mikko wrote:In sufficient as you have provided much more contrary >>>>>>>>>>>>>>>> evidence.
On 2024-03-21 14:17:04 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 3/21/2024 4:47 AM, Mikko wrote:Perhaps you must. Others needn't.
On 2024-03-20 19:30:03 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 3/20/2024 2:21 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>
Every H(D,D) that does not abort its simulation is >>>>>>>>>>>>>>>>>>>>> exactly equal inVery weak response. I did not say different from >>>>>>>>>>>>>>>>>>>>>> every H.Can D correctly simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x) // ptr is pointer to int function >>>>>>>>>>>>>>>>>>>>>>> 02 {On 3/20/2024 3:24 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>Therefore the correct answer H(D,D) should >>>>>>>>>>>>>>>>>>>>>>>>>> give is "yes".
On 3/19/2024 12:41 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) must either abort or >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fail to abort? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
*counter factual*If Ĥ is your x86utm function D, then "yes" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is the correct answer to all entities. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort.When are you going to extend this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> theory of simulating abort deciders so >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it solves the halting problem >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instead of merely solving the Olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort problem? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>You can learn calculus without the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of algebra. You can't learn >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt deciders without the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of simulating abort deciders. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>If you can't even understand that H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a correct abort decider then >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you can't understand anything else >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that requires the prerequisite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> knowledge that H is a correct abort >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*We are talking about the abort >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Strawman deception. H is a halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider if it tells whether the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of its input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Strawman deception. It is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem, not the Olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort problem. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(2) The halting problem requires the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct answer to an incorrect question >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus must be redefined. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But (2) is a LIE. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
There is nothing "Incorrect" about the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Question. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one entity
and YES is an incorrect answer from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another entity
is an incorrect question when posed to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this second entity. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩
What is true is true even when contradicted >>>>>>>>>>>>>>>>>>>>>>>>>>>> by a liar.
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and >>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are> >>>>>>>>>>>>>>>>>>>>>>>>>>> correctly reporting on what they actually see. >>>>>>>>>>>>>>>>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. >>>>>>>>>>>>>>>>>>>>>>>
03 int Halt_Status = H(x, x); >>>>>>>>>>>>>>>>>>>>>>> 04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation >>>>>>>>>>>>>>>>>>>>>>> input never
stops running.
It would be correct for this D. We can build >>>>>>>>>>>>>>>>>>>>>>>> another D, based on the new H, but then the >>>>>>>>>>>>>>>>>>>>>>>> question changes, because the input changes. The >>>>>>>>>>>>>>>>>>>>>>>> new H does not give the correct answer for the >>>>>>>>>>>>>>>>>>>>>>>> new D.
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. >>>>>>>>>>>>>>>>>>>>>>>> It would be correct for this D. We can build >>>>>>>>>>>>>>>>>>>>>>>> another D, based on the new H, but then the >>>>>>>>>>>>>>>>>>>>>>>> question changes, because the input changes. The >>>>>>>>>>>>>>>>>>>>>>>> new H does not give the correct answer for the >>>>>>>>>>>>>>>>>>>>>>>> new D.
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. >>>>>>>>>>>>>>>>>>>>>>>> It would be correct for this D. We can build >>>>>>>>>>>>>>>>>>>>>>>> another D, based on the new H, but then the >>>>>>>>>>>>>>>>>>>>>>>> question changes, because the input changes. The >>>>>>>>>>>>>>>>>>>>>>>> new H does not give the correct answer for the >>>>>>>>>>>>>>>>>>>>>>>> new D.
Both questions have a correct answer, but the >>>>>>>>>>>>>>>>>>>>>>>> corresponding H failed to give it. It seems >>>>>>>>>>>>>>>>>>>>>>>> Olcott is again confused, because he uses the >>>>>>>>>>>>>>>>>>>>>>>> same names for different things. >>>>>>>>>>>>>>>>>>>>>>>>
Every H(D,D) that does not abort its simulation >>>>>>>>>>>>>>>>>>>>>>> input never
stops running.
Trying to refer to a different H than every H is >>>>>>>>>>>>>>>>>>>>>>> a very lame
attempt to get away with the strawman deception. >>>>>>>>>>>>>>>>>>>>>>
It seems Olcott does not understand that if he >>>>>>>>>>>>>>>>>>>>>> speaks about 'every H' then not all these H are >>>>>>>>>>>>>>>>>>>>>> equal, but they are different. So two examples >>>>>>>>>>>>>>>>>>>>>
that none of them ever stop running.
True but not very relevant as none of them is a halt >>>>>>>>>>>>>>>>>>>> decider.
We must start with H(D,D) is a correct abort decider >>>>>>>>>>>>>>>>>>> before we move on to the next step of the analysis. >>>>>>>>>>>>>>>>>>
Until this is understood one lacks the sufficient >>>>>>>>>>>>>>>>> prerequisites to
comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual >>>>>>>>>>>>>>>>> agreement
must be reached.
I admitted that I was wrong about the details of some >>>>>>>>>>>>>>>>> things:
H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is >>>>>>>>>>>>>>>>> this
exact same H. I was wrong when I said that it could. >>>>>>>>>>>>>>>>>
*This provides evidence that I want an honest dialogue* >>>>>>>>>>>>>>>>
No honest dialogue can be reasonable expected when you >>>>>>>>>>>>>>>> participate.
In other words you misconstrue rhetoric as a kind of >>>>>>>>>>>>>>> reasoning
that can be applied to rebutting logical arguments. >>>>>>>>>>>>>>
Yet can't correctly point out any errors.
It is sufficient to note that you claim that various proofs are >>>>>>>>>>>> erroneous without pointing out any errors.
That the various proofs are correct within their false
assumptions
provides zero evidence that they are correct.
The false assumption that a halt decider must report on behavior >>>>>>>>> that is different than the behavior that it actually sees.
The false assumption is that a halt decider must report in
behaviour
it acutally hallucinates even when that is different from the
behaviour
specified by the input.
In other words you had no clue that all deciders must compute the >>>>>>> mapping from their actual inputs. You cannot use your own ignorance >>>>>>> as a correct basis for any rebuttal.
Not just a mappaing but the one mapping required by the specificaiton >>>>>> of the particular type of decider.
The mapping that H(D,D) does correctly compute is that D correctly
simulated by H cannot possibly halt.
Which is not the mapping of a halting decider.
It certainly <is> the mapping of an abort decider.
That is not proven. Without the necessary definitions it cannot be
proven.
I provided this at least 100 times. When I provide a definition
and it is not clear enough for you to understand say that. Don't
lie and say that I never provided a definition.
*Been providing this definition (with one word changed) for over a year*
(a) If simulating abort decider H correctly simulates its input D until
H correctly determines that its simulated D would never stop running
unless aborted then...
On 3/26/2024 9:17 PM, Richard Damon wrote:
On 3/26/24 10:24 AM, olcott wrote:
On 3/26/2024 3:27 AM, Mikko wrote:
On 2024-03-25 22:45:37 +0000, olcott said:
On 3/24/2024 11:51 AM, Mikko wrote:
On 2024-03-23 23:23:32 +0000, olcott said:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether >>>>>>>> a "correct simulation" of that program halts.
Right, and since D,D specifies the program D(D) and that Halts, >>>>>>>>>Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
The halting problem is about computing the mapping from the inputs >>>>>>> to an accept or reject state on the basis of the behavior that the >>>>>>> input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
The input D,D specifies exaclty one behaviour that does not depend >>>>>> on whom that behaviour is told. Any misinterpretation by H does not >>>>>> change the specified behaviour.
If that was true then H(D,D) would never need to abort
its simulation or H1(D,D) would need to abort its simulation.
Right, except that instead of "would" it is better to say "does".
H1(D,D) does not need to abort only because H(D,D) does need to abort.
No, they are simulating the same thing, so they have the same need to
abort or not. They are jus making a different decision about if they
wlll.
You already admitted many times that if no H every aborts its
simulation that D(D) never halts. How are you not lying now?
Your argument about CHANGING H to not abort is just INVALID as that
change the behavior of the inpout, since it uses the code of THIS H,
as it currectly is.
The error is actually in you encoding of D, by excluding the machine
it is based on.
THAT action make the question "invalid", but the actual question and
input of the Halting problem is still valid and shows that H is just
wrong.
We can verify that H1(D,D) does not need abort: it does not abortThat is true.
and does not run foreer.
Therefor the only remaining option is
that H(D,D) does not need to abort but aborts anyway because
otherwise it would not be H(D,D).
Unless you are clueless about computer programming I can't see how
you could possibly be not lying about that. If H(D,D) does not abort
then H1(D,D), D(D) and H(D,D) all keep running forever...
But that is an IMPOSSIBILITTY.
You are saying that it is an impossibility that I comment
out the part of the source-code of H that does the abort?
It is far too confusing to have a different name for each
variation of the same function this would be far too expensive
in software engineering.
An H that does not abort is the DOES-NOT-ABORT version of H.
It is not H_version_501C_651F.
On 3/27/2024 7:48 PM, Richard Damon wrote:
On 3/26/24 11:19 PM, olcott wrote:
On 3/26/2024 9:17 PM, Richard Damon wrote:
On 3/26/24 10:24 AM, olcott wrote:
On 3/26/2024 3:27 AM, Mikko wrote:No, they are simulating the same thing, so they have the same need
On 2024-03-25 22:45:37 +0000, olcott said:
On 3/24/2024 11:51 AM, Mikko wrote:
On 2024-03-23 23:23:32 +0000, olcott said:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not
Right, and since D,D specifies the program D(D) and that Halts, >>>>>>>>>>>Since you know that D(D) correctly simulated by H cannot >>>>>>>>>>> possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
whether a "correct simulation" of that program halts.
The halting problem is about computing the mapping from the inputs >>>>>>>>> to an accept or reject state on the basis of the behavior that the >>>>>>>>> input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied >>>>>>>>> without error.
The input D,D specifies exaclty one behaviour that does not depend >>>>>>>> on whom that behaviour is told. Any misinterpretation by H does not >>>>>>>> change the specified behaviour.
If that was true then H(D,D) would never need to abort
its simulation or H1(D,D) would need to abort its simulation.
Right, except that instead of "would" it is better to say "does".
H1(D,D) does not need to abort only because H(D,D) does need to abort. >>>>
to abort or not. They are jus making a different decision about if
they wlll.
You already admitted many times that if no H every aborts its
simulation that D(D) never halts. How are you not lying now?
Right, No H can simulate the input that is based on it to the point
that it halts.
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Not quite:
Because D calls H in recursive simulation every correct simulation
of 1 to ∞ steps of D never reach their final state at line 07 and halt.
That doesn't mean that no correct simulation of the input, or more
importantly, that the direct execution of the input doesn't halt.
THAT is what matters, and you claims are just lies about your fantasy
worlds of partial simulations.
Your argument about CHANGING H to not abort is just INVALID as that
change the behavior of the inpout, since it uses the code of THIS H,
as it currectly is.
The error is actually in you encoding of D, by excluding the machine
it is based on.
THAT action make the question "invalid", but the actual question and
input of the Halting problem is still valid and shows that H is just
wrong.
We can verify that H1(D,D) does not need abort: it does not abortThat is true.
and does not run foreer.
Therefor the only remaining option is
that H(D,D) does not need to abort but aborts anyway because
otherwise it would not be H(D,D).
Unless you are clueless about computer programming I can't see how
you could possibly be not lying about that. If H(D,D) does not abort >>>>> then H1(D,D), D(D) and H(D,D) all keep running forever...
But that is an IMPOSSIBILITTY.
You are saying that it is an impossibility that I comment
out the part of the source-code of H that does the abort?
And thus have a DIFFERENT PROGRAM and proof that you "proof" is based
oh a LIE/
This H is still a member of every implementation of H(D,D)
that simulates its input. You keep trying to get away with
misdirecting the dialogue to irrelevant details.
It is far too confusing to have a different name for each
variation of the same function this would be far too expensive
in software engineering.
Nope.
An H that does not abort is the DOES-NOT-ABORT version of H.
It is not H_version_501C_651F.
The "Source Code" may still call it "H", but the trouble ticket on it
needs to list what version of H it was.
It is a member of the infinite set of every H(D,D) that simulates
its input and every member of this set either aborts its simulation
or fails to halt.
Just saying "We found a bug in a version of H", fix it, with out
specifing WHICH ONE is just foolish.
I have repeated the above paragraph dozens of times and each time
you dishonestly try to get away with denying it. That would
seem to be you in the set of "all liars" of Revelations 21:8.
As you have shown yourself to be.
On 3/27/2024 8:45 PM, Richard Damon wrote:
On 3/27/24 9:06 PM, olcott wrote:
On 3/27/2024 7:48 PM, Richard Damon wrote:And each number of steps was a DIFFENT "program" D, when you include
On 3/26/24 11:19 PM, olcott wrote:
On 3/26/2024 9:17 PM, Richard Damon wrote:
On 3/26/24 10:24 AM, olcott wrote:
On 3/26/2024 3:27 AM, Mikko wrote:
On 2024-03-25 22:45:37 +0000, olcott said:H1(D,D) does not need to abort only because H(D,D) does need to
On 3/24/2024 11:51 AM, Mikko wrote:Right, except that instead of "would" it is better to say "does". >>>>>>>
On 2024-03-23 23:23:32 +0000, olcott said:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not >>>>>>>>>>>> whether a "correct simulation" of that program halts.
Right, and since D,D specifies the program D(D) and that >>>>>>>>>>>>>> Halts,
Since you know that D(D) correctly simulated by H cannot >>>>>>>>>>>>> possibly halt, why lie about this and use the strawman >>>>>>>>>>>>> deception to refer to an instance of D(D) that does not >>>>>>>>>>>>> even exist in the above computation?
The halting problem is about computing the mapping from the >>>>>>>>>>> inputs
to an accept or reject state on the basis of the behavior >>>>>>>>>>> that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H* >>>>>>>>>>> The above are self-evidently true facts and cannot be denied >>>>>>>>>>> without error.
The input D,D specifies exaclty one behaviour that does not >>>>>>>>>> depend
on whom that behaviour is told. Any misinterpretation by H >>>>>>>>>> does not
change the specified behaviour.
If that was true then H(D,D) would never need to abort
its simulation or H1(D,D) would need to abort its simulation. >>>>>>>>
abort.
No, they are simulating the same thing, so they have the same need >>>>>> to abort or not. They are jus making a different decision about if >>>>>> they wlll.
You already admitted many times that if no H every aborts its
simulation that D(D) never halts. How are you not lying now?
Right, No H can simulate the input that is based on it to the point
that it halts.
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Not quite:
Because D calls H in recursive simulation every correct simulation
of 1 to ∞ steps of D never reach their final state at line 07 and halt. >>
the "hidden" input of the H that it calls.
*Yes right these two identical finite strings*
*are different because they are identical* 83c4088945fc837dfc007402ebfe8b45fc8be55dc3 83c4088945fc837dfc007402ebfe8b45fc8be55dc3
Every H(D,D) that simulates its input <is> equivalent
except for whether it aborts its simulation of not.
Thus for all practical purposes there are only two.
(a) Every H(D,D) that simulates its input and aborts.
(b) Every H(D,D) that simulates its input and does not abort.
Every H must make sure it is a (b) and not an (a).
Thus, your question is INVALID based on being a "complex question"
with a hidden presumption.
You already knew that all of these details are irrelevant
yet keep trying to get away with saying that they are relevant.
<snip>
This H is still a member of every implementation of H(D,D)
that simulates its input. You keep trying to get away with
misdirecting the dialogue to irrelevant details.
And EACH H gets a DIFFERENT effective D.
*You keep trying to get away with misdirecting to irrelevant details*
*You keep trying to get away with misdirecting to irrelevant details*
*You keep trying to get away with misdirecting to irrelevant details*
*You keep trying to get away with misdirecting to irrelevant details*
*You keep trying to get away with misdirecting to irrelevant details*
YOU keep on trying to LIE about that fact.
Or, are just admitting that you are so stupid you don't see that fact.
It is far too confusing to have a different name for each
variation of the same function this would be far too expensive
in software engineering.
Nope.
An H that does not abort is the DOES-NOT-ABORT version of H.
It is not H_version_501C_651F.
The "Source Code" may still call it "H", but the trouble ticket on
it needs to list what version of H it was.
It is a member of the infinite set of every H(D,D) that simulates
its input and every member of this set either aborts its simulation
or fails to halt.
And every member of that infinite set has a DIFFERENT effective D, and
thus the behavior of one doesn't tell you about the behavior of another,
The behavior of the entire class tells you all of the relevant
details about every member of that class.
The behavior of the entire class tells you all of the relevant
details about every member of that class.
The behavior of the entire class tells you all of the relevant
details about every member of that class.
The behavior of the entire class tells you all of the relevant
details about every member of that class.
Unless you want to say you can tell the weight of a 10 story office
building by weighing the cat that you call part of the same set.
We can tell that every office building that weighs between
150 and 200 tons weighs between 150 and 200 tons and none
them weight less than 150 tons or more than 200 tones.
Just saying "We found a bug in a version of H", fix it, with out
specifing WHICH ONE is just foolish.
I have repeated the above paragraph dozens of times and each time
you dishonestly try to get away with denying it. That would
seem to be you in the set of "all liars" of Revelations 21:8.
Nope. YOU ARE.
Your words are not in agreement with the truth, but you speak your
native language of LIEs. You confuse all the different Ds and try to
call them the same.
*There is no relevant difference and you know it*
*There is no relevant difference and you know it*
*There is no relevant difference and you know it*
*There is no relevant difference and you know it*
On 3/27/2024 9:50 PM, Richard Damon wrote:
On 3/27/24 10:26 PM, olcott wrote:
On 3/27/2024 8:45 PM, Richard Damon wrote:
On 3/27/24 9:06 PM, olcott wrote:
On 3/27/2024 7:48 PM, Richard Damon wrote:
On 3/26/24 11:19 PM, olcott wrote:
On 3/26/2024 9:17 PM, Richard Damon wrote:
On 3/26/24 10:24 AM, olcott wrote:
On 3/26/2024 3:27 AM, Mikko wrote:
On 2024-03-25 22:45:37 +0000, olcott said:H1(D,D) does not need to abort only because H(D,D) does need to >>>>>>>>> abort.
On 3/24/2024 11:51 AM, Mikko wrote:Right, except that instead of "would" it is better to say "does". >>>>>>>>>
On 2024-03-23 23:23:32 +0000, olcott said:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:The halting problem is about computing the mapping from the >>>>>>>>>>>>> inputs
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not >>>>>>>>>>>>>> whether a "correct simulation" of that program halts. >>>>>>>>>>>>>
Right, and since D,D specifies the program D(D) and that >>>>>>>>>>>>>>>> Halts,
Since you know that D(D) correctly simulated by H cannot >>>>>>>>>>>>>>> possibly halt, why lie about this and use the strawman >>>>>>>>>>>>>>> deception to refer to an instance of D(D) that does not >>>>>>>>>>>>>>> even exist in the above computation?
to an accept or reject state on the basis of the behavior >>>>>>>>>>>>> that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H* >>>>>>>>>>>>> The above are self-evidently true facts and cannot be denied >>>>>>>>>>>>> without error.
The input D,D specifies exaclty one behaviour that does not >>>>>>>>>>>> depend
on whom that behaviour is told. Any misinterpretation by H >>>>>>>>>>>> does not
change the specified behaviour.
If that was true then H(D,D) would never need to abort
its simulation or H1(D,D) would need to abort its simulation. >>>>>>>>>>
No, they are simulating the same thing, so they have the same
need to abort or not. They are jus making a different decision >>>>>>>> about if they wlll.
You already admitted many times that if no H every aborts its
simulation that D(D) never halts. How are you not lying now?
Right, No H can simulate the input that is based on it to the
point that it halts.
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Not quite:
Because D calls H in recursive simulation every correct simulation
of 1 to ∞ steps of D never reach their final state at line 07 and
halt.
And each number of steps was a DIFFENT "program" D, when you include
the "hidden" input of the H that it calls.
*Yes right these two identical finite strings*
*are different because they are identical*
83c4088945fc837dfc007402ebfe8b45fc8be55dc3
83c4088945fc837dfc007402ebfe8b45fc8be55dc3
No, they are different effective programs because they reference
different version of H.
You admit that will
Every H(D,D) that simulates its input <is> equivalent
except for whether it aborts its simulation of not.
Which means they are different, and you are using DEVIL TALK.
Thus for all practical purposes there are only two.
(a) Every H(D,D) that simulates its input and aborts.
(b) Every H(D,D) that simulates its input and does not abort.
Every H must make sure it is a (b) and not an (a).
Right, but every D built from an H that is a (B) will also Halt, and
thus its simulation doesn't need to be aborted.
In other words every D built from an H aborts never needed to be
build from an H that aborts.
This is the kind of deception that could cost your soul, unless
it is an honest mistake.
On 3/27/2024 10:19 PM, Richard Damon wrote:
On 3/27/24 10:59 PM, olcott wrote:
On 3/27/2024 9:50 PM, Richard Damon wrote:
On 3/27/24 10:26 PM, olcott wrote:
On 3/27/2024 8:45 PM, Richard Damon wrote:
On 3/27/24 9:06 PM, olcott wrote:
On 3/27/2024 7:48 PM, Richard Damon wrote:
On 3/26/24 11:19 PM, olcott wrote:
On 3/26/2024 9:17 PM, Richard Damon wrote:
On 3/26/24 10:24 AM, olcott wrote:
On 3/26/2024 3:27 AM, Mikko wrote:
On 2024-03-25 22:45:37 +0000, olcott said:
On 3/24/2024 11:51 AM, Mikko wrote:Right, except that instead of "would" it is better to say >>>>>>>>>>>> "does".
On 2024-03-23 23:23:32 +0000, olcott said:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:The halting problem is about computing the mapping from >>>>>>>>>>>>>>> the inputs
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not >>>>>>>>>>>>>>>> whether a "correct simulation" of that program halts. >>>>>>>>>>>>>>>
Right, and since D,D specifies the program D(D) and >>>>>>>>>>>>>>>>>> that Halts,
Since you know that D(D) correctly simulated by H cannot >>>>>>>>>>>>>>>>> possibly halt, why lie about this and use the strawman >>>>>>>>>>>>>>>>> deception to refer to an instance of D(D) that does not >>>>>>>>>>>>>>>>> even exist in the above computation?
to an accept or reject state on the basis of the behavior >>>>>>>>>>>>>>> that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H* >>>>>>>>>>>>>>> The above are self-evidently true facts and cannot be denied >>>>>>>>>>>>>>> without error.
The input D,D specifies exaclty one behaviour that does >>>>>>>>>>>>>> not depend
on whom that behaviour is told. Any misinterpretation by H >>>>>>>>>>>>>> does not
change the specified behaviour.
If that was true then H(D,D) would never need to abort >>>>>>>>>>>>> its simulation or H1(D,D) would need to abort its simulation. >>>>>>>>>>>>
H1(D,D) does not need to abort only because H(D,D) does need >>>>>>>>>>> to abort.
No, they are simulating the same thing, so they have the same >>>>>>>>>> need to abort or not. They are jus making a different decision >>>>>>>>>> about if they wlll.
You already admitted many times that if no H every aborts its >>>>>>>>> simulation that D(D) never halts. How are you not lying now?
Right, No H can simulate the input that is based on it to the
point that it halts.
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Not quite:
Because D calls H in recursive simulation every correct simulation >>>>>>> of 1 to ∞ steps of D never reach their final state at line 07 and >>>>>>> halt.
And each number of steps was a DIFFENT "program" D, when you
include the "hidden" input of the H that it calls.
*Yes right these two identical finite strings*
*are different because they are identical*
83c4088945fc837dfc007402ebfe8b45fc8be55dc3
83c4088945fc837dfc007402ebfe8b45fc8be55dc3
No, they are different effective programs because they reference
different version of H.
You admit that will
Every H(D,D) that simulates its input <is> equivalent
except for whether it aborts its simulation of not.
Which means they are different, and you are using DEVIL TALK.
Thus for all practical purposes there are only two.
(a) Every H(D,D) that simulates its input and aborts.
(b) Every H(D,D) that simulates its input and does not abort.
Every H must make sure it is a (b) and not an (a).
Right, but every D built from an H that is a (B) will also Halt, and
thus its simulation doesn't need to be aborted.
In other words every D built from an H aborts never needed to be
build from an H that aborts.
No, its simulation never needed to be aborted.
Your every that H(D,D) is not a correct abort decider takes this form:
*Every H(D,D) that needs to abort its input never needed to abort*
*its input because some other H somewhere else that did not abort*
*its input already aborted its input that it never aborted*
On 3/26/2024 3:27 AM, Mikko wrote:
On 2024-03-25 22:45:37 +0000, olcott said:
On 3/24/2024 11:51 AM, Mikko wrote:
On 2024-03-23 23:23:32 +0000, olcott said:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether a >>>>>> "correct simulation" of that program halts.
Right, and since D,D specifies the program D(D) and that Halts, >>>>>>>Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
The halting problem is about computing the mapping from the inputs
to an accept or reject state on the basis of the behavior that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
The input D,D specifies exaclty one behaviour that does not depend
on whom that behaviour is told. Any misinterpretation by H does not
change the specified behaviour.
If that was true then H(D,D) would never need to abort
its simulation or H1(D,D) would need to abort its simulation.
Right, except that instead of "would" it is better to say "does".
H1(D,D) does not need to abort only because H(D,D) does need to abort.
On 3/26/2024 3:33 AM, Mikko wrote:
On 2024-03-25 22:43:42 +0000, olcott said:
On 3/24/2024 12:04 PM, Mikko wrote:
On 2024-03-23 16:28:22 +0000, olcott said:
On 3/23/2024 11:05 AM, Mikko wrote:
On 2024-03-23 14:09:35 +0000, olcott said:
On 3/23/2024 6:07 AM, Mikko wrote:
On 2024-03-22 21:22:55 +0000, olcott said:
On 3/22/2024 4:17 PM, immibis wrote:
On 22/03/24 22:01, olcott wrote:
On 3/22/2024 3:34 PM, immibis wrote:
On 22/03/24 20:49, olcott wrote:
The false assumption that a halt decider must report on behavior
that is different than the behavior that it actually sees.
That is a true assumption. That is the specification of a halt decider.
It must report whether a program would ever halt even though it cannot
see whether a program would ever halt.
That contradicts the correct definition of a decider that
must compute the mapping from its input on the basis of a
(in this case semantic) property of this input.
It does not contradict.
Since D does specify non-halting behavior to H then H(D,D)
is necessarily correct to reject this input as non-halting.
D specifies a program which halts when executed.
That the simulation of D must be aborted by H to prevent its own
infinite execution conclusively proves that D specifies non-halting
behavior to H. *The only "rebuttals" to this are damned lies*
Linz and many others have proven that there are no halt deciders.
Olcott's only "rebuttals" to this are damned lies.
You can't even found an actual mistake and have the audacity
to call me a liar?
Both mistakes and lies have been found and pointed out. No need
to repeat.
What matters is that you have't retracted your claim that Linz
made a mistake that you can't point out.
*I think that I remember that we are at this point now*
Linz did not make a mistake within the mistaken notions of the
foundation of computation.
Have you found any mistake in Linz' book?
Yes both Ben and I agree that Ĥ should not have two start states.
Perhaps Linz' presentation is not clear enough for you but Linz Ĥ
has only one start state. When Linz says that an action is prepended
that means that the start state of H is not the sart state of Ĥ.
--
Mikko
Whatever you did to the formatting it screwed it up.
*Linz Ĥ has q0 at its first state and q0 at its second state*
*My Ĥ has one q0 state and the next q0 is an H state*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
On 3/26/2024 3:35 AM, Mikko wrote:
On 2024-03-25 22:42:29 +0000, olcott said:
On 3/24/2024 12:07 PM, Mikko wrote:
On 2024-03-23 16:30:35 +0000, olcott said:
On 3/23/2024 11:07 AM, Mikko wrote:
On 2024-03-23 14:05:09 +0000, olcott said:
On 3/23/2024 6:04 AM, Mikko wrote:
On 2024-03-22 19:49:09 +0000, olcott said:
On 3/22/2024 2:45 PM, immibis wrote:
On 22/03/24 19:46, olcott wrote:
On 3/22/2024 1:35 PM, Mikko wrote:Assumptions such as "every program/input pair either halts or doesn't halt"?
On 2024-03-22 15:43:04 +0000, olcott said:
On 3/22/2024 2:50 AM, Mikko wrote:
On 2024-03-21 16:34:02 +0000, olcott said:
On 3/21/2024 11:29 AM, Mikko wrote:I misconstrue nothong you say as any kind of reasoning. >>>>>>>>>>>>>>
On 2024-03-21 15:28:13 +0000, olcott said:
On 3/21/2024 10:14 AM, Mikko wrote:In sufficient as you have provided much more contrary evidence.
On 2024-03-21 14:17:04 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 3/21/2024 4:47 AM, Mikko wrote:Perhaps you must. Others needn't.
On 2024-03-20 19:30:03 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 3/20/2024 2:21 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 20:07 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>
Very weak response. I did not say different from every H.Can D correctly simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x) // ptr is pointer to int function >>>>>>>>>>>>>>>>>>>>>>> 02 {On 3/20/2024 3:24 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>Therefore the correct answer H(D,D) should give is "yes".
On 3/19/2024 12:41 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:43, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) The halting problem requires the correct answer to an incorrectIf you can't even understand that H is a correct abort decider then*We are talking about the abort criteria*Do you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Strawman deception. H is a halt decider if it tells whether the direct
execution of its input would halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
you can't understand anything else that requires the prerequisite
knowledge that H is a correct abort decider.
Strawman deception. It is the halting problem, not the Olcott abort problem.
You can learn calculus without the basis of algebra. You can't learn
simulating halt deciders without the basis of simulating abort deciders.
When are you going to extend this theory of simulating abort deciders
so that it solves the halting problem instead of merely solving the
Olcott abort problem? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
question thus must be redefined. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But (2) is a LIE. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
There is nothing "Incorrect" about the Halting Question.
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> such that YES is a correct answer from one entity
and YES is an incorrect answer from another entity
is an incorrect question when posed to this second entity.
If Ĥ is your x86utm function D, then "yes" is the correct answer to all
entities.
*counter factual*
That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
What is true is true even when contradicted by a liar.
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see. >>>>>>>>>>>>>>>>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. >>>>>>>>>>>>>>>>>>>>>>>
03 int Halt_Status = H(x, x); >>>>>>>>>>>>>>>>>>>>>>> 04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }
Every H(D,D) that does not abort its simulation input never
stops running.
It would be correct for this D. We can build another D, based on the
new H, but then the question changes, because the input changes. The
new H does not give the correct answer for the new D. >>>>>>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the
question changes, because the input changes. The new H does not give
the correct answer for the new D. >>>>>>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer* >>>>>>>>>>>>>>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the
question changes, because the input changes. The new H does not give
the correct answer for the new D. >>>>>>>>>>>>>>>>>>>>>>>>
Both questions have a correct answer, but the corresponding H failed to
give it. It seems Olcott is again confused, because he uses the same
names for different things.
Every H(D,D) that does not abort its simulation input never
stops running.
Trying to refer to a different H than every H is a very lame
attempt to get away with the strawman deception. >>>>>>>>>>>>>>>>>>>>>>
It seems Olcott does not understand that if he speaks about 'every H'
then not all these H are equal, but they are different. So two examples
Every H(D,D) that does not abort its simulation is exactly equal in
that none of them ever stop running.
True but not very relevant as none of them is a halt decider.
We must start with H(D,D) is a correct abort decider >>>>>>>>>>>>>>>>>>> before we move on to the next step of the analysis. >>>>>>>>>>>>>>>>>>
Until this is understood one lacks the sufficient prerequisites to
comprehend any further elaborations.
If an honest dialogue is the goal then points of mutual agreement
must be reached.
I admitted that I was wrong about the details of some things: >>>>>>>>>>>>>>>>> H cannot simply wait for Ĥ ⟨Ĥ⟩ to complete when Ĥ.H is this
exact same H. I was wrong when I said that it could. >>>>>>>>>>>>>>>>>
*This provides evidence that I want an honest dialogue* >>>>>>>>>>>>>>>>
No honest dialogue can be reasonable expected when you participate.
In other words you misconstrue rhetoric as a kind of reasoning >>>>>>>>>>>>>>> that can be applied to rebutting logical arguments. >>>>>>>>>>>>>>
Yet can't correctly point out any errors.
It is sufficient to note that you claim that various proofs are >>>>>>>>>>>> erroneous without pointing out any errors.
That the various proofs are correct within their false assumptions >>>>>>>>>>> provides zero evidence that they are correct.
The false assumption that a halt decider must report on behavior >>>>>>>>> that is different than the behavior that it actually sees.
The false assumption is that a halt decider must report in behaviour >>>>>>>> it acutally hallucinates even when that is different from the behaviour
specified by the input.
In other words you had no clue that all deciders must compute the >>>>>>> mapping from their actual inputs. You cannot use your own ignorance >>>>>>> as a correct basis for any rebuttal.
Not just a mappaing but the one mapping required by the specificaiton >>>>>> of the particular type of decider.
The mapping that H(D,D) does correctly compute is that D correctly
simulated by H cannot possibly halt.
Which is not the mapping of a halting decider.
It certainly <is> the mapping of an abort decider.
That is not proven. Without the necessary definitions it cannot be proven. >>
I provided this at least 100 times. When I provide a definition
and it is not clear enough for you to understand say that. Don't
lie and say that I never provided a definition.
*Been providing this definition (with one word changed) for over a year*
(a) If simulating abort decider H correctly simulates its input D until
H correctly determines that its simulated D would never stop running
unless aborted then...
On 3/28/2024 7:54 AM, Mikko wrote:
On 2024-03-26 14:37:38 +0000, olcott said:
<snip>
I have not seen anything that even pretends to be a definition of
an abort decider.
*Been providing this definition (with one word changed) for over a year* >>> (a) If simulating abort decider H correctly simulates its input D until
H correctly determines that its simulated D would never stop running
unless aborted then...
That does not pretend to definition of anything. It uses the term
"simulationg abort decider" as if that (or at least "abort decider")
were defined before that.
A simulating abort decider simulates its input until this input matches
one of three non-halting behavior patterns:
(a) Infinite loop (b) Infinite recursion (c) recursive simulation.
or the input halts.
On 3/28/2024 7:30 AM, Mikko wrote:
On 2024-03-26 14:24:37 +0000, olcott said:
On 3/26/2024 3:27 AM, Mikko wrote:
On 2024-03-25 22:45:37 +0000, olcott said:
On 3/24/2024 11:51 AM, Mikko wrote:
On 2024-03-23 23:23:32 +0000, olcott said:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not whether >>>>>>>> a "correct simulation" of that program halts.
Right, and since D,D specifies the program D(D) and that Halts, >>>>>>>>>Since you know that D(D) correctly simulated by H cannot
possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
The halting problem is about computing the mapping from the inputs >>>>>>> to an accept or reject state on the basis of the behavior that the >>>>>>> input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied
without error.
The input D,D specifies exaclty one behaviour that does not depend >>>>>> on whom that behaviour is told. Any misinterpretation by H does not >>>>>> change the specified behaviour.
If that was true then H(D,D) would never need to abort
its simulation or H1(D,D) would need to abort its simulation.
Right, except that instead of "would" it is better to say "does".
H1(D,D) does not need to abort only because H(D,D) does need to abort.
Much bettter.
Richard tries to get away with this:
*Every H(D,D) that needs to abort its input never needed to abort*
*its input because some other H somewhere else that did not abort*
*its input already aborted its input that it never aborted*
On 3/28/2024 7:06 PM, Richard Damon wrote:
On 3/28/24 10:32 AM, olcott wrote:
On 3/28/2024 7:30 AM, Mikko wrote:
On 2024-03-26 14:24:37 +0000, olcott said:
On 3/26/2024 3:27 AM, Mikko wrote:Much bettter.
On 2024-03-25 22:45:37 +0000, olcott said:
On 3/24/2024 11:51 AM, Mikko wrote:
On 2024-03-23 23:23:32 +0000, olcott said:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not
Right, and since D,D specifies the program D(D) and that Halts, >>>>>>>>>>>Since you know that D(D) correctly simulated by H cannot >>>>>>>>>>> possibly halt, why lie about this and use the strawman
deception to refer to an instance of D(D) that does not
even exist in the above computation?
whether a "correct simulation" of that program halts.
The halting problem is about computing the mapping from the inputs >>>>>>>>> to an accept or reject state on the basis of the behavior that the >>>>>>>>> input specifies.
*The input to H(D,D) specifies non-halting behavior to H*
The above are self-evidently true facts and cannot be denied >>>>>>>>> without error.
The input D,D specifies exaclty one behaviour that does not depend >>>>>>>> on whom that behaviour is told. Any misinterpretation by H does not >>>>>>>> change the specified behaviour.
If that was true then H(D,D) would never need to abort
its simulation or H1(D,D) would need to abort its simulation.
Right, except that instead of "would" it is better to say "does".
H1(D,D) does not need to abort only because H(D,D) does need to abort. >>>>
Richard tries to get away with this:
*Every H(D,D) that needs to abort its input never needed to abort*
*its input because some other H somewhere else that did not abort*
*its input already aborted its input that it never aborted*
Nope, you keep on lying by changing the words and thus the meaning.
The H that DOES abort, turns out to not NEED to abort (but still
does), because the version of it called by D WILL abort, and return 0
and thus D(D) Halts, so this H could have reached a conclusion if
somehow this version of it could not abort (but leave all the other
version as they were).
Because every H in the entire recursive chain has the exact same machine
code unless the outermost directly executed one aborts its simulation
then none of them do.
On 3/28/2024 9:27 PM, Richard Damon wrote:
On 3/28/24 10:03 PM, olcott wrote:
On 3/28/2024 7:06 PM, Richard Damon wrote:
On 3/28/24 10:32 AM, olcott wrote:
On 3/28/2024 7:30 AM, Mikko wrote:
On 2024-03-26 14:24:37 +0000, olcott said:
On 3/26/2024 3:27 AM, Mikko wrote:
On 2024-03-25 22:45:37 +0000, olcott said:H1(D,D) does not need to abort only because H(D,D) does need to
On 3/24/2024 11:51 AM, Mikko wrote:Right, except that instead of "would" it is better to say "does". >>>>>>>
On 2024-03-23 23:23:32 +0000, olcott said:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not >>>>>>>>>>>> whether a "correct simulation" of that program halts.
Right, and since D,D specifies the program D(D) and that >>>>>>>>>>>>>> Halts,
Since you know that D(D) correctly simulated by H cannot >>>>>>>>>>>>> possibly halt, why lie about this and use the strawman >>>>>>>>>>>>> deception to refer to an instance of D(D) that does not >>>>>>>>>>>>> even exist in the above computation?
The halting problem is about computing the mapping from the >>>>>>>>>>> inputs
to an accept or reject state on the basis of the behavior >>>>>>>>>>> that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H* >>>>>>>>>>> The above are self-evidently true facts and cannot be denied >>>>>>>>>>> without error.
The input D,D specifies exaclty one behaviour that does not >>>>>>>>>> depend
on whom that behaviour is told. Any misinterpretation by H >>>>>>>>>> does not
change the specified behaviour.
If that was true then H(D,D) would never need to abort
its simulation or H1(D,D) would need to abort its simulation. >>>>>>>>
abort.
Much bettter.
Richard tries to get away with this:
*Every H(D,D) that needs to abort its input never needed to abort*
*its input because some other H somewhere else that did not abort*
*its input already aborted its input that it never aborted*
Nope, you keep on lying by changing the words and thus the meaning.
The H that DOES abort, turns out to not NEED to abort (but still
does), because the version of it called by D WILL abort, and return
0 and thus D(D) Halts, so this H could have reached a conclusion if
somehow this version of it could not abort (but leave all the other
version as they were).
Because every H in the entire recursive chain has the exact same machine >>> code unless the outermost directly executed one aborts its simulation
then none of them do.
So?
If the outer one is coded to abort, then they ALL abort
Counter-factual and you know it.
They would abort if their code is reachable which it is not.
, and it can be shown that NONE of them actually "Needed" to abort,
because the next level does and halts.
Counter-factual and you know it.
They would abort if their code is reachable which it is not.
(your repeating just shows you have the emotions of a two year ole)
Allowing for your ADD.
*If I don't get ridiculous about repeating it*
*you perpetually act like I never said it*
*If I don't get ridiculous about repeating it*
*you perpetually act like I never said it*
*If I don't get ridiculous about repeating it*
*you perpetually act like I never said it*
You don't get to compare H to some other H (which has a different
behaving input) to determine need, as there could be an infinite
number of alternates, but you have to compare H to what a "correct
simulator" would do
*AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*
*AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*
*AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*
*AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*
*AN ABORT DECIDER MUST REPORT ON THE BEHAVIOR THAT IT ACTUALLY SEES*
with the exact same input (i.e. paired with this H).
You are just proving that you don't understand the meaning of the
words, and are just LYING about everything you say.
On 3/28/2024 9:57 AM, Mikko wrote:
On 2024-03-28 14:23:57 +0000, olcott said:
On 3/28/2024 7:54 AM, Mikko wrote:
On 2024-03-26 14:37:38 +0000, olcott said:
<snip>
I have not seen anything that even pretends to be a definition of
an abort decider.
*Been providing this definition (with one word changed) for over a year* >>>>> (a) If simulating abort decider H correctly simulates its input D until >>>>> H correctly determines that its simulated D would never stop running >>>>> unless aborted then...
That does not pretend to definition of anything. It uses the term
"simulationg abort decider" as if that (or at least "abort decider")
were defined before that.
A simulating abort decider simulates its input until this input matches
one of three non-halting behavior patterns:
(a) Infinite loop (b) Infinite recursion (c) recursive simulation.
or the input halts.
Is that a definition or a dexcription?
*That is the architectural overview, the definitions are here* https://github.com/plolcott/x86utm/blob/master/Halt7.c
On 3/28/2024 9:53 PM, Richard Damon wrote:
On 3/28/24 10:39 PM, olcott wrote:
On 3/28/2024 9:27 PM, Richard Damon wrote:
On 3/28/24 10:03 PM, olcott wrote:
On 3/28/2024 7:06 PM, Richard Damon wrote:
On 3/28/24 10:32 AM, olcott wrote:
On 3/28/2024 7:30 AM, Mikko wrote:
On 2024-03-26 14:24:37 +0000, olcott said:
On 3/26/2024 3:27 AM, Mikko wrote:
On 2024-03-25 22:45:37 +0000, olcott said:H1(D,D) does not need to abort only because H(D,D) does need to >>>>>>>>> abort.
On 3/24/2024 11:51 AM, Mikko wrote:Right, except that instead of "would" it is better to say "does". >>>>>>>>>
On 2024-03-23 23:23:32 +0000, olcott said:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:The halting problem is about computing the mapping from the >>>>>>>>>>>>> inputs
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not >>>>>>>>>>>>>> whether a "correct simulation" of that program halts. >>>>>>>>>>>>>
Right, and since D,D specifies the program D(D) and that >>>>>>>>>>>>>>>> Halts,
Since you know that D(D) correctly simulated by H cannot >>>>>>>>>>>>>>> possibly halt, why lie about this and use the strawman >>>>>>>>>>>>>>> deception to refer to an instance of D(D) that does not >>>>>>>>>>>>>>> even exist in the above computation?
to an accept or reject state on the basis of the behavior >>>>>>>>>>>>> that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H* >>>>>>>>>>>>> The above are self-evidently true facts and cannot be denied >>>>>>>>>>>>> without error.
The input D,D specifies exaclty one behaviour that does not >>>>>>>>>>>> depend
on whom that behaviour is told. Any misinterpretation by H >>>>>>>>>>>> does not
change the specified behaviour.
If that was true then H(D,D) would never need to abort
its simulation or H1(D,D) would need to abort its simulation. >>>>>>>>>>
Much bettter.
Richard tries to get away with this:
*Every H(D,D) that needs to abort its input never needed to abort* >>>>>>> *its input because some other H somewhere else that did not abort* >>>>>>> *its input already aborted its input that it never aborted*
Nope, you keep on lying by changing the words and thus the meaning. >>>>>>
The H that DOES abort, turns out to not NEED to abort (but still
does), because the version of it called by D WILL abort, and
return 0 and thus D(D) Halts, so this H could have reached a
conclusion if somehow this version of it could not abort (but
leave all the other version as they were).
Because every H in the entire recursive chain has the exact same
machine
code unless the outermost directly executed one aborts its simulation >>>>> then none of them do.
So?
If the outer one is coded to abort, then they ALL abort
Counter-factual and you know it.
They would abort if their code is reachable which it is not.
Why isn't it reachable to a correct simulation or direct execution?
That is your evil strawman deception away from this abort
decider.
01 void D(ptr x) // ptr is pointer to void function
02 {
03 H(x, x);
04 return;
05 }
06
07 void main()
08 {
09 H(D,D);
10 }
Validation of POD24 as a robust early clinical end point of
poor survival in FL from 5225 patients on 13 clinical trials https://pubmed.ncbi.nlm.nih.gov/34614146/
An abort decider is relevant to comp theory.
An abort decider is relevant to comp theory.
An abort decider is relevant to comp theory.
An abort decider is relevant to comp theory.
An abort decider is relevant to comp theory.
On 3/29/2024 8:13 AM, Richard Damon wrote:
On 3/28/24 11:01 PM, olcott wrote:
On 3/28/2024 9:53 PM, Richard Damon wrote:
On 3/28/24 10:39 PM, olcott wrote:
On 3/28/2024 9:27 PM, Richard Damon wrote:
On 3/28/24 10:03 PM, olcott wrote:
On 3/28/2024 7:06 PM, Richard Damon wrote:
On 3/28/24 10:32 AM, olcott wrote:
On 3/28/2024 7:30 AM, Mikko wrote:
On 2024-03-26 14:24:37 +0000, olcott said:
On 3/26/2024 3:27 AM, Mikko wrote:
On 2024-03-25 22:45:37 +0000, olcott said:
On 3/24/2024 11:51 AM, Mikko wrote:Right, except that instead of "would" it is better to say >>>>>>>>>>>> "does".
On 2024-03-23 23:23:32 +0000, olcott said:
On 3/23/2024 5:59 PM, immibis wrote:
On 23/03/24 15:41, olcott wrote:The halting problem is about computing the mapping from >>>>>>>>>>>>>>> the inputs
On 3/23/2024 9:18 AM, Richard Damon wrote:The halting problem is about whether a program halts not >>>>>>>>>>>>>>>> whether a "correct simulation" of that program halts. >>>>>>>>>>>>>>>
Right, and since D,D specifies the program D(D) and >>>>>>>>>>>>>>>>>> that Halts,
Since you know that D(D) correctly simulated by H cannot >>>>>>>>>>>>>>>>> possibly halt, why lie about this and use the strawman >>>>>>>>>>>>>>>>> deception to refer to an instance of D(D) that does not >>>>>>>>>>>>>>>>> even exist in the above computation?
to an accept or reject state on the basis of the behavior >>>>>>>>>>>>>>> that the
input specifies.
*The input to H(D,D) specifies non-halting behavior to H* >>>>>>>>>>>>>>> The above are self-evidently true facts and cannot be denied >>>>>>>>>>>>>>> without error.
The input D,D specifies exaclty one behaviour that does >>>>>>>>>>>>>> not depend
on whom that behaviour is told. Any misinterpretation by H >>>>>>>>>>>>>> does not
change the specified behaviour.
If that was true then H(D,D) would never need to abort >>>>>>>>>>>>> its simulation or H1(D,D) would need to abort its simulation. >>>>>>>>>>>>
H1(D,D) does not need to abort only because H(D,D) does need >>>>>>>>>>> to abort.
Much bettter.
Richard tries to get away with this:
*Every H(D,D) that needs to abort its input never needed to abort* >>>>>>>>> *its input because some other H somewhere else that did not abort* >>>>>>>>> *its input already aborted its input that it never aborted*
Nope, you keep on lying by changing the words and thus the meaning. >>>>>>>>
The H that DOES abort, turns out to not NEED to abort (but still >>>>>>>> does), because the version of it called by D WILL abort, and
return 0 and thus D(D) Halts, so this H could have reached a
conclusion if somehow this version of it could not abort (but
leave all the other version as they were).
Because every H in the entire recursive chain has the exact same >>>>>>> machine
code unless the outermost directly executed one aborts its
simulation
then none of them do.
So?
If the outer one is coded to abort, then they ALL abort
Counter-factual and you know it.
They would abort if their code is reachable which it is not.
Why isn't it reachable to a correct simulation or direct execution?
That is your evil strawman deception away from this abort
decider.
Which is just YOUR strawman to avoid the question you claim to be
working on.
01 void D(ptr x) // ptr is pointer to void function
02 {
03 H(x, x);
04 return;
05 }
06
07 void main()
08 {
09 H(D,D);
10 }
Validation of POD24 as a robust early clinical end point of
poor survival in FL from 5225 patients on 13 clinical trials
https://pubmed.ncbi.nlm.nih.gov/34614146/
So? Maybe you should just die already then.
A clear violation of this law: https://www.biblegateway.com/verse/en/Galatians%205:14
That could very well have these consequences https://www.biblegateway.com/verse/en/Galatians%206:7
On 3/29/2024 6:24 AM, Mikko wrote:
On 2024-03-28 15:39:49 +0000, olcott said:
On 3/28/2024 9:57 AM, Mikko wrote:
On 2024-03-28 14:23:57 +0000, olcott said:
On 3/28/2024 7:54 AM, Mikko wrote:
On 2024-03-26 14:37:38 +0000, olcott said:
<snip>
I have not seen anything that even pretends to be a definition of
an abort decider.
*Been providing this definition (with one word changed) for over >>>>>>> a year*
(a) If simulating abort decider H correctly simulates its input D >>>>>>> until H correctly determines that its simulated D would never
stop running unless aborted then...
That does not pretend to definition of anything. It uses the term
"simulationg abort decider" as if that (or at least "abort decider") >>>>>> were defined before that.
A simulating abort decider simulates its input until this input
matches one of three non-halting behavior patterns:
(a) Infinite loop (b) Infinite recursion (c) recursive simulation.
or the input halts.
Is that a definition or a dexcription?
*That is the architectural overview, the definitions are here*
https://github.com/plolcott/x86utm/blob/master/Halt7.c
On that page the word "abort" is used (in dfferent forms) 5 times
but the term "abort decider" is not defined.
You should quote the definition here or post a more accureate pointer.
01 void D(ptr x) // ptr is pointer to void function
02 {
03 H(x, x);
04 return;
05 }
06
07 void main()
08 {
09 H(D,D);
10 }
H can be construed as an abort decider for the above D.
This gets the exact same result as the original D.
D has been simplified to eliminate distracting details.
On 3/29/2024 12:02 PM, Richard Damon wrote:
On 3/29/24 10:44 AM, olcott wrote:
On 3/29/2024 6:24 AM, Mikko wrote:
On 2024-03-28 15:39:49 +0000, olcott said:
On 3/28/2024 9:57 AM, Mikko wrote:
On 2024-03-28 14:23:57 +0000, olcott said:
On 3/28/2024 7:54 AM, Mikko wrote:
On 2024-03-26 14:37:38 +0000, olcott said:
<snip>
I have not seen anything that even pretends to be a definition of >>>>>>>> an abort decider.
*Been providing this definition (with one word changed) for
over a year*
(a) If simulating abort decider H correctly simulates its input >>>>>>>>> D until H correctly determines that its simulated D would never >>>>>>>>> stop running unless aborted then...
That does not pretend to definition of anything. It uses the term >>>>>>>> "simulationg abort decider" as if that (or at least "abort
decider")
were defined before that.
A simulating abort decider simulates its input until this input
matches one of three non-halting behavior patterns:
(a) Infinite loop (b) Infinite recursion (c) recursive simulation. >>>>>>> or the input halts.
Is that a definition or a dexcription?
*That is the architectural overview, the definitions are here*
https://github.com/plolcott/x86utm/blob/master/Halt7.c
On that page the word "abort" is used (in dfferent forms) 5 times
but the term "abort decider" is not defined.
You should quote the definition here or post a more accureate pointer. >>>>
01 void D(ptr x) // ptr is pointer to void function
02 {
03 H(x, x);
04 return;
05 }
06
07 void main()
08 {
09 H(D,D);
10 }
H can be construed as an abort decider for the above D.
This gets the exact same result as the original D.
D has been simplified to eliminate distracting details.
Except that your "abort decider" definition isn't a "decider" that has
requires a non-trivial answer.
And H that always immediately aborts and says it did is trivially
correct.
D, is also, not a valid input, as it isn't a "Computation", as its
behavior is dependent on which version of H you give it. (For
instance, an H that never aborts cause D to be non-halting, and thus
needed to be aborted, but an H that always answers, makes D halting,
and thus H doesn't need to abort it.
When you try to explain the details of this you contradict yourself.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 498 |
| Nodes: | 16 (1 / 15) |
| Uptime: | 62:46:42 |
| Calls: | 9,813 |
| Calls today: | 1 |
| Files: | 13,754 |
| Messages: | 6,191,217 |