Re: Richard KEEPS TRYING to get away with this falsehood

Liste des GroupesRevenir à theory 
Sujet : Re: Richard KEEPS TRYING to get away with this falsehood
De : polcott333 (at) *nospam* gmail.com (olcott)
Groupes : comp.theory sci.logic
Date : 13. May 2024, 14:19:59
Autres entêtes
Organisation : A noiseless patient Spider
Message-ID : <v1t420$3frjs$1@dont-email.me>
References : 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
User-Agent : Mozilla Thunderbird
On 5/12/2024 11:53 PM, immibis wrote:
On 10/05/24 19:49, olcott wrote:
On 5/10/2024 11:12 AM, Richard Damon wrote:
On 5/10/24 11:50 AM, olcott wrote:
On 5/10/2024 9:18 AM, Richard Damon wrote:
On 5/9/24 11:10 PM, olcott wrote:
On 5/9/2024 9:31 PM, Richard Damon wrote:
On 5/9/24 11:38 AM, olcott wrote:
On 5/8/2024 8:38 PM, immibis wrote:
On 8/05/24 21:05, olcott wrote:
On 5/8/2024 10:13 AM, Mike Terry wrote:
On 08/05/2024 14:01, olcott wrote:
On 5/8/2024 3:59 AM, Mikko wrote:
On 2024-05-07 19:05:54 +0000, olcott said:
>
On 5/7/2024 1:54 PM, Fred. Zwarts wrote:
Op 07.mei.2024 om 17:40 schreef olcott:
On 5/7/2024 6:18 AM, Richard Damon wrote:
On 5/7/24 3:30 AM, Mikko wrote:
On 2024-05-06 18:28:37 +0000, olcott said:
>
On 5/6/2024 11:19 AM, Mikko wrote:
On 2024-05-05 17:02:25 +0000, olcott said:
>
The x86utm operating system: https://github.com/plolcott/x86utm enables
one C function to execute another C function in debug step mode.
Simulating Termination analyzer H simulates the x86 machine code of its
input (using libx86emu) in debug step mode until it correctly matches a
correct non-halting behavior pattern proving that its input will never
stop running unless aborted.
>
Can D correctly simulated by H terminate normally?
00 int H(ptr x, ptr x)  // ptr is pointer to int function
01 int D(ptr x)
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 int main()
10 {
11   H(D,D);
12 }
>
*Execution Trace*
Line 11: main() invokes H(D,D);
>
*keeps repeating* (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.
>
The above execution trace proves that (for every H/D pair of the
infinite set of H/D pairs) each D(D) simulated by the H that this D(D)
calls cannot possibly reach past its own line 03.
>
When you say "every H/D pair" you should specify which set of pairs
you are talking about. As you don't, your words don't mean anything.
>
>
Every H/D pair in the universe where D(D) is simulated by the
same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
and also includes zero to ∞ recursive simulations where H
H simulates itself simulating D(D).
>
"In the universe" is not a set. In typical set theories like ZFC there
is no universal set.
>
>
This template defines an infinite set of finite string H/D pairs where each D(D) that is simulated by H(D,D) also calls this same H(D,D).
>
These H/D pairs can be enumerated by the one to ∞ simulated steps of D and involve zero to ∞ recursive simulations of H simulating itself simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.
>
1st element of H/D pairs 1 step  of D  is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H
>
4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01
>
5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02
>
6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03
>
7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01
>
Is this the definition of the infinite set of H? We can think of many more simulations that only these.
>
This template defines an infinite set of finite string H/D pairs where
each D(D) that is simulated by H(D,D) also calls this same H(D,D).
>
No-one can possibly show one element of this set where D(D) reaches
past its own line 03.
>
If H is a decider of any kind then the D build from it reaches its line
4 as numberd above. Whether the simulation of D by H reaches that line
is another question.
>
>
*My fully operational code proves otherwise*
>
I seems like you guys don't have a clue about how infinite
recursion works. You can run the code and see that I am correct.
>
I have one concrete instance as fully operational code.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
line 555 u32 HH(ptr P, ptr I) its input in on
line 932 int DD(int (*x)())
>
HH is completely broken - it uses a global variable which is allows HH to detect whether it is the outer HH or a nested (simulated) HH. As a result, the nested HH behaves completely differently to the outer HH - I mean /completely/ differently: it goes through a totally separate "I am called in nested mode" code path!
>
>
The encoding of HH is not the pure function that it needs to be to
be a computable function.
>
*Maybe you can settle this*
>
The disagreement is entirely over an enormously much simpler thing.
The disagreement is that Richard says that a D simulated by H could
reach past its own line 03 and halt.
>
Here's the proof:
>
1. A simulation always produces an identical execution trace to the direct execution.
>
*When pathological self-reference is involved this is counter-factual*
That no one can possibly show the steps of how D simulated by H possibly
reach line 06 of H proves this.
>
>
>
>
Richard tried to get away with D never simulated by H as an example
of D simulated by H:
>
Nope, you are looking at the WRONG message, and I have told you this multiple times.
>
Message-ID: <v0ummt$2qov3$2@i2pn2.org>
*When you interpret*
On 5/1/2024 7:28 PM, Richard Damon wrote:
 > On 5/1/24 11:51 AM, olcott wrote:
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
>
as *D NEVER simulated by H*
>
you have shown a reckless disregard for the truth
that would win a defamation case.
>
>
My H simulated 0 steps of D, of which was ALL of the steps it simulated correctly.
>
*THAT DOES NOT MEET THE SPEC*
>
You haven't GIVEN a defined SPEC.
>
The only definition within Computation Theory, which is the space you started in, and claim to get to, doesn't have "aborted" simulations, so you don't have a defintion of what simulatioin actually means, other than doing something that tells you something about the behavior of what is simulated.
>
My H does that, by aborting its "simulation" in shows that THIS H did not simulate its input to a final state.
>
Just the same result that you partial set of H's showed.
>
*THAT DOES NOT MEET THE SPEC*
*THAT DOES NOT MEET THE SPEC*
*THAT DOES NOT MEET THE SPEC*
>
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
>
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
>
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
>
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
>
*Every D simulated by H that cannot possibly*
*stop running unless aborted by H*
>
>
>
Right, and simulating zero steps correctly and them aborting means H
>
*cannot possibly stop running unless aborted is not met*
*cannot possibly stop running unless aborted is not met*
*cannot possibly stop running unless aborted is not met*
*cannot possibly stop running unless aborted is not met*
*cannot possibly stop running unless aborted is not met*
 If H never simulates any steps and always aborts then its input cannot possibly stop running unless aborted because its input never has the chance to execute a return instruction before the abort.
The instant that the executed H(D,D) stops simulating its input all simulations immediately stop running.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Date Sujet#  Auteur
23 Dec 24 o 

Haut de la page

Les messages affichés proviennent d'usenet.

NewsPortal