01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness:
Simulation invariant (while DD is simulated by HHH)
Line 03: simulated DD() invokes simulated HHH(DD) that simulates DD()
DD simulated by HHH according to the operational semantics
of the C programming language cannot possibly reach its own
simulated return statement while being simulated by HHH.
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
On 10/31/26 8:25 AM, olcott wrote:
On 10/31/2026 10:20 AM, dart200 wrote:
On 10/31/26 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness:
Simulation invariant (while DD is simulated by HHH)
Line 03: simulated DD() invokes simulated HHH(DD) that simulates >>>>>>>> DD()
DD simulated by HHH according to the operational semantics
of the C programming language cannot possibly reach its own
simulated return statement while being simulated by HHH.
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
HHH only runs a modified simulator that cuts off the simulated DD >>>>>>> resulting in only a partial simulation
a universal simulator (? as defined by turing himself) does _not_ >>>>>>> interfere with the simulation being run, like a turing machine
itself does not interfere with it's own execution
HHH does interfere, therefore it's not a universal simulator.
it's only reporting on a truncated partial trace of DD, not the >>>>>>> full execution of DD
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT
HHH is not ? the universal simulator and does not simulate DD in
total.
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
i'm trying to help u polcott and u pull this kinda brainrot crap on me
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
simulation invariant (while olcott is simulated by comp.theory):
line 01: simulated olcott() invokes all-caps macro repeating line 01
looks like your own brain just entered the infinite recursion you
claimed HHH could detect. too bad HHH didn't abort before line 5.
HHH cuts off the simulation of DD short, so ofc it doesn't reach
DD's return statement
asking for a rebuttal to explain how HHH simulating DD reaches DDs
return statement is just ... nonsense. HHH is _not_ a universal
simulator and does _not_ simulate DD in total nor even is expected
to do so!
it is therefore _not_ actually reporting on a complete simulation
of DD, objectively so as HHH cuts off DDs simulation before DD
reaches it's final state. if u compared the states the HHH(DD)
records in it's simulation, this would not match the states that
?(DD) records in it's simulation. HHH(DD) would match up to some
point, at which point HHH(DD) would record no more states, while
?(DD) does.
HHH is merely a broken algorithm that does not refute the halting
theorem in the slightest. i don't even think it's a total algorithm >>>>> cause who tf knows what HHH(collatz_conj) would return, if even. i
bet it wouldn't, i bet HHH(collatz_conj) diverges as written.
now idk if ur gunna accept that or not, prolly u stopped reading by >>>>> now tbh ... but you wanna know what i think is useful about this
issue of HHH that you bring up?
ur kinda right that HHH _should_ be able to detect an infinite
looping recursion like what it tries on DD, because that's how the
inductive math proofs work. but u can't actually build a machine
that totally implements that as an automated prover precisely
because of the machine DD that u wrote...
something feels off about that for sure, if the math was good HHH
should work cause the algo is so dead simple.
On 10/31/2026 10:36 AM, dart200 wrote:
On 10/31/26 8:25 AM, olcott wrote:
On 10/31/2026 10:20 AM, dart200 wrote:
On 10/31/26 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness:
Simulation invariant (while DD is simulated by HHH)
Line 03: simulated DD() invokes simulated HHH(DD) that
simulates DD()
DD simulated by HHH according to the operational semantics
of the C programming language cannot possibly reach its own
simulated return statement while being simulated by HHH.
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
HHH only runs a modified simulator that cuts off the simulated >>>>>>>> DD resulting in only a partial simulation
a universal simulator (? as defined by turing himself) does
_not_ interfere with the simulation being run, like a turing
machine itself does not interfere with it's own execution
HHH does interfere, therefore it's not a universal simulator. >>>>>>>> it's only reporting on a truncated partial trace of DD, not the >>>>>>>> full execution of DD
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT
HHH is not ? the universal simulator and does not simulate DD in
total.
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
i'm trying to help u polcott and u pull this kinda brainrot crap on me >>>>
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
simulation invariant (while olcott is simulated by comp.theory):
line 01: simulated olcott() invokes all-caps macro repeating line 01
looks like your own brain just entered the infinite recursion you
claimed HHH could detect. too bad HHH didn't abort before line 5.
So you never really were a programmer and
want to hide your ignorance of programming
by diversion and head games?
Exactly what Are your programming credentials?
The lack of a direct answer to this question
will be taken as the reason to end this
conversation with you.
HHH cuts off the simulation of DD short, so ofc it doesn't reach
DD's return statement
asking for a rebuttal to explain how HHH simulating DD reaches DDs >>>>>> return statement is just ... nonsense. HHH is _not_ a universal
simulator and does _not_ simulate DD in total nor even is expected >>>>>> to do so!
it is therefore _not_ actually reporting on a complete simulation >>>>>> of DD, objectively so as HHH cuts off DDs simulation before DD
reaches it's final state. if u compared the states the HHH(DD)
records in it's simulation, this would not match the states that
?(DD) records in it's simulation. HHH(DD) would match up to some
point, at which point HHH(DD) would record no more states, while
?(DD) does.
HHH is merely a broken algorithm that does not refute the halting >>>>>> theorem in the slightest. i don't even think it's a total
algorithm cause who tf knows what HHH(collatz_conj) would return, >>>>>> if even. i bet it wouldn't, i bet HHH(collatz_conj) diverges as
written.
now idk if ur gunna accept that or not, prolly u stopped reading
by now tbh ... but you wanna know what i think is useful about
this issue of HHH that you bring up?
ur kinda right that HHH _should_ be able to detect an infinite
looping recursion like what it tries on DD, because that's how the >>>>>> inductive math proofs work. but u can't actually build a machine
that totally implements that as an automated prover precisely
because of the machine DD that u wrote...
something feels off about that for sure, if the math was good HHH >>>>>> should work cause the algo is so dead simple.
On 10/31/26 8:42 AM, olcott wrote:
On 10/31/2026 10:36 AM, dart200 wrote:
On 10/31/26 8:25 AM, olcott wrote:
On 10/31/2026 10:20 AM, dart200 wrote:
On 10/31/26 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness:
Simulation invariant (while DD is simulated by HHH)
Line 03: simulated DD() invokes simulated HHH(DD) that
simulates DD()
DD simulated by HHH according to the operational semantics >>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>> simulated return statement while being simulated by HHH.
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
HHH only runs a modified simulator that cuts off the simulated >>>>>>>>> DD resulting in only a partial simulation
a universal simulator (? as defined by turing himself) does >>>>>>>>> _not_ interfere with the simulation being run, like a turing >>>>>>>>> machine itself does not interfere with it's own execution
HHH does interfere, therefore it's not a universal simulator. >>>>>>>>> it's only reporting on a truncated partial trace of DD, not the >>>>>>>>> full execution of DD
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT
HHH is not ? the universal simulator and does not simulate DD in >>>>>>> total.
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
i'm trying to help u polcott and u pull this kinda brainrot crap on me >>>>>
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
simulation invariant (while olcott is simulated by comp.theory):
line 01: simulated olcott() invokes all-caps macro repeating line 01
looks like your own brain just entered the infinite recursion you
claimed HHH could detect. too bad HHH didn't abort before line 5.
So you never really were a programmer and
want to hide your ignorance of programming
by diversion and head games?
Exactly what Are your programming credentials?
i have a computer engineering degree from ucsd and ~10 yrs of
professional experience
The lack of a direct answer to this question
will be taken as the reason to end this
conversation with you.
bruh u pulling fallacy after fallacy after fallacy is a much bigger
reason for me to end the convo with you ...
but haven't done that now, have i??? u don't give me the courtesy of
reading all that i wrote, and that really is ur loss because i'm most definitely not like the other chucklefucks around here
HHH cuts off the simulation of DD short, so ofc it doesn't reach >>>>>>> DD's return statement
asking for a rebuttal to explain how HHH simulating DD reaches
DDs return statement is just ... nonsense. HHH is _not_ a
universal simulator and does _not_ simulate DD in total nor even >>>>>>> is expected to do so!
it is therefore _not_ actually reporting on a complete simulation >>>>>>> of DD, objectively so as HHH cuts off DDs simulation before DD
reaches it's final state. if u compared the states the HHH(DD)
records in it's simulation, this would not match the states that >>>>>>> ?(DD) records in it's simulation. HHH(DD) would match up to some >>>>>>> point, at which point HHH(DD) would record no more states, while >>>>>>> ?(DD) does.
HHH is merely a broken algorithm that does not refute the halting >>>>>>> theorem in the slightest. i don't even think it's a total
algorithm cause who tf knows what HHH(collatz_conj) would return, >>>>>>> if even. i bet it wouldn't, i bet HHH(collatz_conj) diverges as >>>>>>> written.
now idk if ur gunna accept that or not, prolly u stopped reading >>>>>>> by now tbh ... but you wanna know what i think is useful about
this issue of HHH that you bring up?
ur kinda right that HHH _should_ be able to detect an infinite
looping recursion like what it tries on DD, because that's how
the inductive math proofs work. but u can't actually build a
machine that totally implements that as an automated prover
precisely because of the machine DD that u wrote...
something feels off about that for sure, if the math was good HHH >>>>>>> should work cause the algo is so dead simple.
On 10/31/26 8:42 AM, olcott wrote:
On 10/31/2026 10:36 AM, dart200 wrote:
On 10/31/26 8:25 AM, olcott wrote:
On 10/31/2026 10:20 AM, dart200 wrote:
On 10/31/26 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness:
Simulation invariant (while DD is simulated by HHH)
Line 03: simulated DD() invokes simulated HHH(DD) that
simulates DD()
DD simulated by HHH according to the operational semantics >>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>> simulated return statement while being simulated by HHH.
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
HHH only runs a modified simulator that cuts off the simulated >>>>>>>>> DD resulting in only a partial simulation
a universal simulator (? as defined by turing himself) does >>>>>>>>> _not_ interfere with the simulation being run, like a turing >>>>>>>>> machine itself does not interfere with it's own execution
HHH does interfere, therefore it's not a universal simulator. >>>>>>>>> it's only reporting on a truncated partial trace of DD, not the >>>>>>>>> full execution of DD
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT
HHH is not ? the universal simulator and does not simulate DD in >>>>>>> total.
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
i'm trying to help u polcott and u pull this kinda brainrot crap on me >>>>>
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
simulation invariant (while olcott is simulated by comp.theory):
line 01: simulated olcott() invokes all-caps macro repeating line 01
looks like your own brain just entered the infinite recursion you
claimed HHH could detect. too bad HHH didn't abort before line 5.
So you never really were a programmer and
want to hide your ignorance of programming
by diversion and head games?
Exactly what Are your programming credentials?
i have a computer engineering degree from ucsd and ~10 yrs of
professional experience
The lack of a direct answer to this question
will be taken as the reason to end this
conversation with you.
bruh u pulling fallacy after fallacy after fallacy is a much bigger
reason for me to end the convo with you ...
but haven't done that now, have i??? u don't give me the courtesy of
reading all that i wrote, and that really is ur loss because i'm most definitely not like the other chucklefucks around here
On 10/31/2026 10:52 AM, dart200 wrote:
On 10/31/26 8:42 AM, olcott wrote:
On 10/31/2026 10:36 AM, dart200 wrote:
On 10/31/26 8:25 AM, olcott wrote:
On 10/31/2026 10:20 AM, dart200 wrote:
On 10/31/26 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness:
Simulation invariant (while DD is simulated by HHH)
Line 03: simulated DD() invokes simulated HHH(DD) that
simulates DD()
DD simulated by HHH according to the operational semantics >>>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>>> simulated return statement while being simulated by HHH. >>>>>>>>>>>
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
HHH only runs a modified simulator that cuts off the simulated >>>>>>>>>> DD resulting in only a partial simulation
a universal simulator (? as defined by turing himself) does >>>>>>>>>> _not_ interfere with the simulation being run, like a turing >>>>>>>>>> machine itself does not interfere with it's own execution
HHH does interfere, therefore it's not a universal simulator. >>>>>>>>>> it's only reporting on a truncated partial trace of DD, not >>>>>>>>>> the full execution of DD
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT
HHH is not ? the universal simulator and does not simulate DD in >>>>>>>> total.
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
i'm trying to help u polcott and u pull this kinda brainrot crap
on me
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
simulation invariant (while olcott is simulated by comp.theory):
line 01: simulated olcott() invokes all-caps macro repeating line 01
looks like your own brain just entered the infinite recursion you
claimed HHH could detect. too bad HHH didn't abort before line 5.
So you never really were a programmer and
want to hide your ignorance of programming
by diversion and head games?
Exactly what Are your programming credentials?
i have a computer engineering degree from ucsd and ~10 yrs of
professional experience
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Then I do not see why that you cannot see that
while DD is simulated by HHH you will not concede
that this same DD simulated by HHH will not reach
its own line 06, unless your primary goal is to
be disagreeable.
If you fail to concede that DD simulated by HHH
cannot reach its own line 06 while DD is being
simulated by HHH
or fail to show exactly how DD simulated by HHH
does reach it own simulated line 06 while DD is
being simulated by HHH I will end this conversation
with you.
The lack of a direct answer to this question
will be taken as the reason to end this
conversation with you.
bruh u pulling fallacy after fallacy after fallacy is a much bigger
reason for me to end the convo with you ...
but haven't done that now, have i??? u don't give me the courtesy of
reading all that i wrote, and that really is ur loss because i'm most
definitely not like the other chucklefucks around here
HHH cuts off the simulation of DD short, so ofc it doesn't reach >>>>>>>> DD's return statement
asking for a rebuttal to explain how HHH simulating DD reaches >>>>>>>> DDs return statement is just ... nonsense. HHH is _not_ a
universal simulator and does _not_ simulate DD in total nor even >>>>>>>> is expected to do so!
it is therefore _not_ actually reporting on a complete
simulation of DD, objectively so as HHH cuts off DDs simulation >>>>>>>> before DD reaches it's final state. if u compared the states the >>>>>>>> HHH(DD) records in it's simulation, this would not match the
states that ?(DD) records in it's simulation. HHH(DD) would
match up to some point, at which point HHH(DD) would record no >>>>>>>> more states, while ?(DD) does.
HHH is merely a broken algorithm that does not refute the
halting theorem in the slightest. i don't even think it's a
total algorithm cause who tf knows what HHH(collatz_conj) would >>>>>>>> return, if even. i bet it wouldn't, i bet HHH(collatz_conj)
diverges as written.
now idk if ur gunna accept that or not, prolly u stopped reading >>>>>>>> by now tbh ... but you wanna know what i think is useful about >>>>>>>> this issue of HHH that you bring up?
ur kinda right that HHH _should_ be able to detect an infinite >>>>>>>> looping recursion like what it tries on DD, because that's how >>>>>>>> the inductive math proofs work. but u can't actually build a
machine that totally implements that as an automated prover
precisely because of the machine DD that u wrote...
something feels off about that for sure, if the math was good >>>>>>>> HHH should work cause the algo is so dead simple.
On 10/31/26 9:31 AM, olcott wrote:
On 10/31/2026 10:52 AM, dart200 wrote:
On 10/31/26 8:42 AM, olcott wrote:
On 10/31/2026 10:36 AM, dart200 wrote:
On 10/31/26 8:25 AM, olcott wrote:
On 10/31/2026 10:20 AM, dart200 wrote:
On 10/31/26 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness:
Simulation invariant (while DD is simulated by HHH)
Line 03: simulated DD() invokes simulated HHH(DD) that >>>>>>>>>>>> simulates DD()
DD simulated by HHH according to the operational semantics >>>>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>>>> simulated return statement while being simulated by HHH. >>>>>>>>>>>>
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
HHH only runs a modified simulator that cuts off the
simulated DD resulting in only a partial simulation
a universal simulator (? as defined by turing himself) does >>>>>>>>>>> _not_ interfere with the simulation being run, like a turing >>>>>>>>>>> machine itself does not interfere with it's own execution >>>>>>>>>>>
HHH does interfere, therefore it's not a universal simulator. >>>>>>>>>>> it's only reporting on a truncated partial trace of DD, not >>>>>>>>>>> the full execution of DD
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT
HHH is not ? the universal simulator and does not simulate DD >>>>>>>>> in total.
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
i'm trying to help u polcott and u pull this kinda brainrot crap >>>>>>> on me
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
simulation invariant (while olcott is simulated by comp.theory):
line 01: simulated olcott() invokes all-caps macro repeating line 01 >>>>>
looks like your own brain just entered the infinite recursion you
claimed HHH could detect. too bad HHH didn't abort before line 5.
So you never really were a programmer and
want to hide your ignorance of programming
by diversion and head games?
Exactly what Are your programming credentials?
i have a computer engineering degree from ucsd and ~10 yrs of
professional experience
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Then I do not see why that you cannot see that
while DD is simulated by HHH you will not concede
that this same DD simulated by HHH will not reach
i've already conceded HHH(DD) does not simulate DD to line 06: HHH(DD)
does a partial simulation of DD, and therefor will not simulate DD to
line 06
its own line 06, unless your primary goal is to
be disagreeable.
i'm agreeing with u polcott on that point, why are you being so
disagreeable about it? ?
If you fail to concede that DD simulated by HHH
cannot reach its own line 06 while DD is being
simulated by HHH
or fail to show exactly how DD simulated by HHH
does reach it own simulated line 06 while DD is
being simulated by HHH I will end this conversation
with you.
let's suppose i could show that HHH(DD) simulating DD reaches line 06 in
the simulation ... how would that refute ur proof?
The lack of a direct answer to this question
will be taken as the reason to end this
conversation with you.
bruh u pulling fallacy after fallacy after fallacy is a much bigger
reason for me to end the convo with you ...
but haven't done that now, have i??? u don't give me the courtesy of
reading all that i wrote, and that really is ur loss because i'm most
definitely not like the other chucklefucks around here
HHH cuts off the simulation of DD short, so ofc it doesn't
reach DD's return statement
asking for a rebuttal to explain how HHH simulating DD reaches >>>>>>>>> DDs return statement is just ... nonsense. HHH is _not_ a
universal simulator and does _not_ simulate DD in total nor >>>>>>>>> even is expected to do so!
it is therefore _not_ actually reporting on a complete
simulation of DD, objectively so as HHH cuts off DDs simulation >>>>>>>>> before DD reaches it's final state. if u compared the states >>>>>>>>> the HHH(DD) records in it's simulation, this would not match >>>>>>>>> the states that ?(DD) records in it's simulation. HHH(DD) would >>>>>>>>> match up to some point, at which point HHH(DD) would record no >>>>>>>>> more states, while ?(DD) does.
HHH is merely a broken algorithm that does not refute the
halting theorem in the slightest. i don't even think it's a >>>>>>>>> total algorithm cause who tf knows what HHH(collatz_conj) would >>>>>>>>> return, if even. i bet it wouldn't, i bet HHH(collatz_conj) >>>>>>>>> diverges as written.
now idk if ur gunna accept that or not, prolly u stopped
reading by now tbh ... but you wanna know what i think is
useful about this issue of HHH that you bring up?
ur kinda right that HHH _should_ be able to detect an infinite >>>>>>>>> looping recursion like what it tries on DD, because that's how >>>>>>>>> the inductive math proofs work. but u can't actually build a >>>>>>>>> machine that totally implements that as an automated prover >>>>>>>>> precisely because of the machine DD that u wrote...
something feels off about that for sure, if the math was good >>>>>>>>> HHH should work cause the algo is so dead simple.
On 10/31/2026 12:33 PM, dart200 wrote:
On 10/31/26 9:31 AM, olcott wrote:
On 10/31/2026 10:52 AM, dart200 wrote:
On 10/31/26 8:42 AM, olcott wrote:
On 10/31/2026 10:36 AM, dart200 wrote:
On 10/31/26 8:25 AM, olcott wrote:
On 10/31/2026 10:20 AM, dart200 wrote:
On 10/31/26 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness:
Simulation invariant (while DD is simulated by HHH)
Line 03: simulated DD() invokes simulated HHH(DD) that >>>>>>>>>>>>> simulates DD()
DD simulated by HHH according to the operational semantics >>>>>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>>>>> simulated return statement while being simulated by HHH. >>>>>>>>>>>>>
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
HHH only runs a modified simulator that cuts off the
simulated DD resulting in only a partial simulation
a universal simulator (? as defined by turing himself) does >>>>>>>>>>>> _not_ interfere with the simulation being run, like a turing >>>>>>>>>>>> machine itself does not interfere with it's own execution >>>>>>>>>>>>
HHH does interfere, therefore it's not a universal
simulator. it's only reporting on a truncated partial trace >>>>>>>>>>>> of DD, not the full execution of DD
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT >>>>>>>>>>>
HHH is not ? the universal simulator and does not simulate DD >>>>>>>>>> in total.
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
i'm trying to help u polcott and u pull this kinda brainrot crap >>>>>>>> on me
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
simulation invariant (while olcott is simulated by comp.theory):
line 01: simulated olcott() invokes all-caps macro repeating line 01 >>>>>>
looks like your own brain just entered the infinite recursion you
claimed HHH could detect. too bad HHH didn't abort before line 5.
So you never really were a programmer and
want to hide your ignorance of programming
by diversion and head games?
Exactly what Are your programming credentials?
i have a computer engineering degree from ucsd and ~10 yrs of
professional experience
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Then I do not see why that you cannot see that
while DD is simulated by HHH you will not concede
that this same DD simulated by HHH will not reach
i've already conceded HHH(DD) does not simulate DD to line 06: HHH(DD)
does a partial simulation of DD, and therefor will not simulate DD to
line 06
its own line 06, unless your primary goal is to
be disagreeable.
i'm agreeing with u polcott on that point, why are you being so
disagreeable about it? ?
If you fail to concede that DD simulated by HHH
cannot reach its own line 06 while DD is being
simulated by HHH
or fail to show exactly how DD simulated by HHH
does reach it own simulated line 06 while DD is
being simulated by HHH I will end this conversation
with you.
let's suppose i could show that HHH(DD) simulating DD reaches line 06
in the simulation ... how would that refute ur proof?
With the credentials that you say that you have you
would already know it is a logical impossibility.
The lack of a direct answer to this question
will be taken as the reason to end this
conversation with you.
bruh u pulling fallacy after fallacy after fallacy is a much bigger
reason for me to end the convo with you ...
but haven't done that now, have i??? u don't give me the courtesy of
reading all that i wrote, and that really is ur loss because i'm
most definitely not like the other chucklefucks around here
HHH cuts off the simulation of DD short, so ofc it doesn't >>>>>>>>>> reach DD's return statement
asking for a rebuttal to explain how HHH simulating DD reaches >>>>>>>>>> DDs return statement is just ... nonsense. HHH is _not_ a >>>>>>>>>> universal simulator and does _not_ simulate DD in total nor >>>>>>>>>> even is expected to do so!
it is therefore _not_ actually reporting on a complete
simulation of DD, objectively so as HHH cuts off DDs
simulation before DD reaches it's final state. if u compared >>>>>>>>>> the states the HHH(DD) records in it's simulation, this would >>>>>>>>>> not match the states that ?(DD) records in it's simulation. >>>>>>>>>> HHH(DD) would match up to some point, at which point HHH(DD) >>>>>>>>>> would record no more states, while ?(DD) does.
HHH is merely a broken algorithm that does not refute the >>>>>>>>>> halting theorem in the slightest. i don't even think it's a >>>>>>>>>> total algorithm cause who tf knows what HHH(collatz_conj) >>>>>>>>>> would return, if even. i bet it wouldn't, i bet
HHH(collatz_conj) diverges as written.
now idk if ur gunna accept that or not, prolly u stopped
reading by now tbh ... but you wanna know what i think is >>>>>>>>>> useful about this issue of HHH that you bring up?
ur kinda right that HHH _should_ be able to detect an infinite >>>>>>>>>> looping recursion like what it tries on DD, because that's how >>>>>>>>>> the inductive math proofs work. but u can't actually build a >>>>>>>>>> machine that totally implements that as an automated prover >>>>>>>>>> precisely because of the machine DD that u wrote...
something feels off about that for sure, if the math was good >>>>>>>>>> HHH should work cause the algo is so dead simple.
WHY THIS REFERENCE POST IS NEEDED
The observation
˙˙ H0 simulates D0
˙˙˙˙ -> D0 calls H1
˙˙˙˙˙˙ -> H1 simulates D1
˙˙˙˙˙˙˙˙ -> D1 calls H2
˙˙˙˙˙˙˙˙˙˙˙ -> ...
certainly establishes the beginning of a recursive simulation pattern.
That point is not disputed.
What IS disputed is
On 10/31/26 10:55 AM, olcott wrote:
On 10/31/2026 12:33 PM, dart200 wrote:
On 10/31/26 9:31 AM, olcott wrote:
On 10/31/2026 10:52 AM, dart200 wrote:
On 10/31/26 8:42 AM, olcott wrote:
On 10/31/2026 10:36 AM, dart200 wrote:
On 10/31/26 8:25 AM, olcott wrote:
On 10/31/2026 10:20 AM, dart200 wrote:
On 10/31/26 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness:
Simulation invariant (while DD is simulated by HHH) >>>>>>>>>>>>>> Line 03: simulated DD() invokes simulated HHH(DD) that >>>>>>>>>>>>>> simulates DD()
DD simulated by HHH according to the operational semantics >>>>>>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>>>>>> simulated return statement while being simulated by HHH. >>>>>>>>>>>>>>
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
HHH only runs a modified simulator that cuts off the >>>>>>>>>>>>> simulated DD resulting in only a partial simulation
a universal simulator (? as defined by turing himself) does >>>>>>>>>>>>> _not_ interfere with the simulation being run, like a >>>>>>>>>>>>> turing machine itself does not interfere with it's own >>>>>>>>>>>>> execution
HHH does interfere, therefore it's not a universal
simulator. it's only reporting on a truncated partial trace >>>>>>>>>>>>> of DD, not the full execution of DD
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT >>>>>>>>>>>>
HHH is not ? the universal simulator and does not simulate DD >>>>>>>>>>> in total.
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
i'm trying to help u polcott and u pull this kinda brainrot >>>>>>>>> crap on me
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
simulation invariant (while olcott is simulated by comp.theory): >>>>>>> line 01: simulated olcott() invokes all-caps macro repeating line 01 >>>>>>>
looks like your own brain just entered the infinite recursion you >>>>>>> claimed HHH could detect. too bad HHH didn't abort before line 5. >>>>>>>
So you never really were a programmer and
want to hide your ignorance of programming
by diversion and head games?
Exactly what Are your programming credentials?
i have a computer engineering degree from ucsd and ~10 yrs of
professional experience
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Then I do not see why that you cannot see that
while DD is simulated by HHH you will not concede
that this same DD simulated by HHH will not reach
i've already conceded HHH(DD) does not simulate DD to line 06:
HHH(DD) does a partial simulation of DD, and therefor will not
simulate DD to line 06
its own line 06, unless your primary goal is to
be disagreeable.
i'm agreeing with u polcott on that point, why are you being so
disagreeable about it? ?
If you fail to concede that DD simulated by HHH
cannot reach its own line 06 while DD is being
simulated by HHH
or fail to show exactly how DD simulated by HHH
does reach it own simulated line 06 while DD is
being simulated by HHH I will end this conversation
with you.
let's suppose i could show that HHH(DD) simulating DD reaches line 06
in the simulation ... how would that refute ur proof?
With the credentials that you say that you have you
would already know it is a logical impossibility.
the only rebuttal u'll accept is in fact a logical impossibility?
so u were just outright lying to me when u said such would be the only acceptable rebuttal... because it's _not_ an acceptable rebuttal
The lack of a direct answer to this question
will be taken as the reason to end this
conversation with you.
bruh u pulling fallacy after fallacy after fallacy is a much bigger >>>>> reason for me to end the convo with you ...
but haven't done that now, have i??? u don't give me the courtesy
of reading all that i wrote, and that really is ur loss because i'm >>>>> most definitely not like the other chucklefucks around here
HHH cuts off the simulation of DD short, so ofc it doesn't >>>>>>>>>>> reach DD's return statement
asking for a rebuttal to explain how HHH simulating DD
reaches DDs return statement is just ... nonsense. HHH is >>>>>>>>>>> _not_ a universal simulator and does _not_ simulate DD in >>>>>>>>>>> total nor even is expected to do so!
it is therefore _not_ actually reporting on a complete
simulation of DD, objectively so as HHH cuts off DDs
simulation before DD reaches it's final state. if u compared >>>>>>>>>>> the states the HHH(DD) records in it's simulation, this would >>>>>>>>>>> not match the states that ?(DD) records in it's simulation. >>>>>>>>>>> HHH(DD) would match up to some point, at which point HHH(DD) >>>>>>>>>>> would record no more states, while ?(DD) does.
HHH is merely a broken algorithm that does not refute the >>>>>>>>>>> halting theorem in the slightest. i don't even think it's a >>>>>>>>>>> total algorithm cause who tf knows what HHH(collatz_conj) >>>>>>>>>>> would return, if even. i bet it wouldn't, i bet
HHH(collatz_conj) diverges as written.
now idk if ur gunna accept that or not, prolly u stopped >>>>>>>>>>> reading by now tbh ... but you wanna know what i think is >>>>>>>>>>> useful about this issue of HHH that you bring up?
ur kinda right that HHH _should_ be able to detect an
infinite looping recursion like what it tries on DD, because >>>>>>>>>>> that's how the inductive math proofs work. but u can't
actually build a machine that totally implements that as an >>>>>>>>>>> automated prover precisely because of the machine DD that u >>>>>>>>>>> wrote...
something feels off about that for sure, if the math was good >>>>>>>>>>> HHH should work cause the algo is so dead simple.
On 10/31/2026 1:06 PM, dart200 wrote:
On 10/31/26 10:55 AM, olcott wrote:
On 10/31/2026 12:33 PM, dart200 wrote:
On 10/31/26 9:31 AM, olcott wrote:
On 10/31/2026 10:52 AM, dart200 wrote:
On 10/31/26 8:42 AM, olcott wrote:
On 10/31/2026 10:36 AM, dart200 wrote:
On 10/31/26 8:25 AM, olcott wrote:
On 10/31/2026 10:20 AM, dart200 wrote:
On 10/31/26 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness:
Simulation invariant (while DD is simulated by HHH) >>>>>>>>>>>>>>> Line 03: simulated DD() invokes simulated HHH(DD) that >>>>>>>>>>>>>>> simulates DD()
DD simulated by HHH according to the operational semantics >>>>>>>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>>>>>>> simulated return statement while being simulated by HHH. >>>>>>>>>>>>>>>
The only acceptable rebuttal
show exactly how DD reaches its return statement >>>>>>>>>>>>>>> on line 06 while DD is being simulated by HHH
HHH only runs a modified simulator that cuts off the >>>>>>>>>>>>>> simulated DD resulting in only a partial simulation >>>>>>>>>>>>>>
a universal simulator (? as defined by turing himself) >>>>>>>>>>>>>> does _not_ interfere with the simulation being run, like a >>>>>>>>>>>>>> turing machine itself does not interfere with it's own >>>>>>>>>>>>>> execution
HHH does interfere, therefore it's not a universal >>>>>>>>>>>>>> simulator. it's only reporting on a truncated partial >>>>>>>>>>>>>> trace of DD, not the full execution of DD
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT >>>>>>>>>>>>>
HHH is not ? the universal simulator and does not simulate >>>>>>>>>>>> DD in total.
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
i'm trying to help u polcott and u pull this kinda brainrot >>>>>>>>>> crap on me
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
simulation invariant (while olcott is simulated by comp.theory): >>>>>>>> line 01: simulated olcott() invokes all-caps macro repeating
line 01
looks like your own brain just entered the infinite recursion you >>>>>>>> claimed HHH could detect. too bad HHH didn't abort before line 5. >>>>>>>>
So you never really were a programmer and
want to hide your ignorance of programming
by diversion and head games?
Exactly what Are your programming credentials?
i have a computer engineering degree from ucsd and ~10 yrs of
professional experience
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Then I do not see why that you cannot see that
while DD is simulated by HHH you will not concede
that this same DD simulated by HHH will not reach
i've already conceded HHH(DD) does not simulate DD to line 06:
HHH(DD) does a partial simulation of DD, and therefor will not
simulate DD to line 06
its own line 06, unless your primary goal is to
be disagreeable.
i'm agreeing with u polcott on that point, why are you being so
disagreeable about it? ?
If you fail to concede that DD simulated by HHH
cannot reach its own line 06 while DD is being
simulated by HHH
or fail to show exactly how DD simulated by HHH
does reach it own simulated line 06 while DD is
being simulated by HHH I will end this conversation
with you.
let's suppose i could show that HHH(DD) simulating DD reaches line
06 in the simulation ... how would that refute ur proof?
With the credentials that you say that you have you
would already know it is a logical impossibility.
the only rebuttal u'll accept is in fact a logical impossibility?
Until you say that you understand it is a logical
impossibility you remain an Eliza bot in rebuttal mode.
so u were just outright lying to me when u said such would be the only
acceptable rebuttal... because it's _not_ an acceptable rebuttal
The lack of a direct answer to this question
will be taken as the reason to end this
conversation with you.
bruh u pulling fallacy after fallacy after fallacy is a much
bigger reason for me to end the convo with you ...
but haven't done that now, have i??? u don't give me the courtesy >>>>>> of reading all that i wrote, and that really is ur loss because
i'm most definitely not like the other chucklefucks around here
HHH cuts off the simulation of DD short, so ofc it doesn't >>>>>>>>>>>> reach DD's return statement
asking for a rebuttal to explain how HHH simulating DD >>>>>>>>>>>> reaches DDs return statement is just ... nonsense. HHH is >>>>>>>>>>>> _not_ a universal simulator and does _not_ simulate DD in >>>>>>>>>>>> total nor even is expected to do so!
it is therefore _not_ actually reporting on a complete >>>>>>>>>>>> simulation of DD, objectively so as HHH cuts off DDs
simulation before DD reaches it's final state. if u compared >>>>>>>>>>>> the states the HHH(DD) records in it's simulation, this >>>>>>>>>>>> would not match the states that ?(DD) records in it's >>>>>>>>>>>> simulation. HHH(DD) would match up to some point, at which >>>>>>>>>>>> point HHH(DD) would record no more states, while ?(DD) does. >>>>>>>>>>>>
HHH is merely a broken algorithm that does not refute the >>>>>>>>>>>> halting theorem in the slightest. i don't even think it's a >>>>>>>>>>>> total algorithm cause who tf knows what HHH(collatz_conj) >>>>>>>>>>>> would return, if even. i bet it wouldn't, i bet
HHH(collatz_conj) diverges as written.
now idk if ur gunna accept that or not, prolly u stopped >>>>>>>>>>>> reading by now tbh ... but you wanna know what i think is >>>>>>>>>>>> useful about this issue of HHH that you bring up?
ur kinda right that HHH _should_ be able to detect an >>>>>>>>>>>> infinite looping recursion like what it tries on DD, because >>>>>>>>>>>> that's how the inductive math proofs work. but u can't >>>>>>>>>>>> actually build a machine that totally implements that as an >>>>>>>>>>>> automated prover precisely because of the machine DD that u >>>>>>>>>>>> wrote...
something feels off about that for sure, if the math was >>>>>>>>>>>> good HHH should work cause the algo is so dead simple. >>>>>>>>>>>>
On 10/31/26 11:13 AM, olcott wrote:
On 10/31/2026 1:06 PM, dart200 wrote:
On 10/31/26 10:55 AM, olcott wrote:
On 10/31/2026 12:33 PM, dart200 wrote:
On 10/31/26 9:31 AM, olcott wrote:
On 10/31/2026 10:52 AM, dart200 wrote:
On 10/31/26 8:42 AM, olcott wrote:
On 10/31/2026 10:36 AM, dart200 wrote:
On 10/31/26 8:25 AM, olcott wrote:
On 10/31/2026 10:20 AM, dart200 wrote:
On 10/31/26 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness:
Simulation invariant (while DD is simulated by HHH) >>>>>>>>>>>>>>>> Line 03: simulated DD() invokes simulated HHH(DD) that >>>>>>>>>>>>>>>> simulates DD()
DD simulated by HHH according to the operational semantics >>>>>>>>>>>>>>>> of the C programming language cannot possibly reach its own >>>>>>>>>>>>>>>> simulated return statement while being simulated by HHH. >>>>>>>>>>>>>>>>
The only acceptable rebuttal
show exactly how DD reaches its return statement >>>>>>>>>>>>>>>> on line 06 while DD is being simulated by HHH
HHH only runs a modified simulator that cuts off the >>>>>>>>>>>>>>> simulated DD resulting in only a partial simulation >>>>>>>>>>>>>>>
a universal simulator (? as defined by turing himself) >>>>>>>>>>>>>>> does _not_ interfere with the simulation being run, like >>>>>>>>>>>>>>> a turing machine itself does not interfere with it's own >>>>>>>>>>>>>>> execution
HHH does interfere, therefore it's not a universal >>>>>>>>>>>>>>> simulator. it's only reporting on a truncated partial >>>>>>>>>>>>>>> trace of DD, not the full execution of DD
The only acceptable rebuttal
show exactly how DD reaches its return statement
on line 06 while DD is being simulated by HHH
EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT >>>>>>>>>>>>>>
HHH is not ? the universal simulator and does not simulate >>>>>>>>>>>>> DD in total.
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
i'm trying to help u polcott and u pull this kinda brainrot >>>>>>>>>>> crap on me
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
simulation invariant (while olcott is simulated by comp.theory): >>>>>>>>> line 01: simulated olcott() invokes all-caps macro repeating >>>>>>>>> line 01
looks like your own brain just entered the infinite recursion you >>>>>>>>> claimed HHH could detect. too bad HHH didn't abort before line 5. >>>>>>>>>
So you never really were a programmer and
want to hide your ignorance of programming
by diversion and head games?
Exactly what Are your programming credentials?
i have a computer engineering degree from ucsd and ~10 yrs of
professional experience
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Then I do not see why that you cannot see that
while DD is simulated by HHH you will not concede
that this same DD simulated by HHH will not reach
i've already conceded HHH(DD) does not simulate DD to line 06:
HHH(DD) does a partial simulation of DD, and therefor will not
simulate DD to line 06
its own line 06, unless your primary goal is to
be disagreeable.
i'm agreeing with u polcott on that point, why are you being so
disagreeable about it? ?
If you fail to concede that DD simulated by HHH
cannot reach its own line 06 while DD is being
simulated by HHH
or fail to show exactly how DD simulated by HHH
does reach it own simulated line 06 while DD is
being simulated by HHH I will end this conversation
with you.
let's suppose i could show that HHH(DD) simulating DD reaches line
06 in the simulation ... how would that refute ur proof?
With the credentials that you say that you have you
would already know it is a logical impossibility.
the only rebuttal u'll accept is in fact a logical impossibility?
Until you say that you understand it is a logical
impossibility you remain an Eliza bot in rebuttal mode.
i already repeatedly agreed HHH(DD) does not simulate DD until line 6 polcott...
the only question i'm left with:
why are you lying about it being an acceptable rebuttal?
so u were just outright lying to me when u said such would be the
only acceptable rebuttal... because it's _not_ an acceptable rebuttal
The lack of a direct answer to this question
will be taken as the reason to end this
conversation with you.
bruh u pulling fallacy after fallacy after fallacy is a much
bigger reason for me to end the convo with you ...
but haven't done that now, have i??? u don't give me the courtesy >>>>>>> of reading all that i wrote, and that really is ur loss because >>>>>>> i'm most definitely not like the other chucklefucks around here
HHH cuts off the simulation of DD short, so ofc it doesn't >>>>>>>>>>>>> reach DD's return statement
asking for a rebuttal to explain how HHH simulating DD >>>>>>>>>>>>> reaches DDs return statement is just ... nonsense. HHH is >>>>>>>>>>>>> _not_ a universal simulator and does _not_ simulate DD in >>>>>>>>>>>>> total nor even is expected to do so!
it is therefore _not_ actually reporting on a complete >>>>>>>>>>>>> simulation of DD, objectively so as HHH cuts off DDs >>>>>>>>>>>>> simulation before DD reaches it's final state. if u >>>>>>>>>>>>> compared the states the HHH(DD) records in it's simulation, >>>>>>>>>>>>> this would not match the states that ?(DD) records in it's >>>>>>>>>>>>> simulation. HHH(DD) would match up to some point, at which >>>>>>>>>>>>> point HHH(DD) would record no more states, while ?(DD) does. >>>>>>>>>>>>>
HHH is merely a broken algorithm that does not refute the >>>>>>>>>>>>> halting theorem in the slightest. i don't even think it's a >>>>>>>>>>>>> total algorithm cause who tf knows what HHH(collatz_conj) >>>>>>>>>>>>> would return, if even. i bet it wouldn't, i bet
HHH(collatz_conj) diverges as written.
now idk if ur gunna accept that or not, prolly u stopped >>>>>>>>>>>>> reading by now tbh ... but you wanna know what i think is >>>>>>>>>>>>> useful about this issue of HHH that you bring up?
ur kinda right that HHH _should_ be able to detect an >>>>>>>>>>>>> infinite looping recursion like what it tries on DD, >>>>>>>>>>>>> because that's how the inductive math proofs work. but u >>>>>>>>>>>>> can't actually build a machine that totally implements that >>>>>>>>>>>>> as an automated prover precisely because of the machine DD >>>>>>>>>>>>> that u wrote...
something feels off about that for sure, if the math was >>>>>>>>>>>>> good HHH should work cause the algo is so dead simple. >>>>>>>>>>>>>
On 10/31/2026 1:51 PM, dart200 wrote:
On 10/31/26 11:13 AM, olcott wrote:
On 10/31/2026 1:06 PM, dart200 wrote:
On 10/31/26 10:55 AM, olcott wrote:
On 10/31/2026 12:33 PM, dart200 wrote:
On 10/31/26 9:31 AM, olcott wrote:
On 10/31/2026 10:52 AM, dart200 wrote:
On 10/31/26 8:42 AM, olcott wrote:
On 10/31/2026 10:36 AM, dart200 wrote:
On 10/31/26 8:25 AM, olcott wrote:
On 10/31/2026 10:20 AM, dart200 wrote:
On 10/31/26 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness:
Simulation invariant (while DD is simulated by HHH) >>>>>>>>>>>>>>>>> Line 03: simulated DD() invokes simulated HHH(DD) that >>>>>>>>>>>>>>>>> simulates DD()
DD simulated by HHH according to the operational semantics >>>>>>>>>>>>>>>>> of the C programming language cannot possibly reach its >>>>>>>>>>>>>>>>> own
simulated return statement while being simulated by HHH. >>>>>>>>>>>>>>>>>
The only acceptable rebuttal
show exactly how DD reaches its return statement >>>>>>>>>>>>>>>>> on line 06 while DD is being simulated by HHH >>>>>>>>>>>>>>>>>
HHH only runs a modified simulator that cuts off the >>>>>>>>>>>>>>>> simulated DD resulting in only a partial simulation >>>>>>>>>>>>>>>>
a universal simulator (? as defined by turing himself) >>>>>>>>>>>>>>>> does _not_ interfere with the simulation being run, like >>>>>>>>>>>>>>>> a turing machine itself does not interfere with it's own >>>>>>>>>>>>>>>> execution
HHH does interfere, therefore it's not a universal >>>>>>>>>>>>>>>> simulator. it's only reporting on a truncated partial >>>>>>>>>>>>>>>> trace of DD, not the full execution of DD
The only acceptable rebuttal
show exactly how DD reaches its return statement >>>>>>>>>>>>>>> on line 06 while DD is being simulated by HHH
EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT >>>>>>>>>>>>>>>
HHH is not ? the universal simulator and does not simulate >>>>>>>>>>>>>> DD in total.
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
i'm trying to help u polcott and u pull this kinda brainrot >>>>>>>>>>>> crap on me
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
simulation invariant (while olcott is simulated by comp.theory): >>>>>>>>>> line 01: simulated olcott() invokes all-caps macro repeating >>>>>>>>>> line 01
looks like your own brain just entered the infinite recursion you >>>>>>>>>> claimed HHH could detect. too bad HHH didn't abort before line 5. >>>>>>>>>>
So you never really were a programmer and
want to hide your ignorance of programming
by diversion and head games?
Exactly what Are your programming credentials?
i have a computer engineering degree from ucsd and ~10 yrs of >>>>>>>> professional experience
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Then I do not see why that you cannot see that
while DD is simulated by HHH you will not concede
that this same DD simulated by HHH will not reach
i've already conceded HHH(DD) does not simulate DD to line 06:
HHH(DD) does a partial simulation of DD, and therefor will not
simulate DD to line 06
its own line 06, unless your primary goal is to
be disagreeable.
i'm agreeing with u polcott on that point, why are you being so
disagreeable about it? ?
If you fail to concede that DD simulated by HHH
cannot reach its own line 06 while DD is being
simulated by HHH
or fail to show exactly how DD simulated by HHH
does reach it own simulated line 06 while DD is
being simulated by HHH I will end this conversation
with you.
let's suppose i could show that HHH(DD) simulating DD reaches line >>>>>> 06 in the simulation ... how would that refute ur proof?
With the credentials that you say that you have you
would already know it is a logical impossibility.
the only rebuttal u'll accept is in fact a logical impossibility?
Until you say that you understand it is a logical
impossibility you remain an Eliza bot in rebuttal mode.
i already repeatedly agreed HHH(DD) does not simulate DD until line 6
polcott...
That has the words backwards and you know it.
This is your last chance.
DD simulated by HHH does not reach its own
simulated "return" statement on its own
line 06 while DD simulated by HHH.
the only question i'm left with:
why are you lying about it being an acceptable rebuttal?
so u were just outright lying to me when u said such would be the
only acceptable rebuttal... because it's _not_ an acceptable rebuttal
The lack of a direct answer to this question
will be taken as the reason to end this
conversation with you.
bruh u pulling fallacy after fallacy after fallacy is a much
bigger reason for me to end the convo with you ...
but haven't done that now, have i??? u don't give me the
courtesy of reading all that i wrote, and that really is ur loss >>>>>>>> because i'm most definitely not like the other chucklefucks
around here
HHH cuts off the simulation of DD short, so ofc it doesn't >>>>>>>>>>>>>> reach DD's return statement
asking for a rebuttal to explain how HHH simulating DD >>>>>>>>>>>>>> reaches DDs return statement is just ... nonsense. HHH is >>>>>>>>>>>>>> _not_ a universal simulator and does _not_ simulate DD in >>>>>>>>>>>>>> total nor even is expected to do so!
it is therefore _not_ actually reporting on a complete >>>>>>>>>>>>>> simulation of DD, objectively so as HHH cuts off DDs >>>>>>>>>>>>>> simulation before DD reaches it's final state. if u >>>>>>>>>>>>>> compared the states the HHH(DD) records in it's
simulation, this would not match the states that ?(DD) >>>>>>>>>>>>>> records in it's simulation. HHH(DD) would match up to some >>>>>>>>>>>>>> point, at which point HHH(DD) would record no more states, >>>>>>>>>>>>>> while ?(DD) does.
HHH is merely a broken algorithm that does not refute the >>>>>>>>>>>>>> halting theorem in the slightest. i don't even think it's >>>>>>>>>>>>>> a total algorithm cause who tf knows what
HHH(collatz_conj) would return, if even. i bet it >>>>>>>>>>>>>> wouldn't, i bet HHH(collatz_conj) diverges as written. >>>>>>>>>>>>>>
now idk if ur gunna accept that or not, prolly u stopped >>>>>>>>>>>>>> reading by now tbh ... but you wanna know what i think is >>>>>>>>>>>>>> useful about this issue of HHH that you bring up?
ur kinda right that HHH _should_ be able to detect an >>>>>>>>>>>>>> infinite looping recursion like what it tries on DD, >>>>>>>>>>>>>> because that's how the inductive math proofs work. but u >>>>>>>>>>>>>> can't actually build a machine that totally implements >>>>>>>>>>>>>> that as an automated prover precisely because of the >>>>>>>>>>>>>> machine DD that u wrote...
something feels off about that for sure, if the math was >>>>>>>>>>>>>> good HHH should work cause the algo is so dead simple. >>>>>>>>>>>>>>
On 10/31/26 11:58 AM, olcott wrote:
On 10/31/2026 1:51 PM, dart200 wrote:
On 10/31/26 11:13 AM, olcott wrote:
On 10/31/2026 1:06 PM, dart200 wrote:
On 10/31/26 10:55 AM, olcott wrote:
On 10/31/2026 12:33 PM, dart200 wrote:
On 10/31/26 9:31 AM, olcott wrote:
On 10/31/2026 10:52 AM, dart200 wrote:
On 10/31/26 8:42 AM, olcott wrote:
On 10/31/2026 10:36 AM, dart200 wrote:
On 10/31/26 8:25 AM, olcott wrote:
On 10/31/2026 10:20 AM, dart200 wrote:
On 10/31/26 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness: >>>>>>>>>>>>>>>>>> Simulation invariant (while DD is simulated by HHH) >>>>>>>>>>>>>>>>>> Line 03: simulated DD() invokes simulated HHH(DD) that >>>>>>>>>>>>>>>>>> simulates DD()
DD simulated by HHH according to the operational >>>>>>>>>>>>>>>>>> semantics
of the C programming language cannot possibly reach >>>>>>>>>>>>>>>>>> its own
simulated return statement while being simulated by HHH. >>>>>>>>>>>>>>>>>>
The only acceptable rebuttal
show exactly how DD reaches its return statement >>>>>>>>>>>>>>>>>> on line 06 while DD is being simulated by HHH >>>>>>>>>>>>>>>>>>
HHH only runs a modified simulator that cuts off the >>>>>>>>>>>>>>>>> simulated DD resulting in only a partial simulation >>>>>>>>>>>>>>>>>
a universal simulator (? as defined by turing himself) >>>>>>>>>>>>>>>>> does _not_ interfere with the simulation being run, >>>>>>>>>>>>>>>>> like a turing machine itself does not interfere with >>>>>>>>>>>>>>>>> it's own execution
HHH does interfere, therefore it's not a universal >>>>>>>>>>>>>>>>> simulator. it's only reporting on a truncated partial >>>>>>>>>>>>>>>>> trace of DD, not the full execution of DD
The only acceptable rebuttal
show exactly how DD reaches its return statement >>>>>>>>>>>>>>>> on line 06 while DD is being simulated by HHH
EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT >>>>>>>>>>>>>>>>
HHH is not ? the universal simulator and does not >>>>>>>>>>>>>>> simulate DD in total.
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
i'm trying to help u polcott and u pull this kinda brainrot >>>>>>>>>>>>> crap on me
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
simulation invariant (while olcott is simulated by comp.theory): >>>>>>>>>>> line 01: simulated olcott() invokes all-caps macro repeating >>>>>>>>>>> line 01
looks like your own brain just entered the infinite recursion >>>>>>>>>>> you
claimed HHH could detect. too bad HHH didn't abort before >>>>>>>>>>> line 5.
So you never really were a programmer and
want to hide your ignorance of programming
by diversion and head games?
Exactly what Are your programming credentials?
i have a computer engineering degree from ucsd and ~10 yrs of >>>>>>>>> professional experience
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Then I do not see why that you cannot see that
while DD is simulated by HHH you will not concede
that this same DD simulated by HHH will not reach
i've already conceded HHH(DD) does not simulate DD to line 06:
HHH(DD) does a partial simulation of DD, and therefor will not
simulate DD to line 06
its own line 06, unless your primary goal is to
be disagreeable.
i'm agreeing with u polcott on that point, why are you being so >>>>>>> disagreeable about it? ?
If you fail to concede that DD simulated by HHH
cannot reach its own line 06 while DD is being
simulated by HHH
or fail to show exactly how DD simulated by HHH
does reach it own simulated line 06 while DD is
being simulated by HHH I will end this conversation
with you.
let's suppose i could show that HHH(DD) simulating DD reaches
line 06 in the simulation ... how would that refute ur proof?
With the credentials that you say that you have you
would already know it is a logical impossibility.
the only rebuttal u'll accept is in fact a logical impossibility?
Until you say that you understand it is a logical
impossibility you remain an Eliza bot in rebuttal mode.
i already repeatedly agreed HHH(DD) does not simulate DD until line 6
polcott...
That has the words backwards and you know it.
HHH simulated with input DD, referred to by HHH(DD), simulates DD.
this DD simulation by HHH(DD) does not reach line 06.
The observation
H0 simulates D0
-> D0 calls H1
-> H1 simulates D1
-> D1 calls H2
-> ...
certainly establishes the beginning of a recursive simulation pattern.
what is backwards?
This is your last chance.
dud why do u keep making threats?
DD simulated by HHH does not reach its own
simulated "return" statement on its own
line 06 while DD simulated by HHH.
the only question i'm left with:
why are you lying about it being an acceptable rebuttal?
so u were just outright lying to me when u said such would be the
only acceptable rebuttal... because it's _not_ an acceptable rebuttal >>>>>
The lack of a direct answer to this question
will be taken as the reason to end this
conversation with you.
bruh u pulling fallacy after fallacy after fallacy is a much >>>>>>>>> bigger reason for me to end the convo with you ...
but haven't done that now, have i??? u don't give me the
courtesy of reading all that i wrote, and that really is ur >>>>>>>>> loss because i'm most definitely not like the other
chucklefucks around here
HHH cuts off the simulation of DD short, so ofc it >>>>>>>>>>>>>>> doesn't reach DD's return statement
asking for a rebuttal to explain how HHH simulating DD >>>>>>>>>>>>>>> reaches DDs return statement is just ... nonsense. HHH is >>>>>>>>>>>>>>> _not_ a universal simulator and does _not_ simulate DD in >>>>>>>>>>>>>>> total nor even is expected to do so!
it is therefore _not_ actually reporting on a complete >>>>>>>>>>>>>>> simulation of DD, objectively so as HHH cuts off DDs >>>>>>>>>>>>>>> simulation before DD reaches it's final state. if u >>>>>>>>>>>>>>> compared the states the HHH(DD) records in it's >>>>>>>>>>>>>>> simulation, this would not match the states that ?(DD) >>>>>>>>>>>>>>> records in it's simulation. HHH(DD) would match up to >>>>>>>>>>>>>>> some point, at which point HHH(DD) would record no more >>>>>>>>>>>>>>> states, while ?(DD) does.
HHH is merely a broken algorithm that does not refute the >>>>>>>>>>>>>>> halting theorem in the slightest. i don't even think it's >>>>>>>>>>>>>>> a total algorithm cause who tf knows what
HHH(collatz_conj) would return, if even. i bet it >>>>>>>>>>>>>>> wouldn't, i bet HHH(collatz_conj) diverges as written. >>>>>>>>>>>>>>>
now idk if ur gunna accept that or not, prolly u stopped >>>>>>>>>>>>>>> reading by now tbh ... but you wanna know what i think is >>>>>>>>>>>>>>> useful about this issue of HHH that you bring up? >>>>>>>>>>>>>>>
ur kinda right that HHH _should_ be able to detect an >>>>>>>>>>>>>>> infinite looping recursion like what it tries on DD, >>>>>>>>>>>>>>> because that's how the inductive math proofs work. but u >>>>>>>>>>>>>>> can't actually build a machine that totally implements >>>>>>>>>>>>>>> that as an automated prover precisely because of the >>>>>>>>>>>>>>> machine DD that u wrote...
something feels off about that for sure, if the math was >>>>>>>>>>>>>>> good HHH should work cause the algo is so dead simple. >>>>>>>>>>>>>>>
On 10/31/2026 2:13 PM, dart200 wrote:
On 10/31/26 11:58 AM, olcott wrote:
On 10/31/2026 1:51 PM, dart200 wrote:
On 10/31/26 11:13 AM, olcott wrote:
On 10/31/2026 1:06 PM, dart200 wrote:
On 10/31/26 10:55 AM, olcott wrote:
On 10/31/2026 12:33 PM, dart200 wrote:
On 10/31/26 9:31 AM, olcott wrote:
On 10/31/2026 10:52 AM, dart200 wrote:
On 10/31/26 8:42 AM, olcott wrote:
On 10/31/2026 10:36 AM, dart200 wrote:
On 10/31/26 8:25 AM, olcott wrote:
On 10/31/2026 10:20 AM, dart200 wrote:
On 10/31/26 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness: >>>>>>>>>>>>>>>>>>> Simulation invariant (while DD is simulated by HHH) >>>>>>>>>>>>>>>>>>> Line 03: simulated DD() invokes simulated HHH(DD) >>>>>>>>>>>>>>>>>>> that simulates DD()
DD simulated by HHH according to the operational >>>>>>>>>>>>>>>>>>> semantics
of the C programming language cannot possibly reach >>>>>>>>>>>>>>>>>>> its own
simulated return statement while being simulated by HHH. >>>>>>>>>>>>>>>>>>>
The only acceptable rebuttal
show exactly how DD reaches its return statement >>>>>>>>>>>>>>>>>>> on line 06 while DD is being simulated by HHH >>>>>>>>>>>>>>>>>>>
HHH only runs a modified simulator that cuts off the >>>>>>>>>>>>>>>>>> simulated DD resulting in only a partial simulation >>>>>>>>>>>>>>>>>>
a universal simulator (? as defined by turing himself) >>>>>>>>>>>>>>>>>> does _not_ interfere with the simulation being run, >>>>>>>>>>>>>>>>>> like a turing machine itself does not interfere with >>>>>>>>>>>>>>>>>> it's own execution
HHH does interfere, therefore it's not a universal >>>>>>>>>>>>>>>>>> simulator. it's only reporting on a truncated partial >>>>>>>>>>>>>>>>>> trace of DD, not the full execution of DD
The only acceptable rebuttal
show exactly how DD reaches its return statement >>>>>>>>>>>>>>>>> on line 06 while DD is being simulated by HHH >>>>>>>>>>>>>>>>> EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT >>>>>>>>>>>>>>>>>
HHH is not ? the universal simulator and does not >>>>>>>>>>>>>>>> simulate DD in total.
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
i'm trying to help u polcott and u pull this kinda >>>>>>>>>>>>>> brainrot crap on me
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
simulation invariant (while olcott is simulated by
comp.theory):
line 01: simulated olcott() invokes all-caps macro repeating >>>>>>>>>>>> line 01
looks like your own brain just entered the infinite
recursion you
claimed HHH could detect. too bad HHH didn't abort before >>>>>>>>>>>> line 5.
So you never really were a programmer and
want to hide your ignorance of programming
by diversion and head games?
Exactly what Are your programming credentials?
i have a computer engineering degree from ucsd and ~10 yrs of >>>>>>>>>> professional experience
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Then I do not see why that you cannot see that
while DD is simulated by HHH you will not concede
that this same DD simulated by HHH will not reach
i've already conceded HHH(DD) does not simulate DD to line 06: >>>>>>>> HHH(DD) does a partial simulation of DD, and therefor will not >>>>>>>> simulate DD to line 06
its own line 06, unless your primary goal is to
be disagreeable.
i'm agreeing with u polcott on that point, why are you being so >>>>>>>> disagreeable about it? ?
If you fail to concede that DD simulated by HHH
cannot reach its own line 06 while DD is being
simulated by HHH
or fail to show exactly how DD simulated by HHH
does reach it own simulated line 06 while DD is
being simulated by HHH I will end this conversation
with you.
let's suppose i could show that HHH(DD) simulating DD reaches >>>>>>>> line 06 in the simulation ... how would that refute ur proof?
With the credentials that you say that you have you
would already know it is a logical impossibility.
the only rebuttal u'll accept is in fact a logical impossibility?
Until you say that you understand it is a logical
impossibility you remain an Eliza bot in rebuttal mode.
i already repeatedly agreed HHH(DD) does not simulate DD until line
6 polcott...
That has the words backwards and you know it.
HHH simulated with input DD, referred to by HHH(DD), simulates DD.
this DD simulation by HHH(DD) does not reach line 06.
That is still not exactly what is required yet
seems closer. The 100% perfectly exact meaning
must be 100% completely retained
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
(a) Yes
(b) No
On 10/31/2026 12:59 PM, Python wrote:
The observation
˙˙˙˙ H0 simulates D0
˙˙˙˙˙˙ -> D0 calls H1
˙˙˙˙˙˙˙˙ -> H1 simulates D1
˙˙˙˙˙˙˙˙˙˙ -> D1 calls H2
˙˙˙˙˙˙˙˙˙˙˙˙˙ -> ...
certainly establishes the beginning of a recursive simulation pattern.
Still will not admit that this means:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
He seems to have some non-standard meaning of ...
There are a whole bunch of steps after this that we
cannot get to with:
Mike Terry
Andr‚ G. Isaak
Kaz Kylheku
Alan Mackenzie
Mike Terry and Kaz Kylheku are very competent.
until the above step is accepted.
what is backwards?
This is your last chance.
dud why do u keep making threats?
dbush didn't take it as a threat he just
understood that I drew the line with his
head games.
DD simulated by HHH does not reach its own
simulated "return" statement on its own
line 06 while DD simulated by HHH.
the only question i'm left with:
why are you lying about it being an acceptable rebuttal?
so u were just outright lying to me when u said such would be the >>>>>> only acceptable rebuttal... because it's _not_ an acceptable rebuttal >>>>>>
The lack of a direct answer to this question
will be taken as the reason to end this
conversation with you.
bruh u pulling fallacy after fallacy after fallacy is a much >>>>>>>>>> bigger reason for me to end the convo with you ...
but haven't done that now, have i??? u don't give me the
courtesy of reading all that i wrote, and that really is ur >>>>>>>>>> loss because i'm most definitely not like the other
chucklefucks around here
HHH cuts off the simulation of DD short, so ofc it >>>>>>>>>>>>>>>> doesn't reach DD's return statement
asking for a rebuttal to explain how HHH simulating DD >>>>>>>>>>>>>>>> reaches DDs return statement is just ... nonsense. HHH >>>>>>>>>>>>>>>> is _not_ a universal simulator and does _not_ simulate >>>>>>>>>>>>>>>> DD in total nor even is expected to do so!
it is therefore _not_ actually reporting on a complete >>>>>>>>>>>>>>>> simulation of DD, objectively so as HHH cuts off DDs >>>>>>>>>>>>>>>> simulation before DD reaches it's final state. if u >>>>>>>>>>>>>>>> compared the states the HHH(DD) records in it's >>>>>>>>>>>>>>>> simulation, this would not match the states that ?(DD) >>>>>>>>>>>>>>>> records in it's simulation. HHH(DD) would match up to >>>>>>>>>>>>>>>> some point, at which point HHH(DD) would record no more >>>>>>>>>>>>>>>> states, while ?(DD) does.
HHH is merely a broken algorithm that does not refute >>>>>>>>>>>>>>>> the halting theorem in the slightest. i don't even think >>>>>>>>>>>>>>>> it's a total algorithm cause who tf knows what >>>>>>>>>>>>>>>> HHH(collatz_conj) would return, if even. i bet it >>>>>>>>>>>>>>>> wouldn't, i bet HHH(collatz_conj) diverges as written. >>>>>>>>>>>>>>>>
now idk if ur gunna accept that or not, prolly u stopped >>>>>>>>>>>>>>>> reading by now tbh ... but you wanna know what i think >>>>>>>>>>>>>>>> is useful about this issue of HHH that you bring up? >>>>>>>>>>>>>>>>
ur kinda right that HHH _should_ be able to detect an >>>>>>>>>>>>>>>> infinite looping recursion like what it tries on DD, >>>>>>>>>>>>>>>> because that's how the inductive math proofs work. but u >>>>>>>>>>>>>>>> can't actually build a machine that totally implements >>>>>>>>>>>>>>>> that as an automated prover precisely because of the >>>>>>>>>>>>>>>> machine DD that u wrote...
something feels off about that for sure, if the math was >>>>>>>>>>>>>>>> good HHH should work cause the algo is so dead simple. >>>>>>>>>>>>>>>>
On 10/31/26 1:20 PM, olcott wrote:
On 10/31/2026 2:13 PM, dart200 wrote:
On 10/31/26 11:58 AM, olcott wrote:
On 10/31/2026 1:51 PM, dart200 wrote:
On 10/31/26 11:13 AM, olcott wrote:
On 10/31/2026 1:06 PM, dart200 wrote:
On 10/31/26 10:55 AM, olcott wrote:
On 10/31/2026 12:33 PM, dart200 wrote:
On 10/31/26 9:31 AM, olcott wrote:
On 10/31/2026 10:52 AM, dart200 wrote:
On 10/31/26 8:42 AM, olcott wrote:
On 10/31/2026 10:36 AM, dart200 wrote:
On 10/31/26 8:25 AM, olcott wrote:
On 10/31/2026 10:20 AM, dart200 wrote:
On 10/31/26 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Mathematical proof of program correctness: >>>>>>>>>>>>>>>>>>>> Simulation invariant (while DD is simulated by HHH) >>>>>>>>>>>>>>>>>>>> Line 03: simulated DD() invokes simulated HHH(DD) >>>>>>>>>>>>>>>>>>>> that simulates DD()
DD simulated by HHH according to the operational >>>>>>>>>>>>>>>>>>>> semantics
of the C programming language cannot possibly reach >>>>>>>>>>>>>>>>>>>> its own
simulated return statement while being simulated by >>>>>>>>>>>>>>>>>>>> HHH.
The only acceptable rebuttal
show exactly how DD reaches its return statement >>>>>>>>>>>>>>>>>>>> on line 06 while DD is being simulated by HHH >>>>>>>>>>>>>>>>>>>>
HHH only runs a modified simulator that cuts off the >>>>>>>>>>>>>>>>>>> simulated DD resulting in only a partial simulation >>>>>>>>>>>>>>>>>>>
a universal simulator (? as defined by turing >>>>>>>>>>>>>>>>>>> himself) does _not_ interfere with the simulation >>>>>>>>>>>>>>>>>>> being run, like a turing machine itself does not >>>>>>>>>>>>>>>>>>> interfere with it's own execution
HHH does interfere, therefore it's not a universal >>>>>>>>>>>>>>>>>>> simulator. it's only reporting on a truncated partial >>>>>>>>>>>>>>>>>>> trace of DD, not the full execution of DD >>>>>>>>>>>>>>>>>>>
The only acceptable rebuttal
show exactly how DD reaches its return statement >>>>>>>>>>>>>>>>>> on line 06 while DD is being simulated by HHH >>>>>>>>>>>>>>>>>> EVERYTHING ELSE IS A DISHONEST DODGE AWAY FROM THE POINT >>>>>>>>>>>>>>>>>>
HHH is not ? the universal simulator and does not >>>>>>>>>>>>>>>>> simulate DD in total.
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
DISHONEST DODGE AWAY FROM THE POINT
i'm trying to help u polcott and u pull this kinda >>>>>>>>>>>>>>> brainrot crap on me
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
DD WHILE IT IS BEING SIMULATED BY HHH
simulation invariant (while olcott is simulated by
comp.theory):
line 01: simulated olcott() invokes all-caps macro
repeating line 01
looks like your own brain just entered the infinite >>>>>>>>>>>>> recursion you
claimed HHH could detect. too bad HHH didn't abort before >>>>>>>>>>>>> line 5.
So you never really were a programmer and
want to hide your ignorance of programming
by diversion and head games?
Exactly what Are your programming credentials?
i have a computer engineering degree from ucsd and ~10 yrs of >>>>>>>>>>> professional experience
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Then I do not see why that you cannot see that
while DD is simulated by HHH you will not concede
that this same DD simulated by HHH will not reach
i've already conceded HHH(DD) does not simulate DD to line 06: >>>>>>>>> HHH(DD) does a partial simulation of DD, and therefor will not >>>>>>>>> simulate DD to line 06
its own line 06, unless your primary goal is to
be disagreeable.
i'm agreeing with u polcott on that point, why are you being so >>>>>>>>> disagreeable about it? ?
If you fail to concede that DD simulated by HHH
cannot reach its own line 06 while DD is being
simulated by HHH
or fail to show exactly how DD simulated by HHH
does reach it own simulated line 06 while DD is
being simulated by HHH I will end this conversation
with you.
let's suppose i could show that HHH(DD) simulating DD reaches >>>>>>>>> line 06 in the simulation ... how would that refute ur proof? >>>>>>>>>
With the credentials that you say that you have you
would already know it is a logical impossibility.
the only rebuttal u'll accept is in fact a logical impossibility? >>>>>>>
Until you say that you understand it is a logical
impossibility you remain an Eliza bot in rebuttal mode.
i already repeatedly agreed HHH(DD) does not simulate DD until line >>>>> 6 polcott...
That has the words backwards and you know it.
HHH simulated with input DD, referred to by HHH(DD), simulates DD.
this DD simulation by HHH(DD) does not reach line 06.
That is still not exactly what is required yet
seems closer. The 100% perfectly exact meaning
must be 100% completely retained
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
(a) Yes
(b) No
(a) Yes
The observation
H0 simulates D0
-> D0 calls H1
-> H1 simulates D1
-> D1 calls H2
-> ...
certainly establishes the beginning of a recursive simulation pattern.
how many more times do i need to agree that HHH(DD) does not simulate DD
to line 06???
On 10/31/2026 12:59 PM, Python wrote:
The observation
˙˙˙˙ H0 simulates D0
˙˙˙˙˙˙ -> D0 calls H1
˙˙˙˙˙˙˙˙ -> H1 simulates D1
˙˙˙˙˙˙˙˙˙˙ -> D1 calls H2
˙˙˙˙˙˙˙˙˙˙˙˙˙ -> ...
certainly establishes the beginning of a recursive simulation pattern.
Still will not admit that this means:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
He seems to have some non-standard meaning of ...
There are a whole bunch of steps after this that we
cannot get to with:
Mike Terry
Andr‚ G. Isaak
Kaz Kylheku
Alan Mackenzie
Mike Terry and Kaz Kylheku are very competent.
until the above step is accepted.
what is backwards?
This is your last chance.
dud why do u keep making threats?
dbush didn't take it as a threat he just
understood that I drew the line with his
head games.
i take it as a threat dud
DD simulated by HHH does not reach its own
simulated "return" statement on its own
line 06 while DD simulated by HHH.
the only question i'm left with:
why are you lying about it being an acceptable rebuttal?
so u were just outright lying to me when u said such would be the >>>>>>> only acceptable rebuttal... because it's _not_ an acceptable
rebuttal
The lack of a direct answer to this question
will be taken as the reason to end this
conversation with you.
bruh u pulling fallacy after fallacy after fallacy is a much >>>>>>>>>>> bigger reason for me to end the convo with you ...
but haven't done that now, have i??? u don't give me the >>>>>>>>>>> courtesy of reading all that i wrote, and that really is ur >>>>>>>>>>> loss because i'm most definitely not like the other
chucklefucks around here
HHH cuts off the simulation of DD short, so ofc it >>>>>>>>>>>>>>>>> doesn't reach DD's return statement
asking for a rebuttal to explain how HHH simulating DD >>>>>>>>>>>>>>>>> reaches DDs return statement is just ... nonsense. HHH >>>>>>>>>>>>>>>>> is _not_ a universal simulator and does _not_ simulate >>>>>>>>>>>>>>>>> DD in total nor even is expected to do so!
it is therefore _not_ actually reporting on a complete >>>>>>>>>>>>>>>>> simulation of DD, objectively so as HHH cuts off DDs >>>>>>>>>>>>>>>>> simulation before DD reaches it's final state. if u >>>>>>>>>>>>>>>>> compared the states the HHH(DD) records in it's >>>>>>>>>>>>>>>>> simulation, this would not match the states that ?(DD) >>>>>>>>>>>>>>>>> records in it's simulation. HHH(DD) would match up to >>>>>>>>>>>>>>>>> some point, at which point HHH(DD) would record no more >>>>>>>>>>>>>>>>> states, while ?(DD) does.
HHH is merely a broken algorithm that does not refute >>>>>>>>>>>>>>>>> the halting theorem in the slightest. i don't even >>>>>>>>>>>>>>>>> think it's a total algorithm cause who tf knows what >>>>>>>>>>>>>>>>> HHH(collatz_conj) would return, if even. i bet it >>>>>>>>>>>>>>>>> wouldn't, i bet HHH(collatz_conj) diverges as written. >>>>>>>>>>>>>>>>>
now idk if ur gunna accept that or not, prolly u >>>>>>>>>>>>>>>>> stopped reading by now tbh ... but you wanna know what >>>>>>>>>>>>>>>>> i think is useful about this issue of HHH that you >>>>>>>>>>>>>>>>> bring up?
ur kinda right that HHH _should_ be able to detect an >>>>>>>>>>>>>>>>> infinite looping recursion like what it tries on DD, >>>>>>>>>>>>>>>>> because that's how the inductive math proofs work. but >>>>>>>>>>>>>>>>> u can't actually build a machine that totally >>>>>>>>>>>>>>>>> implements that as an automated prover precisely >>>>>>>>>>>>>>>>> because of the machine DD that u wrote...
something feels off about that for sure, if the math >>>>>>>>>>>>>>>>> was good HHH should work cause the algo is so dead simple. >>>>>>>>>>>>>>>>>
On 10/31/26 1:20 PM, olcott wrote:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
(a) Yes
(b) No
(a) Yes
how many more times do i need to agree that HHH(DD) does not simulate DD
to line 06???
The observation
H0 simulates D0
-> D0 calls H1
-> H1 simulates D1
-> D1 calls H2
-> ...
certainly establishes the beginning of a recursive simulation pattern.
On 01/11/2026 01:10, Python wrote:
Le 01/11/2026 … 02:05, olcott a ‚crit :
On 10/31/2026 3:37 PM, dart200 wrote:
On 10/31/26 1:20 PM, olcott wrote:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
(a) Yes
(b) No
(a) Yes
how many more times do i need to agree that HHH(DD) does not
simulate DD to line 06? ? ?
I think that makes you the first person to agree
that knows anything about the halting theorem. I
have had three C programmers agree.
On 10/31/2026 12:59 PM, Python wrote:
The observationpattern.
˙˙˙˙ H0 simulates D0
˙˙˙˙˙˙ -> D0 calls H1
˙˙˙˙˙˙˙˙ -> H1 simulates D1
˙˙˙˙˙˙˙˙˙˙ -> D1 calls H2
˙˙˙˙˙˙˙˙˙˙˙˙˙ -> ...
certainly establishes the beginning of a recursive simulation
Python agreed and then said
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
is not what he means even though that IS
what his above words specify.
Mike Terry and Kaz Kylheku expressly disagreed
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Even though the code itself completely proves:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
Peter, STOP misrepresenting what I agreed to.
I agreed that:
˙˙˙ H0 simulates D0
˙˙˙˙˙ -> D0 calls H1
˙˙˙˙˙˙˙ -> H1 simulates D1
˙˙˙˙˙˙˙˙˙ -> D1 calls H2
˙˙˙˙˙˙˙˙˙˙˙˙ -> ...
establishes the BEGINNING of a recursive simulation pattern.
I did NOT agree that this proves:
˙˙˙ DD can never reach line 06.
Those are different propositions.
The missing inference is still:
˙˙˙ finite recursive prefix
˙˙˙˙˙˙˙ =>
˙˙˙ recursion necessarily continues forever
and I have explicitly REJECTED that inference.
Worse, you have already acknowledged that you misunderstood what I meant:
˙˙˙ "I did not realize that you did not mean..."
˙˙˙ "I thought that you were saying..."
So there is no ambiguity left.
You may argue that I am WRONG.
You may NOT claim that I AGREED with something I have explicitly told
you I do not agree with.
You misunderstood my statement.
I corrected you.
You acknowledged the misunderstanding.
STOP citing my words as agreement with your conclusion.
I've lost count of the number of times PO has misrepresented my words
(and many others) in his posts, either to support his arguments, or
simply because he is genuinely clueless and doesn't understand what has
been said.˙ I'm afraid it's just something he does.
I doubt there are any regular readers here who take such claims by PO seriously, but it's still irritating...
Mike.
Le 01/11/2026 … 02:05, olcott a ‚crit :
On 10/31/2026 3:37 PM, dart200 wrote:
On 10/31/26 1:20 PM, olcott wrote:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
(a) Yes
(b) No
(a) Yes
how many more times do i need to agree that HHH(DD) does not simulate
DD to line 06? ? ?
I think that makes you the first person to agree
that knows anything about the halting theorem. I
have had three C programmers agree.
On 10/31/2026 12:59 PM, Python wrote:
The observation
˙˙˙˙ H0 simulates D0
˙˙˙˙˙˙ -> D0 calls H1
˙˙˙˙˙˙˙˙ -> H1 simulates D1
˙˙˙˙˙˙˙˙˙˙ -> D1 calls H2
˙˙˙˙˙˙˙˙˙˙˙˙˙ -> ...
certainly establishes the beginning of a recursive simulation pattern.
Python agreed and then said
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
is not what he means even though that IS
what his above words specify.
Mike Terry and Kaz Kylheku expressly disagreed
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Even though the code itself completely proves:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
Peter, STOP misrepresenting what I agreed to.
I agreed that:
˙˙ H0 simulates D0
˙˙˙˙ -> D0 calls H1
˙˙˙˙˙˙ -> H1 simulates D1
˙˙˙˙˙˙˙˙ -> D1 calls H2
˙˙˙˙˙˙˙˙˙˙˙ -> ...
establishes the BEGINNING of a recursive simulation pattern.
I did NOT agree that this proves:
˙˙ DD can never reach line 06.
On 10/31/2026 3:37 PM, dart200 wrote:
On 10/31/26 1:20 PM, olcott wrote:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
(a) Yes
(b) No
(a) Yes
how many more times do i need to agree that HHH(DD) does not simulate
DD to line 06???
I think that makes you the first person to agree
that knows anything about the halting theorem. I
have had three C programmers agree.
On 10/31/2026 12:59 PM, Python wrote:
The observation
˙˙˙˙ H0 simulates D0
˙˙˙˙˙˙ -> D0 calls H1
˙˙˙˙˙˙˙˙ -> H1 simulates D1
˙˙˙˙˙˙˙˙˙˙ -> D1 calls H2
˙˙˙˙˙˙˙˙˙˙˙˙˙ -> ...
certainly establishes the beginning of a recursive simulation pattern.
Python agreed and then said
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
is not what he means even though that IS
what his above words specify.
Mike Terry and Kaz Kylheku expressly disagreed
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Even though the code itself completely proves:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
On 10/31/26 6:05 PM, olcott wrote:
On 10/31/2026 3:37 PM, dart200 wrote:
On 10/31/26 1:20 PM, olcott wrote:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
(a) Yes
(b) No
(a) Yes
how many more times do i need to agree that HHH(DD) does not simulate
DD to line 06???
I think that makes you the first person to agree
that knows anything about the halting theorem. I
what exactly does HHH(DD) not simulating DD to it's return statement
have to do with the halting theorem???
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
have had three C programmers agree.
On 10/31/2026 12:59 PM, Python wrote:
The observation
˙˙˙˙ H0 simulates D0
˙˙˙˙˙˙ -> D0 calls H1
˙˙˙˙˙˙˙˙ -> H1 simulates D1
˙˙˙˙˙˙˙˙˙˙ -> D1 calls H2
˙˙˙˙˙˙˙˙˙˙˙˙˙ -> ...
certainly establishes the beginning of a recursive simulation pattern.
Python agreed and then said
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
is not what he means even though that IS
what his above words specify.
Mike Terry and Kaz Kylheku expressly disagreed
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Even though the code itself completely proves:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
On 10/31/2026 10:30 PM, dart200 wrote:
On 10/31/26 6:05 PM, olcott wrote:
On 10/31/2026 3:37 PM, dart200 wrote:
On 10/31/26 1:20 PM, olcott wrote:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
(a) Yes
(b) No
(a) Yes
how many more times do i need to agree that HHH(DD) does not
simulate DD to line 06???
I think that makes you the first person to agree
that knows anything about the halting theorem. I
what exactly does HHH(DD) not simulating DD to it's return statement
have to do with the halting theorem???
That is a bad paraphrase so we must go back a step.
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
It took me 22 years to get the words exactly
right they cannot be changed at all without
totally screwing everything up
have had three C programmers agree.
On 10/31/2026 12:59 PM, Python wrote:
The observationpattern.
˙˙˙˙ H0 simulates D0
˙˙˙˙˙˙ -> D0 calls H1
˙˙˙˙˙˙˙˙ -> H1 simulates D1
˙˙˙˙˙˙˙˙˙˙ -> D1 calls H2
˙˙˙˙˙˙˙˙˙˙˙˙˙ -> ...
certainly establishes the beginning of a recursive simulation
Python agreed and then said
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
is not what he means even though that IS
what his above words specify.
Mike Terry and Kaz Kylheku expressly disagreed
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Even though the code itself completely proves:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
On 10/31/26 6:05 PM, olcott wrote:[SNIP]
On 10/31/26 8:37 PM, olcott wrote:
On 10/31/2026 10:30 PM, dart200 wrote:
On 10/31/26 6:05 PM, olcott wrote:
On 10/31/2026 3:37 PM, dart200 wrote:
On 10/31/26 1:20 PM, olcott wrote:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
(a) Yes
(b) No
(a) Yes
how many more times do i need to agree that HHH(DD) does not
simulate DD to line 06???
I think that makes you the first person to agree
that knows anything about the halting theorem. I
what exactly does HHH(DD) not simulating DD to it's return statement
have to do with the halting theorem???
That is a bad paraphrase so we must go back a step.
bro i'm not joking: what does any of this have to do with disproving the halting theorem???
i agree HHH(DD) does not simulate DD to the point of line 06. so what?
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
HHH(DD) does analysis on every configuration of DD during the simulation
of DD and aborts the simulation of DD before DD reaches it's natural
halting state
the problem with HHH's analysis is that it recognizes the initiation of
the recursion, but does so before it then prevents that recursion from happening by breaking the simulation. the proof of recursion becomes outdated once HHH breaks DD recursion
there's something concerning about the fact that the self-analysis
breaks the simple proof of an infinitely recursive loop. like ur taking
a legit algo, a legit method of proving a divergent recursion, sticking
it in code, to then fumbles all over itself with a really simple case
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
It took me 22 years to get the words exactly
right they cannot be changed at all without
totally screwing everything up
have had three C programmers agree.
On 10/31/2026 12:59 PM, Python wrote:
The observationpattern.
˙˙˙˙ H0 simulates D0
˙˙˙˙˙˙ -> D0 calls H1
˙˙˙˙˙˙˙˙ -> H1 simulates D1
˙˙˙˙˙˙˙˙˙˙ -> D1 calls H2
˙˙˙˙˙˙˙˙˙˙˙˙˙ -> ...
certainly establishes the beginning of a recursive simulation
Python agreed and then said
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
is not what he means even though that IS
what his above words specify.
Mike Terry and Kaz Kylheku expressly disagreed
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
Even though the code itself completely proves:
DD simulated by HHH does not reach its own
simulated "return" statement on its own line
06 while DD simulated by HHH.
| Sysop: | Tetrazocine |
|---|---|
| Location: | Melbourne, VIC, Australia |
| Users: | 4 |
| Nodes: | 8 (0 / 8) |
| Uptime: | 76:28:49 |
| Calls: | 221 |
| Files: | 21,513 |
| Messages: | 83,321 |