XPost: sci.logic

On 7/3/24 8:40 PM, olcott wrote:

On 7/3/2024 6:18 PM, Richard Damon wrote:

On 7/3/24 10:19 AM, olcott wrote:

On 7/3/2024 9:11 AM, joes wrote:

Am Tue, 02 Jul 2024 22:55:12 -0500 schrieb olcott:

On 7/2/2024 10:50 PM, joes wrote:

Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:

On 7/2/2024 2:17 PM, Fred. Zwarts wrote:

Op 02.jul.2024 om 21:00 schreef olcott:

On 7/2/2024 1:42 PM, Fred. Zwarts wrote:

Op 02.jul.2024 om 14:22 schreef olcott:

On 7/2/2024 3:22 AM, Fred. Zwarts wrote:

Op 02.jul.2024 om 03:25 schreef olcott:

HHH repeats the process twice and aborts too soon.

DDD is correctly emulated by any HHH that can exist which calls this >>>>>>> emulated HHH(DDD) to repeat the process until aborted (which may be >>>>>>> never).

Whatever HHH does, it does not run forever but aborts.

HHH halts on input DDD.
DDD correctly simulated by HHH cannot possibly halt.

WTF? It only calls HHH, which you just said halts.

An aborted simulation does not count as halting.

And doesn't show non-halting either.

Reaching it own machine address 00002183 counts as halting.
DDD correctly simulated by HHH cannot possibly do that.

But HHH doesn't DO a "Correct Simulation" that can show that, it only
does a PARTIAL simulation.

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

until H correctly determines
until H correctly determines
until H correctly determines
until H correctly determines
until H correctly determines
until H correctly determines
until H correctly determines

Which it doesn't.

THUS STIPULATING THAT A PARTIAL SIMULATION IS CORRECT
THUS STIPULATING THAT A PARTIAL SIMULATION IS CORRECT
THUS STIPULATING THAT A PARTIAL SIMULATION IS CORRECT
THUS STIPULATING THAT A PARTIAL SIMULATION IS CORRECT
THUS STIPULATING THAT A PARTIAL SIMULATION IS CORRECT
THUS STIPULATING THAT A PARTIAL SIMULATION IS CORRECT
THUS STIPULATING THAT A PARTIAL SIMULATION IS CORRECT

Nope, just double talk.

H never CORRECTLY determined that a CORRECT SIMULATION (which means one
that matchs the behavior of the machine represented by the input) would
never halt, sinc ehta tmachine halts.

You can't argue that H has correctly determined it did something it
never did,

You laid a perfect trap for yourself in your words, and you fell into it,

You would be an absolute genius if you had an IQ of 250. But since you
don't you aren't.

Or, Trump would be president right now if he had gotten the most votes.
He didn't so he isn't.

If H can correctly determine that H did something right that it never
does, is a similar false premise.

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

On 2024-07-04 00:40:37 +0000, olcott said:

On 7/3/2024 6:18 PM, Richard Damon wrote:

On 7/3/24 10:19 AM, olcott wrote:

On 7/3/2024 9:11 AM, joes wrote:

Am Tue, 02 Jul 2024 22:55:12 -0500 schrieb olcott:

On 7/2/2024 10:50 PM, joes wrote:

Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:

On 7/2/2024 2:17 PM, Fred. Zwarts wrote:

Op 02.jul.2024 om 21:00 schreef olcott:

On 7/2/2024 1:42 PM, Fred. Zwarts wrote:

Op 02.jul.2024 om 14:22 schreef olcott:

On 7/2/2024 3:22 AM, Fred. Zwarts wrote:

Op 02.jul.2024 om 03:25 schreef olcott:

HHH repeats the process twice and aborts too soon.

DDD is correctly emulated by any HHH that can exist which calls this >>>>>>> emulated HHH(DDD) to repeat the process until aborted (which may be >>>>>>> never).

Whatever HHH does, it does not run forever but aborts.

HHH halts on input DDD.
DDD correctly simulated by HHH cannot possibly halt.

WTF? It only calls HHH, which you just said halts.

An aborted simulation does not count as halting.

And doesn't show non-halting either.

Reaching it own machine address 00002183 counts as halting.
DDD correctly simulated by HHH cannot possibly do that.

But HHH doesn't DO a "Correct Simulation" that can show that, it only
does a PARTIAL simulation.

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

until H correctly determines

Does that ever happen?

--
Mikko

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

On 7/4/24 8:41 AM, olcott wrote:

On 7/4/2024 1:42 AM, Mikko wrote:

On 2024-07-04 00:40:37 +0000, olcott said:

On 7/3/2024 6:18 PM, Richard Damon wrote:

On 7/3/24 10:19 AM, olcott wrote:

On 7/3/2024 9:11 AM, joes wrote:

Am Tue, 02 Jul 2024 22:55:12 -0500 schrieb olcott:

On 7/2/2024 10:50 PM, joes wrote:

Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:

On 7/2/2024 2:17 PM, Fred. Zwarts wrote:

Op 02.jul.2024 om 21:00 schreef olcott:

On 7/2/2024 1:42 PM, Fred. Zwarts wrote:

Op 02.jul.2024 om 14:22 schreef olcott:

On 7/2/2024 3:22 AM, Fred. Zwarts wrote:

Op 02.jul.2024 om 03:25 schreef olcott:

HHH repeats the process twice and aborts too soon.

DDD is correctly emulated by any HHH that can exist which calls >>>>>>>>> this
emulated HHH(DDD) to repeat the process until aborted (which >>>>>>>>> may be
never).

Whatever HHH does, it does not run forever but aborts.

HHH halts on input DDD.
DDD correctly simulated by HHH cannot possibly halt.

WTF? It only calls HHH, which you just said halts.

An aborted simulation does not count as halting.

And doesn't show non-halting either.

Reaching it own machine address 00002183 counts as halting.
DDD correctly simulated by HHH cannot possibly do that.

But HHH doesn't DO a "Correct Simulation" that can show that, it
only does a PARTIAL simulation.

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

until H correctly determines

Does that ever happen?

Knowledge of the C programming language proves that it happens
in these three cases.

void Infinite_Loop()
{
  HERE: goto HERE;
}

void Infinite_Recursion()
{
  Infinite_Recursion();
}

void DDD()
{
  HHH(DDD);
}

int main()
{
  HHH(Infinite_Loop);
  HHH(Infinite_Recursion);
  HHH(DDD);
}

Every C programmer that knows what an x86 emulator is knows that when
HHH emulates the machine language of Infinite_Loop, Infinite_Recursion,
and DDD that it must abort these emulations so that itself can terminate normally.

And any competent programmer knows the proofs that show that
Infinite_Loop and Infinte_Recursion will never halt, and the fact that
the execution of DDD will halt since your HHH(DDD) returns so it can be
a decider means that, by the right definition, the correct simulation of
DDD shows that it does halt, and HHH's claim that it doesn't is just a LIE.


You are, of course, excluded from that class of competent programmers,
as you think that the partial simulation of DDD some how makes DDD to
just stop running at the point its simulation is aborted.

You don't seem to understand that the details of the program fully
define its behavior, and the simulation is just a method to observe
that, and shutting your eyes by terminating the simulation doesn't stop
the behavior that is there.

The behavior of just the partial simulation of DDD by HHH isn't a
behavior of DDD (but shows part of it) but is part of the behavior of
HHH as applied to DDD.

So, you are just using wrong (and improper) definitions in your logic
and don't seem to know better.

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

On 2024-07-04 12:41:30 +0000, olcott said:

On 7/4/2024 1:42 AM, Mikko wrote:

On 2024-07-04 00:40:37 +0000, olcott said:

On 7/3/2024 6:18 PM, Richard Damon wrote:

On 7/3/24 10:19 AM, olcott wrote:

On 7/3/2024 9:11 AM, joes wrote:

Am Tue, 02 Jul 2024 22:55:12 -0500 schrieb olcott:

On 7/2/2024 10:50 PM, joes wrote:

Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:

On 7/2/2024 2:17 PM, Fred. Zwarts wrote:

Op 02.jul.2024 om 21:00 schreef olcott:

On 7/2/2024 1:42 PM, Fred. Zwarts wrote:

Op 02.jul.2024 om 14:22 schreef olcott:

On 7/2/2024 3:22 AM, Fred. Zwarts wrote:

Op 02.jul.2024 om 03:25 schreef olcott:

HHH repeats the process twice and aborts too soon.

DDD is correctly emulated by any HHH that can exist which calls this >>>>>>>>> emulated HHH(DDD) to repeat the process until aborted (which may be >>>>>>>>> never).

Whatever HHH does, it does not run forever but aborts.

HHH halts on input DDD.
DDD correctly simulated by HHH cannot possibly halt.

WTF? It only calls HHH, which you just said halts.

An aborted simulation does not count as halting.

And doesn't show non-halting either.

Reaching it own machine address 00002183 counts as halting.
DDD correctly simulated by HHH cannot possibly do that.

But HHH doesn't DO a "Correct Simulation" that can show that, it only
does a PARTIAL simulation.

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

until H correctly determines

Does that ever happen?

Knowledge of the C programming language proves that it happens
in these three cases.

void Infinite_Loop()
{
HERE: goto HERE;
}

void Infinite_Recursion()
{
Infinite_Recursion();
}

void DDD()
{
HHH(DDD);
}

int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}

Every C programmer that knows what an x86 emulator is knows that when
HHH emulates the machine language of Infinite_Loop, Infinite_Recursion,
and DDD that it must abort these emulations so that itself can
terminate normally.

You haven't proven that in any of those cases. In particular, about DDD it seems that your claim cannot be proven. The other cases might be provable.

--
Mikko

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

On 7/5/24 8:10 AM, olcott wrote:

On 7/5/2024 2:27 AM, Mikko wrote:

On 2024-07-04 12:41:30 +0000, olcott said:

On 7/4/2024 1:42 AM, Mikko wrote:

On 2024-07-04 00:40:37 +0000, olcott said:

On 7/3/2024 6:18 PM, Richard Damon wrote:

On 7/3/24 10:19 AM, olcott wrote:

On 7/3/2024 9:11 AM, joes wrote:

Am Tue, 02 Jul 2024 22:55:12 -0500 schrieb olcott:

On 7/2/2024 10:50 PM, joes wrote:

Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:

On 7/2/2024 2:17 PM, Fred. Zwarts wrote:

Op 02.jul.2024 om 21:00 schreef olcott:

On 7/2/2024 1:42 PM, Fred. Zwarts wrote:

Op 02.jul.2024 om 14:22 schreef olcott:

On 7/2/2024 3:22 AM, Fred. Zwarts wrote:

Op 02.jul.2024 om 03:25 schreef olcott:

HHH repeats the process twice and aborts too soon.

DDD is correctly emulated by any HHH that can exist which >>>>>>>>>>> calls this
emulated HHH(DDD) to repeat the process until aborted (which >>>>>>>>>>> may be
never).

Whatever HHH does, it does not run forever but aborts.

HHH halts on input DDD.
DDD correctly simulated by HHH cannot possibly halt.

WTF? It only calls HHH, which you just said halts.

An aborted simulation does not count as halting.

And doesn't show non-halting either.

Reaching it own machine address 00002183 counts as halting.
DDD correctly simulated by HHH cannot possibly do that.

But HHH doesn't DO a "Correct Simulation" that can show that, it
only does a PARTIAL simulation.

<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> >>>>>
until H correctly determines

Does that ever happen?

Knowledge of the C programming language proves that it happens
in these three cases.

void Infinite_Loop()
{
   HERE: goto HERE;
}

void Infinite_Recursion()
{
   Infinite_Recursion();
}

void DDD()
{
   HHH(DDD);
}

int main()
{
   HHH(Infinite_Loop);
   HHH(Infinite_Recursion);
   HHH(DDD);
}

Every C programmer that knows what an x86 emulator is knows that when
HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations so
that itself can terminate normally.

You haven't proven that in any of those cases. In particular, about
DDD it
seems that your claim cannot be proven. The other cases might be
provable.

HHH(DDD) simulates its input that calls HHH(DDD)
to simulate its input and this continues until aborted.

And when it aborts, it shows that DDD calling HHH(DDD) will return.

HHH has no power over DDD, only its emulation of it.

You are just stuck in the world of your imagination, and can't see reality.

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