Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.software-eng > #3590 > unrolled thread

Software engineers needed to validate this

Back to article view | Back to comp.software-eng

Contents

  Software engineers needed to validate this olcott <NoOne@NoWhere.com> - 2022-07-11 09:55 -0500
    Re: Software engineers needed to validate this Mr Flibble <flibble@reddwarf.jmc.corp> - 2022-07-11 18:21 +0100
      Re: Software engineers needed to validate this Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2022-07-11 11:35 -0700

#3590 — Software engineers needed to validate this

Only an ordinary understanding of C and software engineering is required.

#define ptr uintptr_t

int H(ptr p, ptr i); // simulating halt decider

H Simulates its input until it correctly predicts that this simulated 
input would never terminate normally then rejects this input as non-halting.

void P(ptr x)
  {
   if (H(x, x))
     HERE: goto HERE;
   return;
  }

int main()
  {
   Output("Input_Halts = ", H(P, P));
  }

When the execution trace of function P() simulated by function H() shows:
(1) Function H() is called from P().
(2) With the same parameters to H().
(3) With no instructions in P() that could escape this infinitely 
recursive simulation: {index jump, conditional branch, return}

Then the function call from P() to H() would never terminate normally.
In this case H aborts its simulation of P and rejects its input as 
non-halting.

-- 
Copyright 2022 Pete Olcott

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

[toc] | [next] | [standalone]

#3591

On Mon, 11 Jul 2022 09:55:45 -0500
olcott <NoOne@NoWhere.com> wrote:

> Only an ordinary understanding of C and software engineering is
> required.
> 
> #define ptr uintptr_t
> 
> int H(ptr p, ptr i); // simulating halt decider
> 
> H Simulates its input until it correctly predicts that this simulated 
> input would never terminate normally then rejects this input as
> non-halting.
> 
> void P(ptr x)
>   {
>    if (H(x, x))
>      HERE: goto HERE;
>    return;
>   }
> 
> int main()
>   {
>    Output("Input_Halts = ", H(P, P));
>   }
> 
> When the execution trace of function P() simulated by function H()
> shows: (1) Function H() is called from P().
> (2) With the same parameters to H().
> (3) With no instructions in P() that could escape this infinitely 
> recursive simulation: {index jump, conditional branch, return}
> 
> Then the function call from P() to H() would never terminate normally.
> In this case H aborts its simulation of P and rejects its input as 
> non-halting.
> 

Can you not post your crap to this newsgroup (comp.lang.c++) please?

And you seem to need reminding YET AGAIN of the following:

I have shown with my signaling halting decider there is no need for
a call to a simulation-based halting decider, H, from the input program
to be recursive; this is compatible with [Strachey 1965] and
associated proofs which are not recursive in nature.  Your H is invalid
as it aborts the simulation to prevent infinite recursion rather than
returning an answer to its caller which results in it giving the wrong
answer for a non-pathological input that calls H.

/Flibble

[toc] | [prev] | [next] | [standalone]

#3592

Mr Flibble <flibble@reddwarf.jmc.corp> writes:
> On Mon, 11 Jul 2022 09:55:45 -0500
> olcott <NoOne@NoWhere.com> wrote:
[34 lines deleted]
>
> Can you not post your crap to this newsgroup (comp.lang.c++) please?

If you must reply to one of olcott's off-topic posts, don't quote
the entire post.

> And you seem to need reminding YET AGAIN of the following:

And don't invite him to post again by trying to continue the discussion
here.

[SNIP]

Followups redirected to comp.theory.

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips
void Void(void) { Void(); } /* The recursive call of the void */

[toc] | [prev] | [standalone]

Back to top | Article view | comp.software-eng

csiph-web