XPost: sci.logic

On 5/19/24 11:09 PM, olcott wrote:

On 5/19/2024 8:10 PM, Richard Damon wrote:

On 5/19/24 8:06 PM, olcott wrote:

On 5/1/2024 7:10 PM, Richard Damon wrote:

typedef int (*ptr)();  // ptr is pointer to int function
00 int H(ptr p, ptr i);
01 int D(ptr p)
02 {
03   int Halt_Status = H(p, p);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 int main()
10 {
11   H(D,D);
12   return 0;
13 }

In the above case a simulator is an x86 emulator that correctly
emulates at least one of the x86 instructions of D in the order
specified by the x86 instructions of D.

This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.

For every H/D pair of the above template D correctly simulated by
*pure function* H cannot possibly reach its own final state at
line 06 and halt.

Ok, so adding that H is a pure function, that means that since your
outer H(D,D) is going to return 0, all logic must be compatible with
the fact that EVERY call to H(D,D) will also eventually return 0.


Remember also, THIS D is defined to call THIS H, that does exactly the
same as the H that is deciding it.

<snip so that Message ID links to whole message>
We can use my unique time/date stamp as an alternative.

Remember, YOU are the one saying you are needing to change the
definition from the classical theory, where we have things well
defined.

YOU have decider that H is just whatever C code you want to write
for it, and D is the input proved. (which doesn't actually match the
Linz or Sipser proof, but fairly close).

With THAT set of definitions we have a lot of options that break
your incorrectly assumed results.

The first method has been discussed here by Flibble. While the final
answer he got to doesn't fit the requirements, the first part of the
method DOES show that it is possible for an H to simulate to past
line 3.

THe basic idea is that if H(M,d) finds that its simulation of M(d)
get to a call to H(M,d) then rather that your idea of just saying it
will get stuck and declair the input invalid, since there ARE a
number of possible inputs that there is a "correct" answer that H
can give to

That D is calling H does not prove recursive simulation.
That D is calling H with its same parameters does seem
to prove non-halting recursive simulation.

Nope. Try to actuall PROVE it.

I am using categorically exhaustive reasoning that can work
through every possibility that can possibly exist in a feasible
amount of time as long as the category is very very narrow.

What "Category", we have a specified H and an SPECIFIED D.

The question is not, can H simulate D to the end, the question is does D
halt.

IF you are going to try to use a "Categorical exhaustive reasoning" you
need to actually DEFINE the category, and what you are going to try to exhaustively search.

Enlarge the category a tiny little bit and then the time
becomes infeasible.

And if you are going to argue that "No H" can do something, that only
applies if you allow for all H.

Your making H a set of pure functions limits the set of machines to not
ve able to actually look at a useful category.

Remember, simulating a machine for a finite number of steps and then
aborting doesn't prove the machine is non-halting.

The tiniest little divergence from the title of this
thread and I totally ignore and erase everything else
that you say.

Then why did you diverge from your problem statment.

You have gone back to using "Halting" terminology, so you are clearly
looking at halting which is not proven by just the behavior of an
aborted simulation.

The problem is that we are now looking at the behavior of THIS D, so
your category might be looking at different H's looking at THIS D (which
calls that original H).

You seem to want to send a lot of time looking at the wiring of the 10
story office building to answer the question about cats.

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

XPost: sci.logic

On 5/19/24 11:32 PM, olcott wrote:

On 5/19/2024 10:24 PM, Richard Damon wrote:

On 5/19/24 11:09 PM, olcott wrote:

On 5/19/2024 8:10 PM, Richard Damon wrote:

On 5/19/24 8:06 PM, olcott wrote:

On 5/1/2024 7:10 PM, Richard Damon wrote:

typedef int (*ptr)();  // ptr is pointer to int function
00 int H(ptr p, ptr i);
01 int D(ptr p)
02 {
03   int Halt_Status = H(p, p);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 int main()
10 {
11   H(D,D);
12   return 0;
13 }

In the above case a simulator is an x86 emulator that correctly
emulates at least one of the x86 instructions of D in the order
specified by the x86 instructions of D.

This may include correctly emulating the x86 instructions of H in
the order specified by the x86 instructions of H thus calling
H(D,D) in recursive simulation.

For every H/D pair of the above template D correctly simulated by
*pure function* H cannot possibly reach its own final state at
line 06 and halt.

Ok, so adding that H is a pure function, that means that since your
outer H(D,D) is going to return 0, all logic must be compatible with
the fact that EVERY call to H(D,D) will also eventually return 0.


Remember also, THIS D is defined to call THIS H, that does exactly
the same as the H that is deciding it.

<snip so that Message ID links to whole message>
We can use my unique time/date stamp as an alternative.

Remember, YOU are the one saying you are needing to change the
definition from the classical theory, where we have things well
defined.

YOU have decider that H is just whatever C code you want to write
for it, and D is the input proved. (which doesn't actually match
the Linz or Sipser proof, but fairly close).

With THAT set of definitions we have a lot of options that break
your incorrectly assumed results.

The first method has been discussed here by Flibble. While the
final answer he got to doesn't fit the requirements, the first
part of the method DOES show that it is possible for an H to
simulate to past line 3.

THe basic idea is that if H(M,d) finds that its simulation of M(d) >>>>>> get to a call to H(M,d) then rather that your idea of just saying
it will get stuck and declair the input invalid, since there ARE a >>>>>> number of possible inputs that there is a "correct" answer that H
can give to

That D is calling H does not prove recursive simulation.
That D is calling H with its same parameters does seem
to prove non-halting recursive simulation.

Nope. Try to actuall PROVE it.

I am using categorically exhaustive reasoning that can work
through every possibility that can possibly exist in a feasible
amount of time as long as the category is very very narrow.

What "Category", we have a specified H and an SPECIFIED D.

The question is not, can H simulate D to the end, the question is does
D halt.

*The subject is in the subject line you diverged, please try again*
*The subject is in the subject line you diverged, please try again*
*The subject is in the subject line you diverged, please try again*

And since YOU brought up the diversion, I just asked you to define it.

After all, who cares about all the other programs you are deceptively
calling D and H, when the actual problem you have admitted you want to
get to does care about it.

You should be happy that we want to keep you from wasting time on side
issues that don't matter.

You say you are preparing to do a "Categorically Exhaustive Reasoning",
but it seems you can't define what "Category" you are look at, and what
goal you are seeking to obtain.

Since you have PROVEN that what you think is "Self-Evident" isn't,
because you come in with false ideas and unstated assumptions, you
should be willing to accept help keeping you onto your real task.

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

XPost: sci.logic

On 5/20/24 2:03 PM, olcott wrote:

On 5/20/2024 6:24 AM, Richard Damon wrote:

On 5/19/24 11:22 PM, olcott wrote:

On 5/19/2024 10:11 PM, Richard Damon wrote:

On 5/19/24 10:52 PM, olcott wrote:

On 5/19/2024 8:10 PM, Richard Damon wrote:

On 5/19/24 8:06 PM, olcott wrote:

On 5/1/2024 7:10 PM, Richard Damon wrote:

typedef int (*ptr)();  // ptr is pointer to int function
00 int H(ptr p, ptr i);
01 int D(ptr p)
02 {
03   int Halt_Status = H(p, p);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 int main()
10 {
11   H(D,D);
12   return 0;
13 }

In the above case a simulator is an x86 emulator that correctly
emulates at least one of the x86 instructions of D in the order
specified by the x86 instructions of D.

This may include correctly emulating the x86 instructions of H in >>>>>>> the order specified by the x86 instructions of H thus calling
H(D,D) in recursive simulation.

For every H/D pair of the above template D correctly simulated by >>>>>>> *pure function* H cannot possibly reach its own final state at
line 06 and halt.

Ok, so adding that H is a pure function, that means that since
your outer H(D,D) is going to return 0, all logic must be
compatible with the fact that EVERY call to H(D,D) will also
eventually return 0.


Remember also, THIS D is defined to call THIS H, that does exactly >>>>>> the same as the H that is deciding it.

OK, good.

Right, so it doesn't matter what any other D does, it matters what
THIS D does, and this D calls aths H.

Remember, you reinstated the Computation model by enforcing Pure
Functions.

<snip so that Message ID links to whole message>
We can use my unique time/date stamp as an alternative.

Remember, YOU are the one saying you are needing to change the >>>>>>>> definition from the classical theory, where we have things well >>>>>>>> defined.

YOU have decider that H is just whatever C code you want to
write for it, and D is the input proved. (which doesn't actually >>>>>>>> match the Linz or Sipser proof, but fairly close).

With THAT set of definitions we have a lot of options that break >>>>>>>> your incorrectly assumed results.

The first method has been discussed here by Flibble. While the >>>>>>>> final answer he got to doesn't fit the requirements, the first >>>>>>>> part of the method DOES show that it is possible for an H to
simulate to past line 3.

THe basic idea is that if H(M,d) finds that its simulation of
M(d) get to a call to H(M,d) then rather that your idea of just >>>>>>>> saying it will get stuck and declair the input invalid, since
there ARE a number of possible inputs that there is a "correct" >>>>>>>> answer that H can give to

That D is calling H does not prove recursive simulation.
That D is calling H with its same parameters does seem
to prove non-halting recursive simulation.

Nope. Try to actuall PROVE it.

That is off-topic for this post.
All that we need know is that no D simulated by any H
ever reaches its own line 06 and halts.

Nope. Make a claim, you need to prove it.

*In other different post not this one*

I am using categorically exhaustive reasoning that can work
through every possibility that can possibly exist in a feasible
amount of time as long as the category is very very narrow.

But you can't PRECISELY define the category, or what you want to
reason about, so your logic is worthless as it is baseless.

*POINT TO ANY ACTUAL MISTAKE OR AMBIGUITY WITH THIS VERSION*

typedef int (*ptr)();  // ptr is pointer to int function
00 int H(ptr p, ptr i);
01 int D(ptr p)
02 {
03   int Halt_Status = H(p, p);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 int main()
10 {
11   H(D,D);
12   return 0;
13 }

In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.

This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.

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

keeps repeating (unless aborted)
Line 01:
Line 02:
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.

For every H/D pair of the above template D correctly simulated by pure function (thus computable function) H cannot possibly reach its own
final state at line 06 and halt.

Which thus doesn't correct simulate the call to H (since H proves that a
call to itself as H(D,D) WILL return the value 0)

Since you have an incorrect step in your simulation, you arguement is
just unsound.

Note, a correct simulation of a call to H(D,D) is NOT another simulation
of D(D), as H SIMULATES its input, not run it, and even if the
"simulation" is "debug stepping", the H still retains control, so if H
will abort its simulation at some point, such simulation is not
"infinite", even if the out H gives up before it gets to that point.

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