On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT correct? >>>>>>>
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being
wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the recursion
is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the initial recursion is demonstrated. HHH only actually demonstrates one step of recursion, not infinite. the infinite recursion only occurs if HHH
doesn't break the invariant of letting the simulation run, but HHH does break that invariant, so invalidating the induction requires to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical"
HHH violates the invariant so it violates it's own proof that DD is
recursive
sipser said that same thing polcott
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT
correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being
wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
the same decision to terminate and return 0, after which DD2 does _not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is still not infinitely recursive it is actually just a simple non-terminating loop
of one repeated state since that is the simplest loop
ur "decider" is equating the binary semantic halting behaviors of
machine terminating machine DD and non-terminating machine DD2, and classifying them the same
how do u respond to this inconsistency polcott?
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the recursion
is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the initial
recursion is demonstrated. HHH only actually demonstrates one step of
recursion, not infinite. the infinite recursion only occurs if HHH
doesn't break the invariant of letting the simulation run, but HHH
does break that invariant, so invalidating the induction requires to
prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical"
HHH violates the invariant so it violates it's own proof that DD is
recursive
sipser said that same thing polcott
On 11/12/26 12:02 AM, dart200 wrote:
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
the same decision to terminate and return 0, after which DD2 does
_not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is
still not infinitely recursive it is actually just a simple non-
terminating loop of one repeated state since that is the simplest loop
ur "decider" is equating the binary semantic halting behaviors of
machine terminating machine DD and non-terminating machine DD2, and
classifying them the same
how do u respond to this inconsistency polcott?
polcott u still haven't responded to the fact HHH classifies both
halting DD and non-halting DD2 into the same set of machines with the
same semantic halting behavior...
this is truly a 1 = 0 type of fault
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated. HHH only actually demonstrates one
step of recursion, not infinite. the infinite recursion only occurs
if HHH doesn't break the invariant of letting the simulation run, but
HHH does break that invariant, so invalidating the induction requires
to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical" >>>>
HHH violates the invariant so it violates it's own proof that DD is >>>>> recursive
sipser said that same thing polcott
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT
correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being
wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
the same decision to terminate and return 0, after which DD2 does _not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is still not infinitely recursive it is actually just a simple non-terminating loop
of one repeated state since that is the simplest loop
ur "decider" is equating the binary semantic halting behaviors of
machine terminating machine DD and non-terminating machine DD2, and classifying them the same
how do u respond to this inconsistency polcott?
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the recursion
is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the initial
recursion is demonstrated. HHH only actually demonstrates one step of
recursion, not infinite. the infinite recursion only occurs if HHH
doesn't break the invariant of letting the simulation run, but HHH
does break that invariant, so invalidating the induction requires to
prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical"
HHH violates the invariant so it violates it's own proof that DD is
recursive
sipser said that same thing polcott
On 11/12/2026 2:02 AM, dart200 wrote:
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
I have already fully addressed this whole category
of ideas already 500 times.
HHH and HHH1 are identical except that DD calls
HHH(DD) and does not call HHH1 at all.
HHH(DD)==0 is correct and HHH1(DD)==1 is correct
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH makes
the same decision to terminate and return 0, after which DD2 does
_not_ halt, unlike DD1 which _does_ halt... but in this case DD2 is
still not infinitely recursive it is actually just a simple non-
terminating loop of one repeated state since that is the simplest loop
ur "decider" is equating the binary semantic halting behaviors of
machine terminating machine DD and non-terminating machine DD2, and
classifying them the same
how do u respond to this inconsistency polcott?
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based on
the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated. HHH only actually demonstrates one
step of recursion, not infinite. the infinite recursion only occurs
if HHH doesn't break the invariant of letting the simulation run, but
HHH does break that invariant, so invalidating the induction requires
to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a hypothetical" >>>>
HHH violates the invariant so it violates it's own proof that DD is >>>>> recursive
sipser said that same thing polcott
On 11/13/26 11:03 AM, olcott wrote:
On 11/12/2026 2:02 AM, dart200 wrote:
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
I have already fully addressed this whole category
of ideas already 500 times.
HHH and HHH1 are identical except that DD calls
HHH(DD) and does not call HHH1 at all.
HHH(DD)==0 is correct and HHH1(DD)==1 is correct
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
dud, what are you talking about???
DD2 is 7 lines of code
and nowhere does it mention HHH1. seriously bro i
have poured over ur comments before and u not giving me the same respect back for literally 7 lines of code, 6 of which is urs i only changed one
for DD2...
my comment is that DD and DD2 are both classified as having the same semantic halting behavior by HHH,
and that's clearly a fault as DD is a halting machine and DD2 is a non- halting machine
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
makes the same decision to terminate and return 0, after which DD2
does _not_ halt, unlike DD1 which _does_ halt... but in this case DD2
is still not infinitely recursive it is actually just a simple non-
terminating loop of one repeated state since that is the simplest loop
ur "decider" is equating the binary semantic halting behaviors of
machine terminating machine DD and non-terminating machine DD2, and
classifying them the same
how do u respond to this inconsistency polcott?
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based
on the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated. HHH only actually demonstrates
one step of recursion, not infinite. the infinite recursion only
occurs if HHH doesn't break the invariant of letting the simulation
run, but HHH does break that invariant, so invalidating the
induction requires to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a
hypothetical"
HHH violates the invariant so it violates it's own proof that DD
is recursive
sipser said that same thing polcott
On 11/13/2026 1:51 PM, dart200 wrote:
On 11/13/26 11:03 AM, olcott wrote:
On 11/12/2026 2:02 AM, dart200 wrote:
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without being >>>>>>>>> wrong about something in regards to it, at least once???
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
I have already fully addressed this whole category
of ideas already 500 times.
HHH and HHH1 are identical except that DD calls
HHH(DD) and does not call HHH1 at all.
HHH(DD)==0 is correct and HHH1(DD)==1 is correct
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
dud, what are you talking about???
DD2 is 7 lines of code
I am not going to address endless diversions from the point.
Either you can understand how my HHH(DD) and HHH1(DD)
already address your variation of the same idea or you
fail to understand.
-aand nowhere does it mention HHH1. seriously bro i have poured over ur
comments before and u not giving me the same respect back for
literally 7 lines of code, 6 of which is urs i only changed one for
DD2...
my comment is that DD and DD2 are both classified as having the same
semantic halting behavior by HHH,
and that's clearly a fault as DD is a halting machine and DD2 is a
non- halting machine
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
makes the same decision to terminate and return 0, after which DD2
does _not_ halt, unlike DD1 which _does_ halt... but in this case
DD2 is still not infinitely recursive it is actually just a simple
non- terminating loop of one repeated state since that is the
simplest loop
ur "decider" is equating the binary semantic halting behaviors of
machine terminating machine DD and non-terminating machine DD2, and
classifying them the same
how do u respond to this inconsistency polcott?
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the
invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based
on the invariant that HHH not cut DD simulation's short after the
initial recursion is demonstrated. HHH only actually demonstrates
one step of recursion, not infinite. the infinite recursion only
occurs if HHH doesn't break the invariant of letting the simulation >>>>> run, but HHH does break that invariant, so invalidating the
induction requires to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a
hypothetical"
HHH violates the invariant so it violates it's own proof that DD >>>>>>> is recursive
sipser said that same thing polcott
On 11/13/26 11:56 AM, olcott wrote:
On 11/13/2026 1:51 PM, dart200 wrote:
On 11/13/26 11:03 AM, olcott wrote:
On 11/12/2026 2:02 AM, dart200 wrote:
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions
in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
I have already fully addressed this whole category
of ideas already 500 times.
HHH and HHH1 are identical except that DD calls
HHH(DD) and does not call HHH1 at all.
HHH(DD)==0 is correct and HHH1(DD)==1 is correct
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
dud, what are you talking about???
DD2 is 7 lines of code
I am not going to address endless diversions from the point.
Either you can understand how my HHH(DD) and HHH1(DD)
already address your variation of the same idea or you
fail to understand.
these are not analogous situations:
HHH(DD) vs HHH1(DD) is the _same_ input into _different_ deciders
HHH(DD) vs HHH(DD2) is _different_ input into the _same_ decider
right now ur claiming that HHH correctly classified halting machine DD
and non-halting machine DD2 into the same semantic set without
justifying how or why this ought to be so... or even acknowledging that
it does so
-aand nowhere does it mention HHH1. seriously bro i have poured over
ur comments before and u not giving me the same respect back for
literally 7 lines of code, 6 of which is urs i only changed one for
DD2...
my comment is that DD and DD2 are both classified as having the same
semantic halting behavior by HHH,
and that's clearly a fault as DD is a halting machine and DD2 is a
non- halting machine
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
makes the same decision to terminate and return 0, after which DD2
does _not_ halt, unlike DD1 which _does_ halt... but in this case
DD2 is still not infinitely recursive it is actually just a simple
non- terminating loop of one repeated state since that is the
simplest loop
ur "decider" is equating the binary semantic halting behaviors of
machine terminating machine DD and non-terminating machine DD2, and >>>>> classifying them the same
how do u respond to this inconsistency polcott?
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the >>>>>>>> invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical based >>>>>> on the invariant that HHH not cut DD simulation's short after the >>>>>> initial recursion is demonstrated. HHH only actually demonstrates >>>>>> one step of recursion, not infinite. the infinite recursion only
occurs if HHH doesn't break the invariant of letting the
simulation run, but HHH does break that invariant, so invalidating >>>>>> the induction requires to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a
hypothetical"
HHH violates the invariant so it violates it's own proof that DD >>>>>>>> is recursive
sipser said that same thing polcott
On 11/13/2026 2:12 PM, dart200 wrote:
On 11/13/26 11:56 AM, olcott wrote:
On 11/13/2026 1:51 PM, dart200 wrote:
On 11/13/26 11:03 AM, olcott wrote:
On 11/12/2026 2:02 AM, dart200 wrote:
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are NOT >>>>>>>>>>>>> correct?
could point to an actual error in the last 22 years.
The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions >>>>>>>>>>>> in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>
I have never been the tiniest bit wrong about my essence.
As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that
I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon.
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
I have already fully addressed this whole category
of ideas already 500 times.
HHH and HHH1 are identical except that DD calls
HHH(DD) and does not call HHH1 at all.
HHH(DD)==0 is correct and HHH1(DD)==1 is correct
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
dud, what are you talking about???
DD2 is 7 lines of code
I am not going to address endless diversions from the point.
Either you can understand how my HHH(DD) and HHH1(DD)
already address your variation of the same idea or you
fail to understand.
these are not analogous situations:
HHH(DD) vs HHH1(DD) is the _same_ input into _different_ deciders
HHH(DD) vs HHH(DD2) is _different_ input into the _same_ decider
right now ur claiming that HHH correctly classified halting machine DD
and non-halting machine DD2 into the same semantic set without
justifying how or why this ought to be so... or even acknowledging
that it does so
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
-aand nowhere does it mention HHH1. seriously bro i have poured over
ur comments before and u not giving me the same respect back for
literally 7 lines of code, 6 of which is urs i only changed one for
DD2...
my comment is that DD and DD2 are both classified as having the same
semantic halting behavior by HHH,
and that's clearly a fault as DD is a halting machine and DD2 is a
non- halting machine
HHH(DD2) is _also_ a possible input to HHH, and in this case HHH
makes the same decision to terminate and return 0, after which DD2 >>>>>> does _not_ halt, unlike DD1 which _does_ halt... but in this case >>>>>> DD2 is still not infinitely recursive it is actually just a simple >>>>>> non- terminating loop of one repeated state since that is the
simplest loop
ur "decider" is equating the binary semantic halting behaviors of >>>>>> machine terminating machine DD and non-terminating machine DD2,
and classifying them the same
how do u respond to this inconsistency polcott?
The fact that in most of the last four years no
one would affirm that DD simulated by HHH according
to the operational semantics of the C programming
language specifies recursive simulation does seems
to indicate that most people here are dishonest.
the recursive simulation is purely a hypothetical based on the >>>>>>>>> invariant that HHH not cut DD simulation's short after the
recursion is demonstrated
let me be abundantly clear polcott:
the /infinite/ recursive simulation is purely a hypothetical
based on the invariant that HHH not cut DD simulation's short
after the initial recursion is demonstrated. HHH only actually
demonstrates one step of recursion, not infinite. the infinite
recursion only occurs if HHH doesn't break the invariant of
letting the simulation run, but HHH does break that invariant, so >>>>>>> invalidating the induction requires to prove infinite recursion
sipser said that same thing polcott
You just contradicted yourself.
"purely a hypothetical" means never happened at all
"after the recursion is demonstrated" means not "purely a
hypothetical"
HHH violates the invariant so it violates it's own proof that >>>>>>>>> DD is recursive
sipser said that same thing polcott
On 11/13/26 12:19 PM, olcott wrote:
On 11/13/2026 2:12 PM, dart200 wrote:
On 11/13/26 11:56 AM, olcott wrote:
On 11/13/2026 1:51 PM, dart200 wrote:
On 11/13/26 11:03 AM, olcott wrote:
On 11/12/2026 2:02 AM, dart200 wrote:
On 11/11/26 11:16 PM, dart200 wrote:
On 11/11/26 8:50 PM, olcott wrote:
On 11/11/2026 10:10 PM, dart200 wrote:
On 11/11/26 11:24 AM, olcott wrote:
On 11/11/2026 1:11 PM, dart200 wrote:
On 11/11/26 8:34 AM, olcott wrote:
On 11/11/2026 9:45 AM, Python wrote:
Peter,If I was not correct then at least one person
Then a reviewer having an honest dialogue
that pays complete attention and makes no
attempt to change the subject can confirm
that I am correct very quickly.
Peter, have you considered the possibility that you are >>>>>>>>>>>>>> NOT correct?
could point to an actual error in the last 22 years. >>>>>>>>>>>>> The closest that anyone ever got is showing that my
words to not conform to their false assumptions.
I can very much better show that these assumptions
are false now that I have anchored computable functions >>>>>>>>>>>>> in their simplest possible essence.
polcott u honestly think u spent 22 years on this without >>>>>>>>>>>> being wrong about something in regards to it, at least once??? >>>>>>>>>>>>
I have never been the tiniest bit wrong about my essence. >>>>>>>>>>> As far as my essence goes I have gotten much more clear
about proving the tiny aspects of nuance of details of
the error of the halting theorem.
I had a bunch of typos. There were quite a few times that >>>>>>>>>>> I misunderstood what someone was saying. The essence of
my work has simply been progressively refined such that
I expect it to pass very rigorous peer review very soon. >>>>>>>>>>>
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
01 int DD2()
02 {
03-a-a int Halt_Status = HHH(DD2);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a HERE2: goto HERE2;
07 }
I have already fully addressed this whole category
of ideas already 500 times.
HHH and HHH1 are identical except that DD calls
HHH(DD) and does not call HHH1 at all.
HHH(DD)==0 is correct and HHH1(DD)==1 is correct
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
dud, what are you talking about???
DD2 is 7 lines of code
I am not going to address endless diversions from the point.
Either you can understand how my HHH(DD) and HHH1(DD)
already address your variation of the same idea or you
fail to understand.
these are not analogous situations:
HHH(DD) vs HHH1(DD) is the _same_ input into _different_ deciders
HHH(DD) vs HHH(DD2) is _different_ input into the _same_ decider
right now ur claiming that HHH correctly classified halting machine
DD and non-halting machine DD2 into the same semantic set without
justifying how or why this ought to be so... or even acknowledging
that it does so
The main thing that I have changed is that HHH
implements its own unify_with_occurs_check().
This means semantically ungrounded thus bad input
instead of non-halting.
ok to clarify:
HHH is _not_ a halting semantics decider,
it's more of a "semantically grounded for halting semantics" decider?
| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 76 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 55:41:18 |
| Calls: | 1,265 |
| Calls today: | 1 |
| Files: | 1,362 |
| D/L today: |
3 files (2,684K bytes) |
| Messages: | 285,687 |