Can D simulated by H terminate normally?

olcott

unread,

Jun 12, 2023, 12:34:42 PM6/12/23

to

Software engineers can easily verify that D correctly simulated by H
cannot possibly reach its own line 09 and terminate normally.

The x86utm operating system based on an open source x86 emulator. This
system enables one C function to execute another C function in debug
step mode. When H simulates D it creates a separate process context for
D with its own memory, stack and virtual registers. H is able to
simulate D simulating itself, thus the only limit to recursive
simulations is RAM.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06 int Halt_Status = H(x, x);
07 if (Halt_Status)
08 HERE: goto HERE;
09 return Halt_Status;
10 }
11
12 void main()
13 {
14 D(D);
15 }

*Execution Trace*
Line 14: main() invokes D(D)

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach its own line 09.

Is it dead obvious to everyone here when examining the execution
trace of lines 14 and 06 above that D correctly simulated by H cannot
possibly terminate normally by reaching its own line 09?

This means that when termination analyzer H aborts its simulation of D
and reports that its correctly simulated input cannot possibly terminate
normally it is merely reporting an easily verified fact.

*THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE ENGINEERING*

I will provide the next steps of the analysis after the above has been
accepted.

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

Bonita Montero

unread,

Jun 12, 2023, 1:05:12 PM6/12/23

to

Does it get you anywhere, obsessing over the same detail for years?

olcott

unread,

Jun 12, 2023, 1:27:36 PM6/12/23

to

I have improved the wording such that anyone with a modicum of software
engineering competence can easily verify that the above is necessarily
correct. H(D,D) does correctly report that D correctly simulated by H
cannot possibly terminate normally by reaching its own line 09.

Also I finally have an easily understood rebuttal to the one remaining
objection to my work that Ben Bacarisse has been so heavily pushing.

Bonita Montero

unread,

Jun 12, 2023, 2:30:54 PM6/12/23

to

How is that related to my question ?

olcott

unread,

Jun 12, 2023, 2:54:08 PM6/12/23

to

*Yes it does here is how it does*
Because I have focused on the issue of H(D,D) determining the halt
status of its input for several years I have simplified my words so that
anyone with a modicum of software engineering knowledge can easily
verify that H(D,D) does correctly determine that D correctly simulated
by H cannot possibly terminate normally.

The latest (very recent) change is to switch the frame-of-reference from
computer science halt deciders to software engineering termination
analyzers.

Chris M. Thomasson

unread,

Jun 12, 2023, 3:53:18 PM6/12/23

to

No shit Bonita! wow.

olcott

unread,

Jun 12, 2023, 4:21:42 PM6/12/23

to

*Yes it does here is how it does*
Because I have focused on the issue of H(D,D) determining the halt
status of its input for several years I have simplified my words so that
anyone with a modicum of software engineering knowledge can easily
verify that H(D,D) does correctly determine that D correctly simulated
by H cannot possibly terminate normally.

The latest (very recent) change is to switch the frame-of-reference from
computer science halt deciders to software engineering termination
analyzers.

The whole system is right here:
https://github.com/plolcott/x86utm

It compiles with the 2017 version of the Community Edition
https://visualstudio.microsoft.com/vs/older-downloads/

Big Dick

unread,

Jun 12, 2023, 5:47:48 PM6/12/23

to

On 12/06/2023 18:04, Bonita Montero wrote:
>
>
> Does it get you anywhere, obsessing over the same detail for years?

He once said he gets a very hard erection to attend Bunga Bunga sex
party organised by late Silvio Berlusconi of Italy. He can show his
prowess in C programming at these parties.

Richard Damon

unread,

Jun 12, 2023, 7:44:58 PM6/12/23

to

On 6/12/23 12:34 PM, olcott wrote:
> Software engineers can easily verify that D correctly simulated by H
> cannot possibly reach its own line 09 and terminate normally.

I showed your flaws in comp.theory

Yes, No H can simulate D to its termination, but that does NOT mean that
D is non-halting

Only that no H can actually do a "correct" simulation and give an answer.

Since Halting is NOT about the simulation done by the decider, you are
just proving that you are totally ignorant of the problem you claim to
be solving.

Tony Oliver

unread,

Jun 14, 2023, 10:35:11 AM6/14/23

to

On Monday, 12 June 2023 at 18:27:36 UTC+1, olcott wrote:
> On 6/12/2023 12:04 PM, Bonita Montero wrote:
> > Am 12.06.2023 um 18:34 schrieb olcott:
> >> Software engineers can easily verify that D correctly simulated by H
> >> cannot possibly reach its own line 09 and terminate normally.

> >> *THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE ENGINEERING*

<snip the remaining bollocks>

It is apparent that you do not have a clue what Software Engineering is.
A Software Engineer is a practitioner of the principles defined by the
Software Development Lifecycle (SDLC). There is no "verified fact
of correct Software Engineering" in your algorithm.

olcott

unread,

Jun 14, 2023, 11:08:11 AM6/14/23

to

*Thanks for replying I really need software engineering feedback*

Software engineering is much more than merely the system development
lifecycle it also includes extremely much more rigor in the development
of software than computer programming.

Software engineers operate within something like axioms of computer
programming, design patterns are an example of this.
https://en.wikipedia.org/wiki/Design_Patterns

The kind of rigorous analysis performed by software engineers
conclusively proves that D correctly simulated by H cannot possibly
terminate normally.

I wrote the x86utm operating system. The most difficult part was
providing the infrastructure to support the context switch so that
termination analyzer H could simulate itself simulating itself to an
arbitrary level of recursive depth.

The x86utm operating system based on an open source x86 emulator. This
system enables one C function to execute another C function in debug
step mode. When H simulates D it creates a separate process context for
D with its own memory, stack and virtual registers. H is able to
simulate D simulating itself, thus the only limit to recursive
simulations is RAM.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06 int Halt_Status = H(x, x);
07 if (Halt_Status)
08 HERE: goto HERE;
09 return Halt_Status;
10 }
11
12 void main()
13 {

14 H(D,D);
15 }

Execution Trace
Line 14: main() invokes H(D,D);

keeps repeating (unless aborted)

Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

Simulation invariant:
D correctly simulated by H cannot possibly reach its own line 09.

H correctly determines that D correctly simulated by H cannot possibly
terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion.

The x86utm operating system (includes several termination analyzers)

https://github.com/plolcott/x86utm

It compiles with the 2017 version of the Community Edition

https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&rel=15

unread,

Jun 14, 2023, 11:58:55 AM6/14/23

to

If you would bother to pay attention and actually examine my work you
would comprehend that termination analyzer H does correctly prevent the
denial of service attack that would otherwise succeed when H is provided
a halting problem styled pathological input D.

*You only have to carefully examine the first page to see this*
(The last two pages apply the same principle to computer science)

*Termination Analyzer H prevents Denial of Service attacks*
https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_prevents_Denial_of_Service_attacks

unread,

Jun 15, 2023, 8:11:04 PM6/15/23

to

On Wednesday, 14 June 2023 at 16:08:11 UTC+1, olcott wrote:
> On 6/14/2023 9:35 AM, Tony Oliver wrote:
> > On Monday, 12 June 2023 at 18:27:36 UTC+1, olcott wrote:
> >> On 6/12/2023 12:04 PM, Bonita Montero wrote:
> >>> Am 12.06.2023 um 18:34 schrieb olcott:
> >>>> Software engineers can easily verify that D correctly simulated by H
> >>>> cannot possibly reach its own line 09 and terminate normally.
> >
> > <snip a load of old bollocks>
> >
> >>>> *THE ABOVE IS AN EASILY VERIFIED FACT OF CORRECT SOFTWARE ENGINEERING*
> >
> > <snip the remaining bollocks>
> >
> > It is apparent that you do not have a clue what Software Engineering is.
> > A Software Engineer is a practitioner of the principles defined by the
> > Software Development Lifecycle (SDLC). There is no "verified fact
> > of correct Software Engineering" in your algorithm.
> *Thanks for replying I really need software engineering feedback*
>
> Software engineering is much more than merely the system development
> lifecycle it also includes extremely much more rigor in the development
> of software than computer programming.

i said nothing of system development. Are you illiterate as well as
deranged?

> Software engineers operate within something like axioms of computer
> programming, design patterns are an example of this.
> https://en.wikipedia.org/wiki/Design_Patterns

Design patterns have nothing to do with Sofware Engineering, you
berk. Get your head tested (your reading and comprehension centres
seem to be failing).

> The kind of rigorous analysis performed by software engineers
> conclusively proves that D correctly simulated by H cannot possibly
> terminate normally.

Again, you're using the term "Software Engineers" wrong.
You might just as well have asserted that "analysis performed by
a tin of baked beans..."

> I wrote the x86utm operating system.

> // The following is written in C

Is it, bollocks. What are all those leading numbers?
C does not recognise then at all.

> 01 typedef int (*ptr)(); // pointer to int function
> 02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input
> 03
> 04 int D(ptr x)
> 05 {
> 06 int Halt_Status = H(x, x);
> 07 if (Halt_Status)
> 08 HERE: goto HERE;
> 09 return Halt_Status;
> 10 }
> 11
> 12 void main()
> 13 {
> 14 H(D,D);
> 15 }

Tony Oliver

unread,

Jun 15, 2023, 8:12:48 PM6/15/23

to

On Wednesday, 14 June 2023 at 16:09:39 UTC+1, Bonita Montero wrote:
> Pete, do you have an occupation as a software engineer ?

Hahahahahahah!!

Of course he hasn't - he doesn't even understand what the title means!.