On 5/31/25 11:28 AM, olcott wrote:
On 5/31/2025 9:57 AM, Ross Finlayson wrote:
On 05/30/2025 07:26 AM, Richard Damon wrote:
On 5/29/25 8:13 PM, olcott wrote:
On 5/29/2025 7:05 PM, Ross Finlayson wrote:
On 05/29/2025 08:37 AM, olcott wrote:
HHH is a simulating termination analyzer that uses
an x86 emulator to emulate its input. HHH is capable
of emulating itself emulating DDD.
HHH is executed within the x86utm operating system
that enables any C function to execute another C
function in debug step mode.
*Here is the fully operational code*
https://github.com/plolcott/x86utm/blob/master/Halt7.c
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>> If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D >>>>>> would never stop running unless aborted then
It is a tautology that any input D to termination
analyzer H that *would never stop running unless aborted*
DOES SPECIFY NON-TERMINATING BEHAVIOR.
Simulating Termination Analyzer H is Not Fooled by Pathological
Input D
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
No it's not.
(Was, "disagreeing with tautologies is always incorrect".)
It's the _deductive_ analysis that makes for the
"analytical bridges" to escape an "inductive impasse".
If by inductive impasse you are referring to mathematical
induction you might be right. If you are referring to logical
induction then you are wrong.
But "Inductive Logic" isn't actually logic in the formal sense, but ways >>> to try to approximate a correct answer when deductive logic can't get
one. Since Deductive Logic DOES determine the correct answer, just one
you don't like, you are just rejecting actual logic and adopting a
system that you can lie in.
So far I have not been able to make a proof by mathematical
induction that I am correct.
Because it is impossible to correctly prove a wrong statement.
The closest that I got is that for any value of N when
N steps of DDD are correctly emulated by HHH the emulated
DDD never reaches its own "ret" instruction final halt state.
But the problmm here is that your system, when properly defined for H to >>> actually be that series of programs, and D to be the programs built on
those H, it becomes immediately apparant that you aren't talking about
hte SAME D in each of those steps, so just talking about D as a singular >>> entity is just a category error.
Making D to be a program fragment which is completed in each instance to >>> try and make D be something singular, just runs afoul of the
requirements that it be a program, and then H needs to not be the
required computation (which can only operate on what it in the input,
and not other outside resource, like other things in memory) as it looks >>> outside to code of the input to "correctly simulate" it.
Thus, what you have proven is not that any of those D are non-halting
(since every D was different), but that no H can prove such a D to be
halting by thing method, even though we CAN, outside of the code of H,
make that proof.
The "inductive" is very much like the "empirical",
and "deduction" isn't only about "elimination".
"There is no but: only yet", reflects that the
modal and temporally modal relevance logic is
not about contradictions, instead change.
The very idea of a Principle of Contradiction
instead of a Principle of Inversion leads to
a very simple obstinacy and fallacies like
those of, "material implication", that aren't so.
Then a principle of inversion can help arrive
at a Principle of Sufficient Reason: yet a
more "Principle of Sufficient, and Thorough, Reason".
The analytical bridges for abduction about the
deduction about the impasses of induction, help
make for the "classical superclassical" reason
usually attributes to Zeno with the most, "paradoxes",
that there are none or that there is one a paradox,
make for a, "wider, fuller dialectic", what makes
for why "axiomless natural deduction" arrives at
being the only true theory of Truth, capital Truth.
Then, that requires a bit of a complete ontological
commitment, yet at least it's true so won't be wrong.
This was, "disagreeing with tautologies is always incorrect",
yet, "disagreeing with tautologies is always correct".
Just a bit longer, ..., for the _sufficient_ reason,
and, the _sufficient, and thorough_, reason.
Here's a bunch of podcasts where this is detailed further,
mostly under that "Logos 2000" section,
https://www.youtube.com/@rossfinlayson .
Won't be wrong, ..., and has a true logic and mathematics.
Not much else, though it does give a science.
Then the idea of physics itself arising from that also occurs.
Reason, Rationality, Reality: Nature
I wish that I could understand that.
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
Not a program, so not a valid input to program decider.
Recursive Emulation Invariant (REI):
DDD correctly emulated by HHH never reaches its own
"ret" instruction (final halt state).
Since your DDD can't be correctly emulated, your "Invarient" is just
non-sense.
Do you have any idea how to form a proper mathematical
induction proof that when each HHH of an infinite set of
HHH correctly simulates N steps of DDD the the REI holds?
The problem is that when you first fix up DDD to be a prgram, either you
keep one DDD, and you WILL hit one of the alternate HHHs that eventually
will emulate far enough to get to the end, or
You admit that each of the DDD are different, but then there is no
actual relationship between the various DDDn to build an induction on.
We start with the base case and simulate one step
at machine address 00002192. The recursive emulation
invariant (REI) is true for the base case.
Anyone that knows programming can see that this REI
is true for every value of N. I don't know the details
of properly proving this.
But each one is a diffferent input, and thus nothing to induct, except
to say that NO HHH can reach the final state in its finite emulation,
and thus none can prove the Halting state that all those DDD can be
proven to have (since they call a HHH(DDD) that will return 0 by the stipuations).
https://en.wikipedia.org/wiki/Mathematical_induction
Which, it seems, is just a buzz word to you as you don't actually
understand what it means.
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)