On 8/16/24 4:36 PM, olcott wrote:

On 8/16/2024 3:11 PM, Mike Terry wrote:

On 16/08/2024 07:57, Fred. Zwarts wrote:

Op 15.aug.2024 om 21:39 schreef olcott:

On 8/15/2024 1:35 PM, Mike Terry wrote:

On 15/08/2024 17:30, olcott wrote:

On 8/15/2024 10:40 AM, Fred. Zwarts wrote:

Op 15.aug.2024 om 14:12 schreef olcott:

On 8/15/2024 2:00 AM, joes wrote:

Am Wed, 14 Aug 2024 16:07:43 +0100 schrieb Mike Terry:

On 14/08/2024 08:43, joes wrote:

Am Tue, 13 Aug 2024 21:38:07 -0500 schrieb olcott:

On 8/13/2024 9:29 PM, Richard Damon wrote:

On 8/13/24 8:52 PM, olcott wrote:

A simulation of N instructions of DDD by HHH according to the >>>>>>>>>>>>>> semantics of the x86 language is necessarily correct. >>>>>>>>>>>>> Nope, it is just the correct PARTIAL emulation of the first N >>>>>>>>>>>>> instructions of DDD, and not of all of DDD,

That is what I said dufuss.

You were trying to label an incomplete/partial/aborted
simulation as
correct.

A correct simulation of N instructions of DDD by HHH is >>>>>>>>>>>>>> sufficient
to correctly predict the behavior of an unlimited simulation. >>>>>>>>>>>>> Nope, if a HHH returns to its caller,

*Try to show exactly how DDD emulated by HHH returns to its >>>>>>>>>>>> caller*

how *HHH* returns

HHH simulates DDD    enter the matrix
    DDD calls HHH(DDD)    Fred: could be eliminated HHH >>>>>>>>>>> simulates

DDD

    second level
      DDD calls HHH(DDD)    recursion detected
    HHH aborts, returns    outside interference DDD halts >>>>>>>>> voila
HHH halts

You're misunderstanding the scenario?  If your simulated HHH >>>>>>>>>> aborts its
simulation [line 5 above],
then the outer level H would have aborted its identical
simulation
earlier.  You know that, right?

Of course. I made it only to illustrate one step in the
paradoxical
reasoning, as long as we're calling programs that do or don't >>>>>>>>> abort
the same.

It is like I always pointed out. The outer HHH cannot
wait for the inner ones to abort because it would be
waiting forever.

Exactly. And when it aborts, it aborts too soon, one cycle before >>>>>>> the simulated HHH would abort and halt.

Mike corrected you on this. You are wrong.

For the record, I did no such thing and Fred is correct.

*Fred has the same incorrect views as joes*
*Here is where you agreed that Fred is wrong*
*when replying to joes*

On 8/14/2024 10:07 AM, Mike Terry wrote:

On 14/08/2024 08:43, joes wrote:

Am Tue, 13 Aug 2024 21:38:07 -0500 schrieb olcott:

*Try to show exactly how DDD emulated by HHH
;  returns to its caller*>>
(the first one doesn't even have a caller)
Use the above machine language instructions to show this.

HHH simulates DDD    enter the matrix
;    DDD calls HHH(DDD)    Fred: could be eliminated
;    HHH simulates DDD    second level
;      DDD calls HHH(DDD)    recursion detected
;    HHH aborts, returns    outside interference
;    DDD halts        voila
HHH halts

;
You're misunderstanding the scenario?  If your
simulated HHH aborts its simulation [line 5 above],
then the outer level H would have aborted its
identical simulation earlier.  You know that, right?
[It's what people have been discussing here endlessly
for the last few months! :) ]
;
So your trace is impossible...
;

It is clear that olcott does not really read what I write. (Or is
very short of memory.)
I never said such a thing.
I repeatedly told that the simulating HHH aborted when the simulated
HHH had only one cycle to go. I never said that the simulated HHH
reached it abort and halted.
In fact, I said that the fact that the simulation fails to reach the
abort and halt of the simulated HHH proves that the simulation is
incomplete and incorrect, because a complete simulation (such as by
HHH1) shows that the simulated HHH would abort and halt.

It now becomes clear that you either never understood what I said, or
your memory is indeed very short.
Give it some time to think about what I say, try to escape from
rebuttal mode, instead of ignoring it immediately.

That's all correct.  Going further I'll suggest that PO really doesn't
"understand" /anything/ with an abstract / logical / mathematical
content.  He can't understand definitions or their role in proofs, or
the role of proofs in establishing knowledge.  I'm not kidding or
being rude or anything like that - it's simply the way his brain
works.  *Of course* PO does not "really read what you write".  Surely
you must have at least suspected this for a long time?!  [I don't
notice any problem with PO's memory.]

I break my points down to the basic facts of the semantics
of the x86 language and the basic facts of the semantics
of the C programming.

I can't ever get to the point of the computer science
because reviewers disagree with these basic facts.

No, the problem is that your "facts" just disagree with the computere
science you claim to be doing.

void DDD()
{
  HHH(DDD);
}

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Which is NOT a program and can not be the complete input to HHH, in
fact, HHH takes the whole of memory being uses as its "finite string"
input, or your problem is just falsely stated.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its input D
    until H correctly determines that its simulated D would never
    stop running unless aborted then

Right, and to statisfy this, since the only simulation that is "Correct"
for the determining of the behavior of a program is a COMPLETE behaivior
(and thus no partial emulation can qualify), to make the determination
that its simulated D would never stop running, we mean the COMPLETELY
simulated D (which can't be done by H, since it will abort its
simulation if it uses part 2) will never stop running.

Since if the HHH called by DDD above EVER aborts its simulation and
returns and answer, that DDD *WILL* stop running, it is IMPOSSIBLE for
HHH to CORRECTLY determine that the simulation of this input will not
stop running, since it will stop.

    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

And part 2 can only be done if part 1 is CORRECTLY determined, and since
if HHH does abort and return, DDD will halt, it is IMPOSSIBLE for HHH to
ever correctly determine that its input will never halt and use part 2.

*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted*

WRONG.

No HHH that aborts its emulation HAS correctly emulated its input
according to the semantics of the x86 language, as that says the
emulation can ony be correctly terminated at a terminal instrucction.

Also, if the HHH that is there does abort its emulation then the
complete and correct x86 emulation of the input WILL REACH that final
state, it just isn't the emulation done by HHH.

Mike might try to change the subject but I doubt if he
would disagree with this basic fact.

*It took me two years to find a way to define correct*
*simulation such that all disagreement looks foolish*

No, you have tried, but you words still betray you.

"DDD emualted by HHH ... reaching a final state" has as a subject, DDD,
which is the PROGRAM and its behavior, not the behavior of the partial emulation done by HHH, which is just references in a subordinate clause.

If you want to talk about the emulation and not the program, then the
emulaiton needs to be the subject of the sentence, something like:

"It is a fact that no correct but partial emulation of DDD by the
decider HHH can ever reach the final state"

The problem with this is that it makes it clear that you are only
looking at the partial emulation and thus the fact that it doesn't make
it to a final state doesn't mean that the program DDD doesn't halt.

In fact, since it can be shown that if HHH does abort and return, that
the DDD that it is emulating WILL halt, you are stuck in a bad corner.

There are more steps to my proof in addition to this
yet the above portion of my proof is a necessary
prerequisite. If people disagree with arithmetic how
are we ever going to get to the subject of algebra?

But since you don't bave this one, your rest just don't work. Your
problem is that you "logic" is based on shifting meaning between parts,
and thus is just based on LIES.

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

On 8/16/24 5:58 PM, olcott wrote:

On 8/16/2024 4:37 PM, Richard Damon wrote:

On 8/16/24 5:08 PM, olcott wrote:

On 8/16/2024 3:54 PM, Richard Damon wrote:

On 8/16/24 4:36 PM, olcott wrote:

I break my points down to the basic facts of the semantics
of the x86 language and the basic facts of the semantics
of the C programming.

I can't ever get to the point of the computer science
because reviewers disagree with these basic facts.

No, the problem is that your "facts" just disagree with the
computere science you claim to be doing.

We never get anywhere near the computer science because
people disagree with 100% concrete fully specified semantics.
If they disagree with arithmetic we can never get to algebra.

If you aren't talking about computer science, then you are using a lot
of words FROM computer science, which bring in their implications.

I get to the computer science only after people
agree to basic facts. When they refuse to agree
with these basis facts I write them off as dishonest
or insufficiently competent.

Since your "Basic facts" include terms from Computer Science, you seem
to want to use the destination before we get there.

Sorry, you are just being dense and illogical.
YOU are the dishonest one and show the lack of sufficient competence.

Those are just the facts.

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

On 8/16/24 5:08 PM, olcott wrote:

On 8/16/2024 3:54 PM, Richard Damon wrote:

On 8/16/24 4:36 PM, olcott wrote:

I break my points down to the basic facts of the semantics
of the x86 language and the basic facts of the semantics
of the C programming.

I can't ever get to the point of the computer science
because reviewers disagree with these basic facts.

No, the problem is that your "facts" just disagree with the computere
science you claim to be doing.

We never get anywhere near the computer science because
people disagree with 100% concrete fully specified semantics.
If they disagree with arithmetic we can never get to algebra.

If you aren't talking about computer science, then you are using a lot
of words FROM computer science, which bring in their implications.

void DDD()
{
   HHH(DDD);
}

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Which is NOT a program

I am talking above the behavior of the C function it is
dishonest to change the subject as any basis of rebuttal.

But the "C Function" doesn't HAVE "Behavior", because it isn't a
complete thing to have behavior.

That is like asking about the color of Truth or the Weight of a Lie.

Behavior is of full entities, in this case PROGRAMS (or subprograms)
which include all of the code they use.

So, the dishonest one is YOU to be trying to talk about something
invalid, and then we can look back as see this is essentially the same
form of input that you have claimed for years is isomorphic to the Linz
Proof of the Halting Problem.

THat is shown to be just a lie.

and can not be the complete input to HHH, in fact, HHH takes the whole
of memory being uses as its "finite string" input, or your problem is
just falsely stated.

The question is can DDD emulated by HHH according to the
semantics of the x86 language even stop running without
being aborted?

Except that isn't a valid question, as the x86 language defines that the
call instruction needs to be followed to code you aren't giving.

Part of your problem is you don't understand that you are trying to
define the behavior of the function DDD, but then trying to define it in
terms of one abstract behavior of HHH, but then use a DIFFERENT abstract behavior of HHH to decide it. The problem is, that by the fundamental
rules, the way you have built you system, the two must be the same, so
your logic falls apart in the contradiciton.

HHH needs to decide on the behavior of DDD when it call the HHH that is
assumed to be there.

Ben is the only one that did not attempt some kind of
dishonesty on this question.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then

Right, and to statisfy this, since the only simulation that is
"Correct" for the determining of the behavior of a program is a
COMPLETE behaivior

UNTIL MEANS LIMITED.
IT DOES NOT MEAN YOUR MISCONCEPTION OF "COMPLETE"

But "Its simulated D" refers to the FULL BEHAIVOR of the PROGRAM D.

That can either be determined by just running D, or COMPLETELY
simulating D, either of which will show that H was just wrong.

YOU DON'T EVEN UNDERSTAND THAT AN INFINITE
EXECUTION CANNOT BE COMPLETE. YOU AND OTHERS
ALWAYS USE THE TERM "COMPLETE" INCORRECTLY

But there IS a definitioin of a complete emulation of a non-halting
program, and that is a emulation that continues forever. That *IS* complete.

THIS IS NO ORDINARY MISTAKE IT IS A STUPID MISTAKE.

No, it is just showing your ignorance and the lack of understanding of
things infinite.

The infinite set of the Natural Numbers 0, 1, 2, 3, 4, ... all the way
for the full Aleph_0 numbers, is a COMPLETE set.

A simulation that will run for an aleph_0 number of steps, IS COMPLETE.

A truth established by an infinite sequence of truth preserving
opetations IS TRUE.

Your mind is just too small.

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

On 8/16/24 6:20 PM, olcott wrote:

On 8/16/2024 5:11 PM, Richard Damon wrote:

On 8/16/24 5:58 PM, olcott wrote:

On 8/16/2024 4:37 PM, Richard Damon wrote:

On 8/16/24 5:08 PM, olcott wrote:

On 8/16/2024 3:54 PM, Richard Damon wrote:

On 8/16/24 4:36 PM, olcott wrote:

I break my points down to the basic facts of the semantics
of the x86 language and the basic facts of the semantics
of the C programming.

I can't ever get to the point of the computer science
because reviewers disagree with these basic facts.

No, the problem is that your "facts" just disagree with the
computere science you claim to be doing.

We never get anywhere near the computer science because
people disagree with 100% concrete fully specified semantics.
If they disagree with arithmetic we can never get to algebra.

If you aren't talking about computer science, then you are using a
lot of words FROM computer science, which bring in their implications. >>>>

I get to the computer science only after people
agree to basic facts. When they refuse to agree
with these basis facts I write them off as dishonest
or insufficiently competent.

Since your "Basic facts" include terms from Computer Science,

If you insist on disagreeing with the x86
language that proves you are dishonest.

Where do I disagree with the x86 language?

That is just another of your unsubstatiated LIES to deflect.

What instruction do I not think should be emulated correctly as the
processor will do?

YOU are the one that claims that the x86 language says that a call to
HHH isn't supposed to generate the full behavior of the function HHH,
but just the emulation it does as if it was unconditional.

Since running DDD will reach its final return, the correct emulation of
DDD must also.

Your claims otherwise are just LIES.

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

On 8/16/24 6:56 PM, olcott wrote:

On 8/16/2024 5:50 PM, Richard Damon wrote:

On 8/16/24 6:20 PM, olcott wrote:

On 8/16/2024 5:11 PM, Richard Damon wrote:

On 8/16/24 5:58 PM, olcott wrote:

On 8/16/2024 4:37 PM, Richard Damon wrote:

On 8/16/24 5:08 PM, olcott wrote:

On 8/16/2024 3:54 PM, Richard Damon wrote:

On 8/16/24 4:36 PM, olcott wrote:

I break my points down to the basic facts of the semantics
of the x86 language and the basic facts of the semantics
of the C programming.

I can't ever get to the point of the computer science
because reviewers disagree with these basic facts.

No, the problem is that your "facts" just disagree with the
computere science you claim to be doing.

We never get anywhere near the computer science because
people disagree with 100% concrete fully specified semantics.
If they disagree with arithmetic we can never get to algebra.

If you aren't talking about computer science, then you are using a >>>>>> lot of words FROM computer science, which bring in their
implications.

I get to the computer science only after people
agree to basic facts. When they refuse to agree
with these basis facts I write them off as dishonest
or insufficiently competent.

Since your "Basic facts" include terms from Computer Science,

If you insist on disagreeing with the x86
language that proves you are dishonest.

Where do I disagree with the x86 language?

*Until you agree with this I will consider you as a liar*
*Until you agree with this I will consider you as a liar*
*Until you agree with this I will consider you as a liar*

Which just shows that you are a LIAR.

If you can't show where I lied, then it is a lie to say that I lied.

Sorry, that is just the facts and definitions.

void DDD()
{
  HHH(DDD);
}

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted*

But your HHH doesn't do that if you mean that HHH COMPLETELY emulates
its input without aborting.

Putting false conditionals on statements makes them worthless.

Also, what you show is NOT a proper description of the PROGRAM DDD, and
it is only PROGRAMS that can be emulated.

Thus, your who concept weems to be based on a category error.

DDD needs to include the code of HHH or it isn't a valid input.

Sorry, you are just proving how stupid you are.

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

On 2024-08-16 21:08:05 +0000, olcott said:

On 8/16/2024 3:54 PM, Richard Damon wrote:

On 8/16/24 4:36 PM, olcott wrote:

I break my points down to the basic facts of the semantics
of the x86 language and the basic facts of the semantics
of the C programming.

I can't ever get to the point of the computer science
because reviewers disagree with these basic facts.

No, the problem is that your "facts" just disagree with the computere
science you claim to be doing.

We never get anywhere near the computer science because
people disagree with 100% concrete fully specified semantics.

You will never get anywhere near the computer (or any other) science.
No "because" will get you any nearer. The only way to get nearer
would be learning but you cant learn before you learn Common Language
or some other language.

--
Mikko

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

Op 16.aug.2024 om 22:36 schreef olcott:

On 8/16/2024 3:11 PM, Mike Terry wrote:

On 16/08/2024 07:57, Fred. Zwarts wrote:

Op 15.aug.2024 om 21:39 schreef olcott:

On 8/15/2024 1:35 PM, Mike Terry wrote:

On 15/08/2024 17:30, olcott wrote:

On 8/15/2024 10:40 AM, Fred. Zwarts wrote:

Op 15.aug.2024 om 14:12 schreef olcott:

On 8/15/2024 2:00 AM, joes wrote:

Am Wed, 14 Aug 2024 16:07:43 +0100 schrieb Mike Terry:

On 14/08/2024 08:43, joes wrote:

Am Tue, 13 Aug 2024 21:38:07 -0500 schrieb olcott:

On 8/13/2024 9:29 PM, Richard Damon wrote:

On 8/13/24 8:52 PM, olcott wrote:

A simulation of N instructions of DDD by HHH according to the >>>>>>>>>>>>>> semantics of the x86 language is necessarily correct. >>>>>>>>>>>>> Nope, it is just the correct PARTIAL emulation of the first N >>>>>>>>>>>>> instructions of DDD, and not of all of DDD,

That is what I said dufuss.

You were trying to label an incomplete/partial/aborted
simulation as
correct.

A correct simulation of N instructions of DDD by HHH is >>>>>>>>>>>>>> sufficient
to correctly predict the behavior of an unlimited simulation. >>>>>>>>>>>>> Nope, if a HHH returns to its caller,

*Try to show exactly how DDD emulated by HHH returns to its >>>>>>>>>>>> caller*

how *HHH* returns

HHH simulates DDD    enter the matrix
    DDD calls HHH(DDD)    Fred: could be eliminated HHH >>>>>>>>>>> simulates

DDD

    second level
      DDD calls HHH(DDD)    recursion detected
    HHH aborts, returns    outside interference DDD halts >>>>>>>>> voila
HHH halts

You're misunderstanding the scenario?  If your simulated HHH >>>>>>>>>> aborts its
simulation [line 5 above],
then the outer level H would have aborted its identical
simulation
earlier.  You know that, right?

Of course. I made it only to illustrate one step in the
paradoxical
reasoning, as long as we're calling programs that do or don't >>>>>>>>> abort
the same.

It is like I always pointed out. The outer HHH cannot
wait for the inner ones to abort because it would be
waiting forever.

Exactly. And when it aborts, it aborts too soon, one cycle before >>>>>>> the simulated HHH would abort and halt.

Mike corrected you on this. You are wrong.

For the record, I did no such thing and Fred is correct.

*Fred has the same incorrect views as joes*
*Here is where you agreed that Fred is wrong*
*when replying to joes*

On 8/14/2024 10:07 AM, Mike Terry wrote:

On 14/08/2024 08:43, joes wrote:

Am Tue, 13 Aug 2024 21:38:07 -0500 schrieb olcott:

*Try to show exactly how DDD emulated by HHH
;  returns to its caller*>>
(the first one doesn't even have a caller)
Use the above machine language instructions to show this.

HHH simulates DDD    enter the matrix
;    DDD calls HHH(DDD)    Fred: could be eliminated
;    HHH simulates DDD    second level
;      DDD calls HHH(DDD)    recursion detected
;    HHH aborts, returns    outside interference
;    DDD halts        voila
HHH halts

;
You're misunderstanding the scenario?  If your
simulated HHH aborts its simulation [line 5 above],
then the outer level H would have aborted its
identical simulation earlier.  You know that, right?
[It's what people have been discussing here endlessly
for the last few months! :) ]
;
So your trace is impossible...
;

It is clear that olcott does not really read what I write. (Or is
very short of memory.)
I never said such a thing.
I repeatedly told that the simulating HHH aborted when the simulated
HHH had only one cycle to go. I never said that the simulated HHH
reached it abort and halted.
In fact, I said that the fact that the simulation fails to reach the
abort and halt of the simulated HHH proves that the simulation is
incomplete and incorrect, because a complete simulation (such as by
HHH1) shows that the simulated HHH would abort and halt.

It now becomes clear that you either never understood what I said, or
your memory is indeed very short.
Give it some time to think about what I say, try to escape from
rebuttal mode, instead of ignoring it immediately.

That's all correct.  Going further I'll suggest that PO really doesn't
"understand" /anything/ with an abstract / logical / mathematical
content.  He can't understand definitions or their role in proofs, or
the role of proofs in establishing knowledge.  I'm not kidding or
being rude or anything like that - it's simply the way his brain
works.  *Of course* PO does not "really read what you write".  Surely
you must have at least suspected this for a long time?!  [I don't
notice any problem with PO's memory.]

I break my points down to the basic facts of the semantics
of the x86 language and the basic facts of the semantics
of the C programming.

I can't ever get to the point of the computer science
because reviewers disagree with these basic facts.

void DDD()
{
  HHH(DDD);
}

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its input D
    until H correctly determines that its simulated D would never
    stop running unless aborted then

    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

Again the same joke. We have proven it incorrect already so many times.

*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted*

And the simulation that failed to reach the end of an aborting and
halting HHH is simply incorrect.

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

Am Fri, 16 Aug 2024 16:08:05 -0500 schrieb olcott:

On 8/16/2024 3:54 PM, Richard Damon wrote:

On 8/16/24 4:36 PM, olcott wrote:

I can't ever get to the point of the computer science because
reviewers disagree with these basic facts.

No, the problem is that your "facts" just disagree with the computere
science you claim to be doing.

We never get anywhere near the computer science because people disagree
with 100% concrete fully specified semantics.

WITH WHAT

void DDD()
{
   HHH(DDD);
}

Which is NOT a program

I am talking above the behavior of the C function it is dishonest to
change the subject as any basis of rebuttal.

This is on topic. That function doesn't compile, since it's missing the
code of HHH.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

Right, and to statisfy this, since the only simulation that is
"Correct"
for the determining of the behavior of a program is a COMPLETE
behaivior

UNTIL MEANS LIMITED.
IT DOES NOT MEAN YOUR MISCONCEPTION OF "COMPLETE"
YOU DON'T EVEN UNDERSTAND THAT AN INFINITE EXECUTION CANNOT BE COMPLETE.
YOU AND OTHERS ALWAYS USE THE TERM "COMPLETE" INCORRECTLY

A complete simulation of something infinite doesn't halt, duh.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.

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

On 8/18/24 8:39 AM, olcott wrote:

On 8/17/2024 7:11 AM, joes wrote:

Am Fri, 16 Aug 2024 16:08:05 -0500 schrieb olcott:

On 8/16/2024 3:54 PM, Richard Damon wrote:

On 8/16/24 4:36 PM, olcott wrote:

I can't ever get to the point of the computer science because
reviewers disagree with these basic facts.

No, the problem is that your "facts" just disagree with the computere
science you claim to be doing.

We never get anywhere near the computer science because people disagree
with 100% concrete fully specified semantics.

WITH WHAT

void DDD()
{
    HHH(DDD);
}

Which is NOT a program

I am talking above the behavior of the C function it is dishonest to
change the subject as any basis of rebuttal.

This is on topic. That function doesn't compile, since it's missing the
code of HHH.

x86utm takes the compiled Halt7.obj file of this c program https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to DDD.

*I am now only talking about this thread*
[Anyone that disagrees with this is not telling the truth ---V2]

And thus the input to HHH isn't the byte you try too app off as it but
ALL of the code of Halt7.obj, so every HHH sees a DIFFERENT input so you
can't use the results of one to try to provide data for a different one
without making the mistake of talking about cats by looking at 10 story
office buildings.

This means that the ONLY HHH that the above applies to is when HHH is non-aborting, and every HHH that does abort, can't use that, as its DDD
doesn't call the needed HHH, but itself.

This means that DDD is Halting, if, and only if, HHH aborts its
emulation and returns, or DDD is non-halting, if, and only if, HHH NEVER
aborts its emulation.

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