Re: D simulated by H never halts no matter what H does V3 ---

On 5/4/24 5:18 PM, olcott wrote:

On 5/4/2024 3:40 PM, Richard Damon wrote:

On 5/4/24 2:46 PM, olcott wrote:

On 5/4/2024 12:15 PM, Richard Damon wrote:

On 5/4/24 12:31 PM, olcott wrote:

On 5/4/2024 10:52 AM, Richard Damon wrote:

On 5/4/24 10:48 AM, olcott wrote:

On 5/4/2024 9:39 AM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 5/4/2024 5:56 AM, Alan Mackenzie wrote:

[ Followup-To: set ]

>

In comp.theory olcott <polcott333@gmail.com> wrote:

>
[ .... ]
>

You are doing better than Alan on this though he doesn't
have a single clue about what execution traces are or how
they work.

>

You should read "How to make friends and influence people" by Dale
Carnegie.  You may not care about the former, but you sure are trying
the latter.  Hint: telling nasty lies about people is not effective.

>
>

The alternative of disparaging my work without even looking at
it is far worse because it meets the

>

https://dictionary.findlaw.com/definition/reckless-disregard-of-the-truth.html

>

required for libel and defamation cases.

>
No.  There have got to be limits on what one spends ones time on. You

>
None-the-less saying that I <am> wrong without looking at what
I said <is> defamatory. Saying that you believe that I am wrong
on the basis that I do not seem to have credibility is not defamatory.
>

have been maintaining false things over the years to such a degree that
it would be a waste of time suddenly to expect brilliant insights from
you.  For example, you insist that robustly proven mathematical theorems
are false, and your "reasoning" hardly merits the word.
>

>
Can D correctly simulated by H terminate normally?
00 int H(ptr x, ptr x)  // ptr is pointer to int function
01 int D(ptr x)
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 void main()
10 {
11   H(D,D);
12 }
>
Execution Trace
Line 11: main() invokes H(D,D);
>
keeps repeating (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
Simulation invariant:
D correctly simulated by H cannot possibly reach past its own line 03.
>
Yet saying that the above is false <is> defamatory because anyone
with ordinary skill in the art of C programming can determine that
it is true by verifying that the execution trace is correct.
>
When you say it is false by either not verifying that the execution
trace is correct or not knowing what execution traces are <is>
defamatory.

>
But it HAS been proven incorrect and YOU are the one disregarding the evidence.
>
I guess I could file defamatory claims against you.
>

>
It may be the case that you did bury another rebuttal in all of
your rhetoric and ad hominem attacks that were vigorously attempting
to get away with the strawman deception change the subject "rebuttal".

>
But very close to my first part of the reply I indicated that there WAS a detailed description of this at the end, and you replied to that mention, saying that since your statement was categorically true it would be easy to refute, and then you just didn't do so.
>

>
If you post the time/date stamp I will carefully examine it.
Until you do that it seems safe to assume that it was only
the same ruse as this.
>
On 5/1/2024 7:28 PM, Richard Damon wrote:
 > On 5/1/24 11:51 AM, olcott wrote:
 >> *I HAVE SAID THIS AT LEAST 10,000 TIMES NOW*
 >> Every D simulated by H that cannot possibly stop running unless
 >> aborted by H does specify non-terminating behavior to H. When
 >> H aborts this simulation that does not count as D halting.
 >
 > Which is just meaningless gobbledygook by your definitions.
 >
 > It means that
 >
 > int H(ptr m, ptr d) {
 >     return 0;
 > }
 >
 > is always correct, because THAT H can not possible simulate
 > the input to the end before it aborts it, and that H is all
 > that that H can be, or it isn't THAT H.
>
*Every D NEVER simulated by H* (as shown above)
is definitely not *Every D simulated by H* (also shown above)
>

So. I guess you ADHD made you forget what you were talking about and made yourself just into a liar.
>
YOU choosing to ignore it, just shows that you are not really interested in an actual honest dialog.
>
I guess it doesn't matter to you what is actually true, as you are going to just assume what you want.
>

>
A reasonable person cannot be reasonably expected to wade through
all of that especially when one of these "rebuttals" interpreted
*D is simulated by H* to mean *D is NEVER simulated by H*

>
But that isn't what distracted you in that message.
>

>
On 5/1/2024 7:28 PM, Richard Damon wrote:
 >> *Every D simulated by H* that cannot possibly stop running unless
 >> aborted by H does specify non-terminating behavior to H. When
 >> H aborts this simulation that does not count as D halting.
 >
 > Which is just meaningless gobbledygook by your definitions.
 >
 > It means that
 >
 > int H(ptr m, ptr d) {
 >     return 0;
 > }
 >
 > is always correct, because THAT H can not possible simulate
 > the input to the end before it aborts it, and that H is all
 > that that H can be, or it isn't THAT H.
>
One shows a reckless-disregard-of-the-truth when they "interpret"
*D is simulated by H*
   to mean
*D is NEVER simulated by H*
>
>

>
But 0 steps is a number of steps.
>

>
*I did not say any number of steps*
>
 > On 5/1/24 11:51 AM, olcott wrote:
 >> *I HAVE SAID THIS AT LEAST 10,000 TIMES NOW*
 >> *Every D simulated by H* that cannot possibly stop running unless
 >> aborted by H does specify non-terminating behavior to H. When
 >> H aborts this simulation that does not count as D halting.
>
*Every D simulated by H* IS NOT *Any D NEVER simulated by H*
*Every D simulated by H* IS NOT *Any D NEVER simulated by H*
*Every D simulated by H* IS NOT *Any D NEVER simulated by H*
*Every D simulated by H* IS NOT *Any D NEVER simulated by H*

>
WITHOUT DEFINING EXACTLY WHAT "SIMULATED" means.
>

 (1) You have already acknowledged that you what it means
by all the times that you did agree that D simulated by H
never reaches its own line 06 and halts.

No, D simulated by THIS H (and a very restricted family of related programs), as you have defined it, will not reach its own line 06.
This happens as either said H abort their simulation before the program gets there, or they create an H that just never returns an answer to H(D,D) and thus fail to be a decider. These are two distinct parts of your "family" of H that you like to talk about, that you need to be a bit imprecise about so you can try to mix them up.

 (2) What could simulated possibly mean besides the C source-code
of D being interpreted by a C interpreter or the machine-language
of D being emulated by an x86 emulator?

Ok, so why doesn't H do that?
After all, H doesn't actually simulate the call H instruction, which should do what the instruction does, and enter H, or at least do the equivalent results of calling H(D,D) which is to return 0.
Typically, to simulate something means to determine what it will do when it is actually done, but you like to claim that H's simulation of the input doesn't need to match the actual behavior of the program described to it, so clearly you are not using simulate in the conventional meanings.
You have EXPLICITLY claimed that just becuase D(D) Halts, doesn't mean that H simulating the description of this machine can't be correct when it says it doesn't.
So, it is clear that you somehow have rejected some of the essential characteristic of what a "simulation" means, but refuse to actually define it. The likely cause is that you know you CAN'T precisely define it, as you can't make weasle words to allow the illogical conclusion that you make for the call to H being simulated, without makeing to too obvious that something is very broken with your system.

 

By some acceptable definitions, the zero step counts.
>

 No that is bullshit and you know it.
There is no way that "I ate lunch" can be interpreted
as "I did not eat lunch".

Maybe not for those words.
But "I ate all my lunch" could be a true statement if you ate nothing, because you didn't have a lunch.
So, to simulate until you make your decision, could involve ZERO simulation if you made you decision before you started.

 

Otherwise, how do you justify H's simulation of a "Call H" instruction.
>

>

And its logic is just as good as your H's, since it is using a FALSE statement.
>

>
When one of ordinary skill in the art of C programming can
easily verify that the execution trace presented is correct:
>
00 int H(ptr x, ptr x)  // ptr is pointer to int function
01 int D(ptr x)
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 int main()
10 {
11   H(D,D);
12 }
>
Execution Trace
Line 11: main() invokes H(D,D);
>
keeps repeating (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
Simulation invariant:
D correctly simulated by H cannot possibly reach past its own line 03.

>
>
And proven to be incorrect and you have ignored the problem.
>

>
I think that the reason why you won't show any time/date stamp
of where this was proven is that you already know that this
other example is the same nonsense that I quoted you saying
in your other "proof" quoted above.

>
>
One key thing I am pointing out is you HABITUALLY LIE about no one ever having refuted you. You often speak about things as "proven" with

 You may believe that you correctly refuted your misunderstandings
of some of the things that I said. This is not at all the same thing
as proof. To correct these seemingly intentional misunderstandings
we go over every detail of every single point.
 (a) It is a verified fact that D(D) simulated by H cannot
possibly reach past line 03 of D(D) simulated by H whether
H aborts its simulation or not.
 

actually no actual proof behind them. It seems that to you, if you think something is true, then it is just true by being obvious, and if you think something is false, it is just obviously false, REGARDLESS of the actual ability to actually prove such a statement to someone else.
>
*IF* you put out a clear statement that I have NOT made such a statement, and if you are shown wrong about that fact, then you will NEVER again make the statements of the form that you have never been refuted, then I will prove that error with the reference. (And if you do, everyone is allowed to point out repeatedly that you have demonstrated that you are just a liar).
>

 When we go over every single detail so that you cannot merely
glance at a couple of words and leap to the conclusion that I
am incorrect then everyone will see that you have no basis for
saying that I am incorrect.
 

Perhaps, if you make a sincere apology, and admit that you don't read all of every reply, and thus there could be a rebuttal you didn't see, and thus you can't honestly make such a claim.
>
>

 I did quit reading every reply when it became clear that you intended
on perpetually using the strawman deception change the subject fake
rebuttal.
 FROM THIS POINT FORWARD AS SOON AS I READ ONE WORD UNRELATED TO
THIS POINT I WILL STOP READING AND INDICATE THAT I STOPPED READING:
 (a) It is a verified fact that D(D) simulated by H cannot
possibly reach past line 03 of D(D) simulated by H whether
H aborts its simulation or not.
 Failure to post the time/date stamp of your other "rebuttal"
will be taken to mean that there never was any legitimate
rebuttal, only the same nonsense as the other fake rebuttal.