void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
THAT FACT THAT NOT ONE PERSON HAS MET THIS CHALLENGE
IN SEVERAL YEARS IS VERY STRONG EVIDENCE THAT I AM CORRECT.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
DDD is a simplified version of DD.
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while, yes,
if HHH does infact do a correct simulation, it will not reach a final
state, that fact only applie *IF* HHH does that, and all the other
HHHs which differ see different inputs.
*I should have said*
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
THAT FACT THAT NOT ONE PERSON HAS MET THIS CHALLENGE
IN SEVERAL YEARS IS VERY STRONG EVIDENCE THAT I AM CORRECT.
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while, yes,
if HHH does infact do a correct simulation, it will not reach a final
state, that fact only applie *IF* HHH does that, and all the other
HHHs which differ see different inputs.
*I should have said*
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
On 6/16/2025 6:28 AM, Richard Damon wrote:
On 6/15/25 8:57 PM, olcott wrote:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while,
yes, if HHH does infact do a correct simulation, it will not reach a
final state, that fact only applie *IF* HHH does that, and all the
other HHHs which differ see different inputs.
*I should have said*
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
So?
Since that isn't the criteria that the decider is supposed to answer
by, it is just a strawman.
*You merely dishonestly changed the subject*
Whenever I challenge anyone to provide the details to show
exactly how the below (a) & (b) is not true they ignore this
challenge and change the subject.
(a) One of more instructions of DDD are correctly
simulated by some simulating termination analyzer HHH.
(b) None of the above simulated DDD instances ever
reach its own simulated "return" statement final halt state.
Whenever I challenge anyone to provide the details to show
exactly how the above (a) & (b) is not true they ignore this
challenge and change the subject.
On 6/16/2025 3:53 AM, Fred. Zwarts wrote:
Op 15.jun.2025 om 22:10 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
It seems very difficult for you to read.
We clearly stated that the challenge is improper.
HHH is incorrect
Baseless dogmatic statements that are utterly bereft of any
supporting reasoning at all DO NOT COUNT AS REBUTTALS.
and there is no way to make a correct HHH for all inputs.
THAT FACT THAT NOT ONE PERSON HAS MET THIS CHALLENGE
IN SEVERAL YEARS IS VERY STRONG EVIDENCE THAT I AM CORRECT.
It has been proven that no correct HHH exists,
Counter-factual, Not one person ever proved this.
so it makes no sense to challenge anybody to make a correct HHH. The
challenge itself shows a lack of understanding of the matter.
In other words you don't have any rebuttal all you
have is dogmatic statements utterly bereft of any
supporting reasoning.
On 6/16/2025 3:53 AM, Fred. Zwarts wrote:
Op 15.jun.2025 om 22:10 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
It seems very difficult for you to read.
We clearly stated that the challenge is improper.
Are you too stupid to understand that dogmatic
assertions that are utterly bereft of any supporting
reasoning DO NOT COUNT AS REBUTTALS ???
Claiming that I made a mistake with no ability to
show this mistake is DISHONEST.
On 6/16/2025 6:28 AM, Richard Damon wrote:
On 6/15/25 8:57 PM, olcott wrote:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while,
yes, if HHH does infact do a correct simulation, it will not reach a
final state, that fact only applie *IF* HHH does that, and all the
other HHHs which differ see different inputs.
*I should have said*
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
So?
Since that isn't the criteria that the decider is supposed to answer
by, it is just a strawman.
Since every decieer that gives an answer has stopped before reaching
the end of the program, for which a complete simulation of it will, it
just shows that it is wrong.
Of course, you first have to fix the system so the input *IS* a
program, which means that it includes the code of the decider it is
built on, which means that decider need to also be a defined program.
Thus, your LIES are exposed as just uses of strawmen to try to put
forward incorrect conditions.
Sorry, all you have been doing is show that your world is built on
lies, and your brain seems to be based on straw.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
Thus no DDD of any HHH/DDD pair halts when "halts"
is defined as reaching a final halt state.
Since this *is* a verified fact any disagreement is
inherently incorrect.
This same reasoning equally applies to the input to HHH(DD)
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
On 6/16/2025 9:13 PM, Richard Damon wrote:
On 6/16/25 2:32 PM, olcott wrote:
On 6/16/2025 6:28 AM, Richard Damon wrote:
On 6/15/25 8:57 PM, olcott wrote:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while,
yes, if HHH does infact do a correct simulation, it will not reach >>>>>> a final state, that fact only applie *IF* HHH does that, and all
the other HHHs which differ see different inputs.
*I should have said*
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
So?
Since that isn't the criteria that the decider is supposed to answer
by, it is just a strawman.
*You merely dishonestly changed the subject*
No I didn't, the subject is about "Halting"
Halting is defined for PROGRAMS
Whenever I challenge anyone to provide the details to show
exactly how the below (a) & (b) is not true they ignore this
challenge and change the subject.
(a) One of more instructions of DDD are correctly
simulated by some simulating termination analyzer HHH.
(b) None of the above simulated DDD instances ever
reach its own simulated "return" statement final halt state.
Since that isn't the definition of Halting/Non-Halting, it is just a
strawman.
Non-Halting isn't just that a partial simulation doesn't reach a final
state, and that is what your (a) describes, as to be NOT partial, it
must simulate *ALL* the instructions.
The fuller definition of non-halting is that a machine is non-halting
if it will not reach a final state performing an UNBOUNDED number of
steps.
In other words you do not understand what every CS graduate
would understand: That once a non-halting behavior pattern
is correctly matched in a finite number of steps that this
conclusively proves non-halting.
On 6/16/2025 9:13 PM, Richard Damon wrote:
On 6/16/25 2:32 PM, olcott wrote:
On 6/16/2025 6:28 AM, Richard Damon wrote:
On 6/15/25 8:57 PM, olcott wrote:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while,
yes, if HHH does infact do a correct simulation, it will not reach >>>>>> a final state, that fact only applie *IF* HHH does that, and all
the other HHHs which differ see different inputs.
*I should have said*
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
So?
Since that isn't the criteria that the decider is supposed to answer
by, it is just a strawman.
*You merely dishonestly changed the subject*
No I didn't, the subject is about "Halting"
Halting is defined for PROGRAMS
Whenever I challenge anyone to provide the details to show
exactly how the below (a) & (b) is not true they ignore this
challenge and change the subject.
(a) One of more instructions of DDD are correctly
simulated by some simulating termination analyzer HHH.
(b) None of the above simulated DDD instances ever
reach its own simulated "return" statement final halt state.
Since that isn't the definition of Halting/Non-Halting, it is just a
strawman.
*In other words you understand that my words are irrefutable*
On 6/16/2025 9:13 PM, Richard Damon wrote:
On 6/16/25 2:32 PM, olcott wrote:
On 6/16/2025 6:28 AM, Richard Damon wrote:
On 6/15/25 8:57 PM, olcott wrote:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while,
yes, if HHH does infact do a correct simulation, it will not reach >>>>>> a final state, that fact only applie *IF* HHH does that, and all
the other HHHs which differ see different inputs.
*I should have said*
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
So?
Since that isn't the criteria that the decider is supposed to answer
by, it is just a strawman.
*You merely dishonestly changed the subject*
No I didn't, the subject is about "Halting"
Halting is defined for PROGRAMS
Whenever I challenge anyone to provide the details to show
exactly how the below (a) & (b) is not true they ignore this
challenge and change the subject.
(a) One of more instructions of DDD are correctly
simulated by some simulating termination analyzer HHH.
(b) None of the above simulated DDD instances ever
reach its own simulated "return" statement final halt state.
Since that isn't the definition of Halting/Non-Halting, it is just a
strawman.
*In other words you understand that my words are irrefutable*
On 6/16/2025 9:13 PM, Richard Damon wrote:
On 6/16/25 2:32 PM, olcott wrote:
On 6/16/2025 6:28 AM, Richard Damon wrote:
On 6/15/25 8:57 PM, olcott wrote:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that while,
yes, if HHH does infact do a correct simulation, it will not reach >>>>>> a final state, that fact only applie *IF* HHH does that, and all
the other HHHs which differ see different inputs.
*I should have said*
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
So?
Since that isn't the criteria that the decider is supposed to answer
by, it is just a strawman.
*You merely dishonestly changed the subject*
No I didn't, the subject is about "Halting"
Halting is defined for PROGRAMS
Whenever I challenge anyone to provide the details to show
exactly how the below (a) & (b) is not true they ignore this
challenge and change the subject.
(a) One of more instructions of DDD are correctly
simulated by some simulating termination analyzer HHH.
(b) None of the above simulated DDD instances ever
reach its own simulated "return" statement final halt state.
Since that isn't the definition of Halting/Non-Halting, it is just a
strawman.
Non-Halting isn't just that a partial simulation doesn't reach a final
state, and that is what your (a) describes, as to be NOT partial, it
must simulate *ALL* the instructions.
The fuller definition of non-halting is that a machine is non-halting
if it will not reach a final state performing an UNBOUNDED number of
steps.
In other words you do not understand what every CS graduate
would understand: That once a non-halting behavior pattern
is correctly matched in a finite number of steps that this
conclusively proves non-halting.
On 6/17/2025 4:31 AM, Fred. Zwarts wrote:
Op 16.jun.2025 om 18:58 schreef olcott:
On 6/16/2025 3:53 AM, Fred. Zwarts wrote:
Op 15.jun.2025 om 22:10 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
It seems very difficult for you to read.
We clearly stated that the challenge is improper.
HHH is incorrect
Baseless dogmatic statements that are utterly bereft of any
supporting reasoning at all DO NOT COUNT AS REBUTTALS.
Dreams that are utterly bereft of any supporting reasoning at all DO
NOT COUNT AS REBUTTALS.
and there is no way to make a correct HHH for all inputs.
THAT FACT THAT NOT ONE PERSON HAS MET THIS CHALLENGE
IN SEVERAL YEARS IS VERY STRONG EVIDENCE THAT I AM CORRECT.
It has been proven that no correct HHH exists,
Counter-factual, Not one person ever proved this.
Wrong. It has been proven, but you close your eyes and pretend that
the proofs do not exit. Very childish.
I ignore most of your messages.
It is categorically impossible to show how DDD correctly
simulated by simulating termination analyzer HHH can
possibly reach its own simulated "return" statement final
halt state.
On 6/17/2025 4:28 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 00:26 schreef olcott:
On 6/16/2025 3:53 AM, Fred. Zwarts wrote:
Op 15.jun.2025 om 22:10 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
It seems very difficult for you to read.
We clearly stated that the challenge is improper.
Are you too stupid to understand that dogmatic
assertions that are utterly bereft of any supporting
reasoning DO NOT COUNT AS REBUTTALS ???
No, you are too stupid to realise that challenging for a recipe to
draw a square circle does not count as a proof that square circles exist.
Claiming that I made a mistake with no ability to
show this mistake is DISHONEST.
Indeed, but irrelevant,
That alternative is that you are dishonest.
When you claim that I am wrong and have
no ability to show how and where I am wrong
this would seem to make you a liar.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
On 6/17/2025 4:44 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 05:07 schreef olcott:
On 6/16/2025 9:13 PM, Richard Damon wrote:
On 6/16/25 2:32 PM, olcott wrote:
On 6/16/2025 6:28 AM, Richard Damon wrote:
On 6/15/25 8:57 PM, olcott wrote:
On 6/15/2025 6:44 PM, Richard Damon wrote:
On 6/15/25 4:10 PM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
And it seems you don't understand that the problem is that
while, yes, if HHH does infact do a correct simulation, it will >>>>>>>> not reach a final state, that fact only applie *IF* HHH does
that, and all the other HHHs which differ see different inputs. >>>>>>>>
*I should have said*
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then DDD never reaches its simulated "return" statement
final halt state.
So?
Since that isn't the criteria that the decider is supposed to
answer by, it is just a strawman.
*You merely dishonestly changed the subject*
No I didn't, the subject is about "Halting"
Halting is defined for PROGRAMS
Whenever I challenge anyone to provide the details to show
exactly how the below (a) & (b) is not true they ignore this
challenge and change the subject.
(a) One of more instructions of DDD are correctly
simulated by some simulating termination analyzer HHH.
(b) None of the above simulated DDD instances ever
reach its own simulated "return" statement final halt state.
Since that isn't the definition of Halting/Non-Halting, it is just a
strawman.
Non-Halting isn't just that a partial simulation doesn't reach a
final state, and that is what your (a) describes, as to be NOT
partial, it must simulate *ALL* the instructions.
The fuller definition of non-halting is that a machine is non-
halting if it will not reach a final state performing an UNBOUNDED
number of steps.
In other words you do not understand what every CS graduate
would understand: That once a non-halting behavior pattern
is correctly matched in a finite number of steps that this
conclusively proves non-halting.
Irrelevant, because such a CS graduate will also understand that a
finite recursion is not a pattern for non-halting behaviour.
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void DDD()
{
HHH(DDD);
return;
}
When correctly simulated by HHH none of the above can
possibly reach their own simulated "return" instruction
final halt state in any finite number of steps.
On 6/18/2025 4:36 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 16:36 schreef olcott:
On 6/17/2025 4:28 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 00:26 schreef olcott:
On 6/16/2025 3:53 AM, Fred. Zwarts wrote:
Op 15.jun.2025 om 22:10 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
It seems very difficult for you to read.
We clearly stated that the challenge is improper.
Are you too stupid to understand that dogmatic
assertions that are utterly bereft of any supporting
reasoning DO NOT COUNT AS REBUTTALS ???
No, you are too stupid to realise that challenging for a recipe to
draw a square circle does not count as a proof that square circles
exist.
Claiming that I made a mistake with no ability to
show this mistake is DISHONEST.
Indeed, but irrelevant,
That alternative is that you are dishonest.
When you claim that I am wrong and have
no ability to show how and where I am wrong
this would seem to make you a liar.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
Indeed, HHH fails to reach the end of the simulation, even though the
end is only one cycle further from the point where it gave up the
simulation.
That is counter-factual and over-your-head.
On 6/19/2025 3:55 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 17:41 schreef olcott:
On 6/18/2025 4:36 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 16:36 schreef olcott:
On 6/17/2025 4:28 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 00:26 schreef olcott:
On 6/16/2025 3:53 AM, Fred. Zwarts wrote:
Op 15.jun.2025 om 22:10 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination
analyzer HHH can possibly reach its own simulated "return"
statement final halt state they ignore this challenge.
It seems very difficult for you to read.
We clearly stated that the challenge is improper.
Are you too stupid to understand that dogmatic
assertions that are utterly bereft of any supporting
reasoning DO NOT COUNT AS REBUTTALS ???
No, you are too stupid to realise that challenging for a recipe to >>>>>> draw a square circle does not count as a proof that square circles >>>>>> exist.
Claiming that I made a mistake with no ability to
show this mistake is DISHONEST.
Indeed, but irrelevant,
That alternative is that you are dishonest.
When you claim that I am wrong and have
no ability to show how and where I am wrong
this would seem to make you a liar.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
Indeed, HHH fails to reach the end of the simulation, even though
the end is only one cycle further from the point where it gave up
the simulation.
That is counter-factual and over-your-head.
No evidence presented for this claim. Dreaming again?
Even a beginner understands that when HHH has code to abort and halt,
the simulated HHH runs one cycle behind the simulating HHH, so that
when the simulating HHH aborts, the simulated HHH is only one cycle
away from the same point.
Proving that you do not understand what unreachable code is.
First year CS students and EE majors may not understand this.
All CS graduates would understand this.
On 6/20/2025 4:42 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:23 schreef olcott:
On 6/19/2025 3:55 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 17:41 schreef olcott:
On 6/18/2025 4:36 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 16:36 schreef olcott:
On 6/17/2025 4:28 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 00:26 schreef olcott:
On 6/16/2025 3:53 AM, Fred. Zwarts wrote:
Op 15.jun.2025 om 22:10 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly
how DDD correctly simulated by ANY simulating termination >>>>>>>>>>> analyzer HHH can possibly reach its own simulated "return" >>>>>>>>>>> statement final halt state they ignore this challenge.
It seems very difficult for you to read.
We clearly stated that the challenge is improper.
Are you too stupid to understand that dogmatic
assertions that are utterly bereft of any supporting
reasoning DO NOT COUNT AS REBUTTALS ???
No, you are too stupid to realise that challenging for a recipe >>>>>>>> to draw a square circle does not count as a proof that square
circles exist.
Claiming that I made a mistake with no ability to
show this mistake is DISHONEST.
Indeed, but irrelevant,
That alternative is that you are dishonest.
When you claim that I am wrong and have
no ability to show how and where I am wrong
this would seem to make you a liar.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
Indeed, HHH fails to reach the end of the simulation, even though
the end is only one cycle further from the point where it gave up
the simulation.
That is counter-factual and over-your-head.
No evidence presented for this claim. Dreaming again?
Even a beginner understands that when HHH has code to abort and
halt, the simulated HHH runs one cycle behind the simulating HHH, so
that when the simulating HHH aborts, the simulated HHH is only one
cycle away from the same point.
Proving that you do not understand what unreachable code is.
First year CS students and EE majors may not understand this.
All CS graduates would understand this.
That you do not understand what I write makes it difficult for you to
learn from your errors.
It is not that difficult. Try again and pay full attention to it.
Even a beginner understands that when HHH has code to abort and halt,
the simulated HHH runs one cycle behind the simulating HHH, so that
when the simulating HHH aborts, the simulated HHH is only one cycle
away from the same point.
Yes this is factual.
*This is only ordinary computer programming with*
*no theory of computation computer science required*
Every simulated HHH remains one cycle behind its simulator
no matter how deep the recursive simulations go. This means
that the outermost directly executed HHH reaches its abort
criteria first.
This means that none of simulated HHH have reached their
abort criteria. This means that their own abort code is
unreachable at the point where the outermost HHH would
abort.
On 6/22/2025 11:01 AM, Fred. Zwarts wrote:
Op 20.jun.2025 om 16:53 schreef olcott:
On 6/20/2025 4:42 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:23 schreef olcott:
On 6/19/2025 3:55 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 17:41 schreef olcott:
On 6/18/2025 4:36 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 16:36 schreef olcott:
On 6/17/2025 4:28 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 00:26 schreef olcott:
On 6/16/2025 3:53 AM, Fred. Zwarts wrote:
Op 15.jun.2025 om 22:10 schreef olcott:
void DDD()It seems very difficult for you to read.
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly >>>>>>>>>>>>> how DDD correctly simulated by ANY simulating termination >>>>>>>>>>>>> analyzer HHH can possibly reach its own simulated "return" >>>>>>>>>>>>> statement final halt state they ignore this challenge. >>>>>>>>>>>>
We clearly stated that the challenge is improper.
Are you too stupid to understand that dogmatic
assertions that are utterly bereft of any supporting
reasoning DO NOT COUNT AS REBUTTALS ???
No, you are too stupid to realise that challenging for a
recipe to draw a square circle does not count as a proof that >>>>>>>>>> square circles exist.
Claiming that I made a mistake with no ability to
show this mistake is DISHONEST.
Indeed, but irrelevant,
That alternative is that you are dishonest.
When you claim that I am wrong and have
no ability to show how and where I am wrong
this would seem to make you a liar.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
Indeed, HHH fails to reach the end of the simulation, even
though the end is only one cycle further from the point where it >>>>>>>> gave up the simulation.
That is counter-factual and over-your-head.
No evidence presented for this claim. Dreaming again?
Even a beginner understands that when HHH has code to abort and
halt, the simulated HHH runs one cycle behind the simulating HHH,
so that when the simulating HHH aborts, the simulated HHH is only
one cycle away from the same point.
Proving that you do not understand what unreachable code is.
First year CS students and EE majors may not understand this.
All CS graduates would understand this.
That you do not understand what I write makes it difficult for you
to learn from your errors.
It is not that difficult. Try again and pay full attention to it.
Even a beginner understands that when HHH has code to abort and halt,
the simulated HHH runs one cycle behind the simulating HHH, so that
when the simulating HHH aborts, the simulated HHH is only one cycle
away from the same point.
Yes this is factual.
*This is only ordinary computer programming with*
*no theory of computation computer science required*
Every simulated HHH remains one cycle behind its simulator
no matter how deep the recursive simulations go. This means
that the outermost directly executed HHH reaches its abort
criteria first.
And it fails to see that the simulated HHH would reach exactly the
same abort criteria one cycle later.
In this way, it misses the fact that it is simulating an HHH that
would abort and halt.
void Infinite_Loop()
{
HERE: goto HERE;
printf("Fred Zwarts can't understand this is never reached\n");
}
On 6/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 22.jun.2025 om 21:27 schreef olcott:
On 6/22/2025 11:01 AM, Fred. Zwarts wrote:Another claim without any evidence.
Op 20.jun.2025 om 16:53 schreef olcott:
On 6/20/2025 4:42 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:23 schreef olcott:
On 6/19/2025 3:55 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 17:41 schreef olcott:
On 6/18/2025 4:36 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 16:36 schreef olcott:
On 6/17/2025 4:28 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 00:26 schreef olcott:
On 6/16/2025 3:53 AM, Fred. Zwarts wrote:
Op 15.jun.2025 om 22:10 schreef olcott:
void DDD()It seems very difficult for you to read.
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly >>>>>>>>>>>>>>> how DDD correctly simulated by ANY simulating termination >>>>>>>>>>>>>>> analyzer HHH can possibly reach its own simulated "return" >>>>>>>>>>>>>>> statement final halt state they ignore this challenge. >>>>>>>>>>>>>>
We clearly stated that the challenge is improper.
Are you too stupid to understand that dogmatic
assertions that are utterly bereft of any supporting >>>>>>>>>>>>> reasoning DO NOT COUNT AS REBUTTALS ???
No, you are too stupid to realise that challenging for a >>>>>>>>>>>> recipe to draw a square circle does not count as a proof >>>>>>>>>>>> that square circles exist.
Claiming that I made a mistake with no ability to
show this mistake is DISHONEST.
Indeed, but irrelevant,
That alternative is that you are dishonest.
When you claim that I am wrong and have
no ability to show how and where I am wrong
this would seem to make you a liar.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH
then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
Indeed, HHH fails to reach the end of the simulation, even >>>>>>>>>> though the end is only one cycle further from the point where >>>>>>>>>> it gave up the simulation.
That is counter-factual and over-your-head.
No evidence presented for this claim. Dreaming again?
Even a beginner understands that when HHH has code to abort and >>>>>>>> halt, the simulated HHH runs one cycle behind the simulating
HHH, so that when the simulating HHH aborts, the simulated HHH >>>>>>>> is only one cycle away from the same point.
Proving that you do not understand what unreachable code is.
First year CS students and EE majors may not understand this.
All CS graduates would understand this.
That you do not understand what I write makes it difficult for you >>>>>> to learn from your errors.
It is not that difficult. Try again and pay full attention to it.
Even a beginner understands that when HHH has code to abort and halt, >>>>>> the simulated HHH runs one cycle behind the simulating HHH, so
that when the simulating HHH aborts, the simulated HHH is only one >>>>>> cycle away from the same point.
Yes this is factual.
*This is only ordinary computer programming with*
*no theory of computation computer science required*
Every simulated HHH remains one cycle behind its simulator
no matter how deep the recursive simulations go. This means
that the outermost directly executed HHH reaches its abort
criteria first.
And it fails to see that the simulated HHH would reach exactly the
same abort criteria one cycle later.
In this way, it misses the fact that it is simulating an HHH that
would abort and halt.
void Infinite_Loop()
{
HERE: goto HERE;
printf("Fred Zwarts can't understand this is never reached\n");
}
Olcott does not understand that his HHH does not see an infinite loop.
It aborts and halt, so the recursion is finite.
You didn't even use the term recursion correctly.
Infinite loops have nothing to do with recursion.
Mike understands that HHH could recognize an infinite
loop correctly.
The process in which a function calls itself directly
or indirectly is called recursion and the corresponding
function is called a recursive function. https://www.geeksforgeeks.org/introduction-to-recursion-2/
Lines 987 to 992 is where infinite loops are recognized
Lines 996 to 1005 is where infinite recursion is recognized https://github.com/plolcott/x86utm/blob/master/Halt7.c
HHH correctly emulates the x86 machine code of its
input until one of those two patterns is matched.
On 6/24/2025 2:54 AM, Fred. Zwarts wrote:False claim without evidence.
Op 23.jun.2025 om 16:50 schreef olcott:
On 6/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 22.jun.2025 om 21:27 schreef olcott:
On 6/22/2025 11:01 AM, Fred. Zwarts wrote:Another claim without any evidence.
Op 20.jun.2025 om 16:53 schreef olcott:
On 6/20/2025 4:42 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:23 schreef olcott:
On 6/19/2025 3:55 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 17:41 schreef olcott:
On 6/18/2025 4:36 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 16:36 schreef olcott:
On 6/17/2025 4:28 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 00:26 schreef olcott:
On 6/16/2025 3:53 AM, Fred. Zwarts wrote:
Op 15.jun.2025 om 22:10 schreef olcott:Are you too stupid to understand that dogmatic
void DDD()It seems very difficult for you to read.
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly >>>>>>>>>>>>>>>>> how DDD correctly simulated by ANY simulating termination >>>>>>>>>>>>>>>>> analyzer HHH can possibly reach its own simulated "return" >>>>>>>>>>>>>>>>> statement final halt state they ignore this challenge. >>>>>>>>>>>>>>>>
We clearly stated that the challenge is improper. >>>>>>>>>>>>>>>
assertions that are utterly bereft of any supporting >>>>>>>>>>>>>>> reasoning DO NOT COUNT AS REBUTTALS ???
No, you are too stupid to realise that challenging for a >>>>>>>>>>>>>> recipe to draw a square circle does not count as a proof >>>>>>>>>>>>>> that square circles exist.
Claiming that I made a mistake with no ability to >>>>>>>>>>>>>>> show this mistake is DISHONEST.
Indeed, but irrelevant,
That alternative is that you are dishonest.
When you claim that I am wrong and have
no ability to show how and where I am wrong
this would seem to make you a liar.
No one has ever even attempted to show the details
of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly
simulated by ANY simulating termination analyzer HHH >>>>>>>>>>>>> then this correctly simulated DDD never reaches its
simulated "return" statement final halt state.
Indeed, HHH fails to reach the end of the simulation, even >>>>>>>>>>>> though the end is only one cycle further from the point >>>>>>>>>>>> where it gave up the simulation.
That is counter-factual and over-your-head.
No evidence presented for this claim. Dreaming again?
Even a beginner understands that when HHH has code to abort >>>>>>>>>> and halt, the simulated HHH runs one cycle behind the
simulating HHH, so that when the simulating HHH aborts, the >>>>>>>>>> simulated HHH is only one cycle away from the same point.
Proving that you do not understand what unreachable code is. >>>>>>>>> First year CS students and EE majors may not understand this. >>>>>>>>> All CS graduates would understand this.
That you do not understand what I write makes it difficult for >>>>>>>> you to learn from your errors.
It is not that difficult. Try again and pay full attention to it. >>>>>>>> Even a beginner understands that when HHH has code to abort and >>>>>>>> halt,
the simulated HHH runs one cycle behind the simulating HHH, so >>>>>>>> that when the simulating HHH aborts, the simulated HHH is only >>>>>>>> one cycle away from the same point.
Yes this is factual.
*This is only ordinary computer programming with*
*no theory of computation computer science required*
Every simulated HHH remains one cycle behind its simulator
no matter how deep the recursive simulations go. This means
that the outermost directly executed HHH reaches its abort
criteria first.
And it fails to see that the simulated HHH would reach exactly the >>>>>> same abort criteria one cycle later.
In this way, it misses the fact that it is simulating an HHH that
would abort and halt.
void Infinite_Loop()
{
HERE: goto HERE;
printf("Fred Zwarts can't understand this is never reached\n"); >>>>> }
Olcott does not understand that his HHH does not see an infinite loop. >>>> It aborts and halt, so the recursion is finite.
You didn't even use the term recursion correctly.
Infinite loops have nothing to do with recursion.
And infinite loops have nothing to do with a simulator simulating
itself. Therefore, talking about infinite loops is changing the subject.
Mike understands that HHH could recognize an infinite
loop correctly.
The process in which a function calls itself directly
or indirectly is called recursion and the corresponding
function is called a recursive function.
https://www.geeksforgeeks.org/introduction-to-recursion-2/
Lines 987 to 992 is where infinite loops are recognized
Lines 996 to 1005 is where infinite recursion is recognized
https://github.com/plolcott/x86utm/blob/master/Halt7.c
HHH correctly emulates the x86 machine code of its
input until one of those two patterns is matched.
But there is a bug in the code that tries to recognise an infinite
recursion.
There is no bug. Quit your defamation.
It forgets to count the conditional branch instructions when
simulating the simulator.
*It does not forget them. They are irrelevant*
On 6/25/2025 2:59 AM, Fred. Zwarts wrote:
Op 24.jun.2025 om 16:06 schreef olcott:
On 6/24/2025 2:54 AM, Fred. Zwarts wrote:
Op 23.jun.2025 om 16:50 schreef olcott:
On 6/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 22.jun.2025 om 21:27 schreef olcott:
On 6/22/2025 11:01 AM, Fred. Zwarts wrote:Another claim without any evidence.
Op 20.jun.2025 om 16:53 schreef olcott:
On 6/20/2025 4:42 AM, Fred. Zwarts wrote:
Op 19.jun.2025 om 17:23 schreef olcott:
On 6/19/2025 3:55 AM, Fred. Zwarts wrote:
Op 18.jun.2025 om 17:41 schreef olcott:Proving that you do not understand what unreachable code is. >>>>>>>>>>> First year CS students and EE majors may not understand this. >>>>>>>>>>> All CS graduates would understand this.
On 6/18/2025 4:36 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 16:36 schreef olcott:
On 6/17/2025 4:28 AM, Fred. Zwarts wrote:
Op 17.jun.2025 om 00:26 schreef olcott:
On 6/16/2025 3:53 AM, Fred. Zwarts wrote:
Op 15.jun.2025 om 22:10 schreef olcott:Are you too stupid to understand that dogmatic >>>>>>>>>>>>>>>>> assertions that are utterly bereft of any supporting >>>>>>>>>>>>>>>>> reasoning DO NOT COUNT AS REBUTTALS ???
void DDD()It seems very difficult for you to read.
{
HHH(DDD);
return;
}
When I challenge anyone to show the details of exactly >>>>>>>>>>>>>>>>>>> how DDD correctly simulated by ANY simulating >>>>>>>>>>>>>>>>>>> termination
analyzer HHH can possibly reach its own simulated >>>>>>>>>>>>>>>>>>> "return"
statement final halt state they ignore this challenge. >>>>>>>>>>>>>>>>>>
We clearly stated that the challenge is improper. >>>>>>>>>>>>>>>>>
No, you are too stupid to realise that challenging for a >>>>>>>>>>>>>>>> recipe to draw a square circle does not count as a proof >>>>>>>>>>>>>>>> that square circles exist.
Claiming that I made a mistake with no ability to >>>>>>>>>>>>>>>>> show this mistake is DISHONEST.
Indeed, but irrelevant,
That alternative is that you are dishonest.
When you claim that I am wrong and have
no ability to show how and where I am wrong
this would seem to make you a liar.
No one has ever even attempted to show the details >>>>>>>>>>>>>>> of how this is not correct:
void DDD()
{
HHH(DDD);
return;
}
When one or more instructions of DDD are correctly >>>>>>>>>>>>>>> simulated by ANY simulating termination analyzer HHH >>>>>>>>>>>>>>> then this correctly simulated DDD never reaches its >>>>>>>>>>>>>>> simulated "return" statement final halt state.
Indeed, HHH fails to reach the end of the simulation, even >>>>>>>>>>>>>> though the end is only one cycle further from the point >>>>>>>>>>>>>> where it gave up the simulation.
That is counter-factual and over-your-head.
No evidence presented for this claim. Dreaming again?
Even a beginner understands that when HHH has code to abort >>>>>>>>>>>> and halt, the simulated HHH runs one cycle behind the
simulating HHH, so that when the simulating HHH aborts, the >>>>>>>>>>>> simulated HHH is only one cycle away from the same point. >>>>>>>>>>>
That you do not understand what I write makes it difficult for >>>>>>>>>> you to learn from your errors.
It is not that difficult. Try again and pay full attention to it. >>>>>>>>>> Even a beginner understands that when HHH has code to abort >>>>>>>>>> and halt,
the simulated HHH runs one cycle behind the simulating HHH, so >>>>>>>>>> that when the simulating HHH aborts, the simulated HHH is only >>>>>>>>>> one cycle away from the same point.
Yes this is factual.
*This is only ordinary computer programming with*
*no theory of computation computer science required*
Every simulated HHH remains one cycle behind its simulator
no matter how deep the recursive simulations go. This means
that the outermost directly executed HHH reaches its abort
criteria first.
And it fails to see that the simulated HHH would reach exactly >>>>>>>> the same abort criteria one cycle later.
In this way, it misses the fact that it is simulating an HHH
that would abort and halt.
void Infinite_Loop()
{
HERE: goto HERE;
printf("Fred Zwarts can't understand this is never reached\n"); >>>>>>> }
Olcott does not understand that his HHH does not see an infinite
loop.
It aborts and halt, so the recursion is finite.
You didn't even use the term recursion correctly.
Infinite loops have nothing to do with recursion.
And infinite loops have nothing to do with a simulator simulating
itself. Therefore, talking about infinite loops is changing the
subject.
Mike understands that HHH could recognize an infinite
loop correctly.
The process in which a function calls itself directly
or indirectly is called recursion and the corresponding
function is called a recursive function.
https://www.geeksforgeeks.org/introduction-to-recursion-2/
Lines 987 to 992 is where infinite loops are recognized
Lines 996 to 1005 is where infinite recursion is recognized
https://github.com/plolcott/x86utm/blob/master/Halt7.c
HHH correctly emulates the x86 machine code of its
input until one of those two patterns is matched.
But there is a bug in the code that tries to recognise an infinite
recursion.
There is no bug. Quit your defamation.
It forgets to count the conditional branch instructions when
simulating the simulator.
*It does not forget them. They are irrelevant*
False claim without evidence.
That is the bug. They determine the behaviour of the program specified
by the input. Therefore, they are relevant.
None of the code in HHH can possibly cause DDD correctly
simulated by HHH to reach its own simulated "return" statement.
Since this is what is being measured then conditional branchNo, because not counting the conditional branch instructions makes HHH
instructions within HHH are irrelevant.
On 6/26/2025 4:16 AM, Fred. Zwarts wrote:As usual irrelevant claims without evidence. No rebuttal.
Op 25.jun.2025 om 16:09 schreef olcott:
On 6/25/2025 2:59 AM, Fred. Zwarts wrote:
Op 24.jun.2025 om 16:06 schreef olcott:
None of the code in HHH can possibly cause DDD correctly
simulated by HHH to reach its own simulated "return" statement.
Yes, exactly, that is the bug.
Recursive emulation is only a tiny bit more complicated
than recursion yet no one here seems to have a clue.
Do you know what recursion is?
(If you don't that would explain a lot)
On 6/28/2025 3:50 AM, Fred. Zwarts wrote:
Op 28.jun.2025 om 01:30 schreef olcott:
On 6/26/2025 4:16 AM, Fred. Zwarts wrote:As usual irrelevant claims without evidence. No rebuttal.
Op 25.jun.2025 om 16:09 schreef olcott:
On 6/25/2025 2:59 AM, Fred. Zwarts wrote:
Op 24.jun.2025 om 16:06 schreef olcott:
None of the code in HHH can possibly cause DDD correctly
simulated by HHH to reach its own simulated "return" statement.
Yes, exactly, that is the bug.
Recursive emulation is only a tiny bit more complicated
than recursion yet no one here seems to have a clue.
Do you know what recursion is?
(If you don't that would explain a lot)
Ah so you don't know what recursion is.
HHH has a bug that makes that it does not recognise the halting
behaviour of the program specified in the input.
If you don't even know what recursion is then
you are totally unqualified to review these things.
The failure of HHH is an incorrect measure for the halting behaviourEven a beginner can see that the input is a pointer to code, including
the code to abort and halt. But HHH is programmed to ignore the
conditional branch instructions, when simulating itself, so it thinks
that there is an infinite loop when there are only a finite number of
recursions.
But Olcott does not understand that not all recursions are infinite.
When the measure is whether or not DDD correctly
simulated by HHH can possibly reach its own "return"
instruction final halt state nothing inside HHH can
possibly have any effect on this.
That you don't know this proves that you are unqualified
to review my work.
On 6/29/2025 5:38 AM, Fred. Zwarts wrote:There is no need to report about another Turing Machine. It only needs
Op 28.jun.2025 om 15:02 schreef olcott:
On 6/28/2025 3:50 AM, Fred. Zwarts wrote:
Op 28.jun.2025 om 01:30 schreef olcott:
On 6/26/2025 4:16 AM, Fred. Zwarts wrote:As usual irrelevant claims without evidence. No rebuttal.
Op 25.jun.2025 om 16:09 schreef olcott:
On 6/25/2025 2:59 AM, Fred. Zwarts wrote:
Op 24.jun.2025 om 16:06 schreef olcott:
None of the code in HHH can possibly cause DDD correctly
simulated by HHH to reach its own simulated "return" statement.
Yes, exactly, that is the bug.
Recursive emulation is only a tiny bit more complicated
than recursion yet no one here seems to have a clue.
Do you know what recursion is?
(If you don't that would explain a lot)
Ah so you don't know what recursion is.
As usual a false claim without evidence.
HHH has a bug that makes that it does not recognise the halting
behaviour of the program specified in the input.
If you don't even know what recursion is then
you are totally unqualified to review these things.
And since the condition in the 'if' fails, the conclusion is not true.
The failure of HHH is an incorrect measure for the halting behaviour
Even a beginner can see that the input is a pointer to code,
including the code to abort and halt. But HHH is programmed to
ignore the conditional branch instructions, when simulating itself,
so it thinks that there is an infinite loop when there are only a
finite number of recursions.
But Olcott does not understand that not all recursions are infinite.
When the measure is whether or not DDD correctly
simulated by HHH can possibly reach its own "return"
instruction final halt state nothing inside HHH can
possibly have any effect on this.
That you don't know this proves that you are unqualified
to review my work.
specified in the input.
That you do not understand this explains your invalid claims.
The halting behaviour of the input can be analysed by several other
methods and they show that HHH is incorrect in its analysis.
No Turing machine can ever report on the behavior of
any directly executing Turing Machine because no TM
can ever take another directly executing Turing Machine
as its input.
On 6/30/2025 2:40 AM, Fred. Zwarts wrote:
Op 29.jun.2025 om 15:46 schreef olcott:
On 6/29/2025 5:38 AM, Fred. Zwarts wrote:There is no need to report about another Turing Machine. It only needs
Op 28.jun.2025 om 15:02 schreef olcott:
On 6/28/2025 3:50 AM, Fred. Zwarts wrote:
Op 28.jun.2025 om 01:30 schreef olcott:
On 6/26/2025 4:16 AM, Fred. Zwarts wrote:As usual irrelevant claims without evidence. No rebuttal.
Op 25.jun.2025 om 16:09 schreef olcott:
On 6/25/2025 2:59 AM, Fred. Zwarts wrote:Yes, exactly, that is the bug.
Op 24.jun.2025 om 16:06 schreef olcott:
None of the code in HHH can possibly cause DDD correctly
simulated by HHH to reach its own simulated "return" statement. >>>>>>>>
Recursive emulation is only a tiny bit more complicated
than recursion yet no one here seems to have a clue.
Do you know what recursion is?
(If you don't that would explain a lot)
Ah so you don't know what recursion is.
As usual a false claim without evidence.
HHH has a bug that makes that it does not recognise the halting
behaviour of the program specified in the input.
If you don't even know what recursion is then
you are totally unqualified to review these things.
And since the condition in the 'if' fails, the conclusion is not true. >>>>
The failure of HHH is an incorrect measure for the halting behaviour
Even a beginner can see that the input is a pointer to code,When the measure is whether or not DDD correctly
including the code to abort and halt. But HHH is programmed to
ignore the conditional branch instructions, when simulating
itself, so it thinks that there is an infinite loop when there are >>>>>> only a finite number of recursions.
But Olcott does not understand that not all recursions are infinite. >>>>>
simulated by HHH can possibly reach its own "return"
instruction final halt state nothing inside HHH can
possibly have any effect on this.
That you don't know this proves that you are unqualified
to review my work.
specified in the input.
That you do not understand this explains your invalid claims.
The halting behaviour of the input can be analysed by several other
methods and they show that HHH is incorrect in its analysis.
No Turing machine can ever report on the behavior of
any directly executing Turing Machine because no TM
can ever take another directly executing Turing Machine
as its input.
to report about its input.
Then the fact that DDD() halts does not contradict the
fact that the input to HHH(DDD) specifies non-halting
behavior because the directly executed DDD() is outside
of the domain of HHH.
On 6/30/2025 2:40 AM, Fred. Zwarts wrote:
Op 29.jun.2025 om 15:46 schreef olcott:
On 6/29/2025 5:38 AM, Fred. Zwarts wrote:There is no need to report about another Turing Machine.
Op 28.jun.2025 om 15:02 schreef olcott:
On 6/28/2025 3:50 AM, Fred. Zwarts wrote:
Op 28.jun.2025 om 01:30 schreef olcott:
On 6/26/2025 4:16 AM, Fred. Zwarts wrote:As usual irrelevant claims without evidence. No rebuttal.
Op 25.jun.2025 om 16:09 schreef olcott:
On 6/25/2025 2:59 AM, Fred. Zwarts wrote:Yes, exactly, that is the bug.
Op 24.jun.2025 om 16:06 schreef olcott:
None of the code in HHH can possibly cause DDD correctly
simulated by HHH to reach its own simulated "return" statement. >>>>>>>>
Recursive emulation is only a tiny bit more complicated
than recursion yet no one here seems to have a clue.
Do you know what recursion is?
(If you don't that would explain a lot)
Ah so you don't know what recursion is.
As usual a false claim without evidence.
HHH has a bug that makes that it does not recognise the halting
behaviour of the program specified in the input.
If you don't even know what recursion is then
you are totally unqualified to review these things.
And since the condition in the 'if' fails, the conclusion is not true. >>>>
The failure of HHH is an incorrect measure for the halting behaviour
Even a beginner can see that the input is a pointer to code,When the measure is whether or not DDD correctly
including the code to abort and halt. But HHH is programmed to
ignore the conditional branch instructions, when simulating
itself, so it thinks that there is an infinite loop when there are >>>>>> only a finite number of recursions.
But Olcott does not understand that not all recursions are infinite. >>>>>
simulated by HHH can possibly reach its own "return"
instruction final halt state nothing inside HHH can
possibly have any effect on this.
That you don't know this proves that you are unqualified
to review my work.
specified in the input.
That you do not understand this explains your invalid claims.
The halting behaviour of the input can be analysed by several other
methods and they show that HHH is incorrect in its analysis.
No Turing machine can ever report on the behavior of
any directly executing Turing Machine because no TM
can ever take another directly executing Turing Machine
as its input.
The conventional halting problem proof incorrectly requires this.
void DDD()
{
HHH(DDD);
return;
}
int main()
{
HHH(DDD);
DDD();
}
When the input to HHH(DDD) is correctly simulated
by HHH then HHH correctly rejects this input as
specifying non-halting behavior.
The directly executed DDD() halts yet is not and cannot
be an input to HHH, thus it outside of the domain of HHH.
It only needs to report about its input. In this case the input
includes the abort code and in this way specifies a halting program.
You keep getting confused about the program under test here.
If HHH was the program under test the the internals of HHH
would be relevant.
Since DDD is the program under test and HHH remains a pure
simulator of DDD until HHH correctly determines that DDD
correctly simulated by HHH cannot possibly reach its own
simulated "return" statement final halt state, the internals
of HHH cease to be relevant.
On 7/1/2025 4:17 AM, Fred. Zwarts wrote:
Op 30.jun.2025 om 19:08 schreef olcott:
On 6/30/2025 2:40 AM, Fred. Zwarts wrote:
Op 29.jun.2025 om 15:46 schreef olcott:
On 6/29/2025 5:38 AM, Fred. Zwarts wrote:There is no need to report about another Turing Machine.
Op 28.jun.2025 om 15:02 schreef olcott:
On 6/28/2025 3:50 AM, Fred. Zwarts wrote:
Op 28.jun.2025 om 01:30 schreef olcott:
On 6/26/2025 4:16 AM, Fred. Zwarts wrote:As usual irrelevant claims without evidence. No rebuttal.
Op 25.jun.2025 om 16:09 schreef olcott:
On 6/25/2025 2:59 AM, Fred. Zwarts wrote:Yes, exactly, that is the bug.
Op 24.jun.2025 om 16:06 schreef olcott:
None of the code in HHH can possibly cause DDD correctly >>>>>>>>>>> simulated by HHH to reach its own simulated "return" statement. >>>>>>>>>>
Recursive emulation is only a tiny bit more complicated
than recursion yet no one here seems to have a clue.
Do you know what recursion is?
(If you don't that would explain a lot)
Ah so you don't know what recursion is.
As usual a false claim without evidence.
HHH has a bug that makes that it does not recognise the halting >>>>>>>> behaviour of the program specified in the input.
If you don't even know what recursion is then
you are totally unqualified to review these things.
And since the condition in the 'if' fails, the conclusion is not
true.
The failure of HHH is an incorrect measure for the halting
Even a beginner can see that the input is a pointer to code,
including the code to abort and halt. But HHH is programmed to >>>>>>>> ignore the conditional branch instructions, when simulating
itself, so it thinks that there is an infinite loop when there >>>>>>>> are only a finite number of recursions.
But Olcott does not understand that not all recursions are
infinite.
When the measure is whether or not DDD correctly
simulated by HHH can possibly reach its own "return"
instruction final halt state nothing inside HHH can
possibly have any effect on this.
That you don't know this proves that you are unqualified
to review my work.
behaviour specified in the input.
That you do not understand this explains your invalid claims.
The halting behaviour of the input can be analysed by several
other methods and they show that HHH is incorrect in its analysis. >>>>>>
No Turing machine can ever report on the behavior of
any directly executing Turing Machine because no TM
can ever take another directly executing Turing Machine
as its input.
The conventional halting problem proof incorrectly requires this.
As usual repeated claims without evidence.
void DDD()
{
HHH(DDD);
return;
}
int main()
{
HHH(DDD);
DDD();
}
When the input to HHH(DDD) is correctly simulated
by HHH then HHH correctly rejects this input as
specifying non-halting behavior.
No, it *incorrectly* does that. The input is DDD calling an aborting
HHH, so the input specifies a halting program.
DDD correctly simulated by HHH cannot possibly
reach its own "return" instruction final halt state
that DOES NOT HALT TO MATTER WHAT THE F YOU CALL IT.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 716 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 58:59:01 |
| Calls: | 12,117 |
| Files: | 15,010 |
| Messages: | 6,518,720 |