Re: Every D correctly simulated by H cannot possible reach its own line 06 and halt

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.