You stupidly claimed termination analysis is only done
on programs. I proved that you were stupidly wrong on
pages 24-27 of the PDF of this paper.
Automated Termination Analysis of C Programs https://publications.rwth-aachen.de/record/972440/files/972440.pdf
On 11/17/2024 8:26 PM, Richard Damon wrote:
On 11/17/24 8:44 PM, olcott wrote:
On 11/17/2024 4:03 PM, Richard Damon wrote:
On 11/17/24 3:49 PM, olcott wrote:
On 11/17/2024 1:56 PM, Richard Damon wrote:
On 11/17/24 1:36 PM, olcott wrote:
I referred to every element of an infinite set of encodings of HHH.
When each of them correctly emulates N instructions of its input
then N instructions have been correctly emulated. It is despicably
dishonest of you to say that when N instructions have been correctly >>>>> emulated that no instructions have been correctly emulating.
No, but it is the fact that it CAN be emulated for an unbounded numberI never said that N instructions correctly emulated is no
instructions correctly emulated, just that it isn't a correct
emulation that provides the answer for the semantic property of
halting, which requires emulating to the final state or an unbounded
number of steps.
of steps that makes it non-halting.
It cannot be emulated for an unbounded number of steps.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N
to infinity number of steps of DDD cannot possibly
reach its "return" instruction final halt state.
This applies to every DDD emulated by any HHH no
matter the recursive depth of emulation. Thus it is
a verified fact that the input to HHH never halts.
On 11/18/2024 3:19 AM, joes wrote:
Am Sun, 17 Nov 2024 20:35:43 -0600 schrieb olcott:
On 11/17/2024 8:26 PM, Richard Damon wrote:
On 11/17/24 8:44 PM, olcott wrote:
On 11/17/2024 4:03 PM, Richard Damon wrote:
On 11/17/24 3:49 PM, olcott wrote:
On 11/17/2024 1:56 PM, Richard Damon wrote:
On 11/17/24 1:36 PM, olcott wrote:
I referred to every element of an infinite set of encodings of HHH.
Do you mean they are parameterised by the number of steps they simulate?
No I do not mean that.
Whether or not DDD emulated by HHH ever reaches its
own "return" instruction final halt state has nothing
to do with any of the internal working of HHH as long
as each HHH emulates N steps of its input according
to the semantics of the x86 language.
When each of them correctly emulates N instructions of its input >>>>>>> then N instructions have been correctly emulated. It is despicably >>>>>>> dishonest of you to say that when N instructions have been correctly >>>>>>> emulated that no instructions have been correctly emulating.
Then not all instructions have been simulated correctly.
It is ridiculously stupid to require a non-halting input to be
emulated completely because of the requirement that HHH itself
must halt.
All emulating termination analyzers are required to correctly
PREDICT whether or not an unlimited emulation of their input
would cause their own non-termination.
When someone (that knows better) insists that this emulation
must be complete they merely make a complete jackass of themselves.
No, but it is the fact that it CAN be emulated for an unbounded number >>>> of steps that makes it non-halting.I never said that N instructions correctly emulated is no
instructions correctly emulated, just that it isn't a correct
emulation that provides the answer for the semantic property of
halting, which requires emulating to the final state or an unbounded >>>>>> number of steps.
It cannot be emulated for an unbounded number of steps.
???
You can continue to simulate an infinite loop forever.
The violates the design requirement that an emulating termination
analyzer must itself halt.
On 11/18/2024 8:56 AM, Richard Damon wrote:
On 11/18/24 8:49 AM, olcott wrote:
On 11/18/2024 3:19 AM, joes wrote:
Am Sun, 17 Nov 2024 20:35:43 -0600 schrieb olcott:
On 11/17/2024 8:26 PM, Richard Damon wrote:
On 11/17/24 8:44 PM, olcott wrote:
On 11/17/2024 4:03 PM, Richard Damon wrote:
On 11/17/24 3:49 PM, olcott wrote:
On 11/17/2024 1:56 PM, Richard Damon wrote:
On 11/17/24 1:36 PM, olcott wrote:
I referred to every element of an infinite set of encodings of >>>>>>>>> HHH.
Do you mean they are parameterised by the number of steps they
simulate?
No I do not mean that.
Then your arguement is based on an equivocation.
Whether or not DDD emulated by HHH ever reaches its
own "return" instruction final halt state has nothing
to do with any of the internal working of HHH as long
as each HHH emulates N steps of its input according
to the semantics of the x86 language.
Except that the behavior DOES depend on if that HHH returns.
Of course, your subjective, non-semantic property of "emulated by HHH"
is just a meaningless term, so doesn't really mean anything, so your
statement is just nonsense anyway.
You are a damned liar trying to get away with lying about
the effect of the pathological relationship that DDD specifies.
On 11/18/2024 1:05 PM, Richard Damon wrote:
On 11/18/24 1:38 PM, olcott wrote:
On 11/18/2024 8:56 AM, Richard Damon wrote:
On 11/18/24 8:49 AM, olcott wrote:
On 11/18/2024 3:19 AM, joes wrote:
Am Sun, 17 Nov 2024 20:35:43 -0600 schrieb olcott:
On 11/17/2024 8:26 PM, Richard Damon wrote:
On 11/17/24 8:44 PM, olcott wrote:
On 11/17/2024 4:03 PM, Richard Damon wrote:
On 11/17/24 3:49 PM, olcott wrote:
On 11/17/2024 1:56 PM, Richard Damon wrote:
On 11/17/24 1:36 PM, olcott wrote:
I referred to every element of an infinite set of encodings >>>>>>>>>>> of HHH.
Do you mean they are parameterised by the number of steps they
simulate?
No I do not mean that.
Then your arguement is based on an equivocation.
Whether or not DDD emulated by HHH ever reaches its
own "return" instruction final halt state has nothing
to do with any of the internal working of HHH as long
as each HHH emulates N steps of its input according
to the semantics of the x86 language.
Except that the behavior DOES depend on if that HHH returns.
Of course, your subjective, non-semantic property of "emulated by
HHH" is just a meaningless term, so doesn't really mean anything, so
your statement is just nonsense anyway.
You are a damned liar trying to get away with lying about
the effect of the pathological relationship that DDD specifies.
Nope, you are a just a damned liar making claims without any form of
actual logic behind them.
Do you have ANY source that backs your claims about what you claim?
DEFECTION FOR BRAINS
DDD emulated by HHH specifies that HHH emulates
itself emulating DDD such that no such DDD can ever
reach its "return" instruction final halt state.
*Professor Hehner recognized this repeating process before I did*
From a programmer's point of view, if we apply an interpreter to a
program text that includes a call to that same interpreter with that
same text as argument, then we have an infinite loop. A halting
program has some of the same character as an interpreter: it applies
to texts through abstract interpretation. Unsurprisingly, if we apply
a halting program to a program text that includes a call to that same
halting program with that same text as argument, then we have an
infinite loop. (Hehner:2011:15)
[5] E C R Hehner. Problems with the Halting Problem, COMPUTING2011
Symposium on 75 years of Turing Machine and Lambda-Calculus, Karlsruhe Germany, invited, 2011 October 20-21; Advances in Computer Science and Engineering v.10 n.1 p.31-60, 2013
https://www.cs.toronto.edu/~hehner/PHP.pdf
On 11/18/2024 1:05 PM, Richard Damon wrote:
On 11/18/24 1:38 PM, olcott wrote:
On 11/18/2024 8:56 AM, Richard Damon wrote:
On 11/18/24 8:49 AM, olcott wrote:
On 11/18/2024 3:19 AM, joes wrote:
Am Sun, 17 Nov 2024 20:35:43 -0600 schrieb olcott:
On 11/17/2024 8:26 PM, Richard Damon wrote:
On 11/17/24 8:44 PM, olcott wrote:
On 11/17/2024 4:03 PM, Richard Damon wrote:
On 11/17/24 3:49 PM, olcott wrote:
On 11/17/2024 1:56 PM, Richard Damon wrote:
On 11/17/24 1:36 PM, olcott wrote:
I referred to every element of an infinite set of encodings >>>>>>>>>>> of HHH.
Do you mean they are parameterised by the number of steps they
simulate?
No I do not mean that.
Then your arguement is based on an equivocation.
Whether or not DDD emulated by HHH ever reaches its
own "return" instruction final halt state has nothing
to do with any of the internal working of HHH as long
as each HHH emulates N steps of its input according
to the semantics of the x86 language.
Except that the behavior DOES depend on if that HHH returns.
Of course, your subjective, non-semantic property of "emulated by
HHH" is just a meaningless term, so doesn't really mean anything, so
your statement is just nonsense anyway.
You are a damned liar trying to get away with lying about
the effect of the pathological relationship that DDD specifies.
Nope, you are a just a damned liar making claims without any form of
actual logic behind them.
Do you have ANY source that backs your claims about what you claim?
DEFECTION FOR BRAINS
DDD emulated by HHH specifies that HHH emulates
itself emulating DDD such that no such DDD can ever
reach its "return" instruction final halt state.
*Professor Hehner recognized this repeating process before I did*
From a programmer's point of view, if we apply an interpreter to a
program text that includes a call to that same interpreter with that
same text as argument, then we have an infinite loop. A halting
program has some of the same character as an interpreter: it applies
to texts through abstract interpretation. Unsurprisingly, if we apply
a halting program to a program text that includes a call to that same
halting program with that same text as argument, then we have an
infinite loop. (Hehner:2011:15)
[5] E C R Hehner. Problems with the Halting Problem, COMPUTING2011
Symposium on 75 years of Turing Machine and Lambda-Calculus, Karlsruhe Germany, invited, 2011 October 20-21; Advances in Computer Science and Engineering v.10 n.1 p.31-60, 2013
https://www.cs.toronto.edu/~hehner/PHP.pdf
On 11/18/2024 3:53 AM, Mikko wrote:
On 2024-11-18 04:04:39 +0000, olcott said:
You stupidly claimed termination analysis is only done
on programs. I proved that you were stupidly wrong on
pages 24-27 of the PDF of this paper.
Automated Termination Analysis of C Programs
https://publications.rwth-aachen.de/record/972440/files/972440.pdf
The claim is not supported by the referred article.
You are a damned liar. Page 24 proves that termination
analysis is performed on C functions. It is damned liars
like you that are causing the rise of the fourth reich.
On 11/18/2024 1:34 PM, Richard Damon wrote:
On 11/18/24 2:19 PM, olcott wrote:
On 11/18/2024 1:05 PM, Richard Damon wrote:
On 11/18/24 1:38 PM, olcott wrote:
On 11/18/2024 8:56 AM, Richard Damon wrote:
On 11/18/24 8:49 AM, olcott wrote:
On 11/18/2024 3:19 AM, joes wrote:
Am Sun, 17 Nov 2024 20:35:43 -0600 schrieb olcott:
On 11/17/2024 8:26 PM, Richard Damon wrote:
On 11/17/24 8:44 PM, olcott wrote:
On 11/17/2024 4:03 PM, Richard Damon wrote:
On 11/17/24 3:49 PM, olcott wrote:
On 11/17/2024 1:56 PM, Richard Damon wrote:
On 11/17/24 1:36 PM, olcott wrote:
I referred to every element of an infinite set of encodings >>>>>>>>>>>>> of HHH.
Do you mean they are parameterised by the number of steps they >>>>>>>> simulate?
No I do not mean that.
Then your arguement is based on an equivocation.
Whether or not DDD emulated by HHH ever reaches its
own "return" instruction final halt state has nothing
to do with any of the internal working of HHH as long
as each HHH emulates N steps of its input according
to the semantics of the x86 language.
Except that the behavior DOES depend on if that HHH returns.
Of course, your subjective, non-semantic property of "emulated by
HHH" is just a meaningless term, so doesn't really mean anything,
so your statement is just nonsense anyway.
You are a damned liar trying to get away with lying about
the effect of the pathological relationship that DDD specifies.
Nope, you are a just a damned liar making claims without any form of
actual logic behind them.
Do you have ANY source that backs your claims about what you claim?
DEFECTION FOR BRAINS
DDD emulated by HHH specifies that HHH emulates
itself emulating DDD such that no such DDD can ever
reach its "return" instruction final halt state.
But the emulation by HHH is NOT the criteria, as the PARTIAL emulation
by HHH is not a semantic property, and is just subjective, not objective
Your ADD must be actual severe brain damage if you
can't keep track of the fact that requiring the complete
emulatiion of a non-terminating input in not ridiculously
stupid when you have been told this dozens of times.
*Professor Hehner recognized this repeating process before I did*
From a programmer's point of view, if we apply an interpreter to a
program text that includes a call to that same interpreter with that >>> same text as argument, then we have an infinite loop. A halting
program has some of the same character as an interpreter: it applies >>> to texts through abstract interpretation. Unsurprisingly, if we apply >>> a halting program to a program text that includes a call to that same >>> halting program with that same text as argument, then we have an
infinite loop. (Hehner:2011:15)
[5] E C R Hehner. Problems with the Halting Problem, COMPUTING2011
Symposium on 75 years of Turing Machine and Lambda-Calculus,
Karlsruhe Germany, invited, 2011 October 20-21; Advances in Computer
Science and Engineering v.10 n.1 p.31-60, 2013
https://www.cs.toronto.edu/~hehner/PHP.pdf
Just showing that you are not alone in making the error.
The meaning of the words prove that it is true.
On 11/18/2024 3:36 PM, Richard Damon wrote:
On 11/18/24 3:44 PM, olcott wrote:
On 11/18/2024 3:53 AM, Mikko wrote:
On 2024-11-18 04:04:39 +0000, olcott said:
You stupidly claimed termination analysis is only done
on programs. I proved that you were stupidly wrong on
pages 24-27 of the PDF of this paper.
Automated Termination Analysis of C Programs
https://publications.rwth-aachen.de/record/972440/files/972440.pdf
The claim is not supported by the referred article.
You are a damned liar. Page 24 proves that termination
analysis is performed on C functions. It is damned liars
like you that are causing the rise of the fourth reich.
LEAF C functions.
You can't retroactively change your original claim
to make it look like you never made a mistake.
That is what damned liars do.
On 11/18/2024 3:53 AM, Mikko wrote:
On 2024-11-18 04:04:39 +0000, olcott said:
You stupidly claimed termination analysis is only done
on programs. I proved that you were stupidly wrong on
pages 24-27 of the PDF of this paper.
Automated Termination Analysis of C Programs
https://publications.rwth-aachen.de/record/972440/files/972440.pdf
The claim is not supported by the referred article.
You are a damned liar. Page 24 proves that termination
analysis is performed on C functions.
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The subject line
does not specify which mapping and there is no larger context that could
specify that. Therefore it should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N
to infinity number of steps of DDD cannot possibly
reach its "return" instruction final halt state.
Because it cannot reach the instructions before tha return.
Because it cannot reach the instruction after the HHH call.
Because it cannot reach return instruction of HHH.
This applies to every DDD emulated by any HHH no
matter the recursive depth of emulation. Thus it is
a verified fact that the input to HHH never halts.
That is too vague to be regareded true or false. It is perfectly possibe
to define two programs and call them DDD and HHH
What a jackass. DDD and HHH have been fully specified
for many months.
On 11/18/24 6:08 PM, olcott wrote:
On 11/18/2024 3:36 PM, Richard Damon wrote:
On 11/18/24 3:44 PM, olcott wrote:
On 11/18/2024 3:53 AM, Mikko wrote:
On 2024-11-18 04:04:39 +0000, olcott said:
You stupidly claimed termination analysis is only done
on programs. I proved that you were stupidly wrong on
pages 24-27 of the PDF of this paper.
Automated Termination Analysis of C Programs
https://publications.rwth-aachen.de/record/972440/files/972440.pdf
The claim is not supported by the referred article.
You are a damned liar. Page 24 proves that termination
analysis is performed on C functions. It is damned liars
like you that are causing the rise of the fourth reich.
LEAF C functions.
You can't retroactively change your original claim
to make it look like you never made a mistake.
That is what damned liars do.
I didn't.
You are just lying.
Your problem is you don't know what you are talking about and just
bring up phases you didn't learn but read by just rote.
On 11/19/2024 5:56 AM, joes wrote:972440.pdf
Am Mon, 18 Nov 2024 14:21:04 -0600 schrieb olcott:
On 11/18/2024 1:23 PM, Richard Damon wrote:
On 11/18/24 2:07 PM, olcott wrote:
On 11/18/2024 1:02 PM, Richard Damon wrote:
On 11/18/24 1:41 PM, olcott wrote:
On 11/18/2024 10:16 AM, Richard Damon wrote:
On 11/17/24 11:04 PM, olcott wrote:
On 11/17/2024 9:19 PM, Richard Damon wrote:
On 11/17/24 9:47 PM, olcott wrote:
On 11/17/2024 8:26 PM, Richard Damon wrote:
On 11/17/24 8:46 PM, olcott wrote:
On 11/17/2024 4:04 PM, Richard Damon wrote:
On 11/17/24 4:30 PM, olcott wrote:
On 11/17/2024 2:51 PM, Richard Damon wrote:
On 11/17/24 1:36 PM, olcott wrote:
You stupidly claimed termination analysis is only done onLook again at what they process. C functions that include all >>>>>>>>>> the functions they call.No stupid I provided a published paper that includes the >>>>>>>>>>> termination analysis of C functions.But then you can talk about "emulation" or x86 semantics, as >>>>>>>>>>>> both of those are operations done on PROGRAMS.Which is just what YOU are doing, as "Halting" and what a >>>>>>>>>>>>>> "Program" is are DEFINED, and you can't change it.YET ANOTHER STUPID LIE.
A SMART LIAR WOULD NEVER SAY THAT I MEANT PROGRAM WHEN I >>>>>>>>>>>>> ALWAYS SPECIFIED A C FUNCTION.
programs. I proved that you were stupidly wrong on pages 24-27 >>>>>>>>> of the PDF of this paper.
Automated Termination Analysis of C Programs
https://publications.rwth-aachen.de/record/972440/files/
The ONLY thing that it relevantWhat happens when we run HHH(HHH)?Since the halting problem is defined to have the input call its ownThose *ARE* "Computation Theory" Programs.The top of PDF page 24 are not programs defection for brains.Termination analysis applies to FUNCTIONS, FULL FUNCTIONS, onesThe problem here is you are mixing language between domains.I said the termination analysis applies to C functions you said
that it does not. No weasel words around it YOU WERE WRONG!
that include everything that is part of them. Those things, in
computation theory, are called PROGRAMS.
https://publications.rwth-aachen.de/record/972440/files/972440.pdf
They are also LEAF functions, unlike your DDD.
NOTHING in that paper (form what I can see) talks about handling non-
leaf-functions with including all the code in the routines it calls.
termination analyzer and the termination analyzer is itself required
to halt then any sequence of this input that would prevent it from
halting IS A NON-HALTING SEQUENCE THAT MUST BE ABORTED AND CANNOT BE
ALLOWED TO CONTINUE.
DDD emulated by HHH1 DOES NOT SPECIFY THAT HHH1 must emulate itselfOf course not. DDD specifies to call HHH, regardless of the simulator.
emulating DDD.
On 11/19/2024 10:32 AM, joes wrote:
Am Tue, 19 Nov 2024 08:44:17 -0600 schrieb olcott:
On 11/19/2024 5:56 AM, joes wrote:972440.pdf
Am Mon, 18 Nov 2024 14:21:04 -0600 schrieb olcott:
On 11/18/2024 1:23 PM, Richard Damon wrote:
On 11/18/24 2:07 PM, olcott wrote:
On 11/18/2024 1:02 PM, Richard Damon wrote:
On 11/18/24 1:41 PM, olcott wrote:
On 11/18/2024 10:16 AM, Richard Damon wrote:
On 11/17/24 11:04 PM, olcott wrote:
On 11/17/2024 9:19 PM, Richard Damon wrote:
On 11/17/24 9:47 PM, olcott wrote:
On 11/17/2024 8:26 PM, Richard Damon wrote:
On 11/17/24 8:46 PM, olcott wrote:
On 11/17/2024 4:04 PM, Richard Damon wrote:
On 11/17/24 4:30 PM, olcott wrote:
On 11/17/2024 2:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 11/17/24 1:36 PM, olcott wrote:
You stupidly claimed termination analysis is only done on >>>>>>>>>>> programs. I proved that you were stupidly wrong on pages 24-27 >>>>>>>>>>> of the PDF of this paper.Look again at what they process. C functions that include all >>>>>>>>>>>> the functions they call.No stupid I provided a published paper that includes the >>>>>>>>>>>>> termination analysis of C functions.But then you can talk about "emulation" or x86 semantics, as >>>>>>>>>>>>>> both of those are operations done on PROGRAMS.Which is just what YOU are doing, as "Halting" and what a >>>>>>>>>>>>>>>> "Program" is are DEFINED, and you can't change it. >>>>>>>>>>>>>>> YET ANOTHER STUPID LIE.A SMART LIAR WOULD NEVER SAY THAT I MEANT PROGRAM WHEN I >>>>>>>>>>>>>>> ALWAYS SPECIFIED A C FUNCTION.
Automated Termination Analysis of C Programs
https://publications.rwth-aachen.de/record/972440/files/
The ONLY thing that it relevantWhat happens when we run HHH(HHH)?termination analyzer and the termination analyzer is itself required >>>>> to halt then any sequence of this input that would prevent it fromThey are also LEAF functions, unlike your DDD.The top of PDF page 24 are not programs defection for brains.Termination analysis applies to FUNCTIONS, FULL FUNCTIONS, ones >>>>>>>> that include everything that is part of them. Those things, in >>>>>>>> computation theory, are called PROGRAMS.The problem here is you are mixing language between domains. >>>>>>>>> I said the termination analysis applies to C functions you said >>>>>>>>> that it does not. No weasel words around it YOU WERE WRONG!
https://publications.rwth-aachen.de/record/972440/files/972440.pdf >>>>>> Those *ARE* "Computation Theory" Programs.
NOTHING in that paper (form what I can see) talks about handling non- >>>>>> leaf-functions with including all the code in the routines it calls. >>>>> Since the halting problem is defined to have the input call its own
halting IS A NON-HALTING SEQUENCE THAT MUST BE ABORTED AND CANNOT BE >>>>> ALLOWED TO CONTINUE.
Whatever. I was asking a different question. Furthermore, what happens
when we run HHH1(DDD), HHH1(DDD1), HHH(DDD1)?
I cannot afford to tolerate changing the subject to irrelevant
points. Ben Bacarisse had me stuck for 15 years with his
change-the-subject rebuttals. My cancer has gotten worse too
soon so I can't waste time on that.
DDD emulated by HHH1 DOES NOT SPECIFY THAT HHH1 must emulate itself
emulating DDD.
Of course not. DDD specifies to call HHH, regardless of the simulator.
Everyone here has been trying to dishonestly pretend that the
behavior of the directly executed DDD is the same as the behavior
of DDD emulated by HHH for three years.
On 11/19/2024 5:37 PM, Richard Damon wrote:
On 11/19/24 11:54 AM, olcott wrote:
On 11/19/2024 10:32 AM, joes wrote:
Am Tue, 19 Nov 2024 08:44:17 -0600 schrieb olcott:
On 11/19/2024 5:56 AM, joes wrote:972440.pdf
Am Mon, 18 Nov 2024 14:21:04 -0600 schrieb olcott:
On 11/18/2024 1:23 PM, Richard Damon wrote:
On 11/18/24 2:07 PM, olcott wrote:
On 11/18/2024 1:02 PM, Richard Damon wrote:
On 11/18/24 1:41 PM, olcott wrote:
On 11/18/2024 10:16 AM, Richard Damon wrote:
On 11/17/24 11:04 PM, olcott wrote:
On 11/17/2024 9:19 PM, Richard Damon wrote:
On 11/17/24 9:47 PM, olcott wrote:
On 11/17/2024 8:26 PM, Richard Damon wrote:
On 11/17/24 8:46 PM, olcott wrote:
On 11/17/2024 4:04 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 11/17/24 4:30 PM, olcott wrote:
On 11/17/2024 2:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 11/17/24 1:36 PM, olcott wrote:
You stupidly claimed termination analysis is only done on >>>>>>>>>>>>> programs. I proved that you were stupidly wrong on pages 24-27 >>>>>>>>>>>>> of the PDF of this paper.Look again at what they process. C functions that include all >>>>>>>>>>>>>> the functions they call.No stupid I provided a published paper that includes the >>>>>>>>>>>>>>> termination analysis of C functions.But then you can talk about "emulation" or x86 >>>>>>>>>>>>>>>> semantics, asWhich is just what YOU are doing, as "Halting" and what a >>>>>>>>>>>>>>>>>> "Program" is are DEFINED, and you can't change it. >>>>>>>>>>>>>>>>> YET ANOTHER STUPID LIE.A SMART LIAR WOULD NEVER SAY THAT I MEANT PROGRAM WHEN I >>>>>>>>>>>>>>>>> ALWAYS SPECIFIED A C FUNCTION.
both of those are operations done on PROGRAMS.
Automated Termination Analysis of C Programs
https://publications.rwth-aachen.de/record/972440/files/
The ONLY thing that it relevantWhat happens when we run HHH(HHH)?Since the halting problem is defined to have the input call its own >>>>>>> termination analyzer and the termination analyzer is itself required >>>>>>> to halt then any sequence of this input that would prevent it from >>>>>>> halting IS A NON-HALTING SEQUENCE THAT MUST BE ABORTED AND CANNOT BE >>>>>>> ALLOWED TO CONTINUE.They are also LEAF functions, unlike your DDD.The top of PDF page 24 are not programs defection for brains. >>>>>>>>> https://publications.rwth-aachen.de/record/972440/files/972440.pdf >>>>>>>> Those *ARE* "Computation Theory" Programs.The problem here is you are mixing language between domains. >>>>>>>>>>> I said the termination analysis applies to C functions you said >>>>>>>>>>> that it does not. No weasel words around it YOU WERE WRONG! >>>>>>>>>> Termination analysis applies to FUNCTIONS, FULL FUNCTIONS, ones >>>>>>>>>> that include everything that is part of them. Those things, in >>>>>>>>>> computation theory, are called PROGRAMS.
NOTHING in that paper (form what I can see) talks about handling >>>>>>>> non-
leaf-functions with including all the code in the routines it
calls.
Whatever. I was asking a different question. Furthermore, what happens >>>> when we run HHH1(DDD), HHH1(DDD1), HHH(DDD1)?
I cannot afford to tolerate changing the subject to irrelevant
points. Ben Bacarisse had me stuck for 15 years with his
change-the-subject rebuttals. My cancer has gotten worse too
soon so I can't waste time on that.
Then why did you do it?
After all, you stated goal is to prove halting is decidable,
Through a specific sequence of steps.
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The subject line >>>> does not specify which mapping and there is no larger context that could >>>> specify that. Therefore it should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N
to infinity number of steps of DDD cannot possibly
reach its "return" instruction final halt state.
Because it cannot reach the instructions before tha return.
Because it cannot reach the instruction after the HHH call.
Because it cannot reach return instruction of HHH.
This applies to every DDD emulated by any HHH no
matter the recursive depth of emulation. Thus it is
a verified fact that the input to HHH never halts.
That is too vague to be regareded true or false. It is perfectly possibe >>>> to define two programs and call them DDD and HHH
What a jackass. DDD and HHH have been fully specified
for many months.
They are specified in a way that makes your "every DDD" and "any DDD"
bad (perhaps even incorrect) use of Common language.
I specify the infinite sets with each element numbered
on the top of page 2 of my paper. Back in April of 2023
https://www.researchgate.net/publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
On 11/19/2024 4:05 AM, Mikko wrote:
On 2024-11-18 20:44:49 +0000, olcott said:There are two different page 24. Page 24 of the PDF
On 11/18/2024 3:53 AM, Mikko wrote:
On 2024-11-18 04:04:39 +0000, olcott said:
You stupidly claimed termination analysis is only done
on programs. I proved that you were stupidly wrong on
pages 24-27 of the PDF of this paper.
Automated Termination Analysis of C Programs
https://publications.rwth-aachen.de/record/972440/files/972440.pdf
The claim is not supported by the referred article.
You are a damned liar. Page 24 proves that termination
analysis is performed on C functions.
You are the liar. Page 24 does not even mention C functions.
not page 24 of the paper.
On 11/20/2024 3:50 AM, Mikko wrote:
On 2024-11-20 03:19:37 +0000, olcott said:
On 11/19/2024 4:05 AM, Mikko wrote:
On 2024-11-18 20:44:49 +0000, olcott said:There are two different page 24. Page 24 of the PDF
On 11/18/2024 3:53 AM, Mikko wrote:
On 2024-11-18 04:04:39 +0000, olcott said:
You stupidly claimed termination analysis is only doneThe claim is not supported by the referred article.
on programs. I proved that you were stupidly wrong on
pages 24-27 of the PDF of this paper.
Automated Termination Analysis of C Programs
https://publications.rwth-aachen.de/record/972440/files/972440.pdf >>>>>>
You are a damned liar. Page 24 proves that termination
analysis is performed on C functions.
You are the liar. Page 24 does not even mention C functions.
not page 24 of the paper.
You failed to tell which one you meant. Such tricks may deceive
somebody but don't work here.
Please quit being a damned jackass.
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The subject
line
does not specify which mapping and there is no larger context that >>>>>> could
specify that. Therefore it should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N
to infinity number of steps of DDD cannot possibly
reach its "return" instruction final halt state.
Because it cannot reach the instructions before tha return.
Because it cannot reach the instruction after the HHH call.
Because it cannot reach return instruction of HHH.
This applies to every DDD emulated by any HHH no
matter the recursive depth of emulation. Thus it is
a verified fact that the input to HHH never halts.
That is too vague to be regareded true or false. It is perfectly
possibe
to define two programs and call them DDD and HHH
What a jackass. DDD and HHH have been fully specified
for many months.
They are specified in a way that makes your "every DDD" and "any DDD"
bad (perhaps even incorrect) use of Common language.
I specify the infinite sets with each element numbered
on the top of page 2 of my paper. Back in April of 2023
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub repository.
Should I assume that you must be lying about
this because you did not quote where I did this?
I honestly do not believe that I would have ever made
the stupid mistake of calling a C function a computer
program.
On 11/20/2024 5:50 PM, Richard Damon wrote:
On 11/20/24 5:04 PM, olcott wrote:
On 11/19/2024 9:41 PM, Richard Damon wrote:
On 11/19/24 10:26 PM, olcott wrote:
On 11/19/2024 5:37 PM, Richard Damon wrote:
On 11/19/24 11:54 AM, olcott wrote:
On 11/19/2024 10:32 AM, joes wrote:
Am Tue, 19 Nov 2024 08:44:17 -0600 schrieb olcott:
On 11/19/2024 5:56 AM, joes wrote:
Am Mon, 18 Nov 2024 14:21:04 -0600 schrieb olcott:The ONLY thing that it relevant
On 11/18/2024 1:23 PM, Richard Damon wrote:What happens when we run HHH(HHH)?
On 11/18/24 2:07 PM, olcott wrote:
On 11/18/2024 1:02 PM, Richard Damon wrote:
On 11/18/24 1:41 PM, olcott wrote:
On 11/18/2024 10:16 AM, Richard Damon wrote:
On 11/17/24 11:04 PM, olcott wrote:
On 11/17/2024 9:19 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 11/17/24 9:47 PM, olcott wrote:
On 11/17/2024 8:26 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 11/17/24 8:46 PM, olcott wrote:
On 11/17/2024 4:04 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 11/17/24 4:30 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 11/17/2024 2:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 11/17/24 1:36 PM, olcott wrote:
Since the halting problem is defined to have the input call >>>>>>>>>>> its ownThose *ARE* "Computation Theory" Programs.The top of PDF page 24 are not programs defection for brains. >>>>>>>>>>>>> https://publications.rwth-aachen.de/record/972440/that include everything that is part of them. Those >>>>>>>>>>>>>> things, inI said the termination analysis applies to C functions >>>>>>>>>>>>>>> you saidThe problem here is you are mixing language between >>>>>>>>>>>>>>>> domains.You stupidly claimed termination analysis is only done on >>>>>>>>>>>>>>>>> programs. I proved that you were stupidly wrong on >>>>>>>>>>>>>>>>> pages 24-27Look again at what they process. C functions that >>>>>>>>>>>>>>>>>> include allBut then you can talk about "emulation" or x86 >>>>>>>>>>>>>>>>>>>> semantics, asWhich is just what YOU are doing, as "Halting" and >>>>>>>>>>>>>>>>>>>>>> what aA SMART LIAR WOULD NEVER SAY THAT I MEANT PROGRAM >>>>>>>>>>>>>>>>>>>>> WHEN I
"Program" is are DEFINED, and you can't change it. >>>>>>>>>>>>>>>>>>>>> YET ANOTHER STUPID LIE.
ALWAYS SPECIFIED A C FUNCTION.
both of those are operations done on PROGRAMS. >>>>>>>>>>>>>>>>>>> No stupid I provided a published paper that includes the >>>>>>>>>>>>>>>>>>> termination analysis of C functions.
the functions they call.
of the PDF of this paper.
Automated Termination Analysis of C Programs >>>>>>>>>>>>>>>>> https://publications.rwth-aachen.de/record/972440/files/ >>>>>>>> 972440.pdf
that it does not. No weasel words around it YOU WERE WRONG! >>>>>>>>>>>>>> Termination analysis applies to FUNCTIONS, FULL FUNCTIONS, >>>>>>>>>>>>>> ones
computation theory, are called PROGRAMS.
files/972440.pdf
They are also LEAF functions, unlike your DDD.
NOTHING in that paper (form what I can see) talks about >>>>>>>>>>>> handling non-
leaf-functions with including all the code in the routines >>>>>>>>>>>> it calls.
termination analyzer and the termination analyzer is itself >>>>>>>>>>> required
to halt then any sequence of this input that would prevent it >>>>>>>>>>> from
halting IS A NON-HALTING SEQUENCE THAT MUST BE ABORTED AND >>>>>>>>>>> CANNOT BE
ALLOWED TO CONTINUE.
Whatever. I was asking a different question. Furthermore, what >>>>>>>> happens
when we run HHH1(DDD), HHH1(DDD1), HHH(DDD1)?
I cannot afford to tolerate changing the subject to irrelevant
points. Ben Bacarisse had me stuck for 15 years with his
change-the-subject rebuttals. My cancer has gotten worse too
soon so I can't waste time on that.
Then why did you do it?
After all, you stated goal is to prove halting is decidable,
Through a specific sequence of steps.
But arguements based on nonsense don't provide steps to a proof.
You are a damned liar.
Nope. but it seems you are.
What I say is proven true by the meaning of its words
and you lie about this condemning yourself to actual Hell.
DDD emulated by any HHH cannot possibly reach its "return"
instruction final halt state.
That you say this is untrue is a despicable lie and
you know it.
That it is true and seems irrelevant to you would not
be a lie. You seem to prefer to lie.
On 11/20/2024 8:47 PM, Richard Damon wrote:
On 11/20/24 9:39 PM, olcott wrote:
What I say is proven true by the meaning of its words
and you lie about this condemning yourself to actual Hell.
No, and you have shown you don't KNOW the meaning of the words,
because you are using "Terms of Art" in an art that you are just
ignorant of.
DDD emulated by any HHH cannot possibly reach its "return"
instruction final halt state.
Which is an invalid criteria for a decider, and even invalid for
saying "never"
THAT IS NOT THE SAME AS SAYING IT IS FALSE.
Your HHH shows that the behavior of DDD doesn't YET reach the return
instruction in the part of its behavior emulated by HHH, but it DOES
reach their under the ACTUAL DEFINITION of the behavior of DDD, that
HHH MUST ANSWER ABOUT, or your whole arguement is just based on lies.
That you say this is untrue is a despicable lie and
you know it.
No, Because your statement is just NONSENSE.
No Jackass it is not nonsense. You may be a condemned
to actual Hell liar for saying that it is nonsense.
Here is actual nonsense: "f4(nmr rgfm59 mn98B"
That it is true and seems irrelevant to you would not
be a lie. You seem to prefer to lie.
No, you are just proving you are nothing but a pathological liar
because you refuse to learn what you words mean.
That you call a point of view that is merely different
than the conventional point of view "nonsense" or a "lie"
IS A LIE THAT MAY GET YOU CONDEMNED TO ACTUAL HELL.
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The subject line >>>>>> does not specify which mapping and there is no larger context that could >>>>>> specify that. Therefore it should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N
to infinity number of steps of DDD cannot possibly
reach its "return" instruction final halt state.
Because it cannot reach the instructions before tha return.
Because it cannot reach the instruction after the HHH call.
Because it cannot reach return instruction of HHH.
This applies to every DDD emulated by any HHH no
matter the recursive depth of emulation. Thus it is
a verified fact that the input to HHH never halts.
That is too vague to be regareded true or false. It is perfectly possibe >>>>>> to define two programs and call them DDD and HHH
What a jackass. DDD and HHH have been fully specified
for many months.
They are specified in a way that makes your "every DDD" and "any DDD"
bad (perhaps even incorrect) use of Common language.
I specify the infinite sets with each element numbered
on the top of page 2 of my paper. Back in April of 2023
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub repository.
Should I assume that you must be lying about
this because you did not quote where I did this?
On 11/20/2024 10:00 PM, Richard Damon wrote:
On 11/20/24 10:45 PM, olcott wrote:
On 11/20/2024 8:47 PM, Richard Damon wrote:
On 11/20/24 9:39 PM, olcott wrote:
What I say is proven true by the meaning of its words
and you lie about this condemning yourself to actual Hell.
No, and you have shown you don't KNOW the meaning of the words,
because you are using "Terms of Art" in an art that you are just
ignorant of.
DDD emulated by any HHH cannot possibly reach its "return"
instruction final halt state.
Which is an invalid criteria for a decider, and even invalid for
saying "never"
THAT IS NOT THE SAME AS SAYING IT IS FALSE.
It surely isn't true, which is what you need it to be.
Of course it is true. I just don't get it why you want to
condemn yourself to Hell over this. Are you a fake Christian?
I guees you are just admitting that you are nothing but a lying
hypocrite.
I haven't even made a mistake, you are the one that is.
Anyone can tell that by the inconsistency of your answers.
Your HHH shows that the behavior of DDD doesn't YET reach the return
instruction in the part of its behavior emulated by HHH, but it DOES
reach their under the ACTUAL DEFINITION of the behavior of DDD, that
HHH MUST ANSWER ABOUT, or your whole arguement is just based on lies.
That you say this is untrue is a despicable lie and
you know it.
No, Because your statement is just NONSENSE.
No Jackass it is not nonsense. You may be a condemned
to actual Hell liar for saying that it is nonsense.
Here is actual nonsense: "f4(nmr rgfm59 mn98B"
Yes, it is nonsense, as it is making a category error.
You just don't understand the words you are using, and your insistance
on incorrect statements is just proving you are nothing but a liar.
That it is true and seems irrelevant to you would not
be a lie. You seem to prefer to lie.
No, you are just proving you are nothing but a pathological liar
because you refuse to learn what you words mean.
That you call a point of view that is merely different
than the conventional point of view "nonsense" or a "lie"
IS A LIE THAT MAY GET YOU CONDEMNED TO ACTUAL HELL.
IT isn't a "point of view" but a failure to meet the objective
requirements of the system you are stuck in.
IT seems that YOU are the one condemned to hell, and Satan has you so
buffaloed that you don't see it coming.
Once he got you to brainwash yourself to not even look at the correct
definitions, he had you in the bag, as you are just unable to
understand the truth, which mean he also cut you off from the possible
solution to your problems, so you don't actually beleive in the right
way of how truth works.
On 11/20/2024 10:00 PM, Richard Damon wrote:Like all of them, it is unable to simulate DDD to its undeniable halting
On 11/20/24 9:57 PM, olcott wrote:
On 11/20/2024 5:51 PM, Richard Damon wrote:
On 11/20/24 5:03 PM, olcott wrote:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The
subject line does not specify which mapping and there is no >>>>>>>>>> larger context that could specify that. Therefore it should be >>>>>>>>>> "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
My code is one example of the infinite set of every possible HHH that
emulates DDD according to the semantics of the x86 language.
Whatever. DDD halts and HHH should return that.But it gets the wrong answer for the halting problem, as DDD dpes halt.DDD emulated by HHH does not halt.
Are you a fake Christian?I am a fake Scientologist.
On 11/21/2024 6:20 AM, Richard Damon wrote:No. That's why it is simulating incorrectly.
On 11/21/24 12:18 AM, olcott wrote:
On 11/20/2024 10:00 PM, Richard Damon wrote:
On 11/20/24 10:45 PM, olcott wrote:
On 11/20/2024 8:47 PM, Richard Damon wrote:
On 11/20/24 9:39 PM, olcott wrote:
DDD emulated by any HHH cannot possibly reach its "return"Which is an invalid criterion for a decider, and even invalid for
instruction final halt state.
saying "never"
It isn't a valid condition to talk about for a decider, so just likeDDD emulating by HHH DOES REACH ITS OWN FINAL STATE?
the Liar's Paradox, it is untrue.
On 11/20/2024 10:00 PM, Richard Damon wrote:
On 11/20/24 9:57 PM, olcott wrote:
On 11/20/2024 5:51 PM, Richard Damon wrote:
On 11/20/24 5:03 PM, olcott wrote:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The
subject line
does not specify which mapping and there is no larger context >>>>>>>>>> that could
specify that. Therefore it should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N
to infinity number of steps of DDD cannot possibly
reach its "return" instruction final halt state.
Because it cannot reach the instructions before tha return. >>>>>>>>>> Because it cannot reach the instruction after the HHH call. >>>>>>>>>> Because it cannot reach return instruction of HHH.
This applies to every DDD emulated by any HHH no
matter the recursive depth of emulation. Thus it is
a verified fact that the input to HHH never halts.
That is too vague to be regareded true or false. It is
perfectly possibe
to define two programs and call them DDD and HHH
What a jackass. DDD and HHH have been fully specified
for many months.
They are specified in a way that makes your "every DDD" and "any >>>>>>>> DDD"
bad (perhaps even incorrect) use of Common language.
I specify the infinite sets with each element numbered
on the top of page 2 of my paper. Back in April of 2023
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub
repository.
Should I assume that you must be lying about
this because you did not quote where I did this?
You forget how many times you have posted the link to your "fully
functioning code"?
You can't have it both ways, either that *IS* the code of HHH.
My code is one example of the infinite set of every possible
HHH that emulates DDD according to the semantics of the x86
language.
But it gets the wrong answer for the halting problem, as DDD dpes halt.
DDD emulated by HHH does not halt. You lie about this
and condemn yourself to actual Hell. Are you a fake Christian?
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The subject line >>>>>>>> does not specify which mapping and there is no larger context that could
specify that. Therefore it should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N
to infinity number of steps of DDD cannot possibly
reach its "return" instruction final halt state.
Because it cannot reach the instructions before tha return.
Because it cannot reach the instruction after the HHH call.
Because it cannot reach return instruction of HHH.
This applies to every DDD emulated by any HHH no
matter the recursive depth of emulation. Thus it is
a verified fact that the input to HHH never halts.
That is too vague to be regareded true or false. It is perfectly possibe
to define two programs and call them DDD and HHH
What a jackass. DDD and HHH have been fully specified
for many months.
They are specified in a way that makes your "every DDD" and "any DDD" >>>>>> bad (perhaps even incorrect) use of Common language.
I specify the infinite sets with each element numbered
on the top of page 2 of my paper. Back in April of 2023
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub repository. >>>>
Should I assume that you must be lying about
this because you did not quote where I did this?
No, you may assume that I was confused by your lack of clarity and
in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH that you have
in your GitHub repository then I needn't to consider the possiblity
that you just triying to deceive by equivcation.
HHH is one concrete example of an infinite set of instances
such that DDD is emulated by HHH N times.
On 11/21/2024 3:11 PM, joes wrote:
Am Thu, 21 Nov 2024 09:19:03 -0600 schrieb olcott:In your case you may simply not even understand what infinite recursion
On 11/20/2024 10:00 PM, Richard Damon wrote:Like all of them, it is unable to simulate DDD to its undeniable
On 11/20/24 9:57 PM, olcott wrote:
On 11/20/2024 5:51 PM, Richard Damon wrote:
On 11/20/24 5:03 PM, olcott wrote:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The >>>>>>>>>>>> subject line does not specify which mapping and there is no >>>>>>>>>>>> larger context that could specify that. Therefore it should >>>>>>>>>>>> be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
My code is one example of the infinite set of every possible HHH
that emulates DDD according to the semantics of the x86 language.
halting state.
is, thus cannot see the isomorphism.
All instances of DDD behave the same (if it is a pure function andIT IS NOT THE SAME INSTANCE OF DDD.Whatever. DDD halts and HHH should return that.But it gets the wrong answer for the halting problem, as DDD dpesDDD emulated by HHH does not halt.
halt.
HHH is reporting on the behavior of its INPUT.And its input is (the encoding of) DDD.
HHH is not reporting on the behavior of some other different DDDYou mean the same DDD when it is not simulated?
instance that behaves differently.
Then it is never wrong about its own result.I can make a "decider" this way: it simulates no steps at all and
returns that all inputs halt when simulated by it.
We can solve this conundrum by rejecting Scientologists as incorrect.That may be the correct Scientologist to be.Are you a fake Christian?I am a fake Scientologist.
On 11/22/2024 6:20 AM, joes wrote:TMs don't have side effects, such as reading a static Root variable.
Am Thu, 21 Nov 2024 15:19:43 -0600 schrieb olcott:Only HHH is required to be a pure function, DDD is expressly allowed to
On 11/21/2024 3:11 PM, joes wrote:All instances of DDD behave the same (if it is a pure function and the
Am Thu, 21 Nov 2024 09:19:03 -0600 schrieb olcott:IT IS NOT THE SAME INSTANCE OF DDD.
On 11/20/2024 10:00 PM, Richard Damon wrote:Like all of them, it is unable to simulate DDD to its undeniable
On 11/20/24 9:57 PM, olcott wrote:
On 11/20/2024 5:51 PM, Richard Damon wrote:
On 11/20/24 5:03 PM, olcott wrote:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The >>>>>>>>>>>>>> subject line does not specify which mapping and there is no >>>>>>>>>>>>>> larger context that could specify that. Therefore it should >>>>>>>>>>>>>> be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
My code is one example of the infinite set of every possible HHH >>>>>>> that emulates DDD according to the semantics of the x86 language.
halting state.
Whatever. DDD halts and HHH should return that.But it gets the wrong answer for the halting problem, as DDD dpesDDD emulated by HHH does not halt.
halt.
HHH called from it doesn't switch behaviour by a static variable).
be any damn thing.
The behavior of DDD emulated by HHH isYes. HHH simulates it incorrectly.
different than the actual behavior of DDD emulated by HHH1.
Note we have been on this one point about the behavior of DDD emulatedYes, you seem hellbent on dying before you can make your point.
by HHH for many months and have not yet even begun to talk about how HHH would report this behavior.
The question does DDD halt?Not in the case of an erroneous simulation.
Is answered by Can DDD emulated by any HHH reach its own "return"
instruction final state?
The question: How could HHH determine whether or not DDD emulated by HHHIt seems very relevant. Since you have an answer to the former question,
can possibly reach its own final state?
is another entirely different question.
On 11/22/2024 6:20 AM, joes wrote:
Am Thu, 21 Nov 2024 15:19:43 -0600 schrieb olcott:
On 11/21/2024 3:11 PM, joes wrote:
Am Thu, 21 Nov 2024 09:19:03 -0600 schrieb olcott:In your case you may simply not even understand what infinite recursion
On 11/20/2024 10:00 PM, Richard Damon wrote:Like all of them, it is unable to simulate DDD to its undeniable
On 11/20/24 9:57 PM, olcott wrote:
On 11/20/2024 5:51 PM, Richard Damon wrote:
On 11/20/24 5:03 PM, olcott wrote:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The >>>>>>>>>>>>>> subject line does not specify which mapping and there is no >>>>>>>>>>>>>> larger context that could specify that. Therefore it should >>>>>>>>>>>>>> be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
My code is one example of the infinite set of every possible HHH >>>>>>> that emulates DDD according to the semantics of the x86 language.
halting state.
is, thus cannot see the isomorphism.
All instances of DDD behave the same (if it is a pure function andIT IS NOT THE SAME INSTANCE OF DDD.Whatever. DDD halts and HHH should return that.But it gets the wrong answer for the halting problem, as DDD dpesDDD emulated by HHH does not halt.
halt.
the HHH called from it doesn't switch behaviour by a static variable).
Only HHH is required to be a pure function, DDD is expressly
allowed to be any damn thing. The actual behavior of DDD
emulated by HHH is different than the actual behavior of DDD
emulated by HHH1.
*ONLY BECAUSE DDD CALLS HHH AND DDD DOES NOT CALL HHH1*
Even Mike does not seem to be able to understand this.
Note we have been on this one point about the behavior of
DDD emulated by HHH for many months and have not yet even
begun to talk about how HHH would report this behavior.
The question does DDD halt?
Is answered by Can DDD emulated by any HHH reach its own
"return" instruction final state?
The question: How could HHH determine whether or not DDD
emulated by HHH can possibly reach its own final state?
is another entirely different question.
On 11/22/2024 2:30 AM, Mikko wrote:
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The
subject line
does not specify which mapping and there is no larger context >>>>>>>>>> that could
specify that. Therefore it should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N
to infinity number of steps of DDD cannot possibly
reach its "return" instruction final halt state.
Because it cannot reach the instructions before tha return. >>>>>>>>>> Because it cannot reach the instruction after the HHH call. >>>>>>>>>> Because it cannot reach return instruction of HHH.
This applies to every DDD emulated by any HHH no
matter the recursive depth of emulation. Thus it is
a verified fact that the input to HHH never halts.
That is too vague to be regareded true or false. It is
perfectly possibe
to define two programs and call them DDD and HHH
What a jackass. DDD and HHH have been fully specified
for many months.
They are specified in a way that makes your "every DDD" and "any >>>>>>>> DDD"
bad (perhaps even incorrect) use of Common language.
I specify the infinite sets with each element numbered
on the top of page 2 of my paper. Back in April of 2023
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub
repository.
Should I assume that you must be lying about
this because you did not quote where I did this?
No, you may assume that I was confused by your lack of clarity and
in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH that you have
in your GitHub repository then I needn't to consider the possiblity
that you just triying to deceive by equivcation.
HHH is one concrete example of an infinite set of instances
such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH, contradicting your
earlier statement that HHH is a generic term for every member of some
set.
You seem to be a damned liar: "infinite set of instances"
On 11/22/2024 9:16 AM, joes wrote:It does. If it were always set to True, all instances of the same HHH
Am Fri, 22 Nov 2024 08:50:33 -0600 schrieb olcott:
On 11/22/2024 6:20 AM, joes wrote:
Am Thu, 21 Nov 2024 15:19:43 -0600 schrieb olcott:
On 11/21/2024 3:11 PM, joes wrote:
Am Thu, 21 Nov 2024 09:19:03 -0600 schrieb olcott:
On 11/20/2024 10:00 PM, Richard Damon wrote:
On 11/20/24 9:57 PM, olcott wrote:
On 11/20/2024 5:51 PM, Richard Damon wrote:
On 11/20/24 5:03 PM, olcott wrote:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The >>>>>>>>>>>>>>>> subject line does not specify which mapping and there is >>>>>>>>>>>>>>>> no larger context that could specify that. Therefore it >>>>>>>>>>>>>>>> should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
The static root variable has not one damn thing to do with theTMs don't have side effects, such as reading a static Root variable.Only HHH is required to be a pure function, DDD is expressly allowedAll instances of DDD behave the same (if it is a pure function andIT IS NOT THE SAME INSTANCE OF DDD.Whatever. DDD halts and HHH should return that.But it gets the wrong answer for the halting problem, as DDD dpes >>>>>>>> halt.DDD emulated by HHH does not halt.
the HHH called from it doesn't switch behaviour by a static
variable).
to be any damn thing.
fact that DDD emulated by HHH cannot possibly reach its own "return" instruction.
--The behavior of DDD emulated by HHH is different than the actualYes. HHH simulates it incorrectly.
behavior of DDD emulated by HHH1.
On 11/22/2024 12:07 PM, joes wrote:
Am Fri, 22 Nov 2024 10:36:25 -0600 schrieb olcott:
On 11/22/2024 9:16 AM, joes wrote:It does. If it were always set to True, all instances of the same HHH
Am Fri, 22 Nov 2024 08:50:33 -0600 schrieb olcott:
On 11/22/2024 6:20 AM, joes wrote:
Am Thu, 21 Nov 2024 15:19:43 -0600 schrieb olcott:
On 11/21/2024 3:11 PM, joes wrote:
Am Thu, 21 Nov 2024 09:19:03 -0600 schrieb olcott:
On 11/20/2024 10:00 PM, Richard Damon wrote:
On 11/20/24 9:57 PM, olcott wrote:
On 11/20/2024 5:51 PM, Richard Damon wrote:
On 11/20/24 5:03 PM, olcott wrote:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The >>>>>>>>>>>>>>>>>> subject line does not specify which mapping and there is >>>>>>>>>>>>>>>>>> no larger context that could specify that. Therefore it >>>>>>>>>>>>>>>>>> should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
The static root variable has not one damn thing to do with theTMs don't have side effects, such as reading a static Root variable.Only HHH is required to be a pure function, DDD is expressly allowed >>>>> to be any damn thing.All instances of DDD behave the same (if it is a pure function and >>>>>> the HHH called from it doesn't switch behaviour by a staticIT IS NOT THE SAME INSTANCE OF DDD.Whatever. DDD halts and HHH should return that.But it gets the wrong answer for the halting problem, as DDD dpes >>>>>>>>>> halt.DDD emulated by HHH does not halt.
variable).
fact that DDD emulated by HHH cannot possibly reach its own "return"
instruction.
would abort and halt. Why else would it be there?
WE HAVE NOT BEEN TALKING ABOUT ABORT/NOT ABORT
FOR THREE FREAKING MONTHS. WAKE THE F-CK UP.
WE HAVE BEEN TALKING ABOUT DDD EMULATED BY HHH
REACHING ITS FINAL HALT STATE
The behavior of DDD emulated by HHH is different than the actualYes. HHH simulates it incorrectly.
behavior of DDD emulated by HHH1.
On 11/22/2024 12:37 PM, Richard Damon wrote:
On 11/22/24 1:28 PM, olcott wrote:
On 11/22/2024 12:07 PM, joes wrote:
Am Fri, 22 Nov 2024 10:36:25 -0600 schrieb olcott:
On 11/22/2024 9:16 AM, joes wrote:It does. If it were always set to True, all instances of the same HHH
Am Fri, 22 Nov 2024 08:50:33 -0600 schrieb olcott:
On 11/22/2024 6:20 AM, joes wrote:
Am Thu, 21 Nov 2024 15:19:43 -0600 schrieb olcott:
On 11/21/2024 3:11 PM, joes wrote:
Am Thu, 21 Nov 2024 09:19:03 -0600 schrieb olcott:
On 11/20/2024 10:00 PM, Richard Damon wrote:
On 11/20/24 9:57 PM, olcott wrote:
On 11/20/2024 5:51 PM, Richard Damon wrote:
On 11/20/24 5:03 PM, olcott wrote:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>> On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not >>>>>>>>>>>>>>>>>>>> correct. The
subject line does not specify which mapping and >>>>>>>>>>>>>>>>>>>> there is
no larger context that could specify that. Therefore it >>>>>>>>>>>>>>>>>>>> should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
fact that DDD emulated by HHH cannot possibly reach its own "return" >>>>> instruction.TMs don't have side effects, such as reading a static Root variable. >>>>> The static root variable has not one damn thing to do with theOnly HHH is required to be a pure function, DDD is expressly allowed >>>>>>> to be any damn thing.All instances of DDD behave the same (if it is a pure function and >>>>>>>> the HHH called from it doesn't switch behaviour by a staticIT IS NOT THE SAME INSTANCE OF DDD.Whatever. DDD halts and HHH should return that.But it gets the wrong answer for the halting problem, as DDD >>>>>>>>>>>> dpesDDD emulated by HHH does not halt.
halt.
variable).
would abort and halt. Why else would it be there?
WE HAVE NOT BEEN TALKING ABOUT ABORT/NOT ABORT
FOR THREE FREAKING MONTHS. WAKE THE F-CK UP.
WE HAVE BEEN TALKING ABOUT DDD EMULATED BY HHH
REACHING ITS FINAL HALT STATE
So, does HHH abort or not abort it emulation?
Of the infinite set of every HHH that emulates N steps
of DDD no DDD ever reaches its final halt state.
On 11/22/2024 2:03 PM, Richard Damon wrote:
On 11/22/24 1:44 PM, olcott wrote:
On 11/22/2024 12:37 PM, Richard Damon wrote:
On 11/22/24 1:28 PM, olcott wrote:
On 11/22/2024 12:07 PM, joes wrote:
Am Fri, 22 Nov 2024 10:36:25 -0600 schrieb olcott:
On 11/22/2024 9:16 AM, joes wrote:It does. If it were always set to True, all instances of the same HHH >>>>>> would abort and halt. Why else would it be there?
Am Fri, 22 Nov 2024 08:50:33 -0600 schrieb olcott:
On 11/22/2024 6:20 AM, joes wrote:
Am Thu, 21 Nov 2024 15:19:43 -0600 schrieb olcott:
On 11/21/2024 3:11 PM, joes wrote:
Am Thu, 21 Nov 2024 09:19:03 -0600 schrieb olcott:
On 11/20/2024 10:00 PM, Richard Damon wrote:
On 11/20/24 9:57 PM, olcott wrote:
On 11/20/2024 5:51 PM, Richard Damon wrote:
On 11/20/24 5:03 PM, olcott wrote:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>> On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>> On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> The "the mapping" on the subject line is not >>>>>>>>>>>>>>>>>>>>>> correct. The
subject line does not specify which mapping and >>>>>>>>>>>>>>>>>>>>>> there is
no larger context that could specify that. >>>>>>>>>>>>>>>>>>>>>> Therefore it
should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
The static root variable has not one damn thing to do with theTMs don't have side effects, such as reading a static RootOnly HHH is required to be a pure function, DDD is expressly >>>>>>>>> allowedAll instances of DDD behave the same (if it is a pure function >>>>>>>>>> andIT IS NOT THE SAME INSTANCE OF DDD.Whatever. DDD halts and HHH should return that.But it gets the wrong answer for the halting problem, as >>>>>>>>>>>>>> DDD dpesDDD emulated by HHH does not halt.
halt.
the HHH called from it doesn't switch behaviour by a static >>>>>>>>>> variable).
to be any damn thing.
variable.
fact that DDD emulated by HHH cannot possibly reach its own "return" >>>>>>> instruction.
WE HAVE NOT BEEN TALKING ABOUT ABORT/NOT ABORT
FOR THREE FREAKING MONTHS. WAKE THE F-CK UP.
WE HAVE BEEN TALKING ABOUT DDD EMULATED BY HHH
REACHING ITS FINAL HALT STATE
So, does HHH abort or not abort it emulation?
Of the infinite set of every HHH that emulates N steps
of DDD no DDD ever reaches its final halt state.
So?
Without including HHH in the input, at least implicitly, they couldn't
have done what you said, so you are admitting that the actual input
DDD must include the code of HHH, or you are just a liar.
You are just trying to get away with changing the subject.
The question is: Can DDD emulated by any HHH possibly
reach its final halt state.
On 11/22/2024 5:03 PM, Richard Damon wrote:
On 11/22/24 5:57 PM, olcott wrote:
On 11/22/2024 2:03 PM, Richard Damon wrote:
On 11/22/24 1:44 PM, olcott wrote:
On 11/22/2024 12:37 PM, Richard Damon wrote:
On 11/22/24 1:28 PM, olcott wrote:
On 11/22/2024 12:07 PM, joes wrote:
Am Fri, 22 Nov 2024 10:36:25 -0600 schrieb olcott:
On 11/22/2024 9:16 AM, joes wrote:It does. If it were always set to True, all instances of the
Am Fri, 22 Nov 2024 08:50:33 -0600 schrieb olcott:
On 11/22/2024 6:20 AM, joes wrote:
Am Thu, 21 Nov 2024 15:19:43 -0600 schrieb olcott:
On 11/21/2024 3:11 PM, joes wrote:
Am Thu, 21 Nov 2024 09:19:03 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 11/20/2024 10:00 PM, Richard Damon wrote:
On 11/20/24 9:57 PM, olcott wrote:
On 11/20/2024 5:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 11/20/24 5:03 PM, olcott wrote:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>> On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>> On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> The "the mapping" on the subject line is not >>>>>>>>>>>>>>>>>>>>>>>> correct. The
subject line does not specify which mapping and >>>>>>>>>>>>>>>>>>>>>>>> there is
no larger context that could specify that. >>>>>>>>>>>>>>>>>>>>>>>> Therefore it
should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
The static root variable has not one damn thing to do with the >>>>>>>>> fact that DDD emulated by HHH cannot possibly reach its ownTMs don't have side effects, such as reading a static Root >>>>>>>>>> variable.Only HHH is required to be a pure function, DDD is expressly >>>>>>>>>>> allowedAll instances of DDD behave the same (if it is a pureIT IS NOT THE SAME INSTANCE OF DDD.Whatever. DDD halts and HHH should return that.But it gets the wrong answer for the halting problem, as >>>>>>>>>>>>>>>> DDD dpesDDD emulated by HHH does not halt.
halt.
function and
the HHH called from it doesn't switch behaviour by a static >>>>>>>>>>>> variable).
to be any damn thing.
"return"
instruction.
same HHH
would abort and halt. Why else would it be there?
WE HAVE NOT BEEN TALKING ABOUT ABORT/NOT ABORT
FOR THREE FREAKING MONTHS. WAKE THE F-CK UP.
WE HAVE BEEN TALKING ABOUT DDD EMULATED BY HHH
REACHING ITS FINAL HALT STATE
So, does HHH abort or not abort it emulation?
Of the infinite set of every HHH that emulates N steps
of DDD no DDD ever reaches its final halt state.
So?
Without including HHH in the input, at least implicitly, they
couldn't have done what you said, so you are admitting that the
actual input DDD must include the code of HHH, or you are just a liar. >>>>
You are just trying to get away with changing the subject.
The question is: Can DDD emulated by any HHH possibly
reach its final halt state.
The question (in computation theory) CAN'T be that, is it isn't a
valid question, as it isn't an objective quesiton about just DDD.
In other words you are trying to get away pretending that
the fact that DDD defines a pathological relationship to
HHH can be simply ignored. How is that not stupid?
On 11/22/2024 6:23 PM, Richard Damon wrote:
On 11/22/24 6:56 PM, olcott wrote:
On 11/22/2024 5:03 PM, Richard Damon wrote:
On 11/22/24 5:57 PM, olcott wrote:
On 11/22/2024 2:03 PM, Richard Damon wrote:
On 11/22/24 1:44 PM, olcott wrote:
On 11/22/2024 12:37 PM, Richard Damon wrote:
On 11/22/24 1:28 PM, olcott wrote:
On 11/22/2024 12:07 PM, joes wrote:
Am Fri, 22 Nov 2024 10:36:25 -0600 schrieb olcott:
On 11/22/2024 9:16 AM, joes wrote:It does. If it were always set to True, all instances of the >>>>>>>>>> same HHH
Am Fri, 22 Nov 2024 08:50:33 -0600 schrieb olcott:The static root variable has not one damn thing to do with the >>>>>>>>>>> fact that DDD emulated by HHH cannot possibly reach its own >>>>>>>>>>> "return"
On 11/22/2024 6:20 AM, joes wrote:TMs don't have side effects, such as reading a static Root >>>>>>>>>>>> variable.
Am Thu, 21 Nov 2024 15:19:43 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 11/21/2024 3:11 PM, joes wrote:Only HHH is required to be a pure function, DDD is
All instances of DDD behave the same (if it is a pure >>>>>>>>>>>>>> function andAm Thu, 21 Nov 2024 09:19:03 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 11/20/2024 10:00 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 11/20/24 9:57 PM, olcott wrote:
Whatever. DDD halts and HHH should return that. >>>>>>>>>>>>>>> IT IS NOT THE SAME INSTANCE OF DDD.DDD emulated by HHH does not halt.On 11/20/2024 5:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 11/20/24 5:03 PM, olcott wrote:But it gets the wrong answer for the halting problem, >>>>>>>>>>>>>>>>>> as DDD dpes
On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>> On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> The "the mapping" on the subject line is not >>>>>>>>>>>>>>>>>>>>>>>>>> correct. The
subject line does not specify which mapping >>>>>>>>>>>>>>>>>>>>>>>>>> and there is
no larger context that could specify that. >>>>>>>>>>>>>>>>>>>>>>>>>> Therefore it
should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>>>>>
halt.
the HHH called from it doesn't switch behaviour by a static >>>>>>>>>>>>>> variable).
expressly allowed
to be any damn thing.
instruction.
would abort and halt. Why else would it be there?
WE HAVE NOT BEEN TALKING ABOUT ABORT/NOT ABORT
FOR THREE FREAKING MONTHS. WAKE THE F-CK UP.
WE HAVE BEEN TALKING ABOUT DDD EMULATED BY HHH
REACHING ITS FINAL HALT STATE
So, does HHH abort or not abort it emulation?
Of the infinite set of every HHH that emulates N steps
of DDD no DDD ever reaches its final halt state.
So?
Without including HHH in the input, at least implicitly, they
couldn't have done what you said, so you are admitting that the
actual input DDD must include the code of HHH, or you are just a
liar.
You are just trying to get away with changing the subject.
The question is: Can DDD emulated by any HHH possibly
reach its final halt state.
The question (in computation theory) CAN'T be that, is it isn't a
valid question, as it isn't an objective quesiton about just DDD.
In other words you are trying to get away pretending that
the fact that DDD defines a pathological relationship to
HHH can be simply ignored. How is that not stupid?
No, but it does mean that HHH needs to CORRECTLY handle that
relationship, which is that it needs to understand that the HHH that
DDD calls will do exactly what it does.
Always lacks enough execution trace data to do
what the outermost HHH does.
On 11/22/2024 7:49 PM, Richard Damon wrote:
On 11/22/24 7:47 PM, olcott wrote:
On 11/22/2024 6:23 PM, Richard Damon wrote:
On 11/22/24 6:56 PM, olcott wrote:
On 11/22/2024 5:03 PM, Richard Damon wrote:
On 11/22/24 5:57 PM, olcott wrote:
On 11/22/2024 2:03 PM, Richard Damon wrote:
On 11/22/24 1:44 PM, olcott wrote:
On 11/22/2024 12:37 PM, Richard Damon wrote:
On 11/22/24 1:28 PM, olcott wrote:
On 11/22/2024 12:07 PM, joes wrote:
Am Fri, 22 Nov 2024 10:36:25 -0600 schrieb olcott:
On 11/22/2024 9:16 AM, joes wrote:It does. If it were always set to True, all instances of the >>>>>>>>>>>> same HHH
Am Fri, 22 Nov 2024 08:50:33 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 11/22/2024 6:20 AM, joes wrote:The static root variable has not one damn thing to do with the >>>>>>>>>>>>> fact that DDD emulated by HHH cannot possibly reach its own >>>>>>>>>>>>> "return"
TMs don't have side effects, such as reading a static Root >>>>>>>>>>>>>> variable.Am Thu, 21 Nov 2024 15:19:43 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 11/21/2024 3:11 PM, joes wrote:Only HHH is required to be a pure function, DDD is >>>>>>>>>>>>>>> expressly allowed
All instances of DDD behave the same (if it is a pure >>>>>>>>>>>>>>>> function andAm Thu, 21 Nov 2024 09:19:03 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 11/20/2024 10:00 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 11/20/24 9:57 PM, olcott wrote:
Whatever. DDD halts and HHH should return that. >>>>>>>>>>>>>>>>> IT IS NOT THE SAME INSTANCE OF DDD.DDD emulated by HHH does not halt.On 11/20/2024 5:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 11/20/24 5:03 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> The "the mapping" on the subject line is not >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct. TheBut it gets the wrong answer for the halting >>>>>>>>>>>>>>>>>>>> problem, as DDD dpes
subject line does not specify which mapping >>>>>>>>>>>>>>>>>>>>>>>>>>>> and there is
no larger context that could specify that. >>>>>>>>>>>>>>>>>>>>>>>>>>>> Therefore it
should be "a mapping". >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>>>>>>>
halt.
the HHH called from it doesn't switch behaviour by a static >>>>>>>>>>>>>>>> variable).
to be any damn thing.
instruction.
would abort and halt. Why else would it be there?
WE HAVE NOT BEEN TALKING ABOUT ABORT/NOT ABORT
FOR THREE FREAKING MONTHS. WAKE THE F-CK UP.
WE HAVE BEEN TALKING ABOUT DDD EMULATED BY HHH
REACHING ITS FINAL HALT STATE
So, does HHH abort or not abort it emulation?
Of the infinite set of every HHH that emulates N steps
of DDD no DDD ever reaches its final halt state.
So?
Without including HHH in the input, at least implicitly, they
couldn't have done what you said, so you are admitting that the >>>>>>>> actual input DDD must include the code of HHH, or you are just a >>>>>>>> liar.
You are just trying to get away with changing the subject.
The question is: Can DDD emulated by any HHH possibly
reach its final halt state.
The question (in computation theory) CAN'T be that, is it isn't a
valid question, as it isn't an objective quesiton about just DDD.
In other words you are trying to get away pretending that
the fact that DDD defines a pathological relationship to
HHH can be simply ignored. How is that not stupid?
No, but it does mean that HHH needs to CORRECTLY handle that
relationship, which is that it needs to understand that the HHH that
DDD calls will do exactly what it does.
Always lacks enough execution trace data to do
what the outermost HHH does.
Exfept that it DOES when you apply the definition of Semantic, which
means executed/emulated to completion.
How many times are you going to insist on the stupid nitwit
idea of emulating a non-terminating input to completion?
*DDD emulated by HHH HAS NO FREAKING COMPLETION NITWIT*
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
On 11/22/2024 8:41 PM, Richard Damon wrote:
On 11/22/24 9:07 PM, olcott wrote:
On 11/22/2024 7:49 PM, Richard Damon wrote:
On 11/22/24 7:47 PM, olcott wrote:
On 11/22/2024 6:23 PM, Richard Damon wrote:
On 11/22/24 6:56 PM, olcott wrote:
On 11/22/2024 5:03 PM, Richard Damon wrote:
On 11/22/24 5:57 PM, olcott wrote:
On 11/22/2024 2:03 PM, Richard Damon wrote:
On 11/22/24 1:44 PM, olcott wrote:
On 11/22/2024 12:37 PM, Richard Damon wrote:
On 11/22/24 1:28 PM, olcott wrote:
On 11/22/2024 12:07 PM, joes wrote:
Am Fri, 22 Nov 2024 10:36:25 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 11/22/2024 9:16 AM, joes wrote:
It does. If it were always set to True, all instances of >>>>>>>>>>>>>> the same HHHAm Fri, 22 Nov 2024 08:50:33 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 11/22/2024 6:20 AM, joes wrote:The static root variable has not one damn thing to do >>>>>>>>>>>>>>> with the
TMs don't have side effects, such as reading a static >>>>>>>>>>>>>>>> Root variable.Am Thu, 21 Nov 2024 15:19:43 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 11/21/2024 3:11 PM, joes wrote:Only HHH is required to be a pure function, DDD is >>>>>>>>>>>>>>>>> expressly allowed
All instances of DDD behave the same (if it is a pure >>>>>>>>>>>>>>>>>> function andAm Thu, 21 Nov 2024 09:19:03 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 11/20/2024 10:00 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 11/20/24 9:57 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 11/20/2024 5:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 11/20/24 5:03 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The "the mapping" on the subject line is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not correct. The
Whatever. DDD halts and HHH should return that. >>>>>>>>>>>>>>>>>>> IT IS NOT THE SAME INSTANCE OF DDD.DDD emulated by HHH does not halt.But it gets the wrong answer for the halting >>>>>>>>>>>>>>>>>>>>>> problem, as DDD dpessubject line does not specify which >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping and there is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no larger context that could specify that. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Therefore it
should be "a mapping". >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>>>>>>>>>
halt.
the HHH called from it doesn't switch behaviour by a >>>>>>>>>>>>>>>>>> static
variable).
to be any damn thing.
fact that DDD emulated by HHH cannot possibly reach its >>>>>>>>>>>>>>> own "return"
instruction.
would abort and halt. Why else would it be there?
WE HAVE NOT BEEN TALKING ABOUT ABORT/NOT ABORT
FOR THREE FREAKING MONTHS. WAKE THE F-CK UP.
WE HAVE BEEN TALKING ABOUT DDD EMULATED BY HHH
REACHING ITS FINAL HALT STATE
So, does HHH abort or not abort it emulation?
Of the infinite set of every HHH that emulates N steps
of DDD no DDD ever reaches its final halt state.
So?
Without including HHH in the input, at least implicitly, they >>>>>>>>>> couldn't have done what you said, so you are admitting that >>>>>>>>>> the actual input DDD must include the code of HHH, or you are >>>>>>>>>> just a liar.
You are just trying to get away with changing the subject.
The question is: Can DDD emulated by any HHH possibly
reach its final halt state.
The question (in computation theory) CAN'T be that, is it isn't >>>>>>>> a valid question, as it isn't an objective quesiton about just DDD. >>>>>>>>
In other words you are trying to get away pretending that
the fact that DDD defines a pathological relationship to
HHH can be simply ignored. How is that not stupid?
No, but it does mean that HHH needs to CORRECTLY handle that
relationship, which is that it needs to understand that the HHH
that DDD calls will do exactly what it does.
Always lacks enough execution trace data to do
what the outermost HHH does.
Exfept that it DOES when you apply the definition of Semantic, which
means executed/emulated to completion.
How many times are you going to insist on the stupid nitwit
idea of emulating a non-terminating input to completion?
*DDD emulated by HHH HAS NO FREAKING COMPLETION NITWIT*
How many times will you just refuse to accept the DEFINITION?
And, how many times will you just ignore that the below input can not
be emulated past the call HHH instructioon.
That is what you have been denying.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
All you are doing is PROVING that you are nothing but a totally
ignorant pathetic pathological lying idiot that just recklessly
disregards the truth to maintain his lie.
The fact that you do nothing to defend against these charges is just
showing that you are really accepting them.
When I back you into a corner making you look stupid
you simply agree with what I said like you just agreed.
On 11/22/2024 2:30 AM, Mikko wrote:
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The subject line
does not specify which mapping and there is no larger context that could
specify that. Therefore it should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N
to infinity number of steps of DDD cannot possibly
reach its "return" instruction final halt state.
Because it cannot reach the instructions before tha return. >>>>>>>>>> Because it cannot reach the instruction after the HHH call. >>>>>>>>>> Because it cannot reach return instruction of HHH.
This applies to every DDD emulated by any HHH no
matter the recursive depth of emulation. Thus it is
a verified fact that the input to HHH never halts.
That is too vague to be regareded true or false. It is perfectly possibe
to define two programs and call them DDD and HHH
What a jackass. DDD and HHH have been fully specified
for many months.
They are specified in a way that makes your "every DDD" and "any DDD" >>>>>>>> bad (perhaps even incorrect) use of Common language.
I specify the infinite sets with each element numbered
on the top of page 2 of my paper. Back in April of 2023
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub repository.
Should I assume that you must be lying about
this because you did not quote where I did this?
No, you may assume that I was confused by your lack of clarity and
in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH that you have
in your GitHub repository then I needn't to consider the possiblity
that you just triying to deceive by equivcation.
HHH is one concrete example of an infinite set of instances
such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH, contradicting your
earlier statement that HHH is a generic term for every member of some
set.
You seem to be a damned liar: "infinite set of instances"
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The >>>>>>>>>>>> subject line
does not specify which mapping and there is no larger
context that could
specify that. Therefore it should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N
to infinity number of steps of DDD cannot possibly
reach its "return" instruction final halt state.
Because it cannot reach the instructions before tha return. >>>>>>>>>>>> Because it cannot reach the instruction after the HHH call. >>>>>>>>>>>> Because it cannot reach return instruction of HHH.
This applies to every DDD emulated by any HHH no
matter the recursive depth of emulation. Thus it is
a verified fact that the input to HHH never halts.
That is too vague to be regareded true or false. It is >>>>>>>>>>>> perfectly possibe
to define two programs and call them DDD and HHH
What a jackass. DDD and HHH have been fully specified
for many months.
They are specified in a way that makes your "every DDD" and >>>>>>>>>> "any DDD"
bad (perhaps even incorrect) use of Common language.
I specify the infinite sets with each element numbered
on the top of page 2 of my paper. Back in April of 2023
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub
repository.
Should I assume that you must be lying about
this because you did not quote where I did this?
No, you may assume that I was confused by your lack of clarity and >>>>>> in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH that you have >>>>>> in your GitHub repository then I needn't to consider the possiblity >>>>>> that you just triying to deceive by equivcation.
HHH is one concrete example of an infinite set of instances
such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH, contradicting your
earlier statement that HHH is a generic term for every member of some
set.
You seem to be a damned liar: "infinite set of instances"
You mean you lied when you said "one concrete example"?
One element of an infinite set does not say there
is no infinite set. Is says there is an infinite set.
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The >>>>>>>>>>>>>> subject line
does not specify which mapping and there is no larger >>>>>>>>>>>>>> context that could
specify that. Therefore it should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N >>>>>>>>>>>>>>> to infinity number of steps of DDD cannot possibly >>>>>>>>>>>>>>> reach its "return" instruction final halt state.
Because it cannot reach the instructions before tha return. >>>>>>>>>>>>>> Because it cannot reach the instruction after the HHH call. >>>>>>>>>>>>>> Because it cannot reach return instruction of HHH. >>>>>>>>>>>>>>
This applies to every DDD emulated by any HHH no >>>>>>>>>>>>>>> matter the recursive depth of emulation. Thus it is >>>>>>>>>>>>>>> a verified fact that the input to HHH never halts. >>>>>>>>>>>>>>That is too vague to be regareded true or false. It is >>>>>>>>>>>>>> perfectly possibe
to define two programs and call them DDD and HHH
What a jackass. DDD and HHH have been fully specified >>>>>>>>>>>>> for many months.
They are specified in a way that makes your "every DDD" and >>>>>>>>>>>> "any DDD"
bad (perhaps even incorrect) use of Common language.
I specify the infinite sets with each element numbered
on the top of page 2 of my paper. Back in April of 2023
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub >>>>>>>>>> repository.
Should I assume that you must be lying about
this because you did not quote where I did this?
No, you may assume that I was confused by your lack of clarity and >>>>>>>> in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH that you have >>>>>>>> in your GitHub repository then I needn't to consider the possiblity >>>>>>>> that you just triying to deceive by equivcation.
HHH is one concrete example of an infinite set of instances
such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH, contradicting your
earlier statement that HHH is a generic term for every member of some >>>>>> set.
You seem to be a damned liar: "infinite set of instances"
You mean you lied when you said "one concrete example"?
One element of an infinite set does not say there
is no infinite set. Is says there is an infinite set.
But one element of an infinite set is not the infinite set.
You are just showing that your logic is based on proven incorrect set
theory.
IF HHH is an ELEMENT of the set, then it is that one element for the
entire evaluation,
Liar:
A proof by induction consists of two cases. The first, the base case,
proves the statement for n=0 without assuming any knowledge of
other cases. The second case, the induction step, proves that if the statement holds for any given case n=k, then it must also hold for
the next case n=k+1. These two steps establish that the statement
holds for every natural number n. The base case does not necessarily
begin with n=0, but often with n=1, and possibly with any fixed natural number n=N, establishing the truth of the statement for all natural
numbers n ≥ N.
https://en.wikipedia.org/wiki/Mathematical_induction
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. >>>>>>>>>>>>>>>> The subject lineWhat a jackass. DDD and HHH have been fully specified >>>>>>>>>>>>>>> for many months.
does not specify which mapping and there is no larger >>>>>>>>>>>>>>>> context that could
specify that. Therefore it should be "a mapping". >>>>>>>>>>>>>>>>
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()Because it cannot reach the instructions before tha return. >>>>>>>>>>>>>>>> Because it cannot reach the instruction after the HHH call. >>>>>>>>>>>>>>>> Because it cannot reach return instruction of HHH. >>>>>>>>>>>>>>>>
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N >>>>>>>>>>>>>>>>> to infinity number of steps of DDD cannot possibly >>>>>>>>>>>>>>>>> reach its "return" instruction final halt state. >>>>>>>>>>>>>>>>
This applies to every DDD emulated by any HHH no >>>>>>>>>>>>>>>>> matter the recursive depth of emulation. Thus it is >>>>>>>>>>>>>>>>> a verified fact that the input to HHH never halts. >>>>>>>>>>>>>>>>That is too vague to be regareded true or false. It is >>>>>>>>>>>>>>>> perfectly possibe
to define two programs and call them DDD and HHH >>>>>>>>>>>>>>>
They are specified in a way that makes your "every DDD" >>>>>>>>>>>>>> and "any DDD"
bad (perhaps even incorrect) use of Common language. >>>>>>>>>>>>>>
I specify the infinite sets with each element numbered >>>>>>>>>>>>> on the top of page 2 of my paper. Back in April of 2023 >>>>>>>>>>>>>
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your >>>>>>>>>>>> GitHub repository.
Should I assume that you must be lying about
this because you did not quote where I did this?
No, you may assume that I was confused by your lack of clarity >>>>>>>>>> and
in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH that you >>>>>>>>>> have
in your GitHub repository then I needn't to consider the
possiblity
that you just triying to deceive by equivcation.
HHH is one concrete example of an infinite set of instances
such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH, contradicting your >>>>>>>> earlier statement that HHH is a generic term for every member of >>>>>>>> some
set.
You seem to be a damned liar: "infinite set of instances"
You mean you lied when you said "one concrete example"?
One element of an infinite set does not say there
is no infinite set. Is says there is an infinite set.
But one element of an infinite set is not the infinite set.
You are just showing that your logic is based on proven incorrect
set theory.
IF HHH is an ELEMENT of the set, then it is that one element for the
entire evaluation,
Liar:
A proof by induction consists of two cases. The first, the base case,
proves the statement for n=0 without assuming any knowledge of
other cases. The second case, the induction step, proves that if the
statement holds for any given case n=k, then it must also hold for
the next case n=k+1. These two steps establish that the statement
holds for every natural number n. The base case does not necessarily
begin with n=0, but often with n=1, and possibly with any fixed natural
number n=N, establishing the truth of the statement for all natural
numbers n ≥ N.
https://en.wikipedia.org/wiki/Mathematical_induction
And when have you ever provided such a proof for your statement?
NOWHERE
Your problem is you don't even have a logical basis to express your
statements in, so you can't do an induction on them.
*As you already admitted below*
when N steps of DDD are emulated by HHH
DDD cannot reach past its call to HHH (statement)
Thus the induction result is proven:
"the (above) statement holds for every natural number n."
On 11/22/2024 8:41 PM, Richard Damon wrote:
On 11/22/24 9:07 PM, olcott wrote:>
And, how many times will you just ignore that
the below input can not be emulated past the
call HHH instructioon.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD is the C function under test.
HHH is not the C function under test.
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:17 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/22/24 11:11 PM, olcott wrote:
On 11/22/2024 9:58 PM, Richard Damon wrote:
On 11/22/24 10:08 PM, olcott wrote:
On 11/22/2024 8:41 PM, Richard Damon wrote:
On 11/22/24 9:07 PM, olcott wrote:
On 11/22/2024 7:49 PM, Richard Damon wrote:
On 11/22/24 7:47 PM, olcott wrote:
On 11/22/2024 6:23 PM, Richard Damon wrote:
On 11/22/24 6:56 PM, olcott wrote:
On 11/22/2024 5:03 PM, Richard Damon wrote:
On 11/22/24 5:57 PM, olcott wrote:
On 11/22/2024 2:03 PM, Richard Damon wrote:
On 11/22/24 1:44 PM, olcott wrote:
On 11/22/2024 12:37 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 11/22/24 1:28 PM, olcott wrote:
On 11/22/2024 12:07 PM, joes wrote:
Am Fri, 22 Nov 2024 10:36:25 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 11/22/2024 9:16 AM, joes wrote:
It does. If it were always set to True, all >>>>>>>>>>>>>>>>>>>> instances of the same HHHAm Fri, 22 Nov 2024 08:50:33 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>> On 11/22/2024 6:20 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>> Am Thu, 21 Nov 2024 15:19:43 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/21/2024 3:11 PM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Am Thu, 21 Nov 2024 09:19:03 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
On 11/20/2024 10:00 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/20/24 9:57 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/20/2024 5:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/20/24 5:03 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said:
On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The "the mapping" on the subject >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> line is not correct. The >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subject line does not specify which >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping and there is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no larger context that could specify >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that. Therefore it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> should be "a mapping". >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-17 18:36:17 +0000, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said:
The static root variable has not one damn thing to >>>>>>>>>>>>>>>>>>>>> do with theTMs don't have side effects, such as reading a >>>>>>>>>>>>>>>>>>>>>> static Root variable.Only HHH is required to be a pure function, DDD >>>>>>>>>>>>>>>>>>>>>>> is expressly allowedthe HHH called from it doesn't switch behaviour >>>>>>>>>>>>>>>>>>>>>>>> by a staticBut it gets the wrong answer for the halting >>>>>>>>>>>>>>>>>>>>>>>>>>>> problem, as DDD dpesDDD emulated by HHH does not halt. >>>>>>>>>>>>>>>>>>>>>>>>>> Whatever. DDD halts and HHH should return that. >>>>>>>>>>>>>>>>>>>>>>>>> IT IS NOT THE SAME INSTANCE OF DDD. >>>>>>>>>>>>>>>>>>>>>>>> All instances of DDD behave the same (if it is a >>>>>>>>>>>>>>>>>>>>>>>> pure function and
halt.
variable).
to be any damn thing.
fact that DDD emulated by HHH cannot possibly reach >>>>>>>>>>>>>>>>>>>>> its own "return"
instruction.
would abort and halt. Why else would it be there? >>>>>>>>>>>>>>>>>>>>
WE HAVE NOT BEEN TALKING ABOUT ABORT/NOT ABORT >>>>>>>>>>>>>>>>>>> FOR THREE FREAKING MONTHS. WAKE THE F-CK UP. >>>>>>>>>>>>>>>>>>>
WE HAVE BEEN TALKING ABOUT DDD EMULATED BY HHH >>>>>>>>>>>>>>>>>>> REACHING ITS FINAL HALT STATE
So, does HHH abort or not abort it emulation? >>>>>>>>>>>>>>>>>>
Of the infinite set of every HHH that emulates N steps >>>>>>>>>>>>>>>>> of DDD no DDD ever reaches its final halt state. >>>>>>>>>>>>>>>>>
So?
Without including HHH in the input, at least implicitly, >>>>>>>>>>>>>>>> they couldn't have done what you said, so you are >>>>>>>>>>>>>>>> admitting that the actual input DDD must include the >>>>>>>>>>>>>>>> code of HHH, or you are just a liar.
You are just trying to get away with changing the subject. >>>>>>>>>>>>>>> The question is: Can DDD emulated by any HHH possibly >>>>>>>>>>>>>>> reach its final halt state.
The question (in computation theory) CAN'T be that, is it >>>>>>>>>>>>>> isn't a valid question, as it isn't an objective quesiton >>>>>>>>>>>>>> about just DDD.
In other words you are trying to get away pretending that >>>>>>>>>>>>> the fact that DDD defines a pathological relationship to >>>>>>>>>>>>> HHH can be simply ignored. How is that not stupid?
No, but it does mean that HHH needs to CORRECTLY handle that >>>>>>>>>>>> relationship, which is that it needs to understand that the >>>>>>>>>>>> HHH that DDD calls will do exactly what it does.
Always lacks enough execution trace data to do
what the outermost HHH does.
Exfept that it DOES when you apply the definition of Semantic, >>>>>>>>>> which means executed/emulated to completion.
How many times are you going to insist on the stupid nitwit
idea of emulating a non-terminating input to completion?
*DDD emulated by HHH HAS NO FREAKING COMPLETION NITWIT*
How many times will you just refuse to accept the DEFINITION?
And, how many times will you just ignore that the below input
can not be emulated past the call HHH instructioon.
That is what you have been denying.
No, You have been LYING by having your HHH go past it.
*a copy of my quote above that you have repeatedly denied*
I haven't "denied" it, I have proven it to be nonsense.
Of the infinite set of every HHH that emulates N steps >>>>> >>>>>>>>>>>> of DDD no DDD ever reaches its final halt state.
And the problem is that since your DDD don't contain the code for HHH,
Then DDD simply calls HHH(DDD) in its shared memory space.
Why act so stupidly?
In other words, you admit that HHH isn't a pure function.
On 11/22/2024 8:41 PM, Richard Damon wrote:
On 11/22/24 9:07 PM, olcott wrote:>
And, how many times will you just ignore that
the below input can not be emulated past the
call HHH instructioon.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
If the above point that DDD emulated by any HHH cannot possibly
reach its own "ret" instruction final halt state is settled
and mutually agreed to thenn (then and only then) can we move
on to the next point.
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The subject line
does not specify which mapping and there is no larger context that could
specify that. Therefore it should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N
to infinity number of steps of DDD cannot possibly
reach its "return" instruction final halt state.
Because it cannot reach the instructions before tha return. >>>>>>>>>>>> Because it cannot reach the instruction after the HHH call. >>>>>>>>>>>> Because it cannot reach return instruction of HHH.
This applies to every DDD emulated by any HHH no
matter the recursive depth of emulation. Thus it is
a verified fact that the input to HHH never halts.
That is too vague to be regareded true or false. It is perfectly possibe
to define two programs and call them DDD and HHH
What a jackass. DDD and HHH have been fully specified
for many months.
They are specified in a way that makes your "every DDD" and "any DDD"
bad (perhaps even incorrect) use of Common language.
I specify the infinite sets with each element numbered
on the top of page 2 of my paper. Back in April of 2023
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub repository.
Should I assume that you must be lying about
this because you did not quote where I did this?
No, you may assume that I was confused by your lack of clarity and >>>>>> in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH that you have >>>>>> in your GitHub repository then I needn't to consider the possiblity >>>>>> that you just triying to deceive by equivcation.
HHH is one concrete example of an infinite set of instances
such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH, contradicting your
earlier statement that HHH is a generic term for every member of some
set.
You seem to be a damned liar: "infinite set of instances"
You mean you lied when you said "one concrete example"?
One element of an infinite set does not say there
is no infinite set. Is says there is an infinite set.
On 11/24/2024 4:22 AM, Mikko wrote:
On 2024-11-23 14:04:07 +0000, olcott said:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The >>>>>>>>>>>>>> subject line
does not specify which mapping and there is no larger >>>>>>>>>>>>>> context that could
specify that. Therefore it should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N >>>>>>>>>>>>>>> to infinity number of steps of DDD cannot possibly >>>>>>>>>>>>>>> reach its "return" instruction final halt state.
Because it cannot reach the instructions before tha return. >>>>>>>>>>>>>> Because it cannot reach the instruction after the HHH call. >>>>>>>>>>>>>> Because it cannot reach return instruction of HHH. >>>>>>>>>>>>>>
This applies to every DDD emulated by any HHH no >>>>>>>>>>>>>>> matter the recursive depth of emulation. Thus it is >>>>>>>>>>>>>>> a verified fact that the input to HHH never halts. >>>>>>>>>>>>>>That is too vague to be regareded true or false. It is >>>>>>>>>>>>>> perfectly possibe
to define two programs and call them DDD and HHH
What a jackass. DDD and HHH have been fully specified >>>>>>>>>>>>> for many months.
They are specified in a way that makes your "every DDD" and >>>>>>>>>>>> "any DDD"
bad (perhaps even incorrect) use of Common language.
I specify the infinite sets with each element numbered
on the top of page 2 of my paper. Back in April of 2023
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub >>>>>>>>>> repository.
Should I assume that you must be lying about
this because you did not quote where I did this?
No, you may assume that I was confused by your lack of clarity and >>>>>>>> in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH that you have >>>>>>>> in your GitHub repository then I needn't to consider the possiblity >>>>>>>> that you just triying to deceive by equivcation.
HHH is one concrete example of an infinite set of instances
such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH, contradicting your
earlier statement that HHH is a generic term for every member of some >>>>>> set.
You seem to be a damned liar: "infinite set of instances"
You mean you lied when you said "one concrete example"?
One element of an infinite set does not say there
is no infinite set. Is says there is an infinite set.
True but irrelevant.
The behavior of one element of that infinite set proves
that every element of that infinite set has the same property:
N steps of DDD emulated by HHH never reach their final
"ret" instruction and halt.
An element of an infinite set is not that infinite
set and in clase of HHH it is not a set at all. If the element has the
same name as the set you have name conflict and any resulting confusion
is your fault.
On 11/23/2024 11:54 AM, Richard Damon wrote:
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. >>>>>>>>>>>>>>>>>> The subject lineWhat a jackass. DDD and HHH have been fully specified >>>>>>>>>>>>>>>>> for many months.
does not specify which mapping and there is no larger >>>>>>>>>>>>>>>>>> context that could
specify that. Therefore it should be "a mapping". >>>>>>>>>>>>>>>>>>
On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>>>>>>>>>>>>>
void DDD()Because it cannot reach the instructions before tha >>>>>>>>>>>>>>>>>> return.
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N >>>>>>>>>>>>>>>>>>> to infinity number of steps of DDD cannot possibly >>>>>>>>>>>>>>>>>>> reach its "return" instruction final halt state. >>>>>>>>>>>>>>>>>>
Because it cannot reach the instruction after the HHH >>>>>>>>>>>>>>>>>> call.
Because it cannot reach return instruction of HHH. >>>>>>>>>>>>>>>>>>
This applies to every DDD emulated by any HHH no >>>>>>>>>>>>>>>>>>> matter the recursive depth of emulation. Thus it is >>>>>>>>>>>>>>>>>>> a verified fact that the input to HHH never halts. >>>>>>>>>>>>>>>>>>That is too vague to be regareded true or false. It is >>>>>>>>>>>>>>>>>> perfectly possibe
to define two programs and call them DDD and HHH >>>>>>>>>>>>>>>>>
They are specified in a way that makes your "every DDD" >>>>>>>>>>>>>>>> and "any DDD"
bad (perhaps even incorrect) use of Common language. >>>>>>>>>>>>>>>>
I specify the infinite sets with each element numbered >>>>>>>>>>>>>>> on the top of page 2 of my paper. Back in April of 2023 >>>>>>>>>>>>>>>
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your >>>>>>>>>>>>>> GitHub repository.
Should I assume that you must be lying about
this because you did not quote where I did this?
No, you may assume that I was confused by your lack of >>>>>>>>>>>> clarity and
in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH that >>>>>>>>>>>> you have
in your GitHub repository then I needn't to consider the >>>>>>>>>>>> possiblity
that you just triying to deceive by equivcation.
HHH is one concrete example of an infinite set of instances >>>>>>>>>>> such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH, contradicting your >>>>>>>>>> earlier statement that HHH is a generic term for every member >>>>>>>>>> of some
set.
You seem to be a damned liar: "infinite set of instances"
You mean you lied when you said "one concrete example"?
One element of an infinite set does not say there
is no infinite set. Is says there is an infinite set.
But one element of an infinite set is not the infinite set.
You are just showing that your logic is based on proven incorrect
set theory.
IF HHH is an ELEMENT of the set, then it is that one element for
the entire evaluation,
Liar:
A proof by induction consists of two cases. The first, the base case, >>>>> proves the statement for n=0 without assuming any knowledge of
other cases. The second case, the induction step, proves that if the >>>>> statement holds for any given case n=k, then it must also hold for
the next case n=k+1. These two steps establish that the statement
holds for every natural number n. The base case does not necessarily >>>>> begin with n=0, but often with n=1, and possibly with any fixed
natural
number n=N, establishing the truth of the statement for all natural
numbers n ≥ N.
https://en.wikipedia.org/wiki/Mathematical_induction
And when have you ever provided such a proof for your statement?
NOWHERE
Your problem is you don't even have a logical basis to express your
statements in, so you can't do an induction on them.
So, you are just demonstrating that your "logic" is based on the
meaningless use of buzzwords that you don't understand, but can parrot
their unlearned meaning, but have no idea how to actually use.
*As you already admitted below*
when N steps of DDD are emulated by HHH
DDD cannot reach past its call to HHH (statement)
But that was for the DDD that INCLUDED HHH as part of it, which you
have now made clear is NOT what you consider DDD to be. And for that
case DDD[n] calls HHH[n] (where HHH[n] is the version of HHH that does
only n steps of emulation) and while we can say that HHH[n[ does not
emulate DDD[n] to its final state, that property is NOT a property of
of DDD[n], but of HHH[n] and DDD[n] as its input.
That every DDD[n] calls its HHH[n] in recursive emulation
conclusively proves that no DDD[n] emulated by HHH[n] halts,
thus each HHH[n] is correct to reject its input as non halting.
Partial emulation do not establish "never" properties, as they are
non-semantic, the semantic property of DDD[n] reaching its final state
or not is only demonstratable by looking at an unbounded emulation of
that input (not necessarily done by the decider) and for DDD[n], for
all finite n, we see that this emulation will reach a final state, so
you claim of NEVER reaching a final state, and thus being able to say
DDD is non-halting is false.
Thus the induction result is proven:
"the (above) statement holds for every natural number n."
Which isn't an induction argument, thus showing your idiocy.
On 11/22/2024 8:41 PM, Richard Damon wrote:
On 11/22/24 9:07 PM, olcott wrote:>
;
And, how many times will you just ignore that
the below input can not be emulated past the
call HHH instructioon.
;
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD is the C function under test.
HHH is not the C function under test.
But, if that is ALL of DDD, and it is JUST the code of that C
function, then there can not exist a pure function HHH that can
emulate more than 4 steps of that input, as to emulate the 5th step,
it would need to know what is at 000015d2, but that is not part of the
input, and to look at that memory address in its address space makes
HHH a non-pure function, and thus proves you to be a liar.
So, all you have done is PROVEN that you are just a stupid liar that
has no idea what he is talking about.
On 11/24/2024 4:22 AM, Mikko wrote:
On 2024-11-23 14:04:07 +0000, olcott said:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The subject line
does not specify which mapping and there is no larger context that could
specify that. Therefore it should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N >>>>>>>>>>>>>>> to infinity number of steps of DDD cannot possibly >>>>>>>>>>>>>>> reach its "return" instruction final halt state.
Because it cannot reach the instructions before tha return. >>>>>>>>>>>>>> Because it cannot reach the instruction after the HHH call. >>>>>>>>>>>>>> Because it cannot reach return instruction of HHH. >>>>>>>>>>>>>>
This applies to every DDD emulated by any HHH no >>>>>>>>>>>>>>> matter the recursive depth of emulation. Thus it is >>>>>>>>>>>>>>> a verified fact that the input to HHH never halts. >>>>>>>>>>>>>>That is too vague to be regareded true or false. It is perfectly possibe
to define two programs and call them DDD and HHH
What a jackass. DDD and HHH have been fully specified >>>>>>>>>>>>> for many months.
They are specified in a way that makes your "every DDD" and "any DDD"
bad (perhaps even incorrect) use of Common language.
I specify the infinite sets with each element numbered
on the top of page 2 of my paper. Back in April of 2023
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub repository.
Should I assume that you must be lying about
this because you did not quote where I did this?
No, you may assume that I was confused by your lack of clarity and >>>>>>>> in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH that you have >>>>>>>> in your GitHub repository then I needn't to consider the possiblity >>>>>>>> that you just triying to deceive by equivcation.
HHH is one concrete example of an infinite set of instances
such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH, contradicting your
earlier statement that HHH is a generic term for every member of some >>>>>> set.
You seem to be a damned liar: "infinite set of instances"
You mean you lied when you said "one concrete example"?
One element of an infinite set does not say there
is no infinite set. Is says there is an infinite set.
True but irrelevant.
The behavior of one element of that infinite set proves
that every element of that infinite set has the same property:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:You mean you lied when you said "one concrete example"?
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not >>>>>>>>>>>>>>>>>>>> correct. The subject lineWhat a jackass. DDD and HHH have been fully specified >>>>>>>>>>>>>>>>>>> for many months.
does not specify which mapping and there is no >>>>>>>>>>>>>>>>>>>> larger context that could
specify that. Therefore it should be "a mapping". >>>>>>>>>>>>>>>>>>>>
On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
void DDD()Because it cannot reach the instructions before tha >>>>>>>>>>>>>>>>>>>> return.
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>>>>>>>>>>>> [00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N >>>>>>>>>>>>>>>>>>>>> to infinity number of steps of DDD cannot possibly >>>>>>>>>>>>>>>>>>>>> reach its "return" instruction final halt state. >>>>>>>>>>>>>>>>>>>>
Because it cannot reach the instruction after the >>>>>>>>>>>>>>>>>>>> HHH call.
Because it cannot reach return instruction of HHH. >>>>>>>>>>>>>>>>>>>>
This applies to every DDD emulated by any HHH no >>>>>>>>>>>>>>>>>>>>> matter the recursive depth of emulation. Thus it is >>>>>>>>>>>>>>>>>>>>> a verified fact that the input to HHH never halts. >>>>>>>>>>>>>>>>>>>>That is too vague to be regareded true or false. It >>>>>>>>>>>>>>>>>>>> is perfectly possibe
to define two programs and call them DDD and HHH >>>>>>>>>>>>>>>>>>>
They are specified in a way that makes your "every >>>>>>>>>>>>>>>>>> DDD" and "any DDD"
bad (perhaps even incorrect) use of Common language. >>>>>>>>>>>>>>>>>>
I specify the infinite sets with each element numbered >>>>>>>>>>>>>>>>> on the top of page 2 of my paper. Back in April of 2023 >>>>>>>>>>>>>>>>>
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your >>>>>>>>>>>>>>>> GitHub repository.
Should I assume that you must be lying about
this because you did not quote where I did this?
No, you may assume that I was confused by your lack of >>>>>>>>>>>>>> clarity and
in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH that >>>>>>>>>>>>>> you have
in your GitHub repository then I needn't to consider the >>>>>>>>>>>>>> possiblity
that you just triying to deceive by equivcation.
HHH is one concrete example of an infinite set of instances >>>>>>>>>>>>> such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH, contradicting >>>>>>>>>>>> your
earlier statement that HHH is a generic term for every >>>>>>>>>>>> member of some
set.
You seem to be a damned liar: "infinite set of instances" >>>>>>>>>>
One element of an infinite set does not say there
is no infinite set. Is says there is an infinite set.
But one element of an infinite set is not the infinite set.
You are just showing that your logic is based on proven
incorrect set theory.
IF HHH is an ELEMENT of the set, then it is that one element for >>>>>>>> the entire evaluation,
Liar:
A proof by induction consists of two cases. The first, the base
case,
proves the statement for n=0 without assuming any knowledge of
other cases. The second case, the induction step, proves that if the >>>>>>> statement holds for any given case n=k, then it must also hold for >>>>>>> the next case n=k+1. These two steps establish that the statement >>>>>>> holds for every natural number n. The base case does not necessarily >>>>>>> begin with n=0, but often with n=1, and possibly with any fixed
natural
number n=N, establishing the truth of the statement for all natural >>>>>>> numbers n ≥ N.
https://en.wikipedia.org/wiki/Mathematical_induction
And when have you ever provided such a proof for your statement?
NOWHERE
Your problem is you don't even have a logical basis to express
your statements in, so you can't do an induction on them.
So, you are just demonstrating that your "logic" is based on the
meaningless use of buzzwords that you don't understand, but can
parrot their unlearned meaning, but have no idea how to actually use.
*As you already admitted below*
when N steps of DDD are emulated by HHH
DDD cannot reach past its call to HHH (statement)
But that was for the DDD that INCLUDED HHH as part of it, which you
have now made clear is NOT what you consider DDD to be. And for that
case DDD[n] calls HHH[n] (where HHH[n] is the version of HHH that
does only n steps of emulation) and while we can say that
HHH[n[ does not emulate DDD[n] to its final state, that property is
NOT a property of of DDD[n], but of HHH[n] and DDD[n] as its input.
That every DDD[n] calls its HHH[n] in recursive emulation
conclusively proves that no DDD[n] emulated by HHH[n] halts,
thus each HHH[n] is correct to reject its input as non halting.
But every HHH[n] aborts its emulaton and returns, and thus DDD[n]
halts, and thus HHH is INCORRECT to call its input non-halting.
*You are a stupid liar*
You know that halting means reaching a final state and you
know that no input to HHH can possibly reach its final state.
So you aren't just a liar, you are a stupid one.
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:You mean you lied when you said "one concrete example"?
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:No, you may assume that I was confused by your lack of >>>>>>>>>>>>>>> clarity and
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not >>>>>>>>>>>>>>>>>>>>> correct. The subject lineWhat a jackass. DDD and HHH have been fully specified >>>>>>>>>>>>>>>>>>>> for many months.
does not specify which mapping and there is no >>>>>>>>>>>>>>>>>>>>> larger context that could
specify that. Therefore it should be "a mapping". >>>>>>>>>>>>>>>>>>>>>
On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>
void DDD()Because it cannot reach the instructions before tha >>>>>>>>>>>>>>>>>>>>> return.
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>> [00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N >>>>>>>>>>>>>>>>>>>>>> to infinity number of steps of DDD cannot possibly >>>>>>>>>>>>>>>>>>>>>> reach its "return" instruction final halt state. >>>>>>>>>>>>>>>>>>>>>
Because it cannot reach the instruction after the >>>>>>>>>>>>>>>>>>>>> HHH call.
Because it cannot reach return instruction of HHH. >>>>>>>>>>>>>>>>>>>>>
This applies to every DDD emulated by any HHH no >>>>>>>>>>>>>>>>>>>>>> matter the recursive depth of emulation. Thus it is >>>>>>>>>>>>>>>>>>>>>> a verified fact that the input to HHH never halts. >>>>>>>>>>>>>>>>>>>>>That is too vague to be regareded true or false. It >>>>>>>>>>>>>>>>>>>>> is perfectly possibe
to define two programs and call them DDD and HHH >>>>>>>>>>>>>>>>>>>>
They are specified in a way that makes your "every >>>>>>>>>>>>>>>>>>> DDD" and "any DDD"
bad (perhaps even incorrect) use of Common language. >>>>>>>>>>>>>>>>>>>
I specify the infinite sets with each element numbered >>>>>>>>>>>>>>>>>> on the top of page 2 of my paper. Back in April of 2023 >>>>>>>>>>>>>>>>>>
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your >>>>>>>>>>>>>>>>> GitHub repository.
Should I assume that you must be lying about
this because you did not quote where I did this? >>>>>>>>>>>>>>>
in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH >>>>>>>>>>>>>>> that you have
in your GitHub repository then I needn't to consider the >>>>>>>>>>>>>>> possiblity
that you just triying to deceive by equivcation. >>>>>>>>>>>>>>>
HHH is one concrete example of an infinite set of instances >>>>>>>>>>>>>> such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH,
contradicting your
earlier statement that HHH is a generic term for every >>>>>>>>>>>>> member of some
set.
You seem to be a damned liar: "infinite set of instances" >>>>>>>>>>>
One element of an infinite set does not say there
is no infinite set. Is says there is an infinite set.
But one element of an infinite set is not the infinite set.
You are just showing that your logic is based on proven
incorrect set theory.
IF HHH is an ELEMENT of the set, then it is that one element >>>>>>>>> for the entire evaluation,
Liar:
A proof by induction consists of two cases. The first, the base >>>>>>>> case,
proves the statement for n=0 without assuming any knowledge of >>>>>>>> other cases. The second case, the induction step, proves that if >>>>>>>> the
statement holds for any given case n=k, then it must also hold for >>>>>>>> the next case n=k+1. These two steps establish that the statement >>>>>>>> holds for every natural number n. The base case does not
necessarily
begin with n=0, but often with n=1, and possibly with any fixed >>>>>>>> natural
number n=N, establishing the truth of the statement for all natural >>>>>>>> numbers n ≥ N.
https://en.wikipedia.org/wiki/Mathematical_induction
And when have you ever provided such a proof for your statement? >>>>>>>
NOWHERE
Your problem is you don't even have a logical basis to express
your statements in, so you can't do an induction on them.
So, you are just demonstrating that your "logic" is based on the
meaningless use of buzzwords that you don't understand, but can
parrot their unlearned meaning, but have no idea how to actually use. >>>>>
*As you already admitted below*
when N steps of DDD are emulated by HHH
DDD cannot reach past its call to HHH (statement)
But that was for the DDD that INCLUDED HHH as part of it, which you
have now made clear is NOT what you consider DDD to be. And for
that case DDD[n] calls HHH[n] (where HHH[n] is the version of HHH
that does only n steps of emulation) and while we can say that
HHH[n[ does not emulate DDD[n] to its final state, that property is
NOT a property of of DDD[n], but of HHH[n] and DDD[n] as its input.
That every DDD[n] calls its HHH[n] in recursive emulation
conclusively proves that no DDD[n] emulated by HHH[n] halts,
thus each HHH[n] is correct to reject its input as non halting.
But every HHH[n] aborts its emulaton and returns, and thus DDD[n]
halts, and thus HHH is INCORRECT to call its input non-halting.
*You are a stupid liar*
You know that halting means reaching a final state and you
know that no input to HHH can possibly reach its final state.
So you aren't just a liar, you are a stupid one.
And you should know that "Halting" is a property of Turing Machines / Computations / Progrzms / completely defined function and the like ONLY.
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:You mean you lied when you said "one concrete example"? >>>>>>>>>>>>
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:No, you may assume that I was confused by your lack of clarity and
On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> The "the mapping" on the subject line is not correct. The subject line
does not specify which mapping and there is no larger context that couldWhat a jackass. DDD and HHH have been fully specified >>>>>>>>>>>>>>>>>>>>> for many months.
specify that. Therefore it should be "a mapping". >>>>>>>>>>>>>>>>>>>>>>
On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>
void DDD()Because it cannot reach the instructions before tha return.
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>>>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> [00002183] c3 ret >>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N >>>>>>>>>>>>>>>>>>>>>>> to infinity number of steps of DDD cannot possibly >>>>>>>>>>>>>>>>>>>>>>> reach its "return" instruction final halt state. >>>>>>>>>>>>>>>>>>>>>>
Because it cannot reach the instruction after the HHH call.
Because it cannot reach return instruction of HHH. >>>>>>>>>>>>>>>>>>>>>>
This applies to every DDD emulated by any HHH no >>>>>>>>>>>>>>>>>>>>>>> matter the recursive depth of emulation. Thus it is >>>>>>>>>>>>>>>>>>>>>>> a verified fact that the input to HHH never halts. >>>>>>>>>>>>>>>>>>>>>>That is too vague to be regareded true or false. It is perfectly possibe
to define two programs and call them DDD and HHH >>>>>>>>>>>>>>>>>>>>>
They are specified in a way that makes your "every DDD" and "any DDD"
bad (perhaps even incorrect) use of Common language. >>>>>>>>>>>>>>>>>>>>
I specify the infinite sets with each element numbered >>>>>>>>>>>>>>>>>>> on the top of page 2 of my paper. Back in April of 2023 >>>>>>>>>>>>>>>>>>>
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub repository.
Should I assume that you must be lying about >>>>>>>>>>>>>>>>> this because you did not quote where I did this? >>>>>>>>>>>>>>>>
in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH that you have
in your GitHub repository then I needn't to consider the possiblity
that you just triying to deceive by equivcation. >>>>>>>>>>>>>>>>
HHH is one concrete example of an infinite set of instances >>>>>>>>>>>>>>> such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH, contradicting your
earlier statement that HHH is a generic term for every member of some
set.
You seem to be a damned liar: "infinite set of instances" >>>>>>>>>>>>
One element of an infinite set does not say there
is no infinite set. Is says there is an infinite set.
But one element of an infinite set is not the infinite set. >>>>>>>>>>
You are just showing that your logic is based on proven incorrect set theory.
IF HHH is an ELEMENT of the set, then it is that one element for the >>>>>>>>>> entire evaluation,
Liar:
A proof by induction consists of two cases. The first, the base case, >>>>>>>>> proves the statement for n=0 without assuming any knowledge of >>>>>>>>> other cases. The second case, the induction step, proves that if the >>>>>>>>> statement holds for any given case n=k, then it must also hold for >>>>>>>>> the next case n=k+1. These two steps establish that the statement >>>>>>>>> holds for every natural number n. The base case does not necessarily >>>>>>>>> begin with n=0, but often with n=1, and possibly with any fixed natural
number n=N, establishing the truth of the statement for all natural >>>>>>>>> numbers n ≥ N.
https://en.wikipedia.org/wiki/Mathematical_induction
And when have you ever provided such a proof for your statement? >>>>>>>>
NOWHERE
Your problem is you don't even have a logical basis to express your >>>>>>>> statements in, so you can't do an induction on them.
So, you are just demonstrating that your "logic" is based on the
meaningless use of buzzwords that you don't understand, but can parrot >>>>>> their unlearned meaning, but have no idea how to actually use.
*As you already admitted below*
when N steps of DDD are emulated by HHH
DDD cannot reach past its call to HHH (statement)
But that was for the DDD that INCLUDED HHH as part of it, which you >>>>>> have now made clear is NOT what you consider DDD to be. And for that >>>>>> case DDD[n] calls HHH[n] (where HHH[n] is the version of HHH that does >>>>>> only n steps of emulation) and while we can say that HHH[n[ does not >>>>>> emulate DDD[n] to its final state, that property is NOT a property of >>>>>> of DDD[n], but of HHH[n] and DDD[n] as its input.
That every DDD[n] calls its HHH[n] in recursive emulation
conclusively proves that no DDD[n] emulated by HHH[n] halts,
thus each HHH[n] is correct to reject its input as non halting.
But every HHH[n] aborts its emulaton and returns, and thus DDD[n]
halts, and thus HHH is INCORRECT to call its input non-halting.
*You are a stupid liar*
You know that halting means reaching a final state and you
know that no input to HHH can possibly reach its final state.
So you aren't just a liar, you are a stupid one.
And you should know that "Halting" is a property of Turing Machines /
Computations / Progrzms / completely defined function and the like ONLY.
I have already proved that halting is a property of C functions.
You are not stupid, and you have good knowledge yet you do lie
stupidly.
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:
On 11/23/24 11:54 AM, olcott wrote:That every DDD[n] calls its HHH[n] in recursive emulation
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:You mean you lied when you said "one concrete example"? >>>>>>>>>>>>
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:No, you may assume that I was confused by your lack of >>>>>>>>>>>>>>>> clarity and
On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> The "the mapping" on the subject line is not >>>>>>>>>>>>>>>>>>>>>> correct. The subject line
does not specify which mapping and there is no >>>>>>>>>>>>>>>>>>>>>> larger context that couldWhat a jackass. DDD and HHH have been fully specified >>>>>>>>>>>>>>>>>>>>> for many months.
specify that. Therefore it should be "a mapping". >>>>>>>>>>>>>>>>>>>>>>
On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>
void DDD()Because it cannot reach the instructions before tha >>>>>>>>>>>>>>>>>>>>>> return.
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>>>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>> [00002183] c3 ret >>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N >>>>>>>>>>>>>>>>>>>>>>> to infinity number of steps of DDD cannot possibly >>>>>>>>>>>>>>>>>>>>>>> reach its "return" instruction final halt state. >>>>>>>>>>>>>>>>>>>>>>
Because it cannot reach the instruction after the >>>>>>>>>>>>>>>>>>>>>> HHH call.
Because it cannot reach return instruction of HHH. >>>>>>>>>>>>>>>>>>>>>>
This applies to every DDD emulated by any HHH no >>>>>>>>>>>>>>>>>>>>>>> matter the recursive depth of emulation. Thus it is >>>>>>>>>>>>>>>>>>>>>>> a verified fact that the input to HHH never halts. >>>>>>>>>>>>>>>>>>>>>>That is too vague to be regareded true or false. It >>>>>>>>>>>>>>>>>>>>>> is perfectly possibe
to define two programs and call them DDD and HHH >>>>>>>>>>>>>>>>>>>>>
They are specified in a way that makes your "every >>>>>>>>>>>>>>>>>>>> DDD" and "any DDD"
bad (perhaps even incorrect) use of Common language. >>>>>>>>>>>>>>>>>>>>
I specify the infinite sets with each element numbered >>>>>>>>>>>>>>>>>>> on the top of page 2 of my paper. Back in April of 2023 >>>>>>>>>>>>>>>>>>>
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your >>>>>>>>>>>>>>>>>> GitHub repository.
Should I assume that you must be lying about >>>>>>>>>>>>>>>>> this because you did not quote where I did this? >>>>>>>>>>>>>>>>
in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH >>>>>>>>>>>>>>>> that you have
in your GitHub repository then I needn't to consider the >>>>>>>>>>>>>>>> possiblity
that you just triying to deceive by equivcation. >>>>>>>>>>>>>>>>
HHH is one concrete example of an infinite set of instances >>>>>>>>>>>>>>> such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH,
contradicting your
earlier statement that HHH is a generic term for every >>>>>>>>>>>>>> member of some
set.
You seem to be a damned liar: "infinite set of instances" >>>>>>>>>>>>
One element of an infinite set does not say there
is no infinite set. Is says there is an infinite set.
But one element of an infinite set is not the infinite set. >>>>>>>>>>
You are just showing that your logic is based on proven
incorrect set theory.
IF HHH is an ELEMENT of the set, then it is that one element >>>>>>>>>> for the entire evaluation,
Liar:
A proof by induction consists of two cases. The first, the base >>>>>>>>> case,
proves the statement for n=0 without assuming any knowledge of >>>>>>>>> other cases. The second case, the induction step, proves that if >>>>>>>>> the
statement holds for any given case n=k, then it must also hold for >>>>>>>>> the next case n=k+1. These two steps establish that the statement >>>>>>>>> holds for every natural number n. The base case does not
necessarily
begin with n=0, but often with n=1, and possibly with any fixed >>>>>>>>> natural
number n=N, establishing the truth of the statement for all natural >>>>>>>>> numbers n ≥ N.
https://en.wikipedia.org/wiki/Mathematical_induction
And when have you ever provided such a proof for your statement? >>>>>>>>
NOWHERE
Your problem is you don't even have a logical basis to express >>>>>>>> your statements in, so you can't do an induction on them.
So, you are just demonstrating that your "logic" is based on the
meaningless use of buzzwords that you don't understand, but can
parrot their unlearned meaning, but have no idea how to actually use. >>>>>>
*As you already admitted below*
when N steps of DDD are emulated by HHH
DDD cannot reach past its call to HHH (statement)
But that was for the DDD that INCLUDED HHH as part of it, which you >>>>>> have now made clear is NOT what you consider DDD to be. And for
that case DDD[n] calls HHH[n] (where HHH[n] is the version of HHH
that does only n steps of emulation) and while we can say that
HHH[n[ does not emulate DDD[n] to its final state, that property is >>>>>> NOT a property of of DDD[n], but of HHH[n] and DDD[n] as its input. >>>>>
conclusively proves that no DDD[n] emulated by HHH[n] halts,
thus each HHH[n] is correct to reject its input as non halting.
But every HHH[n] aborts its emulaton and returns, and thus DDD[n]
halts, and thus HHH is INCORRECT to call its input non-halting.
*You are a stupid liar*
You know that halting means reaching a final state and you
know that no input to HHH can possibly reach its final state.
So you aren't just a liar, you are a stupid one.
And you should know that "Halting" is a property of Turing Machines /
Computations / Progrzms / completely defined function and the like ONLY.
I have already proved that halting is a property of C functions.
You are not stupid, and you have good knowledge yet you do lie
stupidly.
On 11/27/2024 6:14 AM, Richard Damon wrote:
olcott <[email protected]> wrote:
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:
On 11/23/24 11:54 AM, olcott wrote:That every DDD[n] calls its HHH[n] in recursive emulation
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:You mean you lied when you said "one concrete example"? >>>>>>>>>>>>>>
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 11/20/2024 3:53 AM, Mikko wrote:No, you may assume that I was confused by your lack of >>>>>>>>>>>>>>>>>> clarity and
On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>
On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> The "the mapping" on the subject line is not >>>>>>>>>>>>>>>>>>>>>>>> correct. The subject line
does not specify which mapping and there is no >>>>>>>>>>>>>>>>>>>>>>>> larger context that couldWhat a jackass. DDD and HHH have been fully >>>>>>>>>>>>>>>>>>>>>>> specified
specify that. Therefore it should be "a mapping". >>>>>>>>>>>>>>>>>>>>>>>>
On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>
void DDD()Because it cannot reach the instructions before tha >>>>>>>>>>>>>>>>>>>>>>>> return.
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>>>>>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call >>>>>>>>>>>>>>>>>>>>>>>>> HHH(DDD)
[0000217f] 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>> [00002183] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by any encoding of HHH that >>>>>>>>>>>>>>>>>>>>>>>>> emulates N
to infinity number of steps of DDD cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>> reach its "return" instruction final halt state. >>>>>>>>>>>>>>>>>>>>>>>>
Because it cannot reach the instruction after the >>>>>>>>>>>>>>>>>>>>>>>> HHH call.
Because it cannot reach return instruction of HHH. >>>>>>>>>>>>>>>>>>>>>>>>
This applies to every DDD emulated by any HHH no >>>>>>>>>>>>>>>>>>>>>>>>> matter the recursive depth of emulation. Thus >>>>>>>>>>>>>>>>>>>>>>>>> it isThat is too vague to be regareded true or false. It >>>>>>>>>>>>>>>>>>>>>>>> is perfectly possibe
a verified fact that the input to HHH never halts. >>>>>>>>>>>>>>>>>>>>>>>>
to define two programs and call them DDD and HHH >>>>>>>>>>>>>>>>>>>>>>>
for many months.
They are specified in a way that makes your "every >>>>>>>>>>>>>>>>>>>>>> DDD" and "any DDD"
bad (perhaps even incorrect) use of Common language. >>>>>>>>>>>>>>>>>>>>>>
I specify the infinite sets with each element numbered >>>>>>>>>>>>>>>>>>>>> on the top of page 2 of my paper. Back in April of >>>>>>>>>>>>>>>>>>>>> 2023
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your >>>>>>>>>>>>>>>>>>>> GitHub repository.
Should I assume that you must be lying about >>>>>>>>>>>>>>>>>>> this because you did not quote where I did this? >>>>>>>>>>>>>>>>>>
in particular by your bad choice of names. >>>>>>>>>>>>>>>>>>
If you clearly state that HHH is not the function HHH >>>>>>>>>>>>>>>>>> that you have
in your GitHub repository then I needn't to consider the >>>>>>>>>>>>>>>>>> possiblity
that you just triying to deceive by equivcation. >>>>>>>>>>>>>>>>>>
HHH is one concrete example of an infinite set of >>>>>>>>>>>>>>>>> instances
such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH, >>>>>>>>>>>>>>>> contradicting your
earlier statement that HHH is a generic term for every >>>>>>>>>>>>>>>> member of some
set.
You seem to be a damned liar: "infinite set of instances" >>>>>>>>>>>>>>
One element of an infinite set does not say there
is no infinite set. Is says there is an infinite set. >>>>>>>>>>>>>
But one element of an infinite set is not the infinite set. >>>>>>>>>>>>
You are just showing that your logic is based on proven >>>>>>>>>>>> incorrect set theory.
IF HHH is an ELEMENT of the set, then it is that one element >>>>>>>>>>>> for the entire evaluation,
Liar:
A proof by induction consists of two cases. The first, the base >>>>>>>>>>> case,
proves the statement for n=0 without assuming any knowledge of >>>>>>>>>>> other cases. The second case, the induction step, proves that if >>>>>>>>>>> the
statement holds for any given case n=k, then it must also >>>>>>>>>>> hold for
the next case n=k+1. These two steps establish that the
statement
holds for every natural number n. The base case does not >>>>>>>>>>> necessarily
begin with n=0, but often with n=1, and possibly with any fixed >>>>>>>>>>> natural
number n=N, establishing the truth of the statement for all >>>>>>>>>>> natural
numbers n ≥ N.
https://en.wikipedia.org/wiki/Mathematical_induction
And when have you ever provided such a proof for your statement? >>>>>>>>>>
NOWHERE
Your problem is you don't even have a logical basis to express >>>>>>>>>> your statements in, so you can't do an induction on them.
So, you are just demonstrating that your "logic" is based on the >>>>>>>> meaningless use of buzzwords that you don't understand, but can >>>>>>>> parrot their unlearned meaning, but have no idea how to actually >>>>>>>> use.
*As you already admitted below*
when N steps of DDD are emulated by HHH
DDD cannot reach past its call to HHH (statement)
But that was for the DDD that INCLUDED HHH as part of it, which you >>>>>>>> have now made clear is NOT what you consider DDD to be. And for >>>>>>>> that case DDD[n] calls HHH[n] (where HHH[n] is the version of HHH >>>>>>>> that does only n steps of emulation) and while we can say that >>>>>>>> HHH[n[ does not emulate DDD[n] to its final state, that property is >>>>>>>> NOT a property of of DDD[n], but of HHH[n] and DDD[n] as its input. >>>>>>>
conclusively proves that no DDD[n] emulated by HHH[n] halts,
thus each HHH[n] is correct to reject its input as non halting.
But every HHH[n] aborts its emulaton and returns, and thus DDD[n]
halts, and thus HHH is INCORRECT to call its input non-halting.
*You are a stupid liar*
You know that halting means reaching a final state and you
know that no input to HHH can possibly reach its final state.
So you aren't just a liar, you are a stupid one.
And you should know that "Halting" is a property of Turing Machines /
Computations / Progrzms / completely defined function and the like
ONLY.
I have already proved that halting is a property of C functions.
You are not stupid, and you have good knowledge yet you do lie
stupidly.
WHERE?
You pointed to a reference that talks about LEAF C-functions as having
that
property.
Since you have made it clear that the description of the input DDD
does NOT
include the code of HHH,
Because HHH emulates DDD the call to HHH(DDD) from DDD
never returns thus DDD never reaches its final halt state.
It is not that hard as soon as you get out of rebuttal
mode and get into honest dialogue mode.
On 11/27/2024 8:03 AM, Richard Damon wrote:
On 11/27/24 8:28 AM, olcott wrote:
On 11/27/2024 6:14 AM, Richard Damon wrote:
olcott <[email protected]> wrote:
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:But every HHH[n] aborts its emulaton and returns, and thus DDD[n] >>>>>>>> halts, and thus HHH is INCORRECT to call its input non-halting. >>>>>>>>
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:You mean you lied when you said "one concrete example"? >>>>>>>>>>>>>>>>
On 2024-11-21 15:32:38 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 11/21/2024 3:12 AM, Mikko wrote:That sentence says that there is only one HHH, >>>>>>>>>>>>>>>>>> contradicting your
On 2024-11-20 22:03:43 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>No, you may assume that I was confused by your lack of >>>>>>>>>>>>>>>>>>>> clarity and
On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>
On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> The "the mapping" on the subject line is not >>>>>>>>>>>>>>>>>>>>>>>>>> correct. The subject line
does not specify which mapping and there is no >>>>>>>>>>>>>>>>>>>>>>>>>> larger context that couldWhat a jackass. DDD and HHH have been fully >>>>>>>>>>>>>>>>>>>>>>>>> specified
specify that. Therefore it should be "a mapping". >>>>>>>>>>>>>>>>>>>>>>>>>>
On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>
void DDD()Because it cannot reach the instructions >>>>>>>>>>>>>>>>>>>>>>>>>> before tha
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; >>>>>>>>>>>>>>>>>>>>>>>>>>> housekeeping
[00002173] 8bec mov ebp,esp ; >>>>>>>>>>>>>>>>>>>>>>>>>>> housekeeping
[00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>>>>>>>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call >>>>>>>>>>>>>>>>>>>>>>>>>>> HHH(DDD)
[0000217f] 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>>>> [00002183] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by any encoding of HHH that >>>>>>>>>>>>>>>>>>>>>>>>>>> emulates N
to infinity number of steps of DDD cannot >>>>>>>>>>>>>>>>>>>>>>>>>>> possibly
reach its "return" instruction final halt state. >>>>>>>>>>>>>>>>>>>>>>>>>>
return.
Because it cannot reach the instruction after the >>>>>>>>>>>>>>>>>>>>>>>>>> HHH call.
Because it cannot reach return instruction of >>>>>>>>>>>>>>>>>>>>>>>>>> HHH.
This applies to every DDD emulated by any HHH no >>>>>>>>>>>>>>>>>>>>>>>>>>> matter the recursive depth of emulation. Thus >>>>>>>>>>>>>>>>>>>>>>>>>>> it is
a verified fact that the input to HHH never >>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
That is too vague to be regareded true or >>>>>>>>>>>>>>>>>>>>>>>>>> false. It
is perfectly possibe
to define two programs and call them DDD and HHH >>>>>>>>>>>>>>>>>>>>>>>>>
for many months.
They are specified in a way that makes your "every >>>>>>>>>>>>>>>>>>>>>>>> DDD" and "any DDD"
bad (perhaps even incorrect) use of Common >>>>>>>>>>>>>>>>>>>>>>>> language.
I specify the infinite sets with each element >>>>>>>>>>>>>>>>>>>>>>> numbered
on the top of page 2 of my paper. Back in April >>>>>>>>>>>>>>>>>>>>>>> of 2023
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in >>>>>>>>>>>>>>>>>>>>>> your
GitHub repository.
Should I assume that you must be lying about >>>>>>>>>>>>>>>>>>>>> this because you did not quote where I did this? >>>>>>>>>>>>>>>>>>>>
in particular by your bad choice of names. >>>>>>>>>>>>>>>>>>>>
If you clearly state that HHH is not the function HHH >>>>>>>>>>>>>>>>>>>> that you have
in your GitHub repository then I needn't to consider >>>>>>>>>>>>>>>>>>>> the
possiblity
that you just triying to deceive by equivcation. >>>>>>>>>>>>>>>>>>>>
HHH is one concrete example of an infinite set of >>>>>>>>>>>>>>>>>>> instances
such that DDD is emulated by HHH N times. >>>>>>>>>>>>>>>>>>
earlier statement that HHH is a generic term for every >>>>>>>>>>>>>>>>>> member of some
set.
You seem to be a damned liar: "infinite set of instances" >>>>>>>>>>>>>>>>
One element of an infinite set does not say there >>>>>>>>>>>>>>> is no infinite set. Is says there is an infinite set. >>>>>>>>>>>>>>>
But one element of an infinite set is not the infinite set. >>>>>>>>>>>>>>
You are just showing that your logic is based on proven >>>>>>>>>>>>>> incorrect set theory.
IF HHH is an ELEMENT of the set, then it is that one element >>>>>>>>>>>>>> for the entire evaluation,
Liar:
A proof by induction consists of two cases. The first, the >>>>>>>>>>>>> base
case,
proves the statement for n=0 without assuming any knowledge of >>>>>>>>>>>>> other cases. The second case, the induction step, proves >>>>>>>>>>>>> that if
the
statement holds for any given case n=k, then it must also >>>>>>>>>>>>> hold for
the next case n=k+1. These two steps establish that the >>>>>>>>>>>>> statement
holds for every natural number n. The base case does not >>>>>>>>>>>>> necessarily
begin with n=0, but often with n=1, and possibly with any >>>>>>>>>>>>> fixed
natural
number n=N, establishing the truth of the statement for all >>>>>>>>>>>>> natural
numbers n ≥ N.
https://en.wikipedia.org/wiki/Mathematical_induction >>>>>>>>>>>>>
And when have you ever provided such a proof for your
statement?
NOWHERE
Your problem is you don't even have a logical basis to express >>>>>>>>>>>> your statements in, so you can't do an induction on them. >>>>>>>>>>>>
So, you are just demonstrating that your "logic" is based on the >>>>>>>>>> meaningless use of buzzwords that you don't understand, but can >>>>>>>>>> parrot their unlearned meaning, but have no idea how to
actually use.
*As you already admitted below*
when N steps of DDD are emulated by HHH
DDD cannot reach past its call to HHH (statement)
But that was for the DDD that INCLUDED HHH as part of it,
which you
have now made clear is NOT what you consider DDD to be. And for >>>>>>>>>> that case DDD[n] calls HHH[n] (where HHH[n] is the version of HHH >>>>>>>>>> that does only n steps of emulation) and while we can say that >>>>>>>>>> HHH[n[ does not emulate DDD[n] to its final state, that
property is
NOT a property of of DDD[n], but of HHH[n] and DDD[n] as its >>>>>>>>>> input.
That every DDD[n] calls its HHH[n] in recursive emulation
conclusively proves that no DDD[n] emulated by HHH[n] halts, >>>>>>>>> thus each HHH[n] is correct to reject its input as non halting. >>>>>>>>
*You are a stupid liar*
You know that halting means reaching a final state and you
know that no input to HHH can possibly reach its final state.
So you aren't just a liar, you are a stupid one.
And you should know that "Halting" is a property of Turing Machines / >>>>>> Computations / Progrzms / completely defined function and the like >>>>>> ONLY.
I have already proved that halting is a property of C functions.
You are not stupid, and you have good knowledge yet you do lie
stupidly.
WHERE?
You pointed to a reference that talks about LEAF C-functions as
having that
property.
Since you have made it clear that the description of the input DDD
does NOT
include the code of HHH,
Because HHH emulates DDD the call to HHH(DDD) from DDD
never returns thus DDD never reaches its final halt state.
It is not that hard as soon as you get out of rebuttal
mode and get into honest dialogue mode.
No, the call to HHH)(DDD) from DDD returns, because the definition of
When DDD is emulated by HHH and DDD calls HHH(DDD) this call
never returns.
Unless proton beam therapy prevents this my Right paracaval lymph
node will soon close off my superior vena cava (all blood flow to
the heart). This lymph node has been growing at a rate of 3.84%
per day for the 68 days between PET scans.
1.0384 ^ 90 = 29.7-fold increase every 90 days. The R2 cancer
treatment that I just started takes 90 days to begin to take effect.
On 11/27/2024 3:29 AM, Mikko wrote:
On 2024-11-27 04:34:55 +0000, olcott said:
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:You mean you lied when you said "one concrete example"? >>>>>>>>>>>>>>
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 11/20/2024 3:53 AM, Mikko wrote:No, you may assume that I was confused by your lack of clarity and
On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>
On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> The "the mapping" on the subject line is not correct. The subject line
does not specify which mapping and there is no larger context that couldWhat a jackass. DDD and HHH have been fully specified >>>>>>>>>>>>>>>>>>>>>>> for many months.
specify that. Therefore it should be "a mapping". >>>>>>>>>>>>>>>>>>>>>>>>
On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>
void DDD()Because it cannot reach the instructions before tha return.
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>>>>>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>> [00002183] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by any encoding of HHH that emulates N >>>>>>>>>>>>>>>>>>>>>>>>> to infinity number of steps of DDD cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>> reach its "return" instruction final halt state. >>>>>>>>>>>>>>>>>>>>>>>>
Because it cannot reach the instruction after the HHH call.
Because it cannot reach return instruction of HHH. >>>>>>>>>>>>>>>>>>>>>>>>
This applies to every DDD emulated by any HHH no >>>>>>>>>>>>>>>>>>>>>>>>> matter the recursive depth of emulation. Thus it is >>>>>>>>>>>>>>>>>>>>>>>>> a verified fact that the input to HHH never halts. >>>>>>>>>>>>>>>>>>>>>>>>That is too vague to be regareded true or false. It is perfectly possibe
to define two programs and call them DDD and HHH >>>>>>>>>>>>>>>>>>>>>>>
They are specified in a way that makes your "every DDD" and "any DDD"
bad (perhaps even incorrect) use of Common language. >>>>>>>>>>>>>>>>>>>>>>
I specify the infinite sets with each element numbered >>>>>>>>>>>>>>>>>>>>> on the top of page 2 of my paper. Back in April of 2023 >>>>>>>>>>>>>>>>>>>>>
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub repository.
Should I assume that you must be lying about >>>>>>>>>>>>>>>>>>> this because you did not quote where I did this? >>>>>>>>>>>>>>>>>>
in particular by your bad choice of names. >>>>>>>>>>>>>>>>>>
If you clearly state that HHH is not the function HHH that you have
in your GitHub repository then I needn't to consider the possiblity
that you just triying to deceive by equivcation. >>>>>>>>>>>>>>>>>>
HHH is one concrete example of an infinite set of instances >>>>>>>>>>>>>>>>> such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH, contradicting your
earlier statement that HHH is a generic term for every member of some
set.
You seem to be a damned liar: "infinite set of instances" >>>>>>>>>>>>>>
One element of an infinite set does not say there
is no infinite set. Is says there is an infinite set. >>>>>>>>>>>>>
But one element of an infinite set is not the infinite set. >>>>>>>>>>>>
You are just showing that your logic is based on proven incorrect set theory.
IF HHH is an ELEMENT of the set, then it is that one element for the
entire evaluation,
Liar:
A proof by induction consists of two cases. The first, the base case,
proves the statement for n=0 without assuming any knowledge of >>>>>>>>>>> other cases. The second case, the induction step, proves that if the
statement holds for any given case n=k, then it must also hold for >>>>>>>>>>> the next case n=k+1. These two steps establish that the statement >>>>>>>>>>> holds for every natural number n. The base case does not necessarily
begin with n=0, but often with n=1, and possibly with any fixed natural
number n=N, establishing the truth of the statement for all natural >>>>>>>>>>> numbers n ≥ N.
https://en.wikipedia.org/wiki/Mathematical_induction
And when have you ever provided such a proof for your statement? >>>>>>>>>>
NOWHERE
Your problem is you don't even have a logical basis to express your >>>>>>>>>> statements in, so you can't do an induction on them.
So, you are just demonstrating that your "logic" is based on the >>>>>>>> meaningless use of buzzwords that you don't understand, but can parrot >>>>>>>> their unlearned meaning, but have no idea how to actually use. >>>>>>>>
*As you already admitted below*
when N steps of DDD are emulated by HHH
DDD cannot reach past its call to HHH (statement)
But that was for the DDD that INCLUDED HHH as part of it, which you >>>>>>>> have now made clear is NOT what you consider DDD to be. And for that >>>>>>>> case DDD[n] calls HHH[n] (where HHH[n] is the version of HHH that does >>>>>>>> only n steps of emulation) and while we can say that HHH[n[ does not >>>>>>>> emulate DDD[n] to its final state, that property is NOT a property of >>>>>>>> of DDD[n], but of HHH[n] and DDD[n] as its input.
That every DDD[n] calls its HHH[n] in recursive emulation
conclusively proves that no DDD[n] emulated by HHH[n] halts,
thus each HHH[n] is correct to reject its input as non halting.
But every HHH[n] aborts its emulaton and returns, and thus DDD[n]
halts, and thus HHH is INCORRECT to call its input non-halting.
*You are a stupid liar*
You know that halting means reaching a final state and you
know that no input to HHH can possibly reach its final state.
So you aren't just a liar, you are a stupid one.
And you should know that "Halting" is a property of Turing Machines /
Computations / Progrzms / completely defined function and the like ONLY. >>>>
I have already proved that halting is a property of C functions.
You are not stupid, and you have good knowledge yet you do lie
stupidly.
So, does the function
void ABC (void) {
XYZ();
}
halt?
void DDD() {
HHH(DDD);
return;
}
https://github.com/plolcott/x86utm/blob/master/Halt7.c
I gave you the complete fully operational source code for
HHH and DDD quit being a JackAss.
We can also know that for every HHH that emulates N steps of DDD
that no DDD ever reaches its "return" instruction final halt state.
On 11/27/2024 8:03 AM, Richard Damon wrote:That's weird. Why can't HHH simulate itself?
On 11/27/24 8:28 AM, olcott wrote:
On 11/27/2024 6:14 AM, Richard Damon wrote:
olcott <[email protected]> wrote:
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:
On 2024-11-21 15:32:38 +0000, olcott said: >>>>>>>>>>>>>>>>>>> On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>> On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>> On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-17 18:36:17 +0000, olcott said:
When DDD is emulated by HHH and DDD calls HHH(DDD) this call never
returns.
On 11/27/2024 9:20 PM, Richard Damon wrote:
On 11/27/24 8:15 PM, olcott wrote:
On 11/27/2024 8:03 AM, Richard Damon wrote:
On 11/27/24 8:28 AM, olcott wrote:
On 11/27/2024 6:14 AM, Richard Damon wrote:
olcott <[email protected]> wrote:
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:But every HHH[n] aborts its emulaton and returns, and thus DDD[n] >>>>>>>>>> halts, and thus HHH is INCORRECT to call its input non-halting. >>>>>>>>>>
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 11/22/2024 2:30 AM, Mikko wrote:
On 2024-11-21 15:32:38 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 11/21/2024 3:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 22:03:43 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>That sentence says that there is only one HHH, >>>>>>>>>>>>>>>>>>>> contradicting your
On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>No, you may assume that I was confused by your >>>>>>>>>>>>>>>>>>>>>> lack of
On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>
On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> The "the mapping" on the subject line is not >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct. The subject line >>>>>>>>>>>>>>>>>>>>>>>>>>>> does not specify which mapping and there is no >>>>>>>>>>>>>>>>>>>>>>>>>>>> larger context that could >>>>>>>>>>>>>>>>>>>>>>>>>>>> specify that. Therefore it should be "a >>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping".
On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ;
housekeeping
[00002173] 8bec mov ebp,esp ; >>>>>>>>>>>>>>>>>>>>>>>>>>>>> housekeeping
[00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call >>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH(DDD)
[0000217f] 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00002183] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by any encoding of HHH that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulates N
to infinity number of steps of DDD cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly
reach its "return" instruction final halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
Because it cannot reach the instructions >>>>>>>>>>>>>>>>>>>>>>>>>>>> before tha
return.
Because it cannot reach the instruction >>>>>>>>>>>>>>>>>>>>>>>>>>>> after the
HHH call.
Because it cannot reach return instruction >>>>>>>>>>>>>>>>>>>>>>>>>>>> of HHH.
This applies to every DDD emulated by any >>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH no
matter the recursive depth of emulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus it is
a verified fact that the input to HHH never >>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
That is too vague to be regareded true or >>>>>>>>>>>>>>>>>>>>>>>>>>>> false. It
is perfectly possibe
to define two programs and call them DDD and >>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH
What a jackass. DDD and HHH have been fully >>>>>>>>>>>>>>>>>>>>>>>>>>> specified
for many months.
They are specified in a way that makes your >>>>>>>>>>>>>>>>>>>>>>>>>> "every
DDD" and "any DDD"
bad (perhaps even incorrect) use of Common >>>>>>>>>>>>>>>>>>>>>>>>>> language.
I specify the infinite sets with each element >>>>>>>>>>>>>>>>>>>>>>>>> numbered
on the top of page 2 of my paper. Back in April >>>>>>>>>>>>>>>>>>>>>>>>> of 2023
https://www.researchgate.net/ >>>>>>>>>>>>>>>>>>>>>>>>> publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program >>>>>>>>>>>>>>>>>>>>>>>> in your
GitHub repository.
Should I assume that you must be lying about >>>>>>>>>>>>>>>>>>>>>>> this because you did not quote where I did this? >>>>>>>>>>>>>>>>>>>>>>
clarity and
in particular by your bad choice of names. >>>>>>>>>>>>>>>>>>>>>>
If you clearly state that HHH is not the function HHH >>>>>>>>>>>>>>>>>>>>>> that you have
in your GitHub repository then I needn't to >>>>>>>>>>>>>>>>>>>>>> consider the
possiblity
that you just triying to deceive by equivcation. >>>>>>>>>>>>>>>>>>>>>>
HHH is one concrete example of an infinite set of >>>>>>>>>>>>>>>>>>>>> instances
such that DDD is emulated by HHH N times. >>>>>>>>>>>>>>>>>>>>
earlier statement that HHH is a generic term for every >>>>>>>>>>>>>>>>>>>> member of some
set.
You seem to be a damned liar: "infinite set of >>>>>>>>>>>>>>>>>>> instances"
You mean you lied when you said "one concrete example"? >>>>>>>>>>>>>>>>>>
One element of an infinite set does not say there >>>>>>>>>>>>>>>>> is no infinite set. Is says there is an infinite set. >>>>>>>>>>>>>>>>>
But one element of an infinite set is not the infinite set. >>>>>>>>>>>>>>>>
You are just showing that your logic is based on proven >>>>>>>>>>>>>>>> incorrect set theory.
IF HHH is an ELEMENT of the set, then it is that one >>>>>>>>>>>>>>>> element
for the entire evaluation,
Liar:
A proof by induction consists of two cases. The first, >>>>>>>>>>>>>>> the base
case,
proves the statement for n=0 without assuming any >>>>>>>>>>>>>>> knowledge of
other cases. The second case, the induction step, proves >>>>>>>>>>>>>>> that if
the
statement holds for any given case n=k, then it must also >>>>>>>>>>>>>>> hold for
the next case n=k+1. These two steps establish that the >>>>>>>>>>>>>>> statement
holds for every natural number n. The base case does not >>>>>>>>>>>>>>> necessarily
begin with n=0, but often with n=1, and possibly with any >>>>>>>>>>>>>>> fixed
natural
number n=N, establishing the truth of the statement for >>>>>>>>>>>>>>> all natural
numbers n ≥ N.
https://en.wikipedia.org/wiki/Mathematical_induction >>>>>>>>>>>>>>>
And when have you ever provided such a proof for your >>>>>>>>>>>>>> statement?
NOWHERE
Your problem is you don't even have a logical basis to >>>>>>>>>>>>>> express
your statements in, so you can't do an induction on them. >>>>>>>>>>>>>>
So, you are just demonstrating that your "logic" is based on >>>>>>>>>>>> the
meaningless use of buzzwords that you don't understand, but can >>>>>>>>>>>> parrot their unlearned meaning, but have no idea how to >>>>>>>>>>>> actually use.
*As you already admitted below*
when N steps of DDD are emulated by HHH
DDD cannot reach past its call to HHH (statement)
But that was for the DDD that INCLUDED HHH as part of it, >>>>>>>>>>>> which you
have now made clear is NOT what you consider DDD to be. And for >>>>>>>>>>>> that case DDD[n] calls HHH[n] (where HHH[n] is the version >>>>>>>>>>>> of HHH
that does only n steps of emulation) and while we can say that >>>>>>>>>>>> HHH[n[ does not emulate DDD[n] to its final state, that >>>>>>>>>>>> property is
NOT a property of of DDD[n], but of HHH[n] and DDD[n] as its >>>>>>>>>>>> input.
That every DDD[n] calls its HHH[n] in recursive emulation >>>>>>>>>>> conclusively proves that no DDD[n] emulated by HHH[n] halts, >>>>>>>>>>> thus each HHH[n] is correct to reject its input as non halting. >>>>>>>>>>
*You are a stupid liar*
You know that halting means reaching a final state and you
know that no input to HHH can possibly reach its final state. >>>>>>>>> So you aren't just a liar, you are a stupid one.
And you should know that "Halting" is a property of Turing
Machines /
Computations / Progrzms / completely defined function and the
like ONLY.
I have already proved that halting is a property of C functions. >>>>>>> You are not stupid, and you have good knowledge yet you do lie
stupidly.
WHERE?
You pointed to a reference that talks about LEAF C-functions as
having that
property.
Since you have made it clear that the description of the input DDD >>>>>> does NOT
include the code of HHH,
Because HHH emulates DDD the call to HHH(DDD) from DDD
never returns thus DDD never reaches its final halt state.
It is not that hard as soon as you get out of rebuttal
mode and get into honest dialogue mode.
No, the call to HHH)(DDD) from DDD returns, because the definition of
When DDD is emulated by HHH and DDD calls HHH(DDD) this call
never returns.
WRONG.
The *DEFINITION* of the behavor of a program is the unbounded
execution=/emulation of it.
Also, you CAN'T emulate the DDD that you have defined, that is, not
including the HHH that it calls,
You already admitted that when DDD is emulated by HHH
that the call from DDD to HHH(DDD) never returns.
On 11/22/2024 8:41 PM, Richard Damon wrote:
On 11/22/24 9:07 PM, olcott wrote:>
And, how many times will you just ignore that
the below input can not be emulated past the
call HHH instructioon.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
All this proves is that you are nothing but a damned liar that has
proven he doesn't know what he is talking about, but juts spouts of
words he just doesn't understand what they mean, but only know by a
rote memorization of the words without understanding their meaning in
context.
Unless proton beam therapy prevents this my Right paracaval lymph
node will soon close off my superior vena cava (all blood flow to
the heart). This lymph node has been growing at a rate of 3.84%
per day for the 68 days between PET scans.
1.0384 ^ 90 = 29.7-fold increase every 90 days. The R2 cancer
treatment that I just started takes 90 days to begin to take effect.
So, you don't have long to repent and try to repair your reputation.
You have done a good job of totally burying it with all the stupid
lies you have said, and your claims that you aren't lying just prove
your stupidity.
Sorry, you don't get to change the rules of the game, and is seems you
are about to have that proved to you.
I just figured out what could save me.
I simply have the dangerous Right paracaval lymph node
surgically removed before it gets much bigger and could
block off my inferior vena cava very much.
On 11/28/2024 6:50 AM, Richard Damon wrote:
On 11/28/24 5:16 AM, olcott wrote:
On 11/27/2024 9:20 PM, Richard Damon wrote:
On 11/27/24 8:15 PM, olcott wrote:
On 11/27/2024 8:03 AM, Richard Damon wrote:
On 11/27/24 8:28 AM, olcott wrote:When DDD is emulated by HHH and DDD calls HHH(DDD) this call
On 11/27/2024 6:14 AM, Richard Damon wrote:
olcott <[email protected]> wrote:
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 11/22/2024 2:30 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-11-21 15:32:38 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>
On 11/21/2024 3:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 22:03:43 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>That sentence says that there is only one HHH, >>>>>>>>>>>>>>>>>>>>>> contradicting your
On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>No, you may assume that I was confused by your >>>>>>>>>>>>>>>>>>>>>>>> lack of
On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>
On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The "the mapping" on the subject line is not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct. The subject line >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not specify which mapping and there >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is no
larger context that could >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify that. Therefore it should be "a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping".
On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void DDD()
{
HHH(DDD); >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;
}
_DDD()
[00002172] 55 push ebp ;
housekeeping
[00002173] 8bec mov ebp,esp ; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> housekeeping
[00002175] 6872210000 push 00002172 ; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push DDD
[0000217a] e853f4ffff call 000015d2 ; >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call HHH(DDD)
[0000217f] 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00002183] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by any encoding of HHH that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulates N
to infinity number of steps of DDD cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly
reach its "return" instruction final halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
Because it cannot reach the instructions >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before tha
return.
Because it cannot reach the instruction >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> after the
HHH call.
Because it cannot reach return instruction >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of HHH.
This applies to every DDD emulated by any >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH no
matter the recursive depth of emulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus it is
a verified fact that the input to HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
That is too vague to be regareded true or >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false. It
is perfectly possibe >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to define two programs and call them DDD >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and HHH
What a jackass. DDD and HHH have been fully >>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified
for many months.
They are specified in a way that makes your >>>>>>>>>>>>>>>>>>>>>>>>>>>> "every
DDD" and "any DDD"
bad (perhaps even incorrect) use of Common >>>>>>>>>>>>>>>>>>>>>>>>>>>> language.
I specify the infinite sets with each element >>>>>>>>>>>>>>>>>>>>>>>>>>> numbered
on the top of page 2 of my paper. Back in >>>>>>>>>>>>>>>>>>>>>>>>>>> April of 2023
https://www.researchgate.net/ >>>>>>>>>>>>>>>>>>>>>>>>>>> publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program >>>>>>>>>>>>>>>>>>>>>>>>>> in your
GitHub repository.
Should I assume that you must be lying about >>>>>>>>>>>>>>>>>>>>>>>>> this because you did not quote where I did this? >>>>>>>>>>>>>>>>>>>>>>>>
clarity and
in particular by your bad choice of names. >>>>>>>>>>>>>>>>>>>>>>>>
If you clearly state that HHH is not the >>>>>>>>>>>>>>>>>>>>>>>> function HHH
that you have
in your GitHub repository then I needn't to >>>>>>>>>>>>>>>>>>>>>>>> consider the
possiblity
that you just triying to deceive by equivcation. >>>>>>>>>>>>>>>>>>>>>>>>
HHH is one concrete example of an infinite set of >>>>>>>>>>>>>>>>>>>>>>> instances
such that DDD is emulated by HHH N times. >>>>>>>>>>>>>>>>>>>>>>
earlier statement that HHH is a generic term for >>>>>>>>>>>>>>>>>>>>>> every
member of some
set.
You seem to be a damned liar: "infinite set of >>>>>>>>>>>>>>>>>>>>> instances"
You mean you lied when you said "one concrete example"? >>>>>>>>>>>>>>>>>>>>
One element of an infinite set does not say there >>>>>>>>>>>>>>>>>>> is no infinite set. Is says there is an infinite set. >>>>>>>>>>>>>>>>>>>
But one element of an infinite set is not the infinite >>>>>>>>>>>>>>>>>> set.
You are just showing that your logic is based on proven >>>>>>>>>>>>>>>>>> incorrect set theory.
IF HHH is an ELEMENT of the set, then it is that one >>>>>>>>>>>>>>>>>> element
for the entire evaluation,
Liar:
A proof by induction consists of two cases. The first, >>>>>>>>>>>>>>>>> the base
case,
proves the statement for n=0 without assuming any >>>>>>>>>>>>>>>>> knowledge of
other cases. The second case, the induction step, >>>>>>>>>>>>>>>>> proves that if
the
statement holds for any given case n=k, then it must >>>>>>>>>>>>>>>>> also hold for
the next case n=k+1. These two steps establish that the >>>>>>>>>>>>>>>>> statement
holds for every natural number n. The base case does not >>>>>>>>>>>>>>>>> necessarily
begin with n=0, but often with n=1, and possibly with >>>>>>>>>>>>>>>>> any fixed
natural
number n=N, establishing the truth of the statement for >>>>>>>>>>>>>>>>> all natural
numbers n ≥ N.
https://en.wikipedia.org/wiki/Mathematical_induction >>>>>>>>>>>>>>>>>
And when have you ever provided such a proof for your >>>>>>>>>>>>>>>> statement?
NOWHERE
Your problem is you don't even have a logical basis to >>>>>>>>>>>>>>>> express
your statements in, so you can't do an induction on them. >>>>>>>>>>>>>>>>
So, you are just demonstrating that your "logic" is based >>>>>>>>>>>>>> on the
meaningless use of buzzwords that you don't understand, >>>>>>>>>>>>>> but can
parrot their unlearned meaning, but have no idea how to >>>>>>>>>>>>>> actually use.
But that was for the DDD that INCLUDED HHH as part of it, >>>>>>>>>>>>>> which you
*As you already admitted below*
when N steps of DDD are emulated by HHH
DDD cannot reach past its call to HHH (statement) >>>>>>>>>>>>>>
have now made clear is NOT what you consider DDD to be. >>>>>>>>>>>>>> And for
that case DDD[n] calls HHH[n] (where HHH[n] is the version >>>>>>>>>>>>>> of HHH
that does only n steps of emulation) and while we can say >>>>>>>>>>>>>> that
HHH[n[ does not emulate DDD[n] to its final state, that >>>>>>>>>>>>>> property is
NOT a property of of DDD[n], but of HHH[n] and DDD[n] as >>>>>>>>>>>>>> its input.
That every DDD[n] calls its HHH[n] in recursive emulation >>>>>>>>>>>>> conclusively proves that no DDD[n] emulated by HHH[n] halts, >>>>>>>>>>>>> thus each HHH[n] is correct to reject its input as non >>>>>>>>>>>>> halting.
But every HHH[n] aborts its emulaton and returns, and thus >>>>>>>>>>>> DDD[n]
halts, and thus HHH is INCORRECT to call its input non-halting. >>>>>>>>>>>>
*You are a stupid liar*
You know that halting means reaching a final state and you >>>>>>>>>>> know that no input to HHH can possibly reach its final state. >>>>>>>>>>> So you aren't just a liar, you are a stupid one.
And you should know that "Halting" is a property of Turing >>>>>>>>>> Machines /
Computations / Progrzms / completely defined function and the >>>>>>>>>> like ONLY.
I have already proved that halting is a property of C functions. >>>>>>>>> You are not stupid, and you have good knowledge yet you do lie >>>>>>>>> stupidly.
WHERE?
You pointed to a reference that talks about LEAF C-functions as >>>>>>>> having that
property.
Since you have made it clear that the description of the input >>>>>>>> DDD does NOT
include the code of HHH,
Because HHH emulates DDD the call to HHH(DDD) from DDD
never returns thus DDD never reaches its final halt state.
It is not that hard as soon as you get out of rebuttal
mode and get into honest dialogue mode.
No, the call to HHH)(DDD) from DDD returns, because the definition of >>>>>
never returns.
WRONG.
The *DEFINITION* of the behavor of a program is the unbounded
execution=/emulation of it.
Also, you CAN'T emulate the DDD that you have defined, that is, not
including the HHH that it calls,
You already admitted that when DDD is emulated by HHH
that the call from DDD to HHH(DDD) never returns.
That was about the DDD that INCLUDED HHH as part of its input.
It has always been the same code dipshit.
Your weasel word intentional deception may get
you sent straight to actual Hell.
I figured out how to save my life at 4:00 AM.
-Right paracaval lymph node (0.63 cm away from SVC)
(fused image 232): 3.5 x 2.3 cm with SUV max 12.0
That is *growing at a daily rate of 3.815 percent*
will have to be removed long before cuts off the
blood flow through by inferior vena cava.
On 11/28/2024 4:04 AM, joes wrote:I don't get it. HHH clearly halts in order to return a value. But that
Am Wed, 27 Nov 2024 19:15:41 -0600 schrieb olcott:I have already told you and conclusively proven that HHH does emulate
On 11/27/2024 8:03 AM, Richard Damon wrote:That's weird. Why can't HHH simulate itself?
On 11/27/24 8:28 AM, olcott wrote:
On 11/27/2024 6:14 AM, Richard Damon wrote:
olcott <[email protected]> wrote:
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said: >>>>>>>>>>>>>>>>>>> On 11/22/2024 2:30 AM, Mikko wrote:
On 2024-11-21 15:32:38 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>> On 11/21/2024 3:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 22:03:43 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>> On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-17 18:36:17 +0000, olcott said:
When DDD is emulated by HHH and DDD calls HHH(DDD) this call never
returns.
itself emulating DDD. I have told you this dozens of times and my code continues to prove this.
On 11/28/2024 10:27 AM, joes wrote:That's what I mean. I can see the code, but the code is wrong.
Am Thu, 28 Nov 2024 10:16:15 -0600 schrieb olcott:https://github.com/plolcott/x86utm You just may not have the required software engineering skill to get it. If you did then you could just carefully study the code and see.
On 11/28/2024 4:04 AM, joes wrote:I don't get it. HHH clearly halts in order to return a value. But that
Am Wed, 27 Nov 2024 19:15:41 -0600 schrieb olcott:I have already told you and conclusively proven that HHH does emulate
On 11/27/2024 8:03 AM, Richard Damon wrote:That's weird. Why can't HHH simulate itself?
On 11/27/24 8:28 AM, olcott wrote:
On 11/27/2024 6:14 AM, Richard Damon wrote:
olcott <[email protected]> wrote:
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>> On 11/22/2024 2:30 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-11-21 15:32:38 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>> On 11/21/2024 3:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 22:03:43 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-17 18:36:17 +0000, olcott said:
When DDD is emulated by HHH and DDD calls HHH(DDD) this call never
returns.
itself emulating DDD. I have told you this dozens of times and my code
continues to prove this.
value is "doesn't halt". Why does HHH, which does only a partial
simulation, report that itself (called by DDD) doesn't halt?
On 11/28/2024 9:47 AM, Richard Damon wrote:*simulated by itself, like any other. I see no agreement. HHH should be
On 11/28/24 10:01 AM, olcott wrote:
And your code never meet your requirement, so you have just been livingDDD emulated by any HHH cannot possibly reach its "ret" instruction
your life as a lie,
final halt state.
*As you have already agreed to*
On 11/22/2024 8:41 PM, Richard Damon wrote:
And, how many times will you just ignore that the below input can not
be emulated past the call HHH instructioon.
We both probably deserve purgatory. I have beenOh, what for?
very seriously repenting for many months.
On 11/28/2024 4:04 AM, joes wrote:
Am Wed, 27 Nov 2024 19:15:41 -0600 schrieb olcott:
On 11/27/2024 8:03 AM, Richard Damon wrote:That's weird. Why can't HHH simulate itself?
On 11/27/24 8:28 AM, olcott wrote:
On 11/27/2024 6:14 AM, Richard Damon wrote:
olcott <[email protected]> wrote:
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said: >>>>>>>>>>>>>>>>>>> On 11/22/2024 2:30 AM, Mikko wrote:
On 2024-11-21 15:32:38 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>> On 11/21/2024 3:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 22:03:43 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>> On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-17 18:36:17 +0000, olcott said:
When DDD is emulated by HHH and DDD calls HHH(DDD) this call never
returns.
I have already told you and conclusively proven that HHH does
emulate itself emulating DDD. I have told you this dozens of
times and my code continues to prove this.
You must be incompetent with software engineering.
On 11/28/2024 9:47 AM, Richard Damon wrote:
On 11/28/24 10:01 AM, olcott wrote:
It has always been the same code dipshit.
Your weasel word intentional deception may get
you sent straight to actual Hell.
And your code never meet your requirement, so you have just been
living your life as a lie,
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any HHH cannot possibly reach its "ret"
instruction final halt state.
*As you have already agreed to*
On 11/22/2024 8:41 PM, Richard Damon wrote:
On 11/22/24 9:07 PM, olcott wrote:>
And, how many times will you just ignore that
the below input can not be emulated past the
call HHH instructioon.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
I honestly hope that you do not get condemned to Hell
for your intentional deception. We both probably deserve
purgatory. I have been very seriously repenting for
many months.
On 11/28/2024 10:51 AM, joes wrote:
Am Thu, 28 Nov 2024 10:47:10 -0600 schrieb olcott:
On 11/28/2024 10:27 AM, joes wrote:That's what I mean. I can see the code, but the code is wrong.
Am Thu, 28 Nov 2024 10:16:15 -0600 schrieb olcott:https://github.com/plolcott/x86utm You just may not have the required
On 11/28/2024 4:04 AM, joes wrote:I don't get it. HHH clearly halts in order to return a value. But that >>>> value is "doesn't halt". Why does HHH, which does only a partial
Am Wed, 27 Nov 2024 19:15:41 -0600 schrieb olcott:I have already told you and conclusively proven that HHH does emulate >>>>> itself emulating DDD. I have told you this dozens of times and my code >>>>> continues to prove this.
On 11/27/2024 8:03 AM, Richard Damon wrote:That's weird. Why can't HHH simulate itself?
On 11/27/24 8:28 AM, olcott wrote:When DDD is emulated by HHH and DDD calls HHH(DDD) this call never >>>>>>> returns.
On 11/27/2024 6:14 AM, Richard Damon wrote:
olcott <[email protected]> wrote:
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-11-22 16:45:52 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>> On 11/22/2024 2:30 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-21 15:32:38 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/21/2024 3:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 22:03:43 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>
simulation, report that itself (called by DDD) doesn't halt?
software engineering skill to get it. If you did then you could just
carefully study the code and see.
The code does do what it does do.
If HHH halts at all, it needs to return that HHH halts.
DDD emulated by any HHH cannot possibly halt.
You can fail to understand that, you can lie
about that, it remains immutably a verified
fact none-the-less.
On 11/28/2024 10:51 AM, joes wrote:Yes, the wrong thing.
Am Thu, 28 Nov 2024 10:47:10 -0600 schrieb olcott:The code does do what it does do.
On 11/28/2024 10:27 AM, joes wrote:That's what I mean. I can see the code, but the code is wrong.
Am Thu, 28 Nov 2024 10:16:15 -0600 schrieb olcott:https://github.com/plolcott/x86utm You just may not have the required
On 11/28/2024 4:04 AM, joes wrote:I don't get it. HHH clearly halts in order to return a value. But
Am Wed, 27 Nov 2024 19:15:41 -0600 schrieb olcott:I have already told you and conclusively proven that HHH does
On 11/27/2024 8:03 AM, Richard Damon wrote:That's weird. Why can't HHH simulate itself?
On 11/27/24 8:28 AM, olcott wrote:
On 11/27/2024 6:14 AM, Richard Damon wrote:
olcott <[email protected]> wrote:
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-11-22 16:45:52 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>> On 11/22/2024 2:30 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-21 15:32:38 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/21/2024 3:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 22:03:43 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-17 18:36:17 +0000, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said:
When DDD is emulated by HHH and DDD calls HHH(DDD) this call never >>>>>>> returns.
emulate itself emulating DDD. I have told you this dozens of times
and my code continues to prove this.
that value is "doesn't halt". Why does HHH, which does only a partial
simulation, report that itself (called by DDD) doesn't halt?
software engineering skill to get it. If you did then you could just
carefully study the code and see.
Yes, HHH can't simulate itself.If HHH halts at all, it needs to return that HHH halts.DDD emulated by any HHH cannot possibly halt.
You can fail to understand that, you can lie about that, it remains
immutably a verified fact none-the-less.
On 11/28/2024 11:32 AM, joes wrote:The code proves that HHH aborts.
Am Thu, 28 Nov 2024 11:07:16 -0600 schrieb olcott:The code proves that HHH does emulate itself emulating DDD why lie?
On 11/28/2024 10:51 AM, joes wrote:Yes, the wrong thing.
Am Thu, 28 Nov 2024 10:47:10 -0600 schrieb olcott:The code does do what it does do.
On 11/28/2024 10:27 AM, joes wrote:That's what I mean. I can see the code, but the code is wrong.
Am Thu, 28 Nov 2024 10:16:15 -0600 schrieb olcott:https://github.com/plolcott/x86utm You just may not have the
On 11/28/2024 4:04 AM, joes wrote:I don't get it. HHH clearly halts in order to return a value. But
Am Wed, 27 Nov 2024 19:15:41 -0600 schrieb olcott:I have already told you and conclusively proven that HHH does
On 11/27/2024 8:03 AM, Richard Damon wrote:That's weird. Why can't HHH simulate itself?
On 11/27/24 8:28 AM, olcott wrote:
On 11/27/2024 6:14 AM, Richard Damon wrote:
olcott <[email protected]> wrote:
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 11/23/24 9:04 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 11/23/2024 1:59 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-22 16:45:52 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/22/2024 2:30 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-21 15:32:38 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/21/2024 3:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 22:03:43 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said:
On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-17 18:36:17 +0000, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said:
When DDD is emulated by HHH and DDD calls HHH(DDD) this call >>>>>>>>> never returns.
emulate itself emulating DDD. I have told you this dozens of times >>>>>>> and my code continues to prove this.
that value is "doesn't halt". Why does HHH, which does only a
partial simulation, report that itself (called by DDD) doesn't
halt?
required software engineering skill to get it. If you did then you
could just carefully study the code and see.
Yes, HHH can't simulate itself.If HHH halts at all, it needs to return that HHH halts.DDD emulated by any HHH cannot possibly halt.
You can fail to understand that, you can lie about that, it remains
immutably a verified fact none-the-less.
On 11/28/2024 11:06 AM, Richard Damon wrote:
On 11/28/24 11:43 AM, olcott wrote:
On 11/28/2024 9:47 AM, Richard Damon wrote:
On 11/28/24 10:01 AM, olcott wrote:
It has always been the same code dipshit.
Your weasel word intentional deception may get
you sent straight to actual Hell.
And your code never meet your requirement, so you have just been
living your life as a lie,
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any HHH cannot possibly reach its "ret"
instruction final halt state.
But that DDD CAN'T be emulated more than 4 instructions by ANY pure
function, as you can't emulate past the call HHH instruction.
You just aren't paying any attention at all or are woefully
inaccurate in your word choice. HHH1 does emulate all of DDD.
HHH1 <is> a pure function.
On 11/28/2024 4:07 AM, Mikko wrote:
On 2024-11-27 13:23:58 +0000, olcott said:
On 11/27/2024 3:29 AM, Mikko wrote:
On 2024-11-27 04:34:55 +0000, olcott said:
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote:
On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote:But every HHH[n] aborts its emulaton and returns, and thus DDD[n] >>>>>>>> halts, and thus HHH is INCORRECT to call its input non-halting. >>>>>>>>
On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote:
On 11/23/24 10:15 AM, olcott wrote:
On 11/23/2024 9:02 AM, Richard Damon wrote:
On 11/23/24 9:04 AM, olcott wrote:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:You mean you lied when you said "one concrete example"? >>>>>>>>>>>>>>>>
On 2024-11-21 15:32:38 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 11/21/2024 3:12 AM, Mikko wrote:That sentence says that there is only one HHH, contradicting your
On 2024-11-20 22:03:43 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>No, you may assume that I was confused by your lack of clarity and
On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>
On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> The "the mapping" on the subject line is not correct. The subject line
does not specify which mapping and there is no larger context that couldWhat a jackass. DDD and HHH have been fully specified >>>>>>>>>>>>>>>>>>>>>>>>> for many months.
specify that. Therefore it should be "a mapping". >>>>>>>>>>>>>>>>>>>>>>>>>>
On 2024-11-17 18:36:17 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>
void DDD()Because it cannot reach the instructions before tha return.
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD >>>>>>>>>>>>>>>>>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04 >>>>>>>>>>>>>>>>>>>>>>>>>>> [00002182] 5d pop ebp >>>>>>>>>>>>>>>>>>>>>>>>>>> [00002183] c3 ret >>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0018) [00002183] >>>>>>>>>>>>>>>>>>>>>>>>>>>
DDD emulated by any encoding of HHH that emulates N >>>>>>>>>>>>>>>>>>>>>>>>>>> to infinity number of steps of DDD cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>> reach its "return" instruction final halt state. >>>>>>>>>>>>>>>>>>>>>>>>>>
Because it cannot reach the instruction after the HHH call.
Because it cannot reach return instruction of HHH. >>>>>>>>>>>>>>>>>>>>>>>>>>
This applies to every DDD emulated by any HHH no >>>>>>>>>>>>>>>>>>>>>>>>>>> matter the recursive depth of emulation. Thus it is >>>>>>>>>>>>>>>>>>>>>>>>>>> a verified fact that the input to HHH never halts. >>>>>>>>>>>>>>>>>>>>>>>>>>That is too vague to be regareded true or false. It is perfectly possibe
to define two programs and call them DDD and HHH >>>>>>>>>>>>>>>>>>>>>>>>>
They are specified in a way that makes your "every DDD" and "any DDD"
bad (perhaps even incorrect) use of Common language. >>>>>>>>>>>>>>>>>>>>>>>>
I specify the infinite sets with each element numbered >>>>>>>>>>>>>>>>>>>>>>> on the top of page 2 of my paper. Back in April of 2023 >>>>>>>>>>>>>>>>>>>>>>>
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub repository.
Should I assume that you must be lying about >>>>>>>>>>>>>>>>>>>>> this because you did not quote where I did this? >>>>>>>>>>>>>>>>>>>>
in particular by your bad choice of names. >>>>>>>>>>>>>>>>>>>>
If you clearly state that HHH is not the function HHH that you have
in your GitHub repository then I needn't to consider the possiblity
that you just triying to deceive by equivcation. >>>>>>>>>>>>>>>>>>>>
HHH is one concrete example of an infinite set of instances >>>>>>>>>>>>>>>>>>> such that DDD is emulated by HHH N times. >>>>>>>>>>>>>>>>>>
earlier statement that HHH is a generic term for every member of some
set.
You seem to be a damned liar: "infinite set of instances" >>>>>>>>>>>>>>>>
One element of an infinite set does not say there >>>>>>>>>>>>>>> is no infinite set. Is says there is an infinite set. >>>>>>>>>>>>>>>
But one element of an infinite set is not the infinite set. >>>>>>>>>>>>>>
You are just showing that your logic is based on proven incorrect set theory.
IF HHH is an ELEMENT of the set, then it is that one element for the
entire evaluation,
Liar:
A proof by induction consists of two cases. The first, the base case,
proves the statement for n=0 without assuming any knowledge of >>>>>>>>>>>>> other cases. The second case, the induction step, proves that if the
statement holds for any given case n=k, then it must also hold for
the next case n=k+1. These two steps establish that the statement >>>>>>>>>>>>> holds for every natural number n. The base case does not necessarily
begin with n=0, but often with n=1, and possibly with any fixed natural
number n=N, establishing the truth of the statement for all natural
numbers n ≥ N.
https://en.wikipedia.org/wiki/Mathematical_induction >>>>>>>>>>>>>
And when have you ever provided such a proof for your statement? >>>>>>>>>>>>
NOWHERE
Your problem is you don't even have a logical basis to express your
statements in, so you can't do an induction on them.
So, you are just demonstrating that your "logic" is based on the >>>>>>>>>> meaningless use of buzzwords that you don't understand, but can parrot
their unlearned meaning, but have no idea how to actually use. >>>>>>>>>>
*As you already admitted below*
when N steps of DDD are emulated by HHH
DDD cannot reach past its call to HHH (statement)
But that was for the DDD that INCLUDED HHH as part of it, which you >>>>>>>>>> have now made clear is NOT what you consider DDD to be. And for that >>>>>>>>>> case DDD[n] calls HHH[n] (where HHH[n] is the version of HHH that does
only n steps of emulation) and while we can say that HHH[n[ does not >>>>>>>>>> emulate DDD[n] to its final state, that property is NOT a property of
of DDD[n], but of HHH[n] and DDD[n] as its input.
That every DDD[n] calls its HHH[n] in recursive emulation
conclusively proves that no DDD[n] emulated by HHH[n] halts, >>>>>>>>> thus each HHH[n] is correct to reject its input as non halting. >>>>>>>>
*You are a stupid liar*
You know that halting means reaching a final state and you
know that no input to HHH can possibly reach its final state.
So you aren't just a liar, you are a stupid one.
And you should know that "Halting" is a property of Turing Machines / >>>>>> Computations / Progrzms / completely defined function and the like ONLY. >>>>>>
I have already proved that halting is a property of C functions.
You are not stupid, and you have good knowledge yet you do lie
stupidly.
So, does the function
void ABC (void) {
XYZ();
}
halt?
void DDD() {
HHH(DDD);
return;
}
https://github.com/plolcott/x86utm/blob/master/Halt7.c
I gave you the complete fully operational source code for
HHH and DDD quit being a JackAss.
We can also know that for every HHH that emulates N steps of DDD
that no DDD ever reaches its "return" instruction final halt state.
So you don't understand your own words? Then you can't reasonably
expect that anyone else would understand them.
Since you don't specify the various possible alternative
interpretations of the above words I will assume that
you are only playing trollish head games.
On 11/24/2024 4:22 AM, Mikko wrote:
On 2024-11-23 14:04:07 +0000, olcott said:
On 11/23/2024 1:59 AM, Mikko wrote:
On 2024-11-22 16:45:52 +0000, olcott said:
On 11/22/2024 2:30 AM, Mikko wrote:
On 2024-11-21 15:32:38 +0000, olcott said:
On 11/21/2024 3:12 AM, Mikko wrote:
On 2024-11-20 22:03:43 +0000, olcott said:
On 11/20/2024 3:53 AM, Mikko wrote:
On 2024-11-20 03:23:12 +0000, olcott said:
On 11/19/2024 4:12 AM, Mikko wrote:
On 2024-11-18 20:42:02 +0000, olcott said:
On 11/18/2024 3:41 AM, Mikko wrote:
The "the mapping" on the subject line is not correct. The subject line
does not specify which mapping and there is no larger context that could
specify that. Therefore it should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD emulated by any encoding of HHH that emulates N >>>>>>>>>>>>>>> to infinity number of steps of DDD cannot possibly >>>>>>>>>>>>>>> reach its "return" instruction final halt state.
Because it cannot reach the instructions before tha return. >>>>>>>>>>>>>> Because it cannot reach the instruction after the HHH call. >>>>>>>>>>>>>> Because it cannot reach return instruction of HHH. >>>>>>>>>>>>>>
This applies to every DDD emulated by any HHH no >>>>>>>>>>>>>>> matter the recursive depth of emulation. Thus it is >>>>>>>>>>>>>>> a verified fact that the input to HHH never halts. >>>>>>>>>>>>>>That is too vague to be regareded true or false. It is perfectly possibe
to define two programs and call them DDD and HHH
What a jackass. DDD and HHH have been fully specified >>>>>>>>>>>>> for many months.
They are specified in a way that makes your "every DDD" and "any DDD"
bad (perhaps even incorrect) use of Common language.
I specify the infinite sets with each element numbered
on the top of page 2 of my paper. Back in April of 2023
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
You have also specifed that HHH is the program in your GitHub repository.
Should I assume that you must be lying about
this because you did not quote where I did this?
No, you may assume that I was confused by your lack of clarity and >>>>>>>> in particular by your bad choice of names.
If you clearly state that HHH is not the function HHH that you have >>>>>>>> in your GitHub repository then I needn't to consider the possiblity >>>>>>>> that you just triying to deceive by equivcation.
HHH is one concrete example of an infinite set of instances
such that DDD is emulated by HHH N times.
That sentence says that there is only one HHH, contradicting your
earlier statement that HHH is a generic term for every member of some >>>>>> set.
You seem to be a damned liar: "infinite set of instances"
You mean you lied when you said "one concrete example"?
One element of an infinite set does not say there
is no infinite set. Is says there is an infinite set.
True but irrelevant.
The behavior of one element of that infinite set proves
that every element of that infinite set has the same property:
On 11/28/2024 1:48 PM, joes wrote:
Am Thu, 28 Nov 2024 11:57:23 -0600 schrieb olcott:
On 11/28/2024 11:06 AM, Richard Damon wrote:Strawman. We are talking about HHH.
On 11/28/24 11:43 AM, olcott wrote:
On 11/28/2024 9:47 AM, Richard Damon wrote:
On 11/28/24 10:01 AM, olcott wrote:
You just aren't paying any attention at all or are woefully inaccurateDDD emulated by any HHH cannot possibly reach its "ret" instruction
final halt state.
But that DDD CAN'T be emulated more than 4 instructions by ANY pure
function, as you can't emulate past the call HHH instruction.
in your word choice. HHH1 does emulate all of DDD.
HHH1 <is> a pure function.
HHH1 has identical source-code to HHH the only difference
is that DDD does not call HHH at all, thus does not call
HHH in recursive emulation.
*You said*
DDD CAN'T be emulated more than 4 instructions by
ANY pure function...
Sure it can! It can be emulated by pure function HHH1
It HHH1 an element of the set of pure functions?
YES IT IS THUS YOU ARE WRONG !!!
On 12/2/2024 9:00 PM, Richard Damon wrote:
On 12/2/24 9:46 PM, olcott wrote:
On 11/28/2024 1:48 PM, joes wrote:
Am Thu, 28 Nov 2024 11:57:23 -0600 schrieb olcott:
On 11/28/2024 11:06 AM, Richard Damon wrote:Strawman. We are talking about HHH.
On 11/28/24 11:43 AM, olcott wrote:
On 11/28/2024 9:47 AM, Richard Damon wrote:
On 11/28/24 10:01 AM, olcott wrote:
You just aren't paying any attention at all or are woefully inaccurate >>>>> in your word choice. HHH1 does emulate all of DDD.DDD emulated by any HHH cannot possibly reach its "ret" instruction >>>>>>> final halt state.
But that DDD CAN'T be emulated more than 4 instructions by ANY pure >>>>>> function, as you can't emulate past the call HHH instruction.
HHH1 <is> a pure function.
HHH1 has identical source-code to HHH the only difference
is that DDD does not call HHH at all, thus does not call
HHH in recursive emulation.
*You said*
DDD CAN'T be emulated more than 4 instructions by
ANY pure function...
Sure it can! It can be emulated by pure function HHH1
It HHH1 an element of the set of pure functions?
YES IT IS THUS YOU ARE WRONG !!!
Nope, becuase if HHH1 looks at the machine code of HHH, which wasn't
part of its input, it isn.t a pure function, BY DEFINITION.
How the Hell do you think that you can get away with
saying that HHH is not part of the input to HHH1?
On 11/28/2024 1:48 PM, joes wrote:We know that HHH halts. It doesn't simulate itself halting.
Am Thu, 28 Nov 2024 11:35:16 -0600 schrieb olcott:You said:
On 11/28/2024 11:32 AM, joes wrote:The code proves that HHH aborts.
Am Thu, 28 Nov 2024 11:07:16 -0600 schrieb olcott:The code proves that HHH does emulate itself emulating DDD why lie?
On 11/28/2024 10:51 AM, joes wrote:Yes, the wrong thing.
Am Thu, 28 Nov 2024 10:47:10 -0600 schrieb olcott:The code does do what it does do.
On 11/28/2024 10:27 AM, joes wrote:That's what I mean. I can see the code, but the code is wrong.
Am Thu, 28 Nov 2024 10:16:15 -0600 schrieb olcott:https://github.com/plolcott/x86utm You just may not have the
On 11/28/2024 4:04 AM, joes wrote:I don't get it. HHH clearly halts in order to return a value. But >>>>>>>> that value is "doesn't halt". Why does HHH, which does only a
Am Wed, 27 Nov 2024 19:15:41 -0600 schrieb olcott:I have already told you and conclusively proven that HHH does >>>>>>>>> emulate itself emulating DDD. I have told you this dozens of >>>>>>>>> times and my code continues to prove this.
On 11/27/2024 8:03 AM, Richard Damon wrote:That's weird. Why can't HHH simulate itself?
On 11/27/24 8:28 AM, olcott wrote:
On 11/27/2024 6:14 AM, Richard Damon wrote:
olcott <[email protected]> wrote:
On 11/26/2024 7:02 AM, Richard Damon wrote:
On 11/25/24 11:08 PM, olcott wrote:
On 11/24/2024 11:18 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 11/24/24 9:30 AM, olcott wrote:
On 11/23/2024 11:54 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 11/23/24 11:54 AM, olcott wrote:
On 11/23/2024 9:35 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 11/23/24 10:15 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 11/23/2024 9:02 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 11/23/24 9:04 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 11/23/2024 1:59 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-22 16:45:52 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/22/2024 2:30 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-21 15:32:38 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/21/2024 3:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 22:03:43 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 11/20/2024 3:53 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-20 03:23:12 +0000, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said:
On 11/19/2024 4:12 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-18 20:42:02 +0000, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said:
On 11/18/2024 3:41 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-11-17 18:36:17 +0000, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said:
When DDD is emulated by HHH and DDD calls HHH(DDD) this call >>>>>>>>>>> never returns.
partial simulation, report that itself (called by DDD) doesn't >>>>>>>> halt?
required software engineering skill to get it. If you did then you >>>>>>> could just carefully study the code and see.
Yes, HHH can't simulate itself.If HHH halts at all, it needs to return that HHH halts.DDD emulated by any HHH cannot possibly halt.
You can fail to understand that, you can lie about that, it remains
immutably a verified fact none-the-less.
That is WRONG !!!HHH can't simulate itself.
HHH DOES EMULATE ITSELF PROVING THAT IT CAN EMULATE ITSELF.
On 12/2/2024 9:18 PM, Richard Damon wrote:
On 12/2/24 10:13 PM, olcott wrote:
On 12/2/2024 9:00 PM, Richard Damon wrote:
On 12/2/24 9:46 PM, olcott wrote:
On 11/28/2024 1:48 PM, joes wrote:
Am Thu, 28 Nov 2024 11:57:23 -0600 schrieb olcott:
On 11/28/2024 11:06 AM, Richard Damon wrote:Strawman. We are talking about HHH.
On 11/28/24 11:43 AM, olcott wrote:
On 11/28/2024 9:47 AM, Richard Damon wrote:
On 11/28/24 10:01 AM, olcott wrote:
You just aren't paying any attention at all or are woefullyDDD emulated by any HHH cannot possibly reach its "ret"
instruction
final halt state.
But that DDD CAN'T be emulated more than 4 instructions by ANY pure >>>>>>>> function, as you can't emulate past the call HHH instruction.
inaccurate
in your word choice. HHH1 does emulate all of DDD.
HHH1 <is> a pure function.
HHH1 has identical source-code to HHH the only difference
is that DDD does not call HHH at all, thus does not call
HHH in recursive emulation.
*You said*
DDD CAN'T be emulated more than 4 instructions by
ANY pure function...
Sure it can! It can be emulated by pure function HHH1
It HHH1 an element of the set of pure functions?
YES IT IS THUS YOU ARE WRONG !!!
Nope, becuase if HHH1 looks at the machine code of HHH, which wasn't
part of its input, it isn.t a pure function, BY DEFINITION.
How the Hell do you think that you can get away with
saying that HHH is not part of the input to HHH1?
Because you have defined that the input is JUST the x86 machine code
of DDD.
I never said anything like that Dumbledore. If I ever
said anything like that then I would have never said
that HHH emulates itself emulating DDD.
*DDD emulated by HHH NEVER HALTS* (wit of a nit).
On 12/3/2024 3:03 AM, joes wrote:
Am Mon, 02 Dec 2024 20:48:49 -0600 schrieb olcott:
On 11/28/2024 1:48 PM, joes wrote:
You said:We know that HHH halts. It doesn't simulate itself halting.
>>> HHH can't simulate itself.
That is WRONG !!!
HHH DOES EMULATE ITSELF PROVING THAT IT CAN EMULATE ITSELF.
Please try and explain how you are not dishonest what you
try to change the subject from my rebuttal of your statement:
HHH can't simulate itself.
That HHH does emulate itself emulating DDD proves
THAT IT CAN DO THIS.
On 12/3/2024 3:03 AM, joes wrote:I'm not changing the subject. HHH is a decider, right?
Am Mon, 02 Dec 2024 20:48:49 -0600 schrieb olcott:
On 11/28/2024 1:48 PM, joes wrote:
Am Thu, 28 Nov 2024 11:35:16 -0600 schrieb olcott:
On 11/28/2024 11:32 AM, joes wrote:
Am Thu, 28 Nov 2024 11:07:16 -0600 schrieb olcott:
On 11/28/2024 10:51 AM, joes wrote:
Am Thu, 28 Nov 2024 10:47:10 -0600 schrieb olcott:
On 11/28/2024 10:27 AM, joes wrote:
Am Thu, 28 Nov 2024 10:16:15 -0600 schrieb olcott:
On 11/28/2024 4:04 AM, joes wrote:
Am Wed, 27 Nov 2024 19:15:41 -0600 schrieb olcott:
On 11/27/2024 8:03 AM, Richard Damon wrote:
On 11/27/24 8:28 AM, olcott wrote:
On 11/27/2024 6:14 AM, Richard Damon wrote:
olcott <[email protected]> wrote:
Please try and explain how you are not dishonest what you try to changeWe know that HHH halts. It doesn't simulate itself halting.You said:The code proves that HHH aborts.The code proves that HHH does emulate itself emulating DDD why lie?Yes, HHH can't simulate itself.If HHH halts at all, it needs to return that HHH halts.DDD emulated by any HHH cannot possibly halt.
You can fail to understand that, you can lie about that, it
remains immutably a verified fact none-the-less.
>>> HHH can't simulate itself.
That is WRONG !!!
HHH DOES EMULATE ITSELF PROVING THAT IT CAN EMULATE ITSELF.
the subject from my rebuttal of your statement:
That HHH does emulate itself emulating DDD proves THAT IT CAN DO THIS.HHH can't simulate itself.
On 12/4/2024 9:32 AM, joes wrote:For that it seems relevant what HHH does. Ok, it simulates some number
Am Tue, 03 Dec 2024 17:08:34 -0600 schrieb olcott:We have not begun to get to that point of the conversation yet. We have
On 12/3/2024 3:03 AM, joes wrote:I'm not changing the subject. HHH is a decider, right?
Am Mon, 02 Dec 2024 20:48:49 -0600 schrieb olcott:
On 11/28/2024 1:48 PM, joes wrote:
Am Thu, 28 Nov 2024 11:35:16 -0600 schrieb olcott:
On 11/28/2024 11:32 AM, joes wrote:
Am Thu, 28 Nov 2024 11:07:16 -0600 schrieb olcott:
On 11/28/2024 10:51 AM, joes wrote:
Am Thu, 28 Nov 2024 10:47:10 -0600 schrieb olcott:
On 11/28/2024 10:27 AM, joes wrote:
Am Thu, 28 Nov 2024 10:16:15 -0600 schrieb olcott:
On 11/28/2024 4:04 AM, joes wrote:
Am Wed, 27 Nov 2024 19:15:41 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 11/27/2024 8:03 AM, Richard Damon wrote:
On 11/27/24 8:28 AM, olcott wrote:
On 11/27/2024 6:14 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> olcott <[email protected]> wrote:
Please try and explain how you are not dishonest what you try toWe know that HHH halts. It doesn't simulate itself halting.You said:The code proves that HHH aborts.The code proves that HHH does emulate itself emulating DDD whyYes, HHH can't simulate itself.If HHH halts at all, it needs to return that HHH halts.DDD emulated by any HHH cannot possibly halt.
You can fail to understand that, you can lie about that, it
remains immutably a verified fact none-the-less.
lie?
>>> HHH can't simulate itself.
That is WRONG !!!
HHH DOES EMULATE ITSELF PROVING THAT IT CAN EMULATE ITSELF.
change the subject from my rebuttal of your statement:
>>> HHH can't simulate itself.
That HHH does emulate itself emulating DDD proves THAT IT CAN DO THIS.
only been talking about the emulation of DDD by HHH for three months.
*We must go though my proof ONE-STEP-AT-A-TIME*Only you must. Why? Just give me the full thing, if you have it.
On 12/4/2024 9:32 AM, joes wrote:
Am Tue, 03 Dec 2024 17:08:34 -0600 schrieb olcott:
On 12/3/2024 3:03 AM, joes wrote:I'm not changing the subject. HHH is a decider, right?
Am Mon, 02 Dec 2024 20:48:49 -0600 schrieb olcott:
On 11/28/2024 1:48 PM, joes wrote:
Am Thu, 28 Nov 2024 11:35:16 -0600 schrieb olcott:
On 11/28/2024 11:32 AM, joes wrote:
Am Thu, 28 Nov 2024 11:07:16 -0600 schrieb olcott:
On 11/28/2024 10:51 AM, joes wrote:
Am Thu, 28 Nov 2024 10:47:10 -0600 schrieb olcott:
On 11/28/2024 10:27 AM, joes wrote:
Am Thu, 28 Nov 2024 10:16:15 -0600 schrieb olcott:
On 11/28/2024 4:04 AM, joes wrote:
Am Wed, 27 Nov 2024 19:15:41 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 11/27/2024 8:03 AM, Richard Damon wrote:
On 11/27/24 8:28 AM, olcott wrote:
On 11/27/2024 6:14 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> olcott <[email protected]> wrote:
Please try and explain how you are not dishonest what you try to changeWe know that HHH halts. It doesn't simulate itself halting.You said:The code proves that HHH does emulate itself emulating DDD why lie? >>>>>> The code proves that HHH aborts.Yes, HHH can't simulate itself.If HHH halts at all, it needs to return that HHH halts.DDD emulated by any HHH cannot possibly halt.
You can fail to understand that, you can lie about that, it
remains immutably a verified fact none-the-less.
>>> HHH can't simulate itself.
That is WRONG !!!
HHH DOES EMULATE ITSELF PROVING THAT IT CAN EMULATE ITSELF.
the subject from my rebuttal of your statement:
>>> HHH can't simulate itself.
That HHH does emulate itself emulating DDD proves THAT IT CAN DO THIS.
We have not begun to get to that point of the
conversation yet. We have only been talking
about the emulation of DDD by HHH for three months.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*We must go though my proof ONE-STEP-AT-A-TIME*
DDD emulated by any HHH according to the semantics of
the x86 language cannot possibly reach it "ret" instruction
whether HHH aborts this emulation after N steps or never aborts.
On 12/4/2024 6:11 PM, Richard Damon wrote:
On 12/4/24 9:27 AM, olcott wrote:
On 12/3/2024 5:39 PM, Richard Damon wrote:
On 12/3/24 6:08 PM, olcott wrote:
On 12/3/2024 3:03 AM, joes wrote:
Am Mon, 02 Dec 2024 20:48:49 -0600 schrieb olcott:
On 11/28/2024 1:48 PM, joes wrote:
You said:We know that HHH halts. It doesn't simulate itself halting.
>>> HHH can't simulate itself.
That is WRONG !!!
HHH DOES EMULATE ITSELF PROVING THAT IT CAN EMULATE ITSELF.
Please try and explain how you are not dishonest what you
try to change the subject from my rebuttal of your statement:
HHH can't simulate itself.
That HHH does emulate itself emulating DDD proves
THAT IT CAN DO THIS.
But only if your think that wrong answer can be right.
I did not mention anything about answers my entire
scope is that HHH does emulate itself emulating DDD
thus conclusively proving that HHH can emulated itself
emulating DDD.
Whenever you go out-of-scope like this it surely
seems dishonest to me.
But the behaivor that HHH shows that it has *IS* an "answer",
DDD emulated by any HHH according to the semantics of
the x86 language cannot possibly reach its "ret" instruction
whether HHH aborts this emulation after N steps or never aborts.
On 12/4/2024 7:31 PM, Richard Damon wrote:
On 12/4/24 8:06 PM, olcott wrote:
On 12/4/2024 6:11 PM, Richard Damon wrote:
On 12/4/24 9:27 AM, olcott wrote:
On 12/3/2024 5:39 PM, Richard Damon wrote:
On 12/3/24 6:08 PM, olcott wrote:
On 12/3/2024 3:03 AM, joes wrote:
Am Mon, 02 Dec 2024 20:48:49 -0600 schrieb olcott:
On 11/28/2024 1:48 PM, joes wrote:
You said:We know that HHH halts. It doesn't simulate itself halting.
>>> HHH can't simulate itself.
That is WRONG !!!
HHH DOES EMULATE ITSELF PROVING THAT IT CAN EMULATE ITSELF.
Please try and explain how you are not dishonest what you
try to change the subject from my rebuttal of your statement:
HHH can't simulate itself.
That HHH does emulate itself emulating DDD proves
THAT IT CAN DO THIS.
But only if your think that wrong answer can be right.
I did not mention anything about answers my entire
scope is that HHH does emulate itself emulating DDD
thus conclusively proving that HHH can emulated itself
emulating DDD.
Whenever you go out-of-scope like this it surely
seems dishonest to me.
But the behaivor that HHH shows that it has *IS* an "answer",
DDD emulated by any HHH according to the semantics of
the x86 language cannot possibly reach its "ret" instruction
whether HHH aborts this emulation after N steps or never aborts.
Just a nonsense sentence, since HHH can't emulate HHH as it isn't
given it,
Why do you have to keep fucking lying about this?
I could die on the operating table in two weeks!
On 12/4/2024 7:45 PM, Richard Damon wrote:
On 12/4/24 8:41 PM, olcott wrote:
On 12/4/2024 7:31 PM, Richard Damon wrote:
On 12/4/24 8:06 PM, olcott wrote:
On 12/4/2024 6:11 PM, Richard Damon wrote:
On 12/4/24 9:27 AM, olcott wrote:
On 12/3/2024 5:39 PM, Richard Damon wrote:
On 12/3/24 6:08 PM, olcott wrote:
On 12/3/2024 3:03 AM, joes wrote:
Am Mon, 02 Dec 2024 20:48:49 -0600 schrieb olcott:
On 11/28/2024 1:48 PM, joes wrote:
You said:
>>> HHH can't simulate itself.
That is WRONG !!!
HHH DOES EMULATE ITSELF PROVING THAT IT CAN EMULATE ITSELF. >>>>>>>>>> We know that HHH halts. It doesn't simulate itself halting. >>>>>>>>>>
Please try and explain how you are not dishonest what you
try to change the subject from my rebuttal of your statement: >>>>>>>>>
HHH can't simulate itself.
That HHH does emulate itself emulating DDD proves
THAT IT CAN DO THIS.
But only if your think that wrong answer can be right.
I did not mention anything about answers my entire
scope is that HHH does emulate itself emulating DDD
thus conclusively proving that HHH can emulated itself
emulating DDD.
Whenever you go out-of-scope like this it surely
seems dishonest to me.
But the behaivor that HHH shows that it has *IS* an "answer",
DDD emulated by any HHH according to the semantics of
the x86 language cannot possibly reach its "ret" instruction
whether HHH aborts this emulation after N steps or never aborts.
Just a nonsense sentence, since HHH can't emulate HHH as it isn't
given it,
Why do you have to keep fucking lying about this?
I could die on the operating table in two weeks!
What's the lie?
Can you point to what I say that is wrong, and a reliable reference
that show it?
All you have is your own lies to call it a lie.
And yes, you might die in two weeks, and the only thing you will have
left behind is all your lies.
Yes you fucking jackass this conclusively proves that
HHH does emulate itself emulating DDD.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
On 11/20/2024 3:50 AM, Mikko wrote:
On 2024-11-20 03:19:37 +0000, olcott said:
On 11/19/2024 4:05 AM, Mikko wrote:
On 2024-11-18 20:44:49 +0000, olcott said:There are two different page 24. Page 24 of the PDF
On 11/18/2024 3:53 AM, Mikko wrote:
On 2024-11-18 04:04:39 +0000, olcott said:
You stupidly claimed termination analysis is only doneThe claim is not supported by the referred article.
on programs. I proved that you were stupidly wrong on
pages 24-27 of the PDF of this paper.
Automated Termination Analysis of C Programs
https://publications.rwth-aachen.de/record/972440/files/972440.pdf >>>>>>
You are a damned liar. Page 24 proves that termination
analysis is performed on C functions.
You are the liar. Page 24 does not even mention C functions.
not page 24 of the paper.
You failed to tell which one you meant. Such tricks may deceive
somebody but don't work here.
Please quit being a damned jackass.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 715 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 150:17:18 |
| Calls: | 12,091 |
| Calls today: | 4 |
| Files: | 15,000 |
| Messages: | 6,517,595 |