Since the conventional HP only mentions a specific halting problem, which is
often believed to be an invalid proof and limited in use.
See https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ

I hereby proudly announce the General Undecidable Rule (2021 WIJ):
+-----------------------------------------------------------------------------------+
| No TM U can decide the property of a TM P if that property can be defied by TM P. |
+-----------------------------------------------------------------------------------+

//---------------------------
// Example 1: U is a function
//
// [Syn] bool U(void (*f)())
// U decides whether f prints character 'Y' or not.
//
// [Ret] true: f prints 'Y'
// false: f does not print 'Y'
//
void (*Func)();
inline bool U(Func f) {
// Rewrite the supposed function U here.
// The rewrite can be in very different but functionally equivalent ways (isomorphic).
}

void P() { // P always prints a character not predicted by U
if(U(P)) {
printf("b");
} else {
printf("Y");
}
}

//---------------------------
// Example 2: U is an executable
/*
[Syn] U <prog>
U Decides whether the program <prog> will return or not,

[Return Status] non-zero: <prog> will return (Or, TM stops at final accept or reject states)
zero: otherwise (<prog> will not return)
*/

/*
Program: P.c

Build: gcc -o P P.c
*/
#include <stdlib.h>

void P() { // P always behaves not predicted by U
int r=system("U P");

if(r) {
for(;;) {}; // infinite loop
}
};
int main() {
P();
};

==============================
The general construct of P (proof of General Undecidable Rule) is intuitive
and above all, REPRODUCIBLE, VERIFIABLE.

// [Ret] true: f has the (dynamic)property Q
// false: otherwise
//
void (*Func)();
inline bool U(Func f) {
// Rewrite U here.
// The rewrite can be in very different but functionally equivalent ways (isomorphic).
}

void P() {
if(U(P)) {
// do whatever Q defines false
} else {
// do whatever Q defines
} };

+-------------+
| Acknowledge |
+-------------+
I would like to acknowledge Olcott tirelessly refuted various wrong
conventional HP proofs over these years for me. So I need not to do the
same work again, though not necessary.

--
Copyright 2021 WIJ
"If I can see further it is by standing on top of the tower of dwarfs."

On 7/16/2021 1:08 PM, wij wrote:
> Since the conventional HP only mentions a specific halting problem, which is
> often believed to be an invalid proof and limited in use.
> See https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
>
> I hereby proudly announce the General Undecidable Rule (2021 WIJ):
> +-----------------------------------------------------------------------------------+
> | No TM U can decide the property of a TM P if that property can be defied by TM P. |
> +-----------------------------------------------------------------------------------+
>
> //---------------------------
> // Example 1: U is a function
> //
> // [Syn] bool U(void (*f)())
> // U decides whether f prints character 'Y' or not.
> //
> // [Ret] true: f prints 'Y'
> // false: f does not print 'Y'
> //
> void (*Func)();
> inline bool U(Func f) {
> // Rewrite the supposed function U here.
> // The rewrite can be in very different but functionally equivalent ways (isomorphic).
> }
>
> void P() { // P always prints a character not predicted by U
> if(U(P)) {
> printf("b");
> } else {
> printf("Y");
> }
> }
>
> //---------------------------
> // Example 2: U is an executable
> /*
> [Syn] U <prog>
> U Decides whether the program <prog> will return or not,
>
> [Return Status] non-zero: <prog> will return (Or, TM stops at final accept or reject states)
> zero: otherwise (<prog> will not return)
> */
>
> /*
> Program: P.c
>
> Build: gcc -o P P.c
> */
> #include <stdlib.h>
>
> void P() { // P always behaves not predicted by U
> int r=system("U P");
>
> if(r) {
> for(;;) {}; // infinite loop
> }
> };
> int main() {
> P();
> };
>
> ==============================
> The general construct of P (proof of General Undecidable Rule) is intuitive
> and above all, REPRODUCIBLE, VERIFIABLE.
>
> // [Ret] true: f has the (dynamic)property Q
> // false: otherwise
> //
> void (*Func)();
> inline bool U(Func f) {
> // Rewrite U here.
> // The rewrite can be in very different but functionally equivalent ways (isomorphic).
> }
>
> void P() {
> if(U(P)) {
> // do whatever Q defines false
> } else {
> // do whatever Q defines
> }
> };
>
> +-------------+
> | Acknowledge |
> +-------------+
> I would like to acknowledge Olcott tirelessly refuted various wrong
> conventional HP proofs over these years for me. So I need not to do the
> same work again, though not necessary.
>

The above statement does not count at all unless you can very accurately
paraphrase the exactly reasoning that proves that I am correct.

> --
> Copyright 2021 WIJ
> "If I can see further it is by standing on top of the tower of dwarfs."
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On Saturday, 17 July 2021 at 03:44:08 UTC+8, olcott wrote:
> On 7/16/2021 1:08 PM, wij wrote:
> > Since the conventional HP only mentions a specific halting problem, which is
> > often believed to be an invalid proof and limited in use.
> > See https://groups.google.com/g/comp.theory/c/RO9Z9eCabeE/m/Ka8-xS2rdEEJ
> >
> > I hereby proudly announce the General Undecidable Rule (2021 WIJ):
> > +-----------------------------------------------------------------------------------+
> > | No TM U can decide the property of a TM P if that property can be defied by TM P. |
> > +-----------------------------------------------------------------------------------+
> >
> > //---------------------------
> > // Example 1: U is a function
> > //
> > // [Syn] bool U(void (*f)())
> > // U decides whether f prints character 'Y' or not.
> > //
> > // [Ret] true: f prints 'Y'
> > // false: f does not print 'Y'
> > //
> > void (*Func)();
> > inline bool U(Func f) {
> > // Rewrite the supposed function U here.
> > // The rewrite can be in very different but functionally equivalent ways (isomorphic).
> > }
> >
> > void P() { // P always prints a character not predicted by U
> > if(U(P)) {
> > printf("b");
> > } else {
> > printf("Y");
> > }
> > }
> >
> > //---------------------------
> > // Example 2: U is an executable
> > /*
> > [Syn] U <prog>
> > U Decides whether the program <prog> will return or not,
> >
> > [Return Status] non-zero: <prog> will return (Or, TM stops at final accept or reject states)
> > zero: otherwise (<prog> will not return)
> > */
> >
> > /*
> > Program: P.c
> >
> > Build: gcc -o P P.c
> > */
> > #include <stdlib.h>
> >
> > void P() { // P always behaves not predicted by U
> > int r=system("U P");
> >
> > if(r) {
> > for(;;) {}; // infinite loop
> > }
> > };
> > int main() {
> > P();
> > };
> >
> > ==============================
> > The general construct of P (proof of General Undecidable Rule) is intuitive
> > and above all, REPRODUCIBLE, VERIFIABLE.
> >
> > // [Ret] true: f has the (dynamic)property Q
> > // false: otherwise
> > //
> > void (*Func)();
> > inline bool U(Func f) {
> > // Rewrite U here.
> > // The rewrite can be in very different but functionally equivalent ways (isomorphic).
> > }
> >
> > void P() {
> > if(U(P)) {
> > // do whatever Q defines false
> > } else {
> > // do whatever Q defines
> > }
> > };
> >
> > +-------------+
> > | Acknowledge |
> > +-------------+
> > I would like to acknowledge Olcott tirelessly refuted various wrong
> > conventional HP proofs over these years for me. So I need not to do the
> > same work again, though not necessary.
> >
> The above statement does not count at all unless you can very accurately
> paraphrase the exactly reasoning that proves that I am correct.
> > --
> > Copyright 2021 WIJ
> > "If I can see further it is by standing on top of the tower of dwarfs."
> >
> --
> Copyright 2021 Pete Olcott
>
> "Great spirits have always encountered violent opposition from mediocre
> minds." Einstein

I need REPRODUCIBLE, VERIFIABLE proof to do that.