XPost: sci.logic

On 5/10/24 1:49 PM, olcott wrote:

On 5/10/2024 11:12 AM, Richard Damon wrote:

On 5/10/24 11:50 AM, olcott wrote:

On 5/10/2024 9:18 AM, Richard Damon wrote:

On 5/9/24 11:10 PM, olcott wrote:

On 5/9/2024 9:31 PM, Richard Damon wrote:

On 5/9/24 11:38 AM, olcott wrote:

On 5/8/2024 8:38 PM, immibis wrote:

On 8/05/24 21:05, olcott wrote:

On 5/8/2024 10:13 AM, Mike Terry wrote:

On 08/05/2024 14:01, olcott wrote:

On 5/8/2024 3:59 AM, Mikko wrote:

On 2024-05-07 19:05:54 +0000, olcott said:

On 5/7/2024 1:54 PM, Fred. Zwarts wrote:

Op 07.mei.2024 om 17:40 schreef olcott:

On 5/7/2024 6:18 AM, Richard Damon wrote:

On 5/7/24 3:30 AM, Mikko wrote:

On 2024-05-06 18:28:37 +0000, olcott said:

On 5/6/2024 11:19 AM, Mikko wrote:

On 2024-05-05 17:02:25 +0000, olcott said: >>>>>>>>>>>>>>>>>>>

The x86utm operating system:
https://github.com/plolcott/x86utm enables >>>>>>>>>>>>>>>>>>>> one C function to execute another C function in >>>>>>>>>>>>>>>>>>>> debug step mode.
Simulating Termination analyzer H simulates the x86 >>>>>>>>>>>>>>>>>>>> machine code of its
input (using libx86emu) in debug step mode until it >>>>>>>>>>>>>>>>>>>> correctly matches a
correct non-halting behavior pattern proving that >>>>>>>>>>>>>>>>>>>> its input will never
stop running unless aborted.

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

The above execution trace proves that (for every H/D >>>>>>>>>>>>>>>>>>>> pair of the
infinite set of H/D pairs) each D(D) simulated by >>>>>>>>>>>>>>>>>>>> the H that this D(D)
calls cannot possibly reach past its own line 03. >>>>>>>>>>>>>>>>>>>

When you say "every H/D pair" you should specify >>>>>>>>>>>>>>>>>>> which set of pairs
you are talking about. As you don't, your words don't >>>>>>>>>>>>>>>>>>> mean anything.

Every H/D pair in the universe where D(D) is simulated >>>>>>>>>>>>>>>>>> by the
same H(D,D) that D(D) calls. This involves 1 to ∞ >>>>>>>>>>>>>>>>>> steps of D
and also includes zero to ∞ recursive simulations where H >>>>>>>>>>>>>>>>>> H simulates itself simulating D(D).

"In the universe" is not a set. In typical set theories >>>>>>>>>>>>>>>>> like ZFC there
is no universal set.

This template defines an infinite set of finite string >>>>>>>>>>>>>>> H/D pairs where each D(D) that is simulated by H(D,D) >>>>>>>>>>>>>>> also calls this same H(D,D).

These H/D pairs can be enumerated by the one to ∞ >>>>>>>>>>>>>>> simulated steps of D and involve zero to ∞ recursive >>>>>>>>>>>>>>> simulations of H simulating itself simulating D(D). Every >>>>>>>>>>>>>>> time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.

1st element of H/D pairs 1 step  of D  is simulated by H >>>>>>>>>>>>>>> 2nd element of H/D pairs 2 steps of D are simulated by H >>>>>>>>>>>>>>> 3rd element of H/D pairs 3 steps of D are simulated by H >>>>>>>>>>>>>>>
4th element of H/D pairs 4 steps of D are simulated by H >>>>>>>>>>>>>>> this begins the first recursive simulation at line 01 >>>>>>>>>>>>>>>
5th element of H/D pairs 5 steps of D are simulated by >>>>>>>>>>>>>>> next step of the first recursive simulation at line 02 >>>>>>>>>>>>>>>
6th element of H/D pairs 6 steps of D are simulated by >>>>>>>>>>>>>>> last step of the first recursive simulation at line 03 >>>>>>>>>>>>>>>
7th element of H/D pairs 7 steps of D are simulated by H >>>>>>>>>>>>>>> this begins the second recursive simulation at line 01 >>>>>>>>>>>>>>

Is this the definition of the infinite set of H? We can >>>>>>>>>>>>>> think of many more simulations that only these.

This template defines an infinite set of finite string H/D >>>>>>>>>>>>> pairs where
each D(D) that is simulated by H(D,D) also calls this same >>>>>>>>>>>>> H(D,D).

No-one can possibly show one element of this set where D(D) >>>>>>>>>>>>> reaches
past its own line 03.

If H is a decider of any kind then the D build from it >>>>>>>>>>>> reaches its line
4 as numberd above. Whether the simulation of D by H reaches >>>>>>>>>>>> that line
is another question.

*My fully operational code proves otherwise*

I seems like you guys don't have a clue about how infinite >>>>>>>>>>> recursion works. You can run the code and see that I am correct. >>>>>>>>>>>
I have one concrete instance as fully operational code.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
line 555 u32 HH(ptr P, ptr I) its input in on
line 932 int DD(int (*x)())

HH is completely broken - it uses a global variable which is >>>>>>>>>> allows HH to detect whether it is the outer HH or a nested >>>>>>>>>> (simulated) HH. As a result, the nested HH behaves completely >>>>>>>>>> differently to the outer HH - I mean /completely/ differently: >>>>>>>>>> it goes through a totally separate "I am called in nested
mode" code path!

The encoding of HH is not the pure function that it needs to be to >>>>>>>>> be a computable function.

*Maybe you can settle this*

The disagreement is entirely over an enormously much simpler >>>>>>>>> thing.
The disagreement is that Richard says that a D simulated by H >>>>>>>>> could
reach past its own line 03 and halt.

Here's the proof:

1. A simulation always produces an identical execution trace to >>>>>>>> the direct execution.

*When pathological self-reference is involved this is
counter-factual*
That no one can possibly show the steps of how D simulated by H
possibly
reach line 06 of H proves this.

Richard tried to get away with D never simulated by H as an example >>>>>>> of D simulated by H:

Nope, you are looking at the WRONG message, and I have told you
this multiple times.

Message-ID: <v0ummt$2qov3$2@i2pn2.org>
*When you interpret*
On 5/1/2024 7:28 PM, Richard Damon wrote:

On 5/1/24 11:51 AM, olcott wrote:

*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*

as *D NEVER simulated by H*

you have shown a reckless disregard for the truth
that would win a defamation case.

My H simulated 0 steps of D, of which was ALL of the steps it
simulated correctly.

*THAT DOES NOT MEET THE SPEC*

You haven't GIVEN a defined SPEC.

The only definition within Computation Theory, which is the space you
started in, and claim to get to, doesn't have "aborted" simulations,
so you don't have a defintion of what simulatioin actually means,
other than doing something that tells you something about the behavior
of what is simulated.

My H does that, by aborting its "simulation" in shows that THIS H did
not simulate its input to a final state.

Just the same result that you partial set of H's showed.

*THAT DOES NOT MEET THE SPEC*
*THAT DOES NOT MEET THE SPEC*
*THAT DOES NOT MEET THE SPEC*

*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*

*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*

*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*

*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*

*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*

Right, and simulating zero steps correctly and them aborting means H

*cannot possibly stop running unless aborted is not met*

Aborted after 0 steps which is all that that H does.

Your term is MEANINGLESS as a given H either does or does not abort a
that point, so if H is a given program it is meaningless.

If H is an "infinite set" of machines, then main can not call such an
infinte set.

So, you question is based on a self-contradictory definition that was
never actually defined.

Which is H, a single program or an infinte set?

Define this or admit you logic is not defined.

*cannot possibly stop running unless aborted is not met*
*cannot possibly stop running unless aborted is not met*
*cannot possibly stop running unless aborted is not met*
*cannot possibly stop running unless aborted is not met*

simulated ALL of its steps correctly when it aborted. Simulating ALL
steps simulated is a corrrect simulation by your definition.

You added LATER, the requirement of 1 to N steps, so, your arguement
is just a LIE.

Remember, when I ask you for definitions, you refused to try to do it.

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