XPost: sci.logic

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.

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.

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.

Then anyone asserting otherwise does meet the definition of https://dictionary.findlaw.com/definition/reckless-disregard-of-the-truth.html required for libel and defamation cases.

So, your claiming that you statement hasn't been disproven meets that definition too.

A valid counter-example would overcome this. Mere rhetoric and
ad hominem attacks instead of a valid counter-example sustain
the characterization of defamation rather than rebut it.

Been given and ignored, thus you ADMIT that your statements have just
become rhetoric, as you have choosen to not try to rebut it.

I prefer honest dialogues. Whenever the other party diverges from this >>>>> I will call it out. It may be fun to have an insult party until this >>>>> makes one look ridiculously foolish.

You do NOT prefer honest dialogues at all.  You are not prepared, ever, >>>> to admit where you are wrong.  You seem to insist that everybody else >>>> takes your pronouncements at face value.  You do not appear to try to >>>> understand others' points of view, even (especially?) where they are
right.

How is that "honest dialogue"?

--
Copyright 2024 Olcott "Talent hits a target no one else can hit;
Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

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.

By some acceptable definitions, the zero step counts.

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
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).

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.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

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.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote:

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.

*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*

I have said this many hundreds of times because this shell-game
deception has been ridiculous https://en.wikipedia.org/wiki/Shell_game

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.

When N steps of D are simulated by the directly executed H
where N is 1 to 1,000,000 no simulated D every reaches past
its own line 03.

When N steps of D are simulated by the directly executed H
where N is 1 to 1,000,000 and H aborts its simulation all of
the nested simulations (if any) immediately totally stop running.
No simulated H ever returns any value to any simulated D.

(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?

We are not talking about my implemented H we are talking about
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*

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.

All of the above is based on the false assumption that we are talking
about something other than this:

We are not talking about my implemented H we are talking about
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*

But what do you mean be "Simulated".

What in the definition of simulated allows a call to H that will return
0 be simulated as "never returns"?

You are just caught in a LIE.

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.

*D is simulated by H*
 cannot be correctly construed as
*D is NEVER simulated by H*

So, you don't understand that in logic, For ALL X, can include the case
of 0 x?

Thus, a analyzer that correctly simulates all of the steps of the input
that it looks at, until it has the information it needs to produce its
answer, can, within that definition, simulate 0 steps (since all were
correct since none of them were simulated incorrectly) and if that gives
it the information it needs to make the answer, just give it.

So, your claim, while it may make some "common sense" isn't strictly true.

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.

That sure seems to be what you are doing.
First you decide that I must be wrong
then you glance at some of my words.

Until you DEFINE what it means to for "H to simulate D", in a way that
allows H to do what you do with the call H instruction, you can't use "definitions", since you don't have one.

Is a car a race car if it never runs a race?

Yep.

Your problem is you don't seem to understand the essential nature of the problems, so you just lie.

This reply of yours seems to be finally getting back on
track of an actual honest dialogue.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/4/24 7:51 PM, olcott wrote:

On 5/4/2024 6:32 PM, Richard Damon wrote:

On 5/4/24 7:01 PM, olcott wrote:

On 5/4/2024 5:36 PM, Richard Damon wrote:

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote:

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. >>>>>>

*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*

I have said this many hundreds of times because this shell-game
deception has been ridiculous https://en.wikipedia.org/wiki/Shell_game >>>>>

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.

When N steps of D are simulated by the directly executed H
where N is 1 to 1,000,000 no simulated D every reaches past
its own line 03.

When N steps of D are simulated by the directly executed H
where N is 1 to 1,000,000 and H aborts its simulation all of
the nested simulations (if any) immediately totally stop running.
No simulated H ever returns any value to any simulated D.

(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?

We are not talking about my implemented H we are talking about
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*

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.

All of the above is based on the false assumption that we are
talking about something other than this:

We are not talking about my implemented H we are talking about
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*

But what do you mean be "Simulated".

What in the definition of simulated allows a call to H that will
return 0 be simulated as "never returns"?

You already understand that infinite recursion never returns.

Right, trivially, since it isn't infinite if it does return.

So, a recursion call loop that has NOTHING in the loop that can break
it, becomes infinite.

You already understand that recursive simulation is isomorphic to
infinite recursion so I can't see how you can say that you don't
understand these things an be sincere.

But only for UNCONDITIONAL simulation, which H doesn't do.

void Infinite_Recursion(u32 N)
{
  Infinite_Recursion(N);
  return;
}

OK we are down to one single point at a time, when that point is
divided into ten more points only one of them at a time we keep
dividing them until your rebuttal looks like ridiculous nonsense
to everyone including yourself.

The ONLY point right now is that H(Infinite_Recursion, (ptr)5));
is correct when it reports that Infinite_Recursion() never halts
on the basis that Infinite_Recursion simulated by H never reaches
its return statement.

Yes, since Infinite_Recursion has a full unconditional loop back to the original point, it will be a non-halting program and thus no correct
simulation of it can reach an end, because the program it is simulating
will never reach an end.


To go forward a step (ignore if you please, but I see where you are
trying to go.

void Infinite_Simulation(ptr p)
{
UTM(p, p);
return;
}

will also be an "infinte behavior" program when looked at as

H(Infinite_Simulation, Infinite_Simulation)

as the FULL loop (including through the UTM) is unconditional.


BUT

void X(ptr p)
{
H(p,p)
return
}

is NOT the same if H(X,X) will ever decide to abort and return a
decision, thinking it is like the Infinite_Simulation case, as the FULL
Loop, which includes the code of H, is not unconditional.

And this is true as if we just run X(X), then it will call H(X,X) which,
since you say H(X,X) will eventually decide to abort its simulation and
return, so X(X) WILL reach its final state, and that says that one of my proposals could detect that and reach past the call.

Note, this is NOT the "imposible program", as it doesn't have the
contray stuff at the end, but your H can't know that, so its logic must
be wrong.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/4/24 7:01 PM, olcott wrote:

On 5/4/2024 5:36 PM, Richard Damon wrote:

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote:

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.

*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*

I have said this many hundreds of times because this shell-game
deception has been ridiculous https://en.wikipedia.org/wiki/Shell_game

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.

When N steps of D are simulated by the directly executed H
where N is 1 to 1,000,000 no simulated D every reaches past
its own line 03.

When N steps of D are simulated by the directly executed H
where N is 1 to 1,000,000 and H aborts its simulation all of
the nested simulations (if any) immediately totally stop running.
No simulated H ever returns any value to any simulated D.

(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?

We are not talking about my implemented H we are talking about
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*

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. >>>>

All of the above is based on the false assumption that we are talking
about something other than this:

We are not talking about my implemented H we are talking about
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*
*Every H/D pair (of the infinite set) where D is simulated by H*

But what do you mean be "Simulated".

What in the definition of simulated allows a call to H that will
return 0 be simulated as "never returns"?

You already understand that infinite recursion never returns.

Right, trivially, since it isn't infinite if it does return.

So, a recursion call loop that has NOTHING in the loop that can break
it, becomes infinite.

You already understand that recursive simulation is isomorphic to
infinite recursion so I can't see how you can say that you don't
understand these things an be sincere.

But only for UNCONDITIONAL simulation, which H doesn't do.

Just as a recursion loop is infinite only if the loop never stops
itself, so with the simulation loop.

In particular, it means that if the "simulator" is actually a DECIDER,
then the recursive "simulation" is only infinite if at no stage will ANY
of the simulators decide to stop simulating.

The slight trick to this compared to the infinite recursion, is that
with recursion, only the current inner most layer can stop the loop, but
with simulation, ANY of the layers of simulation can stop the whole stack.

You are just caught in a LIE.

If you are pretending to not understand that infinite recursion
never returns it is not me that is the liar hare.

As I explained, you are playing with words. Your problem is that you
confuse your nesting conditional simulation with the unconditional
recursion loop.

So you LIE.

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.

*D is simulated by H*
  cannot be correctly construed as
*D is NEVER simulated by H*

So, you don't understand that in logic, For ALL X, can include the
case of 0 x?

Let drop this endless circle.

Go ahead. If you are going to start to actually put in some requirement
on your analyzer that you initially refused to do, and require that it
must analyze at least 1 step, the trivial version simulates for one step
and them aborts, saying that (since it does abort) that its simulation
can not reach the end and thus it can correctly say its input is
non-halting.

YOUR H can't use the argument that no H could get past there, because it
has been shown that some do, and thus H can only argue that because ITS simulation didn't get there, it was right to do so.

Thus, a analyzer that correctly simulates all of the steps of the
input that it looks at, until it has the information it needs to
produce its answer, can, within that definition, simulate 0 steps

NO IT CAN FREAKING NOT

void test()
{
  return;
}

Why?

Until you define what rule my trivial decider is breaking that your H
isn't, you have no grounds to complain.

That is the whole point. Without YOU making a REAL FORMAL DEFINITION of
what you are claiming to be doing, your logic is just useless.

My guess is all of this is just beyound your understanding, because I
don't think you have enough understand of what formal requirements
actually are, because it seems most of your "study" is in the informal philosophical soft-science part of the theories, not the formal side
which has the strict rules.

(since all were correct since none of them were simulated incorrectly)
and if that gives it the information it needs to make the answer, just
give it.

So, your claim, while it may make some "common sense" isn't strictly
true.

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.

That sure seems to be what you are doing.
First you decide that I must be wrong
then you glance at some of my words.

Until you DEFINE what it means to for "H to simulate D",

It is the ordinary meaning of the word.
It does not mean that H will bake a cake.
It does not mean that H will jump up and down.

So, you are just admitting that your H isn't a simulating Termination
analysis program because it just fails to simulate the call H
instruction according to the ordinary meaning of the word. Since H's
"analysis" of what THAT call H would do doesn't match what it actually
would do makes it wrong.

It means that H will either interpret a finite number
of the instructions specified by the source-code of D
of H will emulate a finite number of the machine-language
instructions of D.

Right, as did my 1 step analyser. So, if you claim that to be wrong, so
is H.

You are running out my clock man I go into surgery again
next week.

No, YOU are running out your clock, by refusing to handle the steps that
need to be handled.

YOU are trying to insist on something that I have shown has problems,
You really do need to make a better foundation for your arguement, which
means you need to actually spend time to define what you are doing.

If you can't, you are just doomed to fail anyway.

in a way that allows H to do what you do with the call H instruction,
you can't use "definitions", since you don't have one.

Is a car a race car if it never runs a race?

Yep.

Your problem is you don't seem to understand the essential nature of
the problems, so you just lie.

This reply of yours seems to be finally getting back on
track of an actual honest dialogue.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/4/24 8:20 PM, olcott wrote:

On 5/4/2024 7:07 PM, Richard Damon wrote:

On 5/4/24 7:51 PM, olcott wrote:

On 5/4/2024 6:32 PM, Richard Damon wrote:

On 5/4/24 7:01 PM, olcott wrote:

On 5/4/2024 5:36 PM, Richard Damon wrote:

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote:

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.

*Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>
I have said this many hundreds of times because this shell-game
deception has been ridiculous
https://en.wikipedia.org/wiki/Shell_game

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.

When N steps of D are simulated by the directly executed H
where N is 1 to 1,000,000 no simulated D every reaches past
its own line 03.

When N steps of D are simulated by the directly executed H
where N is 1 to 1,000,000 and H aborts its simulation all of
the nested simulations (if any) immediately totally stop running. >>>>>>> No simulated H ever returns any value to any simulated D.

(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?

We are not talking about my implemented H we are talking about
*Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>

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.

All of the above is based on the false assumption that we are
talking about something other than this:

We are not talking about my implemented H we are talking about
*Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>

But what do you mean be "Simulated".

What in the definition of simulated allows a call to H that will
return 0 be simulated as "never returns"?

You already understand that infinite recursion never returns.

Right, trivially, since it isn't infinite if it does return.

So, a recursion call loop that has NOTHING in the loop that can
break it, becomes infinite.

You already understand that recursive simulation is isomorphic to
infinite recursion so I can't see how you can say that you don't
understand these things an be sincere.

But only for UNCONDITIONAL simulation, which H doesn't do.

void Infinite_Recursion(u32 N)
{
   Infinite_Recursion(N);
   return;
}

OK we are down to one single point at a time, when that point is
divided into ten more points only one of them at a time we keep
dividing them until your rebuttal looks like ridiculous nonsense
to everyone including yourself.

The ONLY point right now is that H(Infinite_Recursion, (ptr)5));
is correct when it reports that Infinite_Recursion() never halts
on the basis that Infinite_Recursion simulated by H never reaches
its return statement.

Yes, since Infinite_Recursion has a full unconditional loop back to
the original point, it will be a non-halting program and thus no
correct simulation of it can reach an end, because the program it is
simulating will never reach an end.

But H does not simulate it forever its simulation
of Infinite_Recursion() is conditional. How it is
that Infinite_Recursion() never halts when H stops
simulating it?

Becuase, as you don't seem to understand, the behavior of programs is
what they do as ideal mathematical objects on the ideal mathematical
machine they are concidered to be run on, NOT what some simulation of
them shows.

As I have mentioned MAMY times, you seem to have a fundamental confusion between the RUNNING of the program, and the SIMULATION of it.

This seems to go back to your lack of understand what Truth actually is.


RUNNING is what happens when it is carried out completely correctly, as
with a real correct processor which is left to run, or on the
mathematical model, that runs until it finishes (even if never)

SIMULATING, in the proper case, means simulating the steps of the
program until you can correctly determine the answer for what you are
tying to do the simulation. IF it is about the behavior of actually
running the program, as is the job of a Halt Decider, then it doesn't
matter if the simulation is stopped at some point, but if the simulation
was able to actually PROVE the behavior of the actual program.

With Infinite_Recursion, there ARE proof steps that can be do to atually formally prove that this program can NEVER reach a final state, and
thus, a properly designed H can correctly abort it simulation and say
the program represented by the input does not halt.

Note, This logic has NOTHING to do with "The input simulated by the
Decideer" type questions, but is ALWAYS asking about the behavior of the original machine as run.

If you want to try to define some meaning into your gobbledygook of "D simulated by H", then YOU need to figure out what you can't figure out
how to handle even these trivial cases, you have a LOT of work in front
of you,

So, if YOU are questioning why H can be correct saying its simulation of Infinite-Recursion would be non-halting, why do you think it is correct
about D?

All other points are ignored until this point is
fully addressed.

Yep, YOU need to decide how you want to define this,

If your criteria is NOT about the actual behavior of the actual program,
YOU need to figure out what you want, and how to define it, THEN you can
try to show why this new condition has any actual practical purpose.

Just makinging something very loosely related to halting decidable,
isn't likely going to win many people over.

To go forward a step (ignore if you please, but I see where you are
trying to go.

void Infinite_Simulation(ptr p)
{
     UTM(p, p);
     return;
}

will also be an "infinte behavior" program when looked at as

H(Infinite_Simulation, Infinite_Simulation)

as the FULL loop (including through the UTM) is unconditional.


BUT

void X(ptr p)
{
     H(p,p)
     return
}

is NOT the same if H(X,X) will ever decide to abort and return a
decision, thinking it is like the Infinite_Simulation case, as the
FULL Loop, which includes the code of H, is not unconditional.

And this is true as if we just run X(X), then it will call H(X,X)
which, since you say H(X,X) will eventually decide to abort its
simulation and return, so X(X) WILL reach its final state, and that
says that one of my proposals could detect that and reach past the call.

Note, this is NOT the "imposible program", as it doesn't have the
contray stuff at the end, but your H can't know that, so its logic
must be wrong.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/4/24 8:49 PM, olcott wrote:

On 5/4/2024 7:44 PM, Richard Damon wrote:

On 5/4/24 8:20 PM, olcott wrote:

On 5/4/2024 7:07 PM, Richard Damon wrote:

On 5/4/24 7:51 PM, olcott wrote:

On 5/4/2024 6:32 PM, Richard Damon wrote:

On 5/4/24 7:01 PM, olcott wrote:

On 5/4/2024 5:36 PM, Richard Damon wrote:

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote:

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.

*Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>
I have said this many hundreds of times because this shell-game >>>>>>>>> deception has been ridiculous
https://en.wikipedia.org/wiki/Shell_game

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.

When N steps of D are simulated by the directly executed H
where N is 1 to 1,000,000 no simulated D every reaches past
its own line 03.

When N steps of D are simulated by the directly executed H
where N is 1 to 1,000,000 and H aborts its simulation all of >>>>>>>>> the nested simulations (if any) immediately totally stop running. >>>>>>>>> No simulated H ever returns any value to any simulated D.

(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?

We are not talking about my implemented H we are talking about >>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>

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.

All of the above is based on the false assumption that we are >>>>>>>>> talking about something other than this:

We are not talking about my implemented H we are talking about >>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>

But what do you mean be "Simulated".

What in the definition of simulated allows a call to H that will >>>>>>>> return 0 be simulated as "never returns"?

You already understand that infinite recursion never returns.

Right, trivially, since it isn't infinite if it does return.

So, a recursion call loop that has NOTHING in the loop that can
break it, becomes infinite.

You already understand that recursive simulation is isomorphic to >>>>>>> infinite recursion so I can't see how you can say that you don't >>>>>>> understand these things an be sincere.

But only for UNCONDITIONAL simulation, which H doesn't do.

void Infinite_Recursion(u32 N)
{
   Infinite_Recursion(N);
   return;
}

OK we are down to one single point at a time, when that point is
divided into ten more points only one of them at a time we keep
dividing them until your rebuttal looks like ridiculous nonsense
to everyone including yourself.

The ONLY point right now is that H(Infinite_Recursion, (ptr)5));
is correct when it reports that Infinite_Recursion() never halts
on the basis that Infinite_Recursion simulated by H never reaches
its return statement.

Yes, since Infinite_Recursion has a full unconditional loop back to
the original point, it will be a non-halting program and thus no
correct simulation of it can reach an end, because the program it is
simulating will never reach an end.

But H does not simulate it forever its simulation
of Infinite_Recursion() is conditional. How it is
that Infinite_Recursion() never halts when H stops
simulating it?

Becuase, as you don't seem to understand, the behavior of programs is
what they do as ideal mathematical objects on the ideal mathematical
machine they are concidered to be run on, NOT what some simulation of
them shows.

Ah so you disagree with UTM's why do disagree with UTM's ?
We must stay on this single point until it is fully addressed.
If it is divided into subpoints the same thing goes for each subpoint.

Why do you say I disagree with UTMs?

I UTM is DEFINED that it produces the exact same result as the direct
execution of the machine. A machine is only a UTM if it does that (and
you can't stipulate that a machine is a UTM if it doesn't do that)

A program is a UTM *IF AND ONLY IF* the results it produces ALWAYS
exactly matches the behavior of the direct execution of the program
descirbed to it.

Thus, BY DEFINITION, a UTM can not "abort" its simulation, as the UTM of
a non-halting program must be non-halting (and not just saying
"non-halting").

A UTM doesn't "describe" what the input program does, it recreates the behavior.

YOU seem to have a misunderstanding on this, as you like to call your H
a "UTM" even though it fails to meet the definition.

Of course, that is because you don't understand the definition, of the definition of definitions.

As I have mentioned MAMY times, you seem to have a fundamental
confusion between the RUNNING of the program, and the SIMULATION of it.

This seems to go back to your lack of understand what Truth actually is.


RUNNING is what happens when it is carried out completely correctly,
as with a real correct processor which is left to run, or on the
mathematical model, that runs until it finishes (even if never)

SIMULATING, in the proper case, means simulating the steps of the
program until you can correctly determine the answer for what you are
tying to do the simulation. IF it is about the behavior of actually
running the program, as is the job of a Halt Decider, then it doesn't
matter if the simulation is stopped at some point, but if the
simulation was able to actually PROVE the behavior of the actual program.

With Infinite_Recursion, there ARE proof steps that can be do to
atually formally prove that this program can NEVER reach a final
state, and thus, a properly designed H can correctly abort it
simulation and say the program represented by the input does not halt.

Note, This logic has NOTHING to do with "The input simulated by the
Decideer" type questions, but is ALWAYS asking about the behavior of
the original machine as run.

If you want to try to define some meaning into your gobbledygook of "D
simulated by H", then YOU need to figure out what you can't figure out
how to handle even these trivial cases, you have a LOT of work in
front of you,

So, if YOU are questioning why H can be correct saying its simulation
of Infinite-Recursion would be non-halting, why do you think it is
correct about D?

All other points are ignored until this point is
fully addressed.

Yep, YOU need to decide how you want to define this,

If your criteria is NOT about the actual behavior of the actual
program, YOU need to figure out what you want, and how to define it,
THEN you can try to show why this new condition has any actual
practical purpose.

Just makinging something very loosely related to halting decidable,
isn't likely going to win many people over.

To go forward a step (ignore if you please, but I see where you are
trying to go.

void Infinite_Simulation(ptr p)
{
     UTM(p, p);
     return;
}

will also be an "infinte behavior" program when looked at as

H(Infinite_Simulation, Infinite_Simulation)

as the FULL loop (including through the UTM) is unconditional.


BUT

void X(ptr p)
{
     H(p,p)
     return
}

is NOT the same if H(X,X) will ever decide to abort and return a
decision, thinking it is like the Infinite_Simulation case, as the
FULL Loop, which includes the code of H, is not unconditional.

And this is true as if we just run X(X), then it will call H(X,X)
which, since you say H(X,X) will eventually decide to abort its
simulation and return, so X(X) WILL reach its final state, and that
says that one of my proposals could detect that and reach past the
call.

Note, this is NOT the "imposible program", as it doesn't have the
contray stuff at the end, but your H can't know that, so its logic
must be wrong.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/4/24 9:30 PM, olcott wrote:

On 5/4/2024 8:05 PM, Richard Damon wrote:

On 5/4/24 8:49 PM, olcott wrote:

On 5/4/2024 7:44 PM, Richard Damon wrote:

On 5/4/24 8:20 PM, olcott wrote:

On 5/4/2024 7:07 PM, Richard Damon wrote:

On 5/4/24 7:51 PM, olcott wrote:

On 5/4/2024 6:32 PM, Richard Damon wrote:

On 5/4/24 7:01 PM, olcott wrote:

On 5/4/2024 5:36 PM, Richard Damon wrote:

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote:

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.

*Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>>
I have said this many hundreds of times because this
shell-game deception has been ridiculous
https://en.wikipedia.org/wiki/Shell_game

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.

When N steps of D are simulated by the directly executed H >>>>>>>>>>> where N is 1 to 1,000,000 no simulated D every reaches past >>>>>>>>>>> its own line 03.

When N steps of D are simulated by the directly executed H >>>>>>>>>>> where N is 1 to 1,000,000 and H aborts its simulation all of >>>>>>>>>>> the nested simulations (if any) immediately totally stop >>>>>>>>>>> running.
No simulated H ever returns any value to any simulated D. >>>>>>>>>>>

(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?

We are not talking about my implemented H we are talking about >>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>>

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. >>>>>>>>>>>>

All of the above is based on the false assumption that we are >>>>>>>>>>> talking about something other than this:

We are not talking about my implemented H we are talking about >>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated by H* >>>>>>>>>>>

But what do you mean be "Simulated".

What in the definition of simulated allows a call to H that >>>>>>>>>> will return 0 be simulated as "never returns"?

You already understand that infinite recursion never returns. >>>>>>>>

Right, trivially, since it isn't infinite if it does return.

So, a recursion call loop that has NOTHING in the loop that can >>>>>>>> break it, becomes infinite.

You already understand that recursive simulation is isomorphic >>>>>>>>> to infinite recursion so I can't see how you can say that you >>>>>>>>> don't understand these things an be sincere.

But only for UNCONDITIONAL simulation, which H doesn't do.

void Infinite_Recursion(u32 N)
{
   Infinite_Recursion(N);
   return;
}

OK we are down to one single point at a time, when that point is >>>>>>> divided into ten more points only one of them at a time we keep
dividing them until your rebuttal looks like ridiculous nonsense >>>>>>> to everyone including yourself.

The ONLY point right now is that H(Infinite_Recursion, (ptr)5)); >>>>>>> is correct when it reports that Infinite_Recursion() never halts >>>>>>> on the basis that Infinite_Recursion simulated by H never reaches >>>>>>> its return statement.

Yes, since Infinite_Recursion has a full unconditional loop back
to the original point, it will be a non-halting program and thus
no correct simulation of it can reach an end, because the program
it is simulating will never reach an end.

But H does not simulate it forever its simulation
of Infinite_Recursion() is conditional. How it is
that Infinite_Recursion() never halts when H stops
simulating it?

Becuase, as you don't seem to understand, the behavior of programs
is what they do as ideal mathematical objects on the ideal
mathematical machine they are concidered to be run on, NOT what some
simulation of them shows.

Ah so you disagree with UTM's why do disagree with UTM's ?
We must stay on this single point until it is fully addressed.
If it is divided into subpoints the same thing goes for each subpoint.

Why do you say I disagree with UTMs?

The quoted paragraph that I am referring to.
If you disagree with yourself on this paragraph please elaborate.

If H doesn't simulate it forever, it just isn't a UTM.

Note, you CAN'T just "Stipulate" that a given machine IS a UTM except by defining that it works just like a UTM, which means, for one thing, it
can NEVER abort its simulation, not even after determining that it will simulate this input forever.

You seem to have a trouble understanding that definitions actually
define what they define, and something that doesn't meet the
requirements can't be considered to be the thing it isn't.

And, you H ISN'T a UTM if it aborts its simulation and answer.

I want you to specify all of the cases where a UTM simulation
of an input is wrong.

A UTM simulation of the input CAN'T be wrong, because if a simulator
differs from the actual behavior of the program described by the input,
the simulator is NOT a UTM.

You don't seem to understand the meaning of the terms, or presume that
you can assume that something can be something it isn't.

I UTM is DEFINED that it produces the exact same result as the direct
execution of the machine. A machine is only a UTM if it does that (and
you can't stipulate that a machine is a UTM if it doesn't do that)

A program is a UTM *IF AND ONLY IF* the results it produces ALWAYS
exactly matches the behavior of the direct execution of the program
descirbed to it.

Thus, BY DEFINITION, a UTM can not "abort" its simulation, as the UTM
of a non-halting program must be non-halting (and not just saying
"non-halting").

A UTM doesn't "describe" what the input program does, it recreates the
behavior.

YOU seem to have a misunderstanding on this, as you like to call your
H a "UTM" even though it fails to meet the definition.

Of course, that is because you don't understand the definition, of the
definition of definitions.

As I have mentioned MAMY times, you seem to have a fundamental
confusion between the RUNNING of the program, and the SIMULATION of it. >>>>
This seems to go back to your lack of understand what Truth actually
is.


RUNNING is what happens when it is carried out completely correctly,
as with a real correct processor which is left to run, or on the
mathematical model, that runs until it finishes (even if never)

SIMULATING, in the proper case, means simulating the steps of the
program until you can correctly determine the answer for what you
are tying to do the simulation. IF it is about the behavior of
actually running the program, as is the job of a Halt Decider, then
it doesn't matter if the simulation is stopped at some point, but if
the simulation was able to actually PROVE the behavior of the actual
program.

With Infinite_Recursion, there ARE proof steps that can be do to
atually formally prove that this program can NEVER reach a final
state, and thus, a properly designed H can correctly abort it
simulation and say the program represented by the input does not halt. >>>>
Note, This logic has NOTHING to do with "The input simulated by the
Decideer" type questions, but is ALWAYS asking about the behavior of
the original machine as run.

If you want to try to define some meaning into your gobbledygook of
"D simulated by H", then YOU need to figure out what you can't
figure out how to handle even these trivial cases, you have a LOT of
work in front of you,

So, if YOU are questioning why H can be correct saying its
simulation of Infinite-Recursion would be non-halting, why do you
think it is correct about D?

All other points are ignored until this point is
fully addressed.

Yep, YOU need to decide how you want to define this,

If your criteria is NOT about the actual behavior of the actual
program, YOU need to figure out what you want, and how to define it,
THEN you can try to show why this new condition has any actual
practical purpose.

Just makinging something very loosely related to halting decidable,
isn't likely going to win many people over.

To go forward a step (ignore if you please, but I see where you
are trying to go.

void Infinite_Simulation(ptr p)
{
     UTM(p, p);
     return;
}

will also be an "infinte behavior" program when looked at as

H(Infinite_Simulation, Infinite_Simulation)

as the FULL loop (including through the UTM) is unconditional.


BUT

void X(ptr p)
{
     H(p,p)
     return
}

is NOT the same if H(X,X) will ever decide to abort and return a
decision, thinking it is like the Infinite_Simulation case, as the >>>>>> FULL Loop, which includes the code of H, is not unconditional.

And this is true as if we just run X(X), then it will call H(X,X)
which, since you say H(X,X) will eventually decide to abort its
simulation and return, so X(X) WILL reach its final state, and
that says that one of my proposals could detect that and reach
past the call.

Note, this is NOT the "imposible program", as it doesn't have the
contray stuff at the end, but your H can't know that, so its logic >>>>>> must be wrong.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Op 05.mei.2024 om 05:17 schreef olcott:

On 5/4/2024 9:49 PM, Richard Damon wrote:

On 5/4/24 9:30 PM, olcott wrote:

On 5/4/2024 8:05 PM, Richard Damon wrote:

On 5/4/24 8:49 PM, olcott wrote:

On 5/4/2024 7:44 PM, Richard Damon wrote:

On 5/4/24 8:20 PM, olcott wrote:

On 5/4/2024 7:07 PM, Richard Damon wrote:

On 5/4/24 7:51 PM, olcott wrote:

On 5/4/2024 6:32 PM, Richard Damon wrote:

On 5/4/24 7:01 PM, olcott wrote:

On 5/4/2024 5:36 PM, Richard Damon wrote:

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote:

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.

*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*

I have said this many hundreds of times because this >>>>>>>>>>>>> shell-game deception has been ridiculous
https://en.wikipedia.org/wiki/Shell_game

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.

When N steps of D are simulated by the directly executed H >>>>>>>>>>>>> where N is 1 to 1,000,000 no simulated D every reaches past >>>>>>>>>>>>> its own line 03.

When N steps of D are simulated by the directly executed H >>>>>>>>>>>>> where N is 1 to 1,000,000 and H aborts its simulation all of >>>>>>>>>>>>> the nested simulations (if any) immediately totally stop >>>>>>>>>>>>> running.
No simulated H ever returns any value to any simulated D. >>>>>>>>>>>>>

(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?

We are not talking about my implemented H we are talking about >>>>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*

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. >>>>>>>>>>>>>>

All of the above is based on the false assumption that we >>>>>>>>>>>>> are talking about something other than this:

We are not talking about my implemented H we are talking about >>>>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*

But what do you mean be "Simulated".

What in the definition of simulated allows a call to H that >>>>>>>>>>>> will return 0 be simulated as "never returns"?

You already understand that infinite recursion never returns. >>>>>>>>>>

Right, trivially, since it isn't infinite if it does return. >>>>>>>>>>
So, a recursion call loop that has NOTHING in the loop that >>>>>>>>>> can break it, becomes infinite.

You already understand that recursive simulation is
isomorphic to infinite recursion so I can't see how you can >>>>>>>>>>> say that you don't understand these things an be sincere. >>>>>>>>>>

But only for UNCONDITIONAL simulation, which H doesn't do. >>>>>>>>>>

void Infinite_Recursion(u32 N)
{
   Infinite_Recursion(N);
   return;
}

OK we are down to one single point at a time, when that point is >>>>>>>>> divided into ten more points only one of them at a time we keep >>>>>>>>> dividing them until your rebuttal looks like ridiculous nonsense >>>>>>>>> to everyone including yourself.

The ONLY point right now is that H(Infinite_Recursion, (ptr)5)); >>>>>>>>> is correct when it reports that Infinite_Recursion() never halts >>>>>>>>> on the basis that Infinite_Recursion simulated by H never reaches >>>>>>>>> its return statement.

Yes, since Infinite_Recursion has a full unconditional loop back >>>>>>>> to the original point, it will be a non-halting program and thus >>>>>>>> no correct simulation of it can reach an end, because the
program it is simulating will never reach an end.

But H does not simulate it forever its simulation
of Infinite_Recursion() is conditional. How it is
that Infinite_Recursion() never halts when H stops
simulating it?

Becuase, as you don't seem to understand, the behavior of programs >>>>>> is what they do as ideal mathematical objects on the ideal
mathematical machine they are concidered to be run on, NOT what
some simulation of them shows.

Ah so you disagree with UTM's why do disagree with UTM's ?
We must stay on this single point until it is fully addressed.
If it is divided into subpoints the same thing goes for each subpoint. >>>>

Why do you say I disagree with UTMs?

The quoted paragraph that I am referring to.
If you disagree with yourself on this paragraph please elaborate.

If H doesn't simulate it forever, it just isn't a UTM.

Whoa, Factorial of 5 must simulate forever?

Note, you CAN'T just "Stipulate" that a given machine IS a UTM except
by defining that it works just like a UTM, which means, for one thing,
it can NEVER abort its simulation, not even after determining that it
will simulate this input forever.

None-the-less a TM that correctly simulates N steps
cannot be said to have simulated those N steps incorrectly
on the basis that it could have simulated N+1 steps.

Those N steps were simulated correctly, but the fact that it stops after
N steps make it an incorrect simulation.
If I order a diner in the restaurant and only the first few steps are
done correctly (writing down the order, bringing the order to the
kitchen), but then the operation is aborted, we cannot say that the
order was processed correctly, even though any step executed was correct
and nobody can point to a step before the abort that was wrong. It is
the abort itself that makes it wrong. Similarly, a simulation that
aborts is not a correct simulation.
Olcott will probably insist that the waiter did a good job, even if I do
not get my diner, because every step of the waiter before he aborted the
order was correct.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/4/24 11:17 PM, olcott wrote:

On 5/4/2024 9:49 PM, Richard Damon wrote:

On 5/4/24 9:30 PM, olcott wrote:

On 5/4/2024 8:05 PM, Richard Damon wrote:

On 5/4/24 8:49 PM, olcott wrote:

On 5/4/2024 7:44 PM, Richard Damon wrote:

On 5/4/24 8:20 PM, olcott wrote:

On 5/4/2024 7:07 PM, Richard Damon wrote:

On 5/4/24 7:51 PM, olcott wrote:

On 5/4/2024 6:32 PM, Richard Damon wrote:

On 5/4/24 7:01 PM, olcott wrote:

On 5/4/2024 5:36 PM, Richard Damon wrote:

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote:

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.

*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*

I have said this many hundreds of times because this >>>>>>>>>>>>> shell-game deception has been ridiculous
https://en.wikipedia.org/wiki/Shell_game

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.

When N steps of D are simulated by the directly executed H >>>>>>>>>>>>> where N is 1 to 1,000,000 no simulated D every reaches past >>>>>>>>>>>>> its own line 03.

When N steps of D are simulated by the directly executed H >>>>>>>>>>>>> where N is 1 to 1,000,000 and H aborts its simulation all of >>>>>>>>>>>>> the nested simulations (if any) immediately totally stop >>>>>>>>>>>>> running.
No simulated H ever returns any value to any simulated D. >>>>>>>>>>>>>

(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?

We are not talking about my implemented H we are talking about >>>>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*

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. >>>>>>>>>>>>>>

All of the above is based on the false assumption that we >>>>>>>>>>>>> are talking about something other than this:

We are not talking about my implemented H we are talking about >>>>>>>>>>>>> *Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*
*Every H/D pair (of the infinite set) where D is simulated >>>>>>>>>>>>> by H*

But what do you mean be "Simulated".

What in the definition of simulated allows a call to H that >>>>>>>>>>>> will return 0 be simulated as "never returns"?

You already understand that infinite recursion never returns. >>>>>>>>>>

Right, trivially, since it isn't infinite if it does return. >>>>>>>>>>
So, a recursion call loop that has NOTHING in the loop that >>>>>>>>>> can break it, becomes infinite.

You already understand that recursive simulation is
isomorphic to infinite recursion so I can't see how you can >>>>>>>>>>> say that you don't understand these things an be sincere. >>>>>>>>>>

But only for UNCONDITIONAL simulation, which H doesn't do. >>>>>>>>>>

void Infinite_Recursion(u32 N)
{
   Infinite_Recursion(N);
   return;
}

OK we are down to one single point at a time, when that point is >>>>>>>>> divided into ten more points only one of them at a time we keep >>>>>>>>> dividing them until your rebuttal looks like ridiculous nonsense >>>>>>>>> to everyone including yourself.

The ONLY point right now is that H(Infinite_Recursion, (ptr)5)); >>>>>>>>> is correct when it reports that Infinite_Recursion() never halts >>>>>>>>> on the basis that Infinite_Recursion simulated by H never reaches >>>>>>>>> its return statement.

Yes, since Infinite_Recursion has a full unconditional loop back >>>>>>>> to the original point, it will be a non-halting program and thus >>>>>>>> no correct simulation of it can reach an end, because the
program it is simulating will never reach an end.

But H does not simulate it forever its simulation
of Infinite_Recursion() is conditional. How it is
that Infinite_Recursion() never halts when H stops
simulating it?

Becuase, as you don't seem to understand, the behavior of programs >>>>>> is what they do as ideal mathematical objects on the ideal
mathematical machine they are concidered to be run on, NOT what
some simulation of them shows.

Ah so you disagree with UTM's why do disagree with UTM's ?
We must stay on this single point until it is fully addressed.
If it is divided into subpoints the same thing goes for each subpoint. >>>>

Why do you say I disagree with UTMs?

The quoted paragraph that I am referring to.
If you disagree with yourself on this paragraph please elaborate.

If H doesn't simulate it forever, it just isn't a UTM.

Whoa, Factorial of 5 must simulate forever?

WHy do you say that?

If you reach a final state, then you reached the final state and have
nothing more to do.

Note, you CAN'T just "Stipulate" that a given machine IS a UTM except
by defining that it works just like a UTM, which means, for one thing,
it can NEVER abort its simulation, not even after determining that it
will simulate this input forever.

None-the-less a TM that correctly simulates N steps
cannot be said to have simulated those N steps incorrectly
on the basis that it could have simulated N+1 steps.

Right, but neither does it say whether the machine it simulates halts in
more than N steps or runs forever.

You seem to have a trouble understanding that definitions actually
define what they define, and something that doesn't meet the
requirements can't be considered to be the thing it isn't.

I get into more nuances than the textbooks bother to discuss.
That I get into more nuances than the textbooks bother to discuss
does not make me wrong.

No, you just get it wrong because you don't know what the textbooks
actually say the rules of the theory are.

And, you H ISN'T a UTM if it aborts its simulation and answer.

I want you to specify all of the cases where a UTM simulation
of an input is wrong.

A UTM simulation of the input CAN'T be wrong, because if a simulator
differs from the actual behavior of the program described by the
input, the simulator is NOT a UTM.

You don't seem to understand the meaning of the terms, or presume that
you can assume that something can be something it isn't.

I am trying to provide the basis for you to correctly extrapolate
beyond what the textbooks say. Many people act as if all new ideas
are always wrong because these new ideas do not precisely parrot
existing ideas. There really is a correct extrapolation from existing
ideas to new ideas and these new ideas are not inherently incorrect.

But then you could show how your answers actually do fit the
requirements of the actual theory, which you can't.

You can't actually extrapolate past the textbooks if you don't know what
the textbooks say.

The fact that you show a failure to understand so many basic terms shows
that you don't understand what the textbooks are saying.

You seem to be working off of a quick scan of the Cliff Notes of the
textbook and then guessing what it must have said.

I UTM is DEFINED that it produces the exact same result as the
direct execution of the machine. A machine is only a UTM if it does
that (and you can't stipulate that a machine is a UTM if it doesn't
do that)

A program is a UTM *IF AND ONLY IF* the results it produces ALWAYS
exactly matches the behavior of the direct execution of the program
descirbed to it.

Thus, BY DEFINITION, a UTM can not "abort" its simulation, as the
UTM of a non-halting program must be non-halting (and not just
saying "non-halting").

A UTM doesn't "describe" what the input program does, it recreates
the behavior.

YOU seem to have a misunderstanding on this, as you like to call
your H a "UTM" even though it fails to meet the definition.

Of course, that is because you don't understand the definition, of
the definition of definitions.

As I have mentioned MAMY times, you seem to have a fundamental
confusion between the RUNNING of the program, and the SIMULATION
of it.

This seems to go back to your lack of understand what Truth
actually is.


RUNNING is what happens when it is carried out completely
correctly, as with a real correct processor which is left to run,
or on the mathematical model, that runs until it finishes (even if >>>>>> never)

SIMULATING, in the proper case, means simulating the steps of the
program until you can correctly determine the answer for what you
are tying to do the simulation. IF it is about the behavior of
actually running the program, as is the job of a Halt Decider,
then it doesn't matter if the simulation is stopped at some point, >>>>>> but if the simulation was able to actually PROVE the behavior of
the actual program.

With Infinite_Recursion, there ARE proof steps that can be do to
atually formally prove that this program can NEVER reach a final
state, and thus, a properly designed H can correctly abort it
simulation and say the program represented by the input does not
halt.

Note, This logic has NOTHING to do with "The input simulated by
the Decideer" type questions, but is ALWAYS asking about the
behavior of the original machine as run.

If you want to try to define some meaning into your gobbledygook
of "D simulated by H", then YOU need to figure out what you can't
figure out how to handle even these trivial cases, you have a LOT
of work in front of you,

So, if YOU are questioning why H can be correct saying its
simulation of Infinite-Recursion would be non-halting, why do you
think it is correct about D?

All other points are ignored until this point is
fully addressed.

Yep, YOU need to decide how you want to define this,

If your criteria is NOT about the actual behavior of the actual
program, YOU need to figure out what you want, and how to define
it, THEN you can try to show why this new condition has any actual >>>>>> practical purpose.

Just makinging something very loosely related to halting
decidable, isn't likely going to win many people over.

To go forward a step (ignore if you please, but I see where you >>>>>>>> are trying to go.

void Infinite_Simulation(ptr p)
{
     UTM(p, p);
     return;
}

will also be an "infinte behavior" program when looked at as

H(Infinite_Simulation, Infinite_Simulation)

as the FULL loop (including through the UTM) is unconditional. >>>>>>>>

BUT

void X(ptr p)
{
     H(p,p)
     return
}

is NOT the same if H(X,X) will ever decide to abort and return a >>>>>>>> decision, thinking it is like the Infinite_Simulation case, as >>>>>>>> the FULL Loop, which includes the code of H, is not unconditional. >>>>>>>>
And this is true as if we just run X(X), then it will call
H(X,X) which, since you say H(X,X) will eventually decide to
abort its simulation and return, so X(X) WILL reach its final
state, and that says that one of my proposals could detect that >>>>>>>> and reach past the call.

Note, this is NOT the "imposible program", as it doesn't have
the contray stuff at the end, but your H can't know that, so its >>>>>>>> logic must be wrong.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Am Sun, 05 May 2024 09:30:20 -0500 schrieb olcott:

On 5/5/2024 5:36 AM, Fred. Zwarts wrote:

Op 05.mei.2024 om 05:17 schreef olcott:

On 5/4/2024 9:49 PM, Richard Damon wrote:

On 5/4/24 9:30 PM, olcott wrote:

On 5/4/2024 8:05 PM, Richard Damon wrote:

On 5/4/24 8:49 PM, olcott wrote:

On 5/4/2024 7:44 PM, Richard Damon wrote:

On 5/4/24 8:20 PM, olcott wrote:

On 5/4/2024 7:07 PM, Richard Damon wrote:

On 5/4/24 7:51 PM, olcott wrote:

On 5/4/2024 6:32 PM, Richard Damon wrote:

On 5/4/24 7:01 PM, olcott wrote:

On 5/4/2024 5:36 PM, Richard Damon wrote:

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote:

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:

[please snip your replies a little]

Note, you CAN'T just "Stipulate" that a given machine IS a UTM except
by defining that it works just like a UTM, which means, for one
thing, it can NEVER abort its simulation, not even after determining
that it will simulate this input forever.

None-the-less a TM that correctly simulates N steps cannot be said to
have simulated those N steps incorrectly on the basis that it could
have simulated N+1 steps.

Those N steps were simulated correctly, but the fact that it stops
after N steps make it an incorrect simulation.

In other words a decider is wrong unless it never stops simulating an non-halting input?

Correct. Simulating here means producing the exact same behaviour.
If it is correct up to a point, it might still make a mistake later.
The only way to know is to keep simulating.

--
joes

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/5/24 10:30 AM, olcott wrote:

On 5/5/2024 5:36 AM, Fred. Zwarts wrote:

Those N steps were simulated correctly, but the fact that it stops
after N steps make it an incorrect simulation.

In other words a decider is wrong unless it never
stops simulating an non-halting input?

No, the decider is wrong if it gives the wrong answer.

Now, if to determine the correct answer requires simulating more, then
it needs to simulate more.

If to determine the correct answer requires simulating to the end, it
needs to simulate to the end, even if that takes forever.

If it needs to simulate forever, but also needs to answer in finite
time, then the method has just been shown not to meet the requirements.

If I order a diner in the restaurant and only the first few steps are
done correctly (writing down the order, bringing the order to the
kitchen), but then the operation is aborted, we cannot say that the
order was processed correctly, even though any step executed was
correct and nobody can point to a step before the abort that was
wrong. It is the abort itself that makes it wrong. Similarly, a
simulation that aborts is not a correct simulation.
Olcott will probably insist that the waiter did a good job, even if I
do not get my diner, because every step of the waiter before he
aborted the order was correct.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/5/24 12:22 PM, olcott wrote:

On 5/5/2024 10:42 AM, joes wrote:

Am Sun, 05 May 2024 09:30:20 -0500 schrieb olcott:

On 5/5/2024 5:36 AM, Fred. Zwarts wrote:

Op 05.mei.2024 om 05:17 schreef olcott:

On 5/4/2024 9:49 PM, Richard Damon wrote:

On 5/4/24 9:30 PM, olcott wrote:

On 5/4/2024 8:05 PM, Richard Damon wrote:

On 5/4/24 8:49 PM, olcott wrote:

On 5/4/2024 7:44 PM, Richard Damon wrote:

On 5/4/24 8:20 PM, olcott wrote:

On 5/4/2024 7:07 PM, Richard Damon wrote:

On 5/4/24 7:51 PM, olcott wrote:

On 5/4/2024 6:32 PM, Richard Damon wrote:

On 5/4/24 7:01 PM, olcott wrote:

On 5/4/2024 5:36 PM, Richard Damon wrote:

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote:

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:

[please snip your replies a little]

Note, you CAN'T just "Stipulate" that a given machine IS a UTM except >>>>>> by defining that it works just like a UTM, which means, for one
thing, it can NEVER abort its simulation, not even after determining >>>>>> that it will simulate this input forever.

None-the-less a TM that correctly simulates N steps cannot be said to >>>>> have simulated those N steps incorrectly on the basis that it could
have simulated N+1 steps.

Those N steps were simulated correctly, but the fact that it stops
after N steps make it an incorrect simulation.

In other words a decider is wrong unless it never stops simulating an
non-halting input?

Correct. Simulating here means producing the exact same behaviour.
If it is correct up to a point, it might still make a mistake later.
The only way to know is to keep simulating.

That sounds screwy when the input computes factorial(5)

And if the simultor doesn't simulate enough to actually know the correct
answer to the quesition about the behavior of the program described by
the input, then it didn't simulate enough.

Since factorial(5) will finish in finite time, any aborting and saying
the input is non-halting would be incorrect.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/5/24 12:29 PM, olcott wrote:

On 5/5/2024 10:42 AM, joes wrote:

Am Sun, 05 May 2024 09:30:20 -0500 schrieb olcott:

On 5/5/2024 5:36 AM, Fred. Zwarts wrote:

Op 05.mei.2024 om 05:17 schreef olcott:

On 5/4/2024 9:49 PM, Richard Damon wrote:

On 5/4/24 9:30 PM, olcott wrote:

On 5/4/2024 8:05 PM, Richard Damon wrote:

On 5/4/24 8:49 PM, olcott wrote:

On 5/4/2024 7:44 PM, Richard Damon wrote:

On 5/4/24 8:20 PM, olcott wrote:

On 5/4/2024 7:07 PM, Richard Damon wrote:

On 5/4/24 7:51 PM, olcott wrote:

On 5/4/2024 6:32 PM, Richard Damon wrote:

On 5/4/24 7:01 PM, olcott wrote:

On 5/4/2024 5:36 PM, Richard Damon wrote:

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote:

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:

[please snip your replies a little]

Note, you CAN'T just "Stipulate" that a given machine IS a UTM except >>>>>> by defining that it works just like a UTM, which means, for one
thing, it can NEVER abort its simulation, not even after determining >>>>>> that it will simulate this input forever.

None-the-less a TM that correctly simulates N steps cannot be said to >>>>> have simulated those N steps incorrectly on the basis that it could
have simulated N+1 steps.

Those N steps were simulated correctly, but the fact that it stops
after N steps make it an incorrect simulation.

In other words a decider is wrong unless it never stops simulating an
non-halting input?

Correct. Simulating here means producing the exact same behaviour.
If it is correct up to a point, it might still make a mistake later.
The only way to know is to keep simulating.

void Infinite_Recursion(u32 N)
{
  Infinite_Recursion(N);
}

It is counter-factual that the above must be infinitely
simulated to correctly determine that it never halts.

No, it doesn't need to be simulated forever to determine that it doesn't
halt.

But, H needs to be able to show that if this EXACT input was given to a
UTM simulator that will not stop until it reaches the end will not reach
an end to be able to correctly say the input is non-halting.

That works with Infinite_Recursion and Infinite_Simulation, but NOT for
a program that calls H, since H doesn't UNCONDITIONALLY simulate its input.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Am Sun, 05 May 2024 11:29:38 -0500 schrieb olcott:

On 5/5/2024 10:42 AM, joes wrote:

Am Sun, 05 May 2024 09:30:20 -0500 schrieb olcott:

On 5/5/2024 5:36 AM, Fred. Zwarts wrote:

Op 05.mei.2024 om 05:17 schreef olcott:

On 5/4/2024 9:49 PM, Richard Damon wrote:

On 5/4/24 9:30 PM, olcott wrote:

On 5/4/2024 8:05 PM, Richard Damon wrote:

On 5/4/24 8:49 PM, olcott wrote:

On 5/4/2024 7:44 PM, Richard Damon wrote:

On 5/4/24 8:20 PM, olcott wrote:

On 5/4/2024 7:07 PM, Richard Damon wrote:

On 5/4/24 7:51 PM, olcott wrote:

On 5/4/2024 6:32 PM, Richard Damon wrote:

On 5/4/24 7:01 PM, olcott wrote:

On 5/4/2024 5:36 PM, Richard Damon wrote:

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote:

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:

[please snip your replies a little]

Note, you CAN'T just "Stipulate" that a given machine IS a UTM
except by defining that it works just like a UTM, which means, for >>>>>> one thing, it can NEVER abort its simulation, not even after
determining that it will simulate this input forever.

None-the-less a TM that correctly simulates N steps cannot be said
to have simulated those N steps incorrectly on the basis that it
could have simulated N+1 steps.

Those N steps were simulated correctly, but the fact that it stops
after N steps make it an incorrect simulation.

In other words a decider is wrong unless it never stops simulating an
non-halting input?

Correct. Simulating here means producing the exact same behaviour. If
it is correct up to a point, it might still make a mistake later.
The only way to know is to keep simulating.

void Infinite_Recursion(u32 N)
{
Infinite_Recursion(N);
}

It is counter-factual that the above must be infinitely simulated to correctly determine that it never halts.

But then it is not „simulation”, rather (static) analysis.

--
joes

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/5/24 11:13 AM, olcott wrote:

On 5/5/2024 6:10 AM, Richard Damon wrote:

On 5/4/24 11:17 PM, olcott wrote:

On 5/4/2024 9:49 PM, Richard Damon wrote:

On 5/4/24 9:30 PM, olcott wrote:

On 5/4/2024 8:05 PM, Richard Damon wrote:

On 5/4/24 8:49 PM, olcott wrote:

On 5/4/2024 7:44 PM, Richard Damon wrote:

On 5/4/24 8:20 PM, olcott wrote:

On 5/4/2024 7:07 PM, Richard Damon wrote:

On 5/4/24 7:51 PM, olcott wrote:

On 5/4/2024 6:32 PM, Richard Damon wrote:

On 5/4/24 7:01 PM, olcott wrote:

On 5/4/2024 5:36 PM, Richard Damon wrote:

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote:

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.

*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*
*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*
*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*
*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*
*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*

I have said this many hundreds of times because this >>>>>>>>>>>>>>> shell-game deception has been ridiculous
https://en.wikipedia.org/wiki/Shell_game

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. >>>>>>>>>>>>>>>

When N steps of D are simulated by the directly executed H >>>>>>>>>>>>>>> where N is 1 to 1,000,000 no simulated D every reaches past >>>>>>>>>>>>>>> its own line 03.

When N steps of D are simulated by the directly executed H >>>>>>>>>>>>>>> where N is 1 to 1,000,000 and H aborts its simulation all of >>>>>>>>>>>>>>> the nested simulations (if any) immediately totally stop >>>>>>>>>>>>>>> running.
No simulated H ever returns any value to any simulated D. >>>>>>>>>>>>>>>

(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?

We are not talking about my implemented H we are talking >>>>>>>>>>>>>>> about
*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*
*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*
*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*
*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*
*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*

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.

All of the above is based on the false assumption that we >>>>>>>>>>>>>>> are talking about something other than this:

We are not talking about my implemented H we are talking >>>>>>>>>>>>>>> about
*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*
*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*
*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*
*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*
*Every H/D pair (of the infinite set) where D is >>>>>>>>>>>>>>> simulated by H*

But what do you mean be "Simulated".

What in the definition of simulated allows a call to H >>>>>>>>>>>>>> that will return 0 be simulated as "never returns"? >>>>>>>>>>>>>>

You already understand that infinite recursion never returns. >>>>>>>>>>>>

Right, trivially, since it isn't infinite if it does return. >>>>>>>>>>>>
So, a recursion call loop that has NOTHING in the loop that >>>>>>>>>>>> can break it, becomes infinite.

You already understand that recursive simulation is
isomorphic to infinite recursion so I can't see how you can >>>>>>>>>>>>> say that you don't understand these things an be sincere. >>>>>>>>>>>>

But only for UNCONDITIONAL simulation, which H doesn't do. >>>>>>>>>>>>

void Infinite_Recursion(u32 N)
{
   Infinite_Recursion(N);
   return;
}

OK we are down to one single point at a time, when that point is >>>>>>>>>>> divided into ten more points only one of them at a time we keep >>>>>>>>>>> dividing them until your rebuttal looks like ridiculous nonsense >>>>>>>>>>> to everyone including yourself.

The ONLY point right now is that H(Infinite_Recursion, (ptr)5)); >>>>>>>>>>> is correct when it reports that Infinite_Recursion() never halts >>>>>>>>>>> on the basis that Infinite_Recursion simulated by H never >>>>>>>>>>> reaches
its return statement.

Yes, since Infinite_Recursion has a full unconditional loop >>>>>>>>>> back to the original point, it will be a non-halting program >>>>>>>>>> and thus no correct simulation of it can reach an end, because >>>>>>>>>> the program it is simulating will never reach an end.

But H does not simulate it forever its simulation
of Infinite_Recursion() is conditional. How it is
that Infinite_Recursion() never halts when H stops
simulating it?

Becuase, as you don't seem to understand, the behavior of
programs is what they do as ideal mathematical objects on the
ideal mathematical machine they are concidered to be run on, NOT >>>>>>>> what some simulation of them shows.

Ah so you disagree with UTM's why do disagree with UTM's ?
We must stay on this single point until it is fully addressed.
If it is divided into subpoints the same thing goes for each
subpoint.

Why do you say I disagree with UTMs?

The quoted paragraph that I am referring to.
If you disagree with yourself on this paragraph please elaborate.

If H doesn't simulate it forever, it just isn't a UTM.

Whoa, Factorial of 5 must simulate forever?

WHy do you say that?

Go back and look at the words that I responded to.

If H doesn't simulate it forever, it just isn't a UTM.

Thus when a UTM does not simulate factorial 5 forever it is not a UTM.

If you reach a final state, then you reached the final state and have
nothing more to do.

That it not what you said.

If H doesn't simulate it forever, it just isn't a UTM.

Note, you CAN'T just "Stipulate" that a given machine IS a UTM
except by defining that it works just like a UTM, which means, for
one thing, it can NEVER abort its simulation, not even after
determining that it will simulate this input forever.

None-the-less a TM that correctly simulates N steps
cannot be said to have simulated those N steps incorrectly
on the basis that it could have simulated N+1 steps.

Right, but neither does it say whether the machine it simulates halts
in more than N steps or runs forever.

Right. The simple fact that H stopped simulating after N steps
proves nothing by itself. However it is dead obvious that simulating termination analyzer are required to abort their simulation at some
point after they recognize a non-terminating behavior pattern. If
they don't do this they are wrong.

Yep, but that requirement to answer after some period of time doesn't
mean that they know the correct answer at that point.

Just because you accepted the task of doing the impossible, doesn't give
you the ability to claim a wrong answer is right.

You seem to have a trouble understanding that definitions actually
define what they define, and something that doesn't meet the
requirements can't be considered to be the thing it isn't.

I get into more nuances than the textbooks bother to discuss.
That I get into more nuances than the textbooks bother to discuss
does not make me wrong.

No, you just get it wrong because you don't know what the textbooks
actually say the rules of the theory are.

I do know all of this stuff and then extend beyond it.
You are saying that I am wrong about things that are a correct
extrapolation from what the textbooks say.

Nope.

It is clear you don't understand what the textbooks actually say.

You have admitted that much, that you were surprised to learn the actual meaning of some of the fundamental terms.

You can't "extrapolate" from something you don't understand.

This is just like Fulton's Folly. We never had steamboats
before thus it is ridiculous non-sense to believe that we
can possibly have them in the future.

Nope.

And, you H ISN'T a UTM if it aborts its simulation and answer.

I want you to specify all of the cases where a UTM simulation
of an input is wrong.

A UTM simulation of the input CAN'T be wrong, because if a simulator
differs from the actual behavior of the program described by the
input, the simulator is NOT a UTM.

You don't seem to understand the meaning of the terms, or presume
that you can assume that something can be something it isn't.

I am trying to provide the basis for you to correctly extrapolate
beyond what the textbooks say. Many people act as if all new ideas
are always wrong because these new ideas do not precisely parrot
existing ideas. There really is a correct extrapolation from existing
ideas to new ideas and these new ideas are not inherently incorrect.

But then you could show how your answers actually do fit the
requirements of the actual theory, which you can't.

Extrapolations beyond what is known cannot be fully justified
within what is known.

You can't actually extrapolate past the textbooks if you don't know
what the textbooks say.

I have never made any mistake on this in years. Initially I was
shocked that C can do things that do not count as computable functions.

I finally have a good measure for discerning which C functions are
computable functions. https://en.wikipedia.org/wiki/Pure_function
I checked that with experts on technical forums.

I also have Mike to thank for validating that a UTM can look into to
any details of the internal state of its simulated Turing Machine
Description as it progresses through the steps of simulating this TMD
and still be a computable function. https://en.wikipedia.org/wiki/Computable_function

The fact that you show a failure to understand so many basic terms
shows that you don't understand what the textbooks are saying.

Try and point this out and it will probably shown your own confusion
about what I am saying. You do seem to have a very hard time paying
complete attention to every word in a sentence. I make this mistake
sometimes too. I fix it by reading and rereading what I said.

You seem to be working off of a quick scan of the Cliff Notes of the
textbook and then guessing what it must have said.

Point out specific mistakes or your above assessment will be
construed as baseless defamation.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/5/24 10:23 AM, olcott wrote:

Sure and if you ate half a hamburger then you incorrectly
ate a hamburger. We cannot say that you ate half a hamburger
correctly when our purpose is unjustified denigration.

If you ate just half a hamburger and said (or were told to) you ate a
whole one, you would be wrong.

IF you said or were told to eat SOME Hamburger, you would be correct.

If you said you ate ALL your Hamburger, but you were not given a
Hamburger to eat, you would have been correct.


That you fill your speech with lies, makes pointing them out not
unjustified denigration.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Am Sun, 05 May 2024 11:22:06 -0500 schrieb olcott:

On 5/5/2024 10:42 AM, joes wrote:

Am Sun, 05 May 2024 09:30:20 -0500 schrieb olcott:

On 5/5/2024 5:36 AM, Fred. Zwarts wrote:

Op 05.mei.2024 om 05:17 schreef olcott:

On 5/4/2024 9:49 PM, Richard Damon wrote:

On 5/4/24 9:30 PM, olcott wrote:

On 5/4/2024 8:05 PM, Richard Damon wrote:

On 5/4/24 8:49 PM, olcott wrote:

On 5/4/2024 7:44 PM, Richard Damon wrote:

On 5/4/24 8:20 PM, olcott wrote:

On 5/4/2024 7:07 PM, Richard Damon wrote:

On 5/4/24 7:51 PM, olcott wrote:

On 5/4/2024 6:32 PM, Richard Damon wrote:

On 5/4/24 7:01 PM, olcott wrote:

On 5/4/2024 5:36 PM, Richard Damon wrote:

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote:

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: >>>>>>>>>>>>>>>>>>>>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> >>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:

[please snip your replies a little]

Note, you CAN'T just "Stipulate" that a given machine IS a UTM
except by defining that it works just like a UTM, which means, for >>>>>> one thing, it can NEVER abort its simulation, not even after
determining that it will simulate this input forever.

None-the-less a TM that correctly simulates N steps cannot be said
to have simulated those N steps incorrectly on the basis that it
could have simulated N+1 steps.

Those N steps were simulated correctly, but the fact that it stops
after N steps make it an incorrect simulation.

In other words a decider is wrong unless it never stops simulating an
non-halting input?

Correct. Simulating here means producing the exact same behaviour. If
it is correct up to a point, it might still make a mistake later.
The only way to know is to keep simulating.

That sounds screwy when the input computes factorial(5)

Screwy? One can write a function that starts behaving like factorial(5)
but later diverges. You can not know beforehand.

--
joes

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/5/24 1:03 PM, joes wrote:

Screwy? One can write a function that starts behaving like factorial(5)
but later diverges. You can not know beforehand.

Right, if an input actually represents a halting program, then showing
that tends to require seeing the full execution of the program to the
very end, as there might be a twist in the code that hasn't been seen yet,

This is one reason that H(D,D) can just look at this part of D:


void D(ptr p)
{
unsigned v = H(p,p);
...
}


and be able to correctly determine the behavior of D (unless H just
never returns, and thus makes that part of D non-halting, but then H
never gave that correct answer to anyone, so can't have correctly decided).

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/5/24 1:28 PM, olcott wrote:

On 5/5/2024 11:46 AM, Richard Damon wrote:

On 5/5/24 12:29 PM, olcott wrote:

On 5/5/2024 10:42 AM, joes wrote:

Am Sun, 05 May 2024 09:30:20 -0500 schrieb olcott:

On 5/5/2024 5:36 AM, Fred. Zwarts wrote:

Op 05.mei.2024 om 05:17 schreef olcott:

On 5/4/2024 9:49 PM, Richard Damon wrote:

On 5/4/24 9:30 PM, olcott wrote:

On 5/4/2024 8:05 PM, Richard Damon wrote:

On 5/4/24 8:49 PM, olcott wrote:

On 5/4/2024 7:44 PM, Richard Damon wrote:

On 5/4/24 8:20 PM, olcott wrote:

On 5/4/2024 7:07 PM, Richard Damon wrote:

On 5/4/24 7:51 PM, olcott wrote:

On 5/4/2024 6:32 PM, Richard Damon wrote:

On 5/4/24 7:01 PM, olcott wrote:

On 5/4/2024 5:36 PM, Richard Damon wrote:

On 5/4/24 6:08 PM, olcott wrote:

On 5/4/2024 4:43 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> 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:

[please snip your replies a little]

Note, you CAN'T just "Stipulate" that a given machine IS a UTM >>>>>>>> except
by defining that it works just like a UTM, which means, for one >>>>>>>> thing, it can NEVER abort its simulation, not even after
determining
that it will simulate this input forever.

None-the-less a TM that correctly simulates N steps cannot be
said to
have simulated those N steps incorrectly on the basis that it could >>>>>>> have simulated N+1 steps.

Those N steps were simulated correctly, but the fact that it stops >>>>>> after N steps make it an incorrect simulation.

In other words a decider is wrong unless it never stops simulating an >>>>> non-halting input?

Correct. Simulating here means producing the exact same behaviour.
If it is correct up to a point, it might still make a mistake later.
The only way to know is to keep simulating.

void Infinite_Recursion(u32 N)
{
   Infinite_Recursion(N);
}

It is counter-factual that the above must be infinitely
simulated to correctly determine that it never halts.

No, it doesn't need to be simulated forever to determine that it
doesn't halt.

But, H needs to be able to show that if this EXACT input was given to
a UTM simulator that will not stop until it reaches the end will not
reach an end to be able to correctly say the input is non-halting.

That works with Infinite_Recursion and Infinite_Simulation, but NOT
for a program that calls H, since H doesn't UNCONDITIONALLY simulate
its input.

*I PROVED OTHERWISE IN MY NEW POST*
[Every D(D) simulated by H presents non-halting behavior to H]

Nope.

You have yet to answer my refutaion of your point (a)

From this we can definitely know that every D(D) of the infinite set of
H/D pairs where this D(D) is simulated by the H that this D(D) calls
that this D(D) presents non-halting behavior to this H.

Nope. A halting program can not present "non-halting behavior to a
correct decider".

Just more of your LIES and proof of your utter stuipdity.

The fact that you can't refute my example, shows how bad your arguement actually is,

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/5/24 1:21 PM, olcott wrote:

On 5/5/2024 11:41 AM, Richard Damon wrote:

On 5/5/24 10:30 AM, olcott wrote:

On 5/5/2024 5:36 AM, Fred. Zwarts wrote:

Those N steps were simulated correctly, but the fact that it stops
after N steps make it an incorrect simulation.

In other words a decider is wrong unless it never
stops simulating an non-halting input?

No, the decider is wrong if it gives the wrong answer.

Now, if to determine the correct answer requires simulating more, then
it needs to simulate more.

If to determine the correct answer requires simulating to the end, it
needs to simulate to the end, even if that takes forever.

If it needs to simulate forever, but also needs to answer in finite
time, then the method has just been shown not to meet the requirements.

Bullshit. Try and show any detail that it incorrect
with the conclusion of my new post:
[Every D(D) simulated by H presents non-halting behavior to H]

I did and you ignored it turning you into a LIAR by restating it.

You even elsewhere said you were going to refute it, but never did.

All you are doing is showing that you don't care about truth, but just
want to push your lies.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/5/2024 9:42 AM, joes wrote:

Lots of snips here

Correct. Simulating here means producing the exact same behaviour.
If it is correct up to a point, it might still make a mistake later.
The only way to know is to keep simulating.

That reminds me of something I encountered in the early 1960s while
working on Apollo. There was a workmate who wrote a really accurate
decent speed numerical integration routine with variations (Adams
Moulton (sp?) 6-point predictor corrector). He adopted it on request to
help do long-term very accurate simulations of a gyro that was to be
part of the guidance package.

He essentially set up the integrator as the main routine of the
simulation and used the predictor corrector to oscillate around an
induced discontinuity, continually reducing its step size and backing up
and going forward in a grad loop. Meanwhile the normal part of the
integrator was capturing very accurate simulation data. This would go on
for millions of steps in order to predict behavior and stability of the
gyro.

As a footnote: The integrator, in some parts, would examine some of the
state variable values for relative size and order arithmetic
computations accordingly. It did a lot of work to preserve low order
bits and of course used double precision while executing on the IBM 7090 computers. There where many other "tricks" in the code and that
integration package was used for a wide variety of Apollo applications.
The fellow doing all of this was named Bill ? and was a key example of
NASA trying to get real capability injected where it was important. The
work was done at North American Aviation in Downy, CA - the prime Apollo contractor and integrator.
--
Jeff Barnett

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Since you haven't, I guess you are just admitting you don't have a
response to my post.

On 5/5/24 2:33 PM, olcott wrote:

I am only responding to my new post
[Every D(D) simulated by H presents non-halting behavior to H]

On 5/5/2024 12:54 PM, Richard Damon wrote:

On 5/5/24 1:21 PM, olcott wrote:

On 5/5/2024 11:41 AM, Richard Damon wrote:

On 5/5/24 10:30 AM, olcott wrote:

On 5/5/2024 5:36 AM, Fred. Zwarts wrote:

Those N steps were simulated correctly, but the fact that it stops >>>>>> after N steps make it an incorrect simulation.

In other words a decider is wrong unless it never
stops simulating an non-halting input?

No, the decider is wrong if it gives the wrong answer.

Now, if to determine the correct answer requires simulating more,
then it needs to simulate more.

If to determine the correct answer requires simulating to the end,
it needs to simulate to the end, even if that takes forever.

If it needs to simulate forever, but also needs to answer in finite
time, then the method has just been shown not to meet the requirements. >>>>

Bullshit. Try and show any detail that it incorrect
with the conclusion of my new post:
[Every D(D) simulated by H presents non-halting behavior to H]

I did and you ignored it turning you into a LIAR by restating it.

You even elsewhere said you were going to refute it, but never did.

All you are doing is showing that you don't care about truth, but just
want to push your lies.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

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

On 5/5/2024 2:47 PM, Richard Damon wrote:

Since you haven't, I guess you are just admitting you don't have a
response to my post.

I have quite a few times now.

They showed up after my message, and long after I made that post.

On 5/5/24 2:33 PM, olcott wrote:

I am only responding to my new post
[Every D(D) simulated by H presents non-halting behavior to H]

On 5/5/2024 12:54 PM, Richard Damon wrote:

On 5/5/24 1:21 PM, olcott wrote:

On 5/5/2024 11:41 AM, Richard Damon wrote:

On 5/5/24 10:30 AM, olcott wrote:

On 5/5/2024 5:36 AM, Fred. Zwarts wrote:

Those N steps were simulated correctly, but the fact that it
stops after N steps make it an incorrect simulation.

In other words a decider is wrong unless it never
stops simulating an non-halting input?

No, the decider is wrong if it gives the wrong answer.

Now, if to determine the correct answer requires simulating more,
then it needs to simulate more.

If to determine the correct answer requires simulating to the end, >>>>>> it needs to simulate to the end, even if that takes forever.

If it needs to simulate forever, but also needs to answer in
finite time, then the method has just been shown not to meet the
requirements.

Bullshit. Try and show any detail that it incorrect
with the conclusion of my new post:
[Every D(D) simulated by H presents non-halting behavior to H]

I did and you ignored it turning you into a LIAR by restating it.

You even elsewhere said you were going to refute it, but never did.

All you are doing is showing that you don't care about truth, but
just want to push your lies.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/5/24 5:09 PM, olcott wrote:

On 5/5/2024 2:47 PM, Richard Damon wrote:

Since you haven't, I guess you are just admitting you don't have a
response to my post.

*I have responded three times to that post*
*I did this before you said that I never responded*

On 5/5/2024 2:40 PM, olcott wrote:

On 5/5/2024 12:22 PM, Richard Damon wrote:

On 5/5/2024 2:10 PM, olcott wrote:

On 5/5/2024 12:22 PM, Richard Damon wrote:

On 5/5/2024 1:43 PM, olcott wrote:

On 5/5/2024 12:22 PM, Richard Damon wrote:

Your posts handn't reached my computer when I looked.

And, none of them addressed the issues, so still no response.

Why do you keep on saying that NO H can simulate past the call to H(D,D)
when I have shown two methods that allow that to happen.

Your repeating the claim just shows you are a liar that doesn't actually
care about the truth.

On 5/5/24 2:33 PM, olcott wrote:

I am only responding to my new post
[Every D(D) simulated by H presents non-halting behavior to H]

On 5/5/2024 12:54 PM, Richard Damon wrote:

On 5/5/24 1:21 PM, olcott wrote:

On 5/5/2024 11:41 AM, Richard Damon wrote:

On 5/5/24 10:30 AM, olcott wrote:

On 5/5/2024 5:36 AM, Fred. Zwarts wrote:

Those N steps were simulated correctly, but the fact that it
stops after N steps make it an incorrect simulation.

In other words a decider is wrong unless it never
stops simulating an non-halting input?

No, the decider is wrong if it gives the wrong answer.

Now, if to determine the correct answer requires simulating more,
then it needs to simulate more.

If to determine the correct answer requires simulating to the end, >>>>>> it needs to simulate to the end, even if that takes forever.

If it needs to simulate forever, but also needs to answer in
finite time, then the method has just been shown not to meet the
requirements.

Bullshit. Try and show any detail that it incorrect
with the conclusion of my new post:
[Every D(D) simulated by H presents non-halting behavior to H]

I did and you ignored it turning you into a LIAR by restating it.

You even elsewhere said you were going to refute it, but never did.

All you are doing is showing that you don't care about truth, but
just want to push your lies.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-05-05 15:13:08 +0000, olcott said:

Extrapolations beyond what is known cannot be fully justified
within what is known.

Sometimes they can. Typically extrapolations cannot be justified
at all because typical extrapolations are wrong.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

On 5/05/24 18:29, olcott wrote:

void Infinite_Recursion(u32 N)
{
  Infinite_Recursion(N);
}

It is counter-factual that the above must be infinitely
simulated to correctly determine that it never halts.

Any program that correctly determines non-termination is not a
simulating termination analyzer.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)