From Newsgroup: comp.theory

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
int Halt_Status = HHH(EE);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int EE()
{
int Halt_Status = HHH(EE);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int main()
{
Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD
but the DD above is new. The opposite nameing would have been better.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 27/08/2025 08:33, Mikko wrote:

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int EE()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD
but the DD above is new. The opposite nameing would have been
better.

I was trying to keep the call from main the same. But okay...

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int FF()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}


int main()
{
Output("Input_Halts = ", HHH(FF));
}

What should HHH(FF) return to main now, and why?

Does HHH() abort FF when it aborts DD (which is part of the FF
simulation)?

HHH() must be able to answer this question, because HHH must report.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/27/2025 2:33 AM, Mikko wrote:

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int EE()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD
but the DD above is new. The opposite nameing would have been better.

That merely adds extraneous complexity that makes
the basic ideas more difficult to understand.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/27/25 10:41 AM, olcott wrote:

On 8/27/2025 2:33 AM, Mikko wrote:

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int EE()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD
but the DD above is new. The opposite nameing would have been better.

That merely adds extraneous complexity that makes
the basic ideas more difficult to understand.

In other words, you admit that you can't answer it with an answer that
your program will give, becuase your logic just can't lie that well.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-08-27 07:49:20 +0000, Richard Heathfield said:

On 27/08/2025 08:33, Mikko wrote:

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int EE()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD
but the DD above is new. The opposite nameing would have been better.

I was trying to keep the call from main the same. But okay...

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int FF()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int main()
{
Output("Input_Halts = ", HHH(FF));
}

What should HHH(FF) return to main now, and why?

Does HHH() abort FF when it aborts DD (which is part of the FF simulation)?

HHH() must be able to answer this question, because HHH must report.

HHH(DD) as implemented returns 0 (which is wrong as DD() halts).
Therefore FF does not halt so HHH(FF) should return 1.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 28/08/2025 07:57, Mikko wrote:

On 2025-08-27 07:49:20 +0000, Richard Heathfield said:

On 27/08/2025 08:33, Mikko wrote:

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int EE()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD
but the DD above is new. The opposite nameing would have been
better.

I was trying to keep the call from main the same. But okay...

int DD()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int FF()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(FF));
}

What should HHH(FF) return to main now, and why?

Does HHH() abort FF when it aborts DD (which is part of the FF
simulation)?

HHH() must be able to answer this question, because HHH must
report.

HHH(DD) as implemented returns 0 (which is wrong as DD() halts).
Therefore FF does not halt so HHH(FF) should return 1.

That's what I think, too. But I strongly suspect that it won't.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/28/2025 1:57 AM, Mikko wrote:

On 2025-08-27 07:49:20 +0000, Richard Heathfield said:

On 27/08/2025 08:33, Mikko wrote:

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int EE()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD
but the DD above is new. The opposite nameing would have been better.

I was trying to keep the call from main the same. But okay...

int DD()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int FF()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(FF));
}

What should HHH(FF) return to main now, and why?

Does HHH() abort FF when it aborts DD (which is part of the FF
simulation)?

HHH() must be able to answer this question, because HHH must report.

HHH(DD) as implemented returns 0 (which is wrong as DD() halts).
Therefore FF does not halt so HHH(FF) should return 1.

Clearly you do not understand that all Turing
machine deciders ONLY compute the mapping from
their inputs. I could say that 5 + 7 = 36 by
ignoring the rules of arithmetic.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/28/2025 10:15 AM, olcott wrote:

On 8/28/2025 1:57 AM, Mikko wrote:

On 2025-08-27 07:49:20 +0000, Richard Heathfield said:

On 27/08/2025 08:33, Mikko wrote:

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int EE()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD
but the DD above is new. The opposite nameing would have been better.

I was trying to keep the call from main the same. But okay...

int DD()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int FF()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(FF));
}

What should HHH(FF) return to main now, and why?

Does HHH() abort FF when it aborts DD (which is part of the FF
simulation)?

HHH() must be able to answer this question, because HHH must report.

HHH(DD) as implemented returns 0 (which is wrong as DD() halts).
Therefore FF does not halt so HHH(FF) should return 1.

Clearly you do not understand that all Turing
machine deciders ONLY compute the mapping from
their inputs. I could say that 5 + 7 = 36 by
ignoring the rules of arithmetic.

You would also say that sum(5,7)==36 is correct because those are the
values that the input to sum(5,7) below specifies.

int sum(int x, int y)
{
return (x+20)+(y+4);
}
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-08-28 14:15:34 +0000, olcott said:

On 8/28/2025 1:57 AM, Mikko wrote:

On 2025-08-27 07:49:20 +0000, Richard Heathfield said:

On 27/08/2025 08:33, Mikko wrote:

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int EE()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD
but the DD above is new. The opposite nameing would have been better.

I was trying to keep the call from main the same. But okay...

int DD()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int FF()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(FF));
}

What should HHH(FF) return to main now, and why?

Does HHH() abort FF when it aborts DD (which is part of the FF simulation)? >>>
HHH() must be able to answer this question, because HHH must report.

HHH(DD) as implemented returns 0 (which is wrong as DD() halts).
Therefore FF does not halt so HHH(FF) should return 1.

Clearly you do not understand that all Turing
machine deciders ONLY compute the mapping from
their inputs. I could say that 5 + 7 = 36 by
ignoring the rules of arithmetic.

It is not a good idea to lie about other people. If you don't know
the truth or don't want to tell it then it is better to say nothing.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/29/2025 1:51 AM, Mikko wrote:

On 2025-08-28 14:15:34 +0000, olcott said:

On 8/28/2025 1:57 AM, Mikko wrote:

On 2025-08-27 07:49:20 +0000, Richard Heathfield said:

On 27/08/2025 08:33, Mikko wrote:

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int EE()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD
but the DD above is new. The opposite nameing would have been better. >>>>>

I was trying to keep the call from main the same. But okay...

int DD()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int FF()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(FF));
}

What should HHH(FF) return to main now, and why?

Does HHH() abort FF when it aborts DD (which is part of the FF
simulation)?

HHH() must be able to answer this question, because HHH must report.

HHH(DD) as implemented returns 0 (which is wrong as DD() halts).
Therefore FF does not halt so HHH(FF) should return 1.

Clearly you do not understand that all Turing
machine deciders ONLY compute the mapping from
their inputs. I could say that 5 + 7 = 36 by
ignoring the rules of arithmetic.

It is not a good idea to lie about other people. If you don't know
the truth or don't want to tell it then it is better to say nothing.

Yet you still continue to prove that you do not understand.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/28/25 10:15 AM, olcott wrote:

On 8/28/2025 1:57 AM, Mikko wrote:

On 2025-08-27 07:49:20 +0000, Richard Heathfield said:

On 27/08/2025 08:33, Mikko wrote:

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int EE()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD
but the DD above is new. The opposite nameing would have been better.

I was trying to keep the call from main the same. But okay...

int DD()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int FF()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(FF));
}

What should HHH(FF) return to main now, and why?

Does HHH() abort FF when it aborts DD (which is part of the FF
simulation)?

HHH() must be able to answer this question, because HHH must report.

HHH(DD) as implemented returns 0 (which is wrong as DD() halts).
Therefore FF does not halt so HHH(FF) should return 1.

Clearly you do not understand that all Turing
machine deciders ONLY compute the mapping from
their inputs. I could say that 5 + 7 = 36 by
ignoring the rules of arithmetic.

Right, and you HHH ignores the rule of Programs, as it thinks partial simjulation of the wrong input are correct.

They only *CAN* compute a computable mapping from their input.

The requrements might be a non-computable mapping of their input, as
defined by what the input represents.

All you are doing is proving your stupidity in not seeing the difference.

Just like you don't understand the difference between Truth and
Knowledge, or what a proof is.

Sorry, you are just sealing your doom as a proving crank.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/29/25 9:58 AM, olcott wrote:

On 8/29/2025 1:51 AM, Mikko wrote:

On 2025-08-28 14:15:34 +0000, olcott said:

On 8/28/2025 1:57 AM, Mikko wrote:

On 2025-08-27 07:49:20 +0000, Richard Heathfield said:

On 27/08/2025 08:33, Mikko wrote:

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int EE()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD
but the DD above is new. The opposite nameing would have been better. >>>>>>

I was trying to keep the call from main the same. But okay...

int DD()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int FF()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(FF));
}

What should HHH(FF) return to main now, and why?

Does HHH() abort FF when it aborts DD (which is part of the FF
simulation)?

HHH() must be able to answer this question, because HHH must report.

HHH(DD) as implemented returns 0 (which is wrong as DD() halts).
Therefore FF does not halt so HHH(FF) should return 1.

Clearly you do not understand that all Turing
machine deciders ONLY compute the mapping from
their inputs. I could say that 5 + 7 = 36 by
ignoring the rules of arithmetic.

It is not a good idea to lie about other people. If you don't know
the truth or don't want to tell it then it is better to say nothing.

Yet you still continue to prove that you do not understand.

No, you do.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-08-29 13:58:06 +0000, olcott said:

On 8/29/2025 1:51 AM, Mikko wrote:

On 2025-08-28 14:15:34 +0000, olcott said:

On 8/28/2025 1:57 AM, Mikko wrote:

On 2025-08-27 07:49:20 +0000, Richard Heathfield said:

On 27/08/2025 08:33, Mikko wrote:

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int EE()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD
but the DD above is new. The opposite nameing would have been better. >>>>>>

I was trying to keep the call from main the same. But okay...

int DD()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int FF()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(FF));
}

What should HHH(FF) return to main now, and why?

Does HHH() abort FF when it aborts DD (which is part of the FF simulation)?

HHH() must be able to answer this question, because HHH must report.

HHH(DD) as implemented returns 0 (which is wrong as DD() halts).
Therefore FF does not halt so HHH(FF) should return 1.

Clearly you do not understand that all Turing
machine deciders ONLY compute the mapping from
their inputs. I could say that 5 + 7 = 36 by
ignoring the rules of arithmetic.

It is not a good idea to lie about other people. If you don't know
the truth or don't want to tell it then it is better to say nothing.

Yet you still continue to prove that you do not understand.

As I already said, it is a sin to lie about other people. In these
discussion there is no need to say anything about anybody.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/30/2025 5:16 AM, Mikko wrote:

On 2025-08-29 13:58:06 +0000, olcott said:

On 8/29/2025 1:51 AM, Mikko wrote:

On 2025-08-28 14:15:34 +0000, olcott said:

On 8/28/2025 1:57 AM, Mikko wrote:

On 2025-08-27 07:49:20 +0000, Richard Heathfield said:

On 27/08/2025 08:33, Mikko wrote:

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int EE()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD >>>>>>> but the DD above is new. The opposite nameing would have been
better.

I was trying to keep the call from main the same. But okay...

int DD()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int FF()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(FF));
}

What should HHH(FF) return to main now, and why?

Does HHH() abort FF when it aborts DD (which is part of the FF
simulation)?

HHH() must be able to answer this question, because HHH must report. >>>>>

HHH(DD) as implemented returns 0 (which is wrong as DD() halts).
Therefore FF does not halt so HHH(FF) should return 1.

Clearly you do not understand that all Turing
machine deciders ONLY compute the mapping from
their inputs. I could say that 5 + 7 = 36 by
ignoring the rules of arithmetic.

It is not a good idea to lie about other people. If you don't know
the truth or don't want to tell it then it is better to say nothing.

Yet you still continue to prove that you do not understand.

As I already said, it is a sin to lie about other people. In these
discussion there is no need to say anything about anybody.

Telling the objective truth is never a lie.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-08-30 16:25:07 +0000, olcott said:

On 8/30/2025 5:16 AM, Mikko wrote:

On 2025-08-29 13:58:06 +0000, olcott said:

On 8/29/2025 1:51 AM, Mikko wrote:

On 2025-08-28 14:15:34 +0000, olcott said:

On 8/28/2025 1:57 AM, Mikko wrote:

On 2025-08-27 07:49:20 +0000, Richard Heathfield said:

On 27/08/2025 08:33, Mikko wrote:

On 2025-08-26 20:10:30 +0000, Richard Heathfield said:

int DD()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int EE()
{
-a-a int Halt_Status = HHH(EE);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(DD));
}

What should HHH(DD) return to main now?

The choice of names is not good. The EE above is like Olcott's DD >>>>>>>> but the DD above is new. The opposite nameing would have been better. >>>>>>>>

I was trying to keep the call from main the same. But okay...

int DD()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}

int FF()
{
-a-a int Halt_Status = HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a return Halt_Status;
}


int main()
{
-a-a Output("Input_Halts = ", HHH(FF));
}

What should HHH(FF) return to main now, and why?

Does HHH() abort FF when it aborts DD (which is part of the FF simulation)?

HHH() must be able to answer this question, because HHH must report. >>>>>>

HHH(DD) as implemented returns 0 (which is wrong as DD() halts).
Therefore FF does not halt so HHH(FF) should return 1.

Clearly you do not understand that all Turing
machine deciders ONLY compute the mapping from
their inputs. I could say that 5 + 7 = 36 by
ignoring the rules of arithmetic.

It is not a good idea to lie about other people. If you don't know
the truth or don't want to tell it then it is better to say nothing.

Yet you still continue to prove that you do not understand.

As I already said, it is a sin to lie about other people. In these
discussion there is no need to say anything about anybody.

Telling the objective truth is never a lie.

Above you told the opposite of the objective truth about me.
That was a sin (not truly serious but a sin anyway).
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2