Philosophy Now Forum

PeteOlcott wrote: ↑Tue May 17, 2022 1:12 am The input to H(P,P) would never reach its final state (the definition of halting) no matter how long H kept simulating it, thus H is correct to reject this input as non-halting.

Skepdick wrote: ↑Tue May 17, 2022 1:21 am

PeteOlcott wrote: ↑Tue May 17, 2022 1:12 am The input to H(P,P) would never reach its final state (the definition of halting) no matter how long H kept simulating it, thus H is correct to reject this input as non-halting.

Which is precisely why you can't solve this problem for H(H, H).

If you terminate H as non-halting for itself, then is it halting or non-halting?

PeteOlcott wrote: ↑Tue May 17, 2022 1:30 am As long as I have refuted the conventional HP proof pattern I have refuted all of the conventional proofs.

Skepdick wrote: ↑Tue May 17, 2022 1:34 am

PeteOlcott wrote: ↑Tue May 17, 2022 1:30 am As long as I have refuted the conventional HP proof pattern I have refuted all of the conventional proofs.

No, you haven't.

If H terminates its own execution because it detected itself as being stuck in an infinite loop then H is not stuck in an infinite loop.

It can't be stuck in an infinite loop BECAUSE IT TERMINATED ITS OWN EXECUTION

PeteOlcott wrote: ↑Tue May 17, 2022 2:36 am H detects that its input would never reach its own final state, thus H correctly rejects (P,P)

Skepdick wrote: ↑Tue May 17, 2022 10:57 am

PeteOlcott wrote: ↑Tue May 17, 2022 2:36 am H detects that its input would never reach its own final state, thus H correctly rejects (P,P)

Precisely! You are a liar!

By definition IF H can solve the halting problem for P then P is a less powerful model of computation than H.

You have "solved" a weaker form of the argument. That's called a strawman.

For any program H that might determine if programs halt, a "pathological"
program P, called with some input, can pass its own source and its input to
H and then specifically do the opposite of what H predicts P will do. No H
can exist that handles this case. https://en.wikipedia.org/wiki/Halting_problem

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

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

PeteOlcott wrote: ↑Tue May 17, 2022 4:09 pm

Skepdick wrote: ↑Tue May 17, 2022 10:57 am

PeteOlcott wrote: ↑Tue May 17, 2022 2:36 am H detects that its input would never reach its own final state, thus H correctly rejects (P,P)

Precisely! You are a liar!

By definition IF H can solve the halting problem for P then P is a less powerful model of computation than H.

You have "solved" a weaker form of the argument. That's called a strawman.

For any program H that might determine if programs halt, a "pathological"
program P, called with some input, can pass its own source and its input to
H and then specifically do the opposite of what H predicts P will do. No H
can exist that handles this case. https://en.wikipedia.org/wiki/Halting_problem

This is that code:

Code: Select all

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

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

int main()
{
  char program[] = "void P(char x[]){ if(H(x,x)) HERE: goto HERE; return; }"
  Output("Input_Halts = ", H(program, program));
}

Skepdick wrote: ↑Tue May 17, 2022 4:53 pm

PeteOlcott wrote: ↑Tue May 17, 2022 4:09 pm

Skepdick wrote: ↑Tue May 17, 2022 10:57 am
Precisely! You are a liar!

By definition IF H can solve the halting problem for P then P is a less powerful model of computation than H.

You have "solved" a weaker form of the argument. That's called a strawman.

For any program H that might determine if programs halt, a "pathological"
program P, called with some input, can pass its own source and its input to
H and then specifically do the opposite of what H predicts P will do. No H
can exist that handles this case. https://en.wikipedia.org/wiki/Halting_problem

This is that code:

Code: Select all

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

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

No, it isn't. You seem to be struggling with basic English comprehension.

The type-signature of your H is wrong.

Nowhere in the example above are you passing the source code for P to H.
You are passing a reference of P to H.

This is closer to what you are looking for:

Code: Select all

int main()
{
  char program[] = "void P(char x[]){ if(H(x,x)) HERE: goto HERE; return; }"
  Output("Input_Halts = ", H(program, program));
}

PeteOlcott wrote: ↑Tue May 17, 2022 5:14 pm Passing a literal string of x86 machine language of P is equivalent to passing the source code of P.

#include <stdio.h>

int main(){
    FILE *file = fopen("p.c", "r");
    char program[512];
    while (fgets(program, 512, file))
    fclose(file);
    Output("Input_Halts = ", H(program, program));
}

void P(char x[]) { if (H(x, x)) HERE: goto HERE; return; }

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

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

For any program H that might determine if programs halt, a "pathological"
program P, called with some input, can pass its own source and its input to
H and then specifically do the opposite of what H predicts P will do. No H
can exist that handles this case. https://en.wikipedia.org/wiki/Halting_problem

PeteOlcott wrote: ↑Tue May 17, 2022 5:35 pm It is the case that the above code matches the following code pattern

For any program H that might determine if programs halt, a "pathological"
program P, called with some input, can pass its own source

PeteOlcott wrote: ↑Tue May 17, 2022 5:56 pm It does not have to be source-code. In only has to specify the actual behavior of the actual input.

For any program H that might determine if programs halt, a "pathological"
program P, called with some input, can pass its own source and its input to
H and then specifically do the opposite of what H predicts P will do. No H
can exist that handles this case. https://en.wikipedia.org/wiki/Halting_problem

PeteOlcott wrote: ↑Tue May 17, 2022 5:56 pm source-code is ambiguous.