On 2/22/2025 5:01 AM, joes wrote:Please do not dodge what line 1059 toggles.
Am Fri, 21 Feb 2025 21:55:32 -0600 schrieb olcott:
On 2/20/2025 4:00 AM, joes wrote:
Unless we go through a 100% precise sequence of steps my reviewers will always consistently dodge the point as they have done for several years.1059https://github.com/plolcott/x86utm/blob/master/Halt7.c You are notTermination analyzers determine whether or not their input couldNot even the variable Root in line 502 of Halt7.c?
possibly terminate normally. Nothing can toggle this.
even in the correct function.
My proof is very important because it provides the key basis for a chatTell your psychotherapist.
bot that can spot and perfectly refute lies in real time. This could
save the planet and save Democracy.
On 2/22/2025 5:01 AM, joes wrote:
Am Fri, 21 Feb 2025 21:55:32 -0600 schrieb olcott:
On 2/20/2025 4:00 AM, joes wrote:
1059Not even the variable Root in line 502 of Halt7.c?https://github.com/plolcott/x86utm/blob/master/Halt7.c You are not even
in the correct function.
Unless we go through a 100% precise sequence of steps
my reviewers will always consistently dodge the point
as they have done for several years.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
The first point is DD correctly simulated by HHH cannot
possibly terminate normally by reaching its own "return"
instruction.
My proof is very important because it provides the key
basis for a chat bot that can spot and perfectly refute
lies in real time. This could save the planet and save
Democracy.
On 2/22/2025 4:59 PM, dbush wrote:
On 2/22/2025 5:53 PM, olcott wrote:
On 2/22/2025 2:59 PM, dbush wrote:
On 2/22/2025 3:53 PM, olcott wrote:
On 2/22/2025 2:09 PM, dbush wrote:
On 2/22/2025 3:03 PM, olcott wrote:
01 int F(int i)
02 {
03 if (i > 10)
04 return 0;
05 else
06 return F(i+1);
07 }
08
09 int no_numbers_greater_than_10()
10 {
11 return F(0);
12 }
13
14 int main()
15 {
16 F((int)no_numbers_greater_than_10);
17 return 0;
18 }
So if the address of no_numbers_greater_than_10 is greater than 10 >>>>>> then 0 is returned right away, otherwise as most 10 recursive
calls will be made before the condition is matched and 0 is returned. >>>>>>
This doesn't change the fact that no_numbers_greater_than_10
correctly
simulated by F cannot possibly return so
F(no_numbers_greater_than_10)
is correct to report non-halting, which means that there is no
natural
number greater than 10.
Agreed?
I think that you will find more bugs when you try to
provide the line number by line number execution trace.
#1 bug F never simulates anything.
It is a verified fact that
F never simulates anything when i > 10.
Remember, you agreed that the behavior of X simulated by Y is defined
by replacing the code of Y with an unconditional simulator and running
Y(X):
On 2/22/2025 1:02 PM, olcott wrote:
On 2/22/2025 11:10 AM, dbush wrote:unconditional simulator then it can be shown that DD is non-halting
On 2/22/2025 11:43 AM, olcott wrote:
The first point is DD correctly simulated by HHH cannot;
possibly terminate normally by reaching its own "return"
instruction.
In other words, if the code of HHH is replaced with an
and therefore HHH(DD)==0 is correct.
;;
Wow finally someone that totally gets it.
So the behavior of no_numbers_greater_than_10 simulated by F is
defined by replacing the code of F with an unconditional simulated and
running F(no_numbers_greater_than_10).
The finite string input to F proves that there are no instructions in
no_numbers_greater_than_10 that can break the recursive simulation.
Try to show how no_numbers_greater_than_10 correctly simulated by F
can possibly halt.
Then is ceases to be analogous to HHH(DD) because no_numbers_greater_than_10() always terminates normally
by reaching its own "return" instruction.
Unlike HHH(DD) F((int)no_numbers_greater_than_10);
does not need to abort the emulation of its input
to prevent its own non-termination.
My proof is very important because it provides the key
basis for a chat bot that can spot and perfectly refute
lies in real time. This could save the planet and save
Democracy.
On 2/23/2025 4:46 AM, Mikko wrote:
On 2025-02-22 16:43:24 +0000, olcott said:
My proof is very important because it provides the key
basis for a chat bot that can spot and perfectly refute
lies in real time. This could save the planet and save
Democracy.
Unlikely to work if you let the chat bot to assume or infer
that false <-> true.
When its knowledge is correctly encoded it would never make
that stupid mistake.
On 2/23/2025 4:46 AM, Mikko wrote:
On 2025-02-22 16:43:24 +0000, olcott said:
My proof is very important because it provides the key
basis for a chat bot that can spot and perfectly refute
lies in real time. This could save the planet and save
Democracy.
Unlikely to work if you let the chat bot to assume or infer
that false <-> true.
When its knowledge is correctly encoded it would never make
that stupid mistake.
On 2/23/2025 10:09 PM, dbush wrote:Do you renounce it?
On 2/23/2025 10:20 PM, olcott wrote:Don't freaking quote what I said in 2022.
On 2/23/2025 9:15 PM, dbush wrote:You don't seem to understand that it doesn't matter what the code of F
On 2/23/2025 9:04 PM, olcott wrote:With such a major bug initially in your example I am assuming that you
On 2/23/2025 7:22 PM, dbush wrote:I'll take that as your admission that you know my example proves you
On 2/23/2025 8:13 PM, olcott wrote:
On 2/23/2025 6:15 PM, dbush wrote:
On 2/23/2025 7:10 PM, olcott wrote:
On 2/23/2025 11:57 AM, dbush wrote:It corresponds to the following C code:
On 2/23/2025 12:30 PM, olcott wrote:
On 2/22/2025 8:34 PM, dbush wrote:Similarly:
On 2/22/2025 7:33 PM, olcott wrote:When DD is correctly simulated by HHH according to the
On 2/22/2025 4:59 PM, dbush wrote:
On 2/22/2025 5:53 PM, olcott wrote:
On 2/22/2025 2:59 PM, dbush wrote:Remember, you agreed that the behavior of X simulated by Y >>>>>>>>>>>>>> is defined by replacing the code of Y with an unconditional >>>>>>>>>>>>>> simulator and running Y(X):
On 2/22/2025 3:53 PM, olcott wrote:F never simulates anything when i > 10.
On 2/22/2025 2:09 PM, dbush wrote:It is a verified fact that
On 2/22/2025 3:03 PM, olcott wrote:
01 int F(int i)
02 {
03 if (i > 10)
04 return 0;
05 else 06 return F(i+1);
07 }
08 09 int no_numbers_greater_than_10()
10 {
11 return F(0);
12 }
13 14 int main()
15 {
16 F((int)no_numbers_greater_than_10);
17 return 0;
18 }
So if the address of no_numbers_greater_than_10 is >>>>>>>>>>>>>>>>>> greater than 10 then 0 is returned right away, >>>>>>>>>>>>>>>>>> otherwise as most 10 recursive calls will be made >>>>>>>>>>>>>>>>>> before the condition is matched and 0 is returned. >>>>>>>>>>>>>>>>>> This doesn't change the fact that
no_numbers_greater_than_10 correctly simulated by F >>>>>>>>>>>>>>>>>> cannot possibly return so F(no_numbers_greater_than_10) >>>>>>>>>>>>>>>>>> is correct to report non-halting, which means that >>>>>>>>>>>>>>>>>> there is no natural number greater than 10. >>>>>>>>>>>>>>>>>> Agreed?
I think that you will find more bugs when you try to >>>>>>>>>>>>>>>>> provide the line number by line number execution trace. >>>>>>>>>>>>>>>>> #1 bug F never simulates anything.
On 2/22/2025 1:02 PM, olcott wrote:
On 2/22/2025 11:10 AM, dbush wrote:
On 2/22/2025 11:43 AM, olcott wrote:Wow finally someone that totally gets it.
The first point is DD correctly simulated by HHH >>>>>>>>>>>>>> >>> cannot possibly terminate normally by reaching its >>>>>>>>>>>>>> >>> own "return" instruction.;
In other words, if the code of HHH is replaced with an >>>>>>>>>>>>>> unconditional simulator then it can be shown that DD is >>>>>>>>>>>>>> non- halting and therefore HHH(DD)==0 is correct.
;
So the behavior of no_numbers_greater_than_10 simulated by >>>>>>>>>>>>>> F is defined by replacing the code of F with an
unconditional simulated and running
F(no_numbers_greater_than_10).
The finite string input to F proves that there are no >>>>>>>>>>>>>> instructions in no_numbers_greater_than_10 that can break >>>>>>>>>>>>>> the recursive simulation.
Try to show how no_numbers_greater_than_10 correctly >>>>>>>>>>>>>> simulated by F can possibly halt.
Then is ceases to be analogous to HHH(DD) because
no_numbers_greater_than_10() always terminates normally by >>>>>>>>>>>>> reaching its own "return" instruction.
In other words, when we actually run
no_numbers_greater_than_10() it reaches its own "return" >>>>>>>>>>>> instruction.
That means we've now established that the direct execution of >>>>>>>>>>>> a program (which includes all the functions it calls
UNMODIFIED) defines whether or not it halts.
Likewise, when we actually run DD() unmodified it also >>>>>>>>>>>> reaches its own "return" instruction.
Therefore HHH(DD)==0 is wrong.
behavior that the above machine code specifies then the call >>>>>>>>>>> from DD to HHH(DD) cannot possibly return and this correctly >>>>>>>>>>> simulated DD cannot possibly terminate normally by reaching >>>>>>>>>>> its own machine address 00002155.
0000000000400534 <no_numbers_greater_than_10>:
400534: 55 push %rbp 400535:
48 89 e5 mov %rsp,%rbp 400538: b8 34
05 40 00 mov $0x400534,%eax 40053d: 48 89
c7 mov %rax,%rdi 400540: e8 a8 ff ff
ff callq 4004ed <F> 400545: >>>>>>>>>> 5d pop %rbp 400546:
c3 retq
When no_numbers_greater_than_10 is correctly simulated by F >>>>>>>>>> according to the behavior that the above machine code specifies >>>>>>>>>> then the call from no_numbers_greater_than_10 to
F(no_numbers_greater_than_10) cannot possibly terminate
normally by reaching its own machine address 400545
So F(no_numbers_greater_than_10)==0 is correct, and therefore >>>>>>>>>> no natural number exists that is greater than 10
Agreed?
I Only understand Intel format assembly language.
int no_numbers_greater_than_10()
{
return F((uintptr_t)no_numbers_greater_than_10);
}
So if DD is non halting, then by the same criteria
no_numbers_greater_than_10 is non-halting
Agreed?
I cannot see any way that you explained that the above invocation >>>>>>> does not always halt. Because of the huge bug in earlier code it >>>>>>> seems that you may be simply.
no_numbers_greater_than_10 is structured exactly the same way as
DD. What the code of the function F does isn't really relevant
because your halting criteria replaces all of it with an
unconditional simulator as the basis for a decision. What matters >>>>>> is that it returns 0.
I am not going to talk about your example any more.
wrong.
don't understand it.
is. As you yourself said:
On 9/17/22 6:46 PM, olcott wrote:
A halt decider must predict what the behavior of its input would be
in the hypothetical case that it directly executed its input. The
means for it to do this are unspecified, thus unconstrained:
(a) Static analysis (b) Partial simulation (c) Wild guess
On 2/24/2025 9:03 AM, dbush wrote:Interesting. What, then, is HHH really, if not a simulator?
On 2/24/2025 9:48 AM, olcott wrote:
On 2/24/2025 7:11 AM, dbush wrote:
On 2/24/2025 12:17 AM, olcott wrote:
On 2/23/2025 11:08 PM, dbush wrote:
On 2/24/2025 12:01 AM, olcott wrote:
On 2/23/2025 10:45 PM, dbush wrote:
No, not this at all. That would be nothing like HHH or HHH with itsint F(uintptr_t p)You say that you code stops after ten recursions and also say that itI'll let you respond to yourself on this point:The above code proves that there's no way forIt looks like you have always been wrong about your code not
no_numbers_greater_than_10 correctly simulated by F to reach its
own "return" instruction.
Therefore F would be correct to report that
no_numbers_greater_than_10 is non-halting.
Agreed?
terminating. It looks like you never understood what you have been
talking about.
On 11/10/2024 10:11 AM, olcott wrote:
If you had a basis in reasoning to show that I was wrong on this
specific point you could provide it. You have no basis in
reasoning on this specific point all you have is presumption.
never stops.
{
/* replace all code with an unconditional simulator */
abort code disabled.
--}
int no_numbers_greater_than_10()
{
return F((uintptr_t)no_numbers_greater_than_10);
}
int main()
{
F((uintptr_t)no_numbers_greater_than_10);
return 0;
}
Try and show how the above code (i.e. no_numbers_greater_than_10
correctly simulated by F) can possibly reach the final "return"
instruction of no_numbers_greater_than_10
F would be correct to report the above as non-halting
On 2/24/2025 2:41 AM, Mikko wrote:
On 2025-02-23 17:35:46 +0000, olcott said:
On 2/23/2025 4:46 AM, Mikko wrote:
On 2025-02-22 16:43:24 +0000, olcott said:
My proof is very important because it provides the key
basis for a chat bot that can spot and perfectly refute
lies in real time. This could save the planet and save
Democracy.
Unlikely to work if you let the chat bot to assume or infer
that false <-> true.
When its knowledge is correctly encoded it would never make
that stupid mistake.
If you build the bot from a proof that implies that true <-> false
THEN YOU ARE ENCODING IT INCORRECTLY.
TRUE ↔ FALSE is stupidly wrong.
Why are you suggesting something that is stupidly wrong?
then it is hard to avoid that "mistake". But you may be right that
in that case the knowledge of the bot will not be correcly encoded.
On 2/24/2025 6:05 PM, Richard Damon wrote:
On 2/24/25 6:28 PM, olcott wrote:
On 2/24/2025 2:41 AM, Mikko wrote:
On 2025-02-23 17:35:46 +0000, olcott said:
On 2/23/2025 4:46 AM, Mikko wrote:
On 2025-02-22 16:43:24 +0000, olcott said:
My proof is very important because it provides the key
basis for a chat bot that can spot and perfectly refute
lies in real time. This could save the planet and save
Democracy.
Unlikely to work if you let the chat bot to assume or infer
that false <-> true.
When its knowledge is correctly encoded it would never make
that stupid mistake.
If you build the bot from a proof that implies that true <-> false
THEN YOU ARE ENCODING IT INCORRECTLY.
TRUE ↔ FALSE is stupidly wrong.
Why are you suggesting something that is stupidly wrong?
Then why do YOU make that claim by saying that when True(LP) returns
FALSE, which means that LP is defined as not FALSE, or TRTUE,
To say that Not(true) = false stupidly ignores that
some expressions are not truth-bearers.
On 2/24/2025 3:47 PM, dbush wrote:Do you mean the simulated HHH does actually abort and terminate?
On 2/24/2025 4:26 PM, olcott wrote:
On 2/24/2025 9:03 AM, dbush wrote:
On 2/24/2025 9:48 AM, olcott wrote:
On 2/24/2025 7:11 AM, dbush wrote:
On 2/24/2025 12:17 AM, olcott wrote:
On 2/23/2025 11:08 PM, dbush wrote:
On 2/24/2025 12:01 AM, olcott wrote:
int F(uintptr_t p)You say that you code stops after ten recursions and also say thatI'll let you respond to yourself on this point:It looks like you have always been wrong about your code notFine, we'll go by your more recent statement:
On 2/22/2025 1:02 PM, olcott wrote:
On 2/22/2025 11:10 AM, dbush wrote:unconditional simulator then it can be shown that DD is non-
On 2/22/2025 11:43 AM, olcott wrote:
The first point is DD correctly simulated by HHH cannot;
possibly terminate normally by reaching its own "return" >>>>>>>> >>> instruction.
In other words, if the code of HHH is replaced with an
halting and therefore HHH(DD)==0 is correct.
;Wow finally someone that totally gets it.
;
Which stipulates that the behavior of no_numbers_greater_than_10 >>>>>>>> correctly simulated by F is decided by what this hypothetical
case will do:
int F(uintptr_t p)
{
/* replace all code with an unconditional simulator */
}
int no_numbers_greater_than_10()
{
return F((uintptr_t)no_numbers_greater_than_10);
}
int main()
{
F((uintptr_t)no_numbers_greater_than_10);
return 0;
}
The above code proves that there's no way for
no_numbers_greater_than_10 correctly simulated by F to reach its >>>>>>>> own "return" instruction.
Therefore F would be correct to report that
no_numbers_greater_than_10 is non-halting.
Agreed?
terminating. It looks like you never understood what you have been >>>>>>> talking about.
On 11/10/2024 10:11 AM, olcott wrote:
If you had a basis in reasoning to show that I was wrong on
this specific point you could provide it. You have no basis in >>>>>> > reasoning on this specific point all you have is presumption.
it never stops.
{
/* replace all code with an unconditional simulator */
No, not this at all. That would be nothing like HHH or HHH with its
abort code disabled.
It is exactly what you said X simulated by Y is defined to be:
On 2/22/2025 1:02 PM, olcott wrote:
On 2/22/2025 11:10 AM, dbush wrote:simulator then it can be shown that DD is non-halting and therefore
On 2/22/2025 11:43 AM, olcott wrote:
The first point is DD correctly simulated by HHH cannot possibly
terminate normally by reaching its own "return"
instruction.
In other words, if the code of HHH is replaced with an
unconditional
HHH(DD)==0 is correct.
Wow finally someone that totally gets it.
According to you, the behavior of DD correctly simulated by HHH is
defined by this code:
int HHH(ptr P)
{
/* replace all code with an unconditional simulator */
}
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
Likewise, the behavior of no_numbers_greater_than_10 correctly
simulated by F is defined by this code:
int F(uintptr_t p)
{
/* replace all code with an unconditional simulator */
That is a stupid idea that has nothing to do with what I am taking
about.
HHH that aborts its simulation and a purely hypothetical (imaginary
never implemented) HHH that never aborts its simulation.
On 2/24/2025 8:04 PM, dbush wrote:Why are you talking about a hypothetical non-input?
On 2/24/2025 8:59 PM, olcott wrote:I already corrected you on this misunderstanding. HHH has two versions
On 2/24/2025 7:51 PM, dbush wrote:That is counter-factual.
On 2/24/2025 8:47 PM, olcott wrote:Your code is not isomorphic to my code thus an irrelevant change of
On 2/24/2025 7:26 PM, dbush wrote:I'll let you respond to yourself here:
On 2/24/2025 8:12 PM, olcott wrote:
On 2/24/2025 6:06 PM, dbush wrote:
On 2/24/2025 6:16 PM, olcott wrote:
On 2/24/2025 3:47 PM, dbush wrote:
On 2/24/2025 4:26 PM, olcott wrote:
HHH that aborts its simulation and a purely hypotheticalSame thing. F aborts its (admittedly poor) simulation by
(imaginary never implemented) HHH that never aborts its
simulation.
breaking out of a recursive chain, and a hypothetical F that
performs a correct unaborted simulation.
The simple fact that the hypothetical HHH would never terminate
conclusively proves that DD specifies behavior that cannot
possibly terminate normally.
And the simple fact that the hypothetical F would never terminate
conclusively proves that no_numbers_greater_than_10 specifies
behavior that cannot possibly terminate normally.
Agreed?
I will not discuss your code.
On 11/10/2024 11:41 PM, olcott wrote:
That is a dishonest dodge. An honest rebuttal would explain all
of the details of how I am incorrect. You can't do that because I
am correct.
subject away from the point.
According to you, the behavior of DD correctly simulated by HHH is
defined by this code:
int HHH(ptr P)
{
/* replace all code with an unconditional simulator */
}
the real one and the imaginary on that never aborts the simulation of
its input.
On 2/24/2025 9:59 PM, dbush wrote:
On 2/24/2025 10:51 PM, olcott wrote:
On 2/24/2025 8:18 PM, dbush wrote:
On 2/24/2025 9:15 PM, olcott wrote:
On 2/24/2025 8:04 PM, dbush wrote:
On 2/24/2025 8:59 PM, olcott wrote:
On 2/24/2025 7:51 PM, dbush wrote:
On 2/24/2025 8:47 PM, olcott wrote:
On 2/24/2025 7:26 PM, dbush wrote:
On 2/24/2025 8:12 PM, olcott wrote:
On 2/24/2025 6:06 PM, dbush wrote:
On 2/24/2025 6:16 PM, olcott wrote:
On 2/24/2025 3:47 PM, dbush wrote:
On 2/24/2025 4:26 PM, olcott wrote:
HHH that aborts its simulation and a purely
hypothetical (imaginary never implemented)
HHH that never aborts its simulation.
Same thing. F aborts its (admittedly poor) simulation by >>>>>>>>>>>> breaking out of a recursive chain, and a hypothetical F that >>>>>>>>>>>> performs a correct unaborted simulation.
The simple fact that the hypothetical HHH would never
terminate conclusively proves that DD specifies behavior >>>>>>>>>>> that cannot possibly terminate normally.
And the simple fact that the hypothetical F would never
terminate conclusively proves that no_numbers_greater_than_10 >>>>>>>>>> specifies behavior that cannot possibly terminate normally. >>>>>>>>>>
Agreed?
I will not discuss your code.
I'll let you respond to yourself here:
On 11/10/2024 11:41 PM, olcott wrote:
That is a dishonest dodge. An honest rebuttal would explain >>>>>>>> > all of the details of how I am incorrect. You can't do that >>>>>>>> > because I am correct.
Your code is not isomorphic to my code thus an
irrelevant change of subject away from the point.
That is counter-factual.
According to you, the behavior of DD correctly simulated by HHH is >>>>>> defined by this code:
int HHH(ptr P)
{
/* replace all code with an unconditional simulator */
}
I already corrected you on this misunderstanding.
HHH has two versions the real one and the imaginary
on that never aborts the simulation of its input.
And F has two versions, a real one and the imaginary one that never
aborts the simulation of its input.
You already said that F halts after ten invocations
and and that F does not halt.
Changing the subject to the direct execution of
no_numbers_greater_than_10 is the dishonest dodge of the strawman
deception.
The subject is the correct simulation of no_numbers_greater_than_10
by F.
Show me all of the code with the > 10
conditional branch and line numbers and
a line number by line number execution
trace or I will write you off as playing head games.
In a couple of weeks I start cancer treatment
that has a 7% chance of killing me very quickly.
On 2/24/2025 2:41 AM, Mikko wrote:
On 2025-02-23 17:35:46 +0000, olcott said:
On 2/23/2025 4:46 AM, Mikko wrote:
On 2025-02-22 16:43:24 +0000, olcott said:
My proof is very important because it provides the key
basis for a chat bot that can spot and perfectly refute
lies in real time. This could save the planet and save
Democracy.
Unlikely to work if you let the chat bot to assume or infer
that false <-> true.
When its knowledge is correctly encoded it would never make
that stupid mistake.
If you build the bot from a proof that implies that true <-> false
THEN YOU ARE ENCODING IT INCORRECTLY.
TRUE ↔ FALSE is stupidly wrong.
Why are you suggesting something that is stupidly wrong?
On 2/25/2025 8:56 AM, dbush wrote:Yes you are turning off the abort check in line 1052 IIRC.
On 2/25/2025 9:41 AM, olcott wrote:I AM NEVER RELPLACING ALL THE CODE STF ABOUT THAT
On 2/24/2025 10:12 PM, dbush wrote:
On 2/24/2025 11:03 PM, olcott wrote:Too vague i > 10 is missing
On 2/24/2025 9:59 PM, dbush wrote:The actual code of F doesn't matter, as your criteria requires
On 2/24/2025 10:51 PM, olcott wrote:
On 2/24/2025 8:18 PM, dbush wrote:Changing the subject to the direct execution of
On 2/24/2025 9:15 PM, olcott wrote:
On 2/24/2025 8:04 PM, dbush wrote:And F has two versions, a real one and the imaginary one that
On 2/24/2025 8:59 PM, olcott wrote:I already corrected you on this misunderstanding. HHH has two >>>>>>>>> versions the real one and the imaginary on that never aborts the >>>>>>>>> simulation of its input.
On 2/24/2025 7:51 PM, dbush wrote:That is counter-factual.
On 2/24/2025 8:47 PM, olcott wrote:Your code is not isomorphic to my code thus an irrelevant >>>>>>>>>>> change of subject away from the point.
On 2/24/2025 7:26 PM, dbush wrote:I'll let you respond to yourself here:
On 2/24/2025 8:12 PM, olcott wrote:
On 2/24/2025 6:06 PM, dbush wrote:
On 2/24/2025 6:16 PM, olcott wrote:
On 2/24/2025 3:47 PM, dbush wrote:
On 2/24/2025 4:26 PM, olcott wrote:
HHH that aborts its simulation and a purely hypothetical >>>>>>>>>>>>>>>>> (imaginary never implemented) HHH that never aborts its >>>>>>>>>>>>>>>>> simulation.Same thing. F aborts its (admittedly poor) simulation by >>>>>>>>>>>>>>>> breaking out of a recursive chain, and a hypothetical F >>>>>>>>>>>>>>>> that performs a correct unaborted simulation.
The simple fact that the hypothetical HHH would never >>>>>>>>>>>>>>> terminate conclusively proves that DD specifies behavior >>>>>>>>>>>>>>> that cannot possibly terminate normally.
And the simple fact that the hypothetical F would never >>>>>>>>>>>>>> terminate conclusively proves that
no_numbers_greater_than_10 specifies behavior that cannot >>>>>>>>>>>>>> possibly terminate normally.
Agreed?
I will not discuss your code.
On 11/10/2024 11:41 PM, olcott wrote:
That is a dishonest dodge. An honest rebuttal would >>>>>>>>>>>> > explain all of the details of how I am incorrect. You >>>>>>>>>>>> > can't do that because I am correct.
According to you, the behavior of DD correctly simulated by HHH >>>>>>>>>> is defined by this code:
int HHH(ptr P)
{
/* replace all code with an unconditional simulator */ >>>>>>>>>> }
never aborts the simulation of its input.
You already said that F halts after ten invocations and and that F >>>>>>> does not halt.
no_numbers_greater_than_10 is the dishonest dodge of the strawman
deception.
The subject is the correct simulation of no_numbers_greater_than_10 >>>>>> by F.
Show me all of the code with the > 10 conditional branch and line
numbers and a line number by line number execution trace or I will
write you off as playing head games.
replacing all of the code of F with an unconditional simulator.
So according to you, the behavior of no_numbers_greater_than_10
simulated by F is defined by the following hypothetical code.
1 int F(uintptr_t p)
2 {
3 /* replace all code with an unconditional simulator */
Not at all. F(no_numbers_greater_than_10) correctly reports that
no_numbers_greater_than_10 specifies non-halting behavior to F, as
measured by your criteria of replacing all code of F with an
unconditional simulator.
--4 }
5
6 int no_numbers_greater_than_10()
7 {
8 return F((uintptr_t)no_numbers_greater_than_10);
9 }
10 11 int main()
12 {
13 F((uintptr_t)no_numbers_greater_than_10);
14 return 0;
15 }
The trace of this is 13, 3 (simulator code), 8, 3 (simulator code),
8, 3 (simulator code), ...
So clearly no_numbers_greater_than_10 specifies non-halting behavior
to F, as per your criteria
On 2/25/2025 8:49 AM, Mikko wrote:
On 2025-02-24 23:28:30 +0000, olcott said:Please provide the reasoning for that stupid nonsense
On 2/24/2025 2:41 AM, Mikko wrote:
On 2025-02-23 17:35:46 +0000, olcott said:
On 2/23/2025 4:46 AM, Mikko wrote:
On 2025-02-22 16:43:24 +0000, olcott said:
My proof is very important because it provides the key
basis for a chat bot that can spot and perfectly refute
lies in real time. This could save the planet and save
Democracy.
Unlikely to work if you let the chat bot to assume or infer
that false <-> true.
When its knowledge is correctly encoded it would never make
that stupid mistake.
If you build the bot from a proof that implies that true <-> false
THEN YOU ARE ENCODING IT INCORRECTLY.
TRUE ↔ FALSE is stupidly wrong.
Why are you suggesting something that is stupidly wrong?
Because what you have presented as "proof" are based on claims that
are sufficient for the proof of true <-> false.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 715 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 158:26:38 |
| Calls: | 12,094 |
| Calls today: | 2 |
| Files: | 15,000 |
| Messages: | 6,517,756 |