Re: Dogma -- other deciders

Am Fri, 21 Jun 2024 23:31:42 -0500 schrieb olcott:

On 6/21/2024 11:24 PM, joes wrote:

Am Fri, 21 Jun 2024 22:16:55 -0500 schrieb olcott:

On 6/21/2024 6:38 PM, Richard Damon wrote:

On 6/21/24 7:27 PM, olcott wrote:

On 6/21/2024 4:46 PM, Richard Damon wrote:

On 6/21/24 5:25 PM, olcott wrote:

On 6/21/2024 4:10 PM, Richard Damon wrote:

On 6/21/24 4:52 PM, olcott wrote:

On 6/21/2024 3:00 PM, Richard Damon wrote:

On 6/21/24 3:45 PM, olcott wrote:

On 6/21/2024 2:33 PM, Richard Damon wrote:

On 6/21/24 3:19 PM, olcott wrote:

The DEFINITION of a Halt Decider gives what H is SUPPOSED to do,
if it is one. You claim it is a correct Halt decider

When we do not simply make false assumptions about the behavior
that the input to H(D,D) specifies:
    That the call from D correctly simulated by H to H(D,D)
    returns

What "False Assumption"?

If it didn't return, H weren't a decider.

To "define" that the call from the D correctly simulated by H to
H(D,D) returns when the actual facts prove that this call *DOES NOT
RETURN* is ultimately unreasonable because *THERE IS NO REASONING*
that supports this.

If H really is a decider, it returns.

The semantics of the x86 language conclusively proves as a verified
fact that the behavior that D specifies to H is different than the
behavior that D specifies to H1.

But D is the same in either case?!

D has a certain behaviour. Of course it depends on the called decider,
which by construction should be the one deciding on it. If those are
different, nothing unusual happens and we get the correct result.

You cannot simply correctly ignore that the pathological relationship
that D calls H(D,D) and does not call H1(D,D) changes the behavior of
D between these two cases.

Naturally. Deciding D (which calls H) with H1 is not the halting problem,
however (same with H deciding D1 which calls H1).

The behaviour changes only because of the called H.

I see you agree:

void DDD()
{
   H0(DDD);
}
int main()
{
   H0(DDD);
   H1(DDD);
}
DDD correctly simulated by H1 halts.
DDD correctly simulated by H0 never halts.

There is exactly one correct simulation, which corresponds to the direct
execution.

--
Man kann mit dunklen Zahlen nicht rechnen. Für die eigentliche Mathematik
sind sie vollkommen nutzlos. --Wolfgang Mückenheim