01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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
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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon the universal simulator and does not simulate DD in total.
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 EYon(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 EYon(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: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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon 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
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 EYon(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 EYon(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 4:58 AM, olcott wrote:
On 10/31/2026 2:52 AM, dart200 wrote:
On 10/30/26 9:26 PM, olcott wrote:DISHONEST DODGE AWAY FROM THE POINT
On 10/30/2026 10:59 PM, dart200 wrote:
On 10/30/26 8:54 PM, olcott wrote:
01 int DD()
02 {
03-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon the universal simulator and does not simulate DD in total. >>
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
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 EYon(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 EYon(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: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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon 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
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 EYon(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 EYon(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: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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon 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
EYon(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
EYon(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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon 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
EYon(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
EYon(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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon 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 >>>>>>> EYon(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 >>>>>>> EYon(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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon 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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon 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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 EYon(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 EYon(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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon 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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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? Efn+
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 EYon(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 EYon(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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon 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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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? Efn+
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 EYon(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 EYon(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 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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon 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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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? Efn+
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 EYon(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 EYon(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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon 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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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? Efn+
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 EYon(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 EYon(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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon 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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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? Efn+
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 EYon(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 EYon(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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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 (EYon 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 EYon 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-a-a int Halt_Status = HHH(DD);
04-a-a if (Halt_Status)
05-a-a-a-a HERE: goto HERE;
06-a-a return Halt_Status;
07 }
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? Efn+
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 EYon(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 EYon(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. >>>>>>>>>>>>>>
| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 76 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 55:28:06 |
| Calls: | 1,265 |
| Calls today: | 1 |
| Files: | 1,362 |
| D/L today: |
3 files (2,684K bytes) |
| Messages: | 285,684 |