Re: At least 100 people kept denying the easily verified fact -- closure

On 6/7/2024 9:56 PM, Richard Damon wrote:

On 6/7/24 10:47 PM, olcott wrote:

On 6/7/2024 9:37 PM, Richard Damon wrote:

On 6/7/24 10:21 PM, olcott wrote:

On 6/7/2024 9:06 PM, Richard Damon wrote:

On 6/7/24 9:45 PM, olcott wrote:

On 6/7/2024 8:39 PM, Richard Damon wrote:

On 6/7/24 9:22 PM, olcott wrote:

On 6/7/2024 7:58 PM, Richard Damon wrote:

On 6/7/24 8:47 PM, olcott wrote:

On 6/7/2024 7:43 PM, Richard Damon wrote:

On 6/7/24 7:38 PM, olcott wrote:

On 6/7/2024 6:18 PM, Richard Damon wrote:

On 6/7/24 7:07 PM, olcott wrote:

On 6/7/2024 6:00 PM, Richard Damon wrote:

On 6/7/24 6:35 PM, olcott wrote:

On 6/7/2024 5:22 PM, joes wrote:

Am Fri, 07 Jun 2024 17:11:00 -0500 schrieb olcott:

That it is literally impossible to prove that the following is false
conclusively proves that it is true and the proof really need not be
wrapped in any tuxedo.

If you consider it unfalsifiable, why do you care?
>

>
The entire body of truth is unfalsifiable.
https://en.wikipedia.org/wiki/Falsifiability
>
That "cats" <are> "animals" is unfalsifiable because
it is inherently true.
>
You are conflating empirical with analytical truth.
Scientific principles do not exactly apply to math.
>

We can get on to other key points only after we have closure on this
{foundation of simulating halt deciders} point.

What do you need closure for? You only want agreement.
>

>
I must get closure on each of the four points of
my proof so that I know that my words can possibly
be understood. Without this publication is hopeless.
>

>
Except that you don't have a "Proof" because it isn't in the form of a formal proof.
>
All you have is an arguement.

>
A proof need not be dressed in any tuxedo. As long as correct
rebuttal has been shown to be categorically impossible then
the point has been fully proven.
>

>
It may not need a "tuxedo", but it needs to start with a clear mention of the accepted truths it is starting from, and then clearly state the acceptable operations being done with them to get to the conclusion.
>

>
That makes perfect sense.
>
So what exactly is missing from this?
>
Try to show how this DD correctly simulated by any HH ever
stops running without having its simulation aborted by HH.
>
_DD()
[00001e12] 55         push ebp
[00001e13] 8bec       mov  ebp,esp
[00001e15] 51         push ecx
[00001e16] 8b4508     mov  eax,[ebp+08]
[00001e19] 50         push eax      ; push DD
[00001e1a] 8b4d08     mov  ecx,[ebp+08]
[00001e1d] 51         push ecx      ; push DD
[00001e1e] e85ff5ffff call 00001382 ; call HH
>
A {correct simulation} means that each instruction of the
above x86 machine language of DD is correctly simulated
by HH and simulated in the correct order.
>
*The definition of the x86 programming language is assumed*
https://c9x.me/x86/
https://www.cs.virginia.edu/~evans/cs216/guides/x86.html
>

>
It isn't actually PROVING anything!!!
>
It is just a statment asking of someone can refute it.
>
Do you not see the difference between starting with known truth and the applying accepted operations on them to get to the final results?
>
Let me ask you a simple question to get you thinking.
>
What is one accepted fact that you started with in the above?
>
The statment that "No DD correctly simulated by an HH ever stops running without haing its simulation aborted by HH" is not such a statement, but is the statement you are trying to prove.
>
As you have said, for a statment to be true, there must be a set of truth-preserving operations from the truth-makers of the system.
>
What are any of them? Where are the truth-makers?
>
Or is that rule only when trying to talk about other things, and not what you need to do to produce a proof?

>
>
I provide a complete proof and ask that someone try and refute it.
You say it is incomplete. I ask what exactly is missing and you
do not say exactly what is missing.
>

>
You did no such thing.
>
WHere is the actual proof?
>
listing the accepted statements that it starts from, and then moves though the accepted operations to the final claim.
>
What is missing, EVERYTHING.
>
You are just stating a claim with a bit of reteric to argue for it, but no actual truthmakers to claim it is based on.

>
_DD()
[00001e12] 55         push ebp
[00001e13] 8bec       mov  ebp,esp
[00001e15] 51         push ecx
[00001e16] 8b4508     mov  eax,[ebp+08]
[00001e19] 50         push eax      ; push DD
[00001e1a] 8b4d08     mov  ecx,[ebp+08]
[00001e1d] 51         push ecx      ; push DD
[00001e1e] e85ff5ffff call 00001382 ; call HH
>
A {correct simulation} means that each instruction of the
above x86 machine language of DD is correctly simulated
by HH and simulated in the correct order.
>
The above is the complete proof that DD correctly simulated
by any HH that can possibly exist never stops running without
having its simulation aborted by HH (or crashing for OOM error).

>
Really? WHERE IS ANY OF THE DEFINED PARTS OF A PROOF?
>

>
The semantics of the x86 language are 99.999% of the proof.

>
Realy? Then state it.
>

>

Do you even know what that means?
>
No wonder you have so many problems.

>
*********
>
DID YOU MISS THE PART BELOW HERE??????
>
*********
>
>

>
What accepted true statements are you basing your proof on?
>
What accepted logical actions are you use to combine them to show something new?
>
You are just showing you don't know what the word "Proof" means in format systems.
>

>
Any expert in the x86 language knows it is complete proof
and to everyone else all x86 code is complete nonsense.
>
>

>
It may be considered a "proof" in philosophy, but it isn't hear.
>
And most "programmers" are not very good at logical proofs, which is why they normally don't try to actualy "Prove" their programs correct.
>
>
You just failed your test of having any knowledge about the field of logic.

>
You never pointed out what is missing.
The semantics of the x86 language is 99.999% of the proof
>
What else is "missing" that I did not already provide?
I say nothing is missing and you are bluffing.
>

>
So the section I marked above
>
>
What accepted true statements are you basing your proof on?
>

>
It is self-evident that any claims about an x86 language
snippet requires expert knowledge of the x86 language.

>
So?
>
Are you admitting you don't know it well enough to cite them?
>
And I will give you a little hint, what you are talking about isn't actually specific to the x86 assembly langugage, but the sort of thing you are talking about would apply (if it is true) to machine level language that is powerful enough to write the simulator in.
>
Of course, you need a different simulator for a different machine language, but the basic principles of simulation would still apply. There is nothing special about the x86 that makes a difference here.
>
I suspect you focus on it because it is the one you know, but knowing many, it doesn't really matter for what you are talking about.
>
>

>
When I say that I saw a dog run across the street this incorporates
by reference (a patent legal term) all of the details about dogs.
>

>
But this isn't a court of law, and those rules do not apply.
>
After all, you can't state a connecting piece of logic without nameing the truth-maker it is connecting to.
>
>

What accepted logical actions are you use to combine them to show something new?
>

>
What I say is proven true by its meaning and at least 99.999%
of this meaning is incorporated by reference to the x86 language.

>
Not a term allowed. "Proven true by its meaning" needs to either be an axiom of the system, or a reference to the actual definitions of the system as its truth makers.
>
Something true in another system can not just be assumed to be true in this system.
>

>

After all, to PROVE something, you need to demonstrate the connections from the truth makers of the system to your statement, via the truth-preserving operations.
>

>
*I incorporate by reference*
(a) The x86 language
(b) The notion of an x86 emulator
>
(c) I provide this complete function

>
So, you just don't know how to write the proof.
>
I thought you understood proofs, why is it so hard to do this supposedly obvious step?
>

>
void DDD(int (*x)())
{
   HH(x, x);
}
>
_DDD()
[00001de2] 55         push ebp
[00001de3] 8bec       mov ebp,esp
[00001de5] 8b4508     mov eax,[ebp+08]
[00001de8] 50         push eax         ; push DD
[00001de9] 8b4d08     mov ecx,[ebp+08]
[00001dec] 51         push ecx         ; push DD
[00001ded] e890f5ffff call 00001382    ; call HH
[00001df2] 83c408     add esp,+08
[00001df5] 5d         pop ebp
[00001df6] c3         ret
Size in bytes:(0021) [00001df6]
>
Then I state that No DDD correctly emulated by any
x86 emulator H can possibly reach its own [00001df6]
instruction.

>
Which you need to try to PROVE, but are unable to.
>
What are the accepted logical inference steps that connect them.
>
One hint, universal statements (All or NO) often need to either be based on some other universal property that they can relate, or need to set up an induction to move from individual items proved to a proof for all items.
>

>
 >> *I incorporate by reference*
 >> (a) The x86 language
 >> (b) The notion of an x86 emulator

 Doesn't work.
 Because without listing connections, you haven't moved from the already accepted truth-makers.
 

>
To anyone having this mandatory prerequisite knowledge
(perhaps not you) every x86 emulation of DDD by any
x86 emulator H continually repeats the first seven lines
of DDD until it crashes due to out-of-memory error.
>

 Nope, that explanation is inconsistent with your definition of "Correct SImulation" as the correct simulation of the Call HH at 00001DED needs to be followed by the correct simulation of the instruciton at 00001382 (that is HH) as that is what that instruction does.
 In fact, it will NEVER get back to 00001DE2 as a sequence, because this top level simulator will never trace the code back to that address.
 

DD correctly simulated by HH remains stuck in recursive emulation
until out-of-memory-error or the outer HH aborts its emulation.
*I just found that even Ben agreed to that*
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
 > I don't think that is the shell game. PO really /has/ an H
 > (it's trivial to do for this one case) that correctly determines
 > that P(P) *would* never stop running *unless* aborted.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer