On 11/2/24 8:24 AM, olcott wrote:
On 11/2/2024 5:35 AM, Mikko wrote:
On 2024-11-01 13:18:48 +0000, olcott said:
>
On 11/1/2024 6:08 AM, Mikko wrote:
On 2024-10-31 12:53:04 +0000, olcott said:
>
On 10/31/2024 5:55 AM, Mikko wrote:
On 2024-10-31 01:20:40 +0000, Mike Terry said:
>
On 30/10/2024 23:35, Richard Damon wrote:
On 10/30/24 8:34 AM, olcott wrote:
On 10/30/2024 6:19 AM, Richard Damon wrote:
On 10/29/24 10:54 AM, olcott wrote:
On 10/29/2024 5:50 AM, Richard Damon wrote:
On 10/28/24 11:08 PM, olcott wrote:
On 10/28/2024 9:56 PM, Richard Damon wrote:
On 10/28/24 9:09 PM, olcott wrote:
On 10/28/2024 6:56 PM, Richard Damon wrote:
>
It is IMPOSSIBLE to emulate DDD per the x86 semantics without the code for HHH, so it needs to be part of the input.
>
>
*You seemed to be a totally Jackass here*
You are not that stupid
You are not that ignorant
and this is not your ADD
>
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
>
At machine address 0000217a HHH emulates itself emulating
DDD without knowing that it is emulating itself.
>
>
Then how did it convert the call HHH into an emulation of DDD again?
>
>
When HHH (unknowingly) emulates itself emulating DDD this
emulated HHH is going to freaking emulate DDD.
>
Did you think it was going to play poker?
>
>
Which is what it would do, get stuck and fail to be a decider. It might figure out that it is emulating an emulating decider, at which point it knows that the decider might choose to abort its conditional emulation to return, so it needs to emulate further.
>
Only by recognizing itself, does it have grounds to say that if I don't abort, it never will, and thus I am stuck, so I need to abort.
>
>
Counter-factual. This algorithm has no ability to KNOW ITS OWN CODE.
https://github.com/plolcott/x86utm/blob/master/Halt7.c // page 801
>
*That people fail to agree with this and also fail to*
*correctly point out any error seems to indicate dishonestly*
*or lack of technical competence*
>
DDD emulated by HHH according to the semantics of the x86
language cannot possibly reach its own "return" instruction
whether or not any HHH ever aborts its emulation of DDD.
>
I read, reread again and again to make sure that my understanding
is correct. You seems to glance at a few words before spouting off a canned rebuttal that does not even apply to my words.
>
>
>
No, it knows its own code because it rule for "No conditional branches" excludes that code.
>
>
It does not know its own code. It merely knows that the
machine address that it is looking at belongs to the
operating system. I simply don't have the fifty labor
years that AProVE: Non-Termination Witnesses for C Programs,
could spend on handling conditional branches.
>
The stupid aspect on your part is that even knowing
that its own code halts THIS HAS NOTHING TO DO WITH
DDD REACHING TS OWN RETURN INSTRUCTION.
>
>
>
No, HHH is NOT part of the "Operating System" so your claims are just a lie,
>
PO definitely has a deep-rooted problem with his thinking here.
>
What PO does does not look like any thingking but more like what one
could expect from ChatgPPT or a similar AI.
>
I don't have the 50 years it would take for me to replicate the work of
AProVE: Non-Termination Witnesses for C Programs.
>
Doesn't matter. Even if you had you could not use it to prove your false
claim that there be some defect in some proof.
>
There has never ever been the least trace of error
in this verified fact:
>
DDD emulated by HHH according to the semantics of the x86
language cannot possibly reach its own "return" instruction
whether or not any HHH ever aborts its emulation of DDD.
>
No, but its relevance to Linz' proof is very thin.
>
When the main motive of people like Richard is to derail
any chance of mutual agreement I cannot proceed with all
of the steps achieving mutual agreement on each step one
at a time in their mandatory prerequisite order.
No, my "motive" is to hold cranks to the truth, or at least get them to admit that they are off in some other system, that they can define.
You keep on wanting to be in the system (since it provides the proof of the things you don't like) but can't hold yourself to actually be in the system.
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[000020a2] 55 push ebp ; housekeeping
[000020a3] 8bec mov ebp,esp ; housekeeping
[000020a5] 68a2200000 push 000020a2 ; push DDD
[000020aa] e8f3f9ffff call 00001aa2 ; call H0
[000020af] 83c404 add esp,+04 ; housekeeping
[000020b2] 5d pop ebp ; housekeeping
[000020b3] c3 ret ; never gets here
Size in bytes:(0018) [000020b3]
DDD emulated by HHH according to the semantics of the x86
language cannot possibly reach its own "return" instruction
whether or not any HHH ever aborts its emulation of DDD.
Equivocation between looking at the behavor of DDD being the actual program (which include a particular version of HHH) and the behavior of a PARTIAL emulation of DDD by HHH, which ends up not having the property you want to show.
Partial doesn't lead to showing never.
Unless and until you have complete and total perfect
understanding the above is perfectly correct I cannot even
begin showing relevance to Linz.
Until you resolve the equivocation your statement doesn't have meaning.
When we do not construe the current received view as
inherently infallible then we can begin to consider
alternative view.
>
You can call a strawman deception (or an attempt of one) an altenative
view but it is still a strawman deception.
>
THE FREAKING SUBJECT OF THE FREAKING THREAD IS THE PHILOSOPHY
OF COMPUTATION.
Which you don't understand what it is, likely because you don't understand what the words mean.
If naive set theory was construed as inherently infallible then
ZFC could have never resolved Russell's Paradox.
>
There is no point in construing an inconsistent theory as inherently
infallible.
>
None-the-less everyone here continues to do that. Everyone here
takes the current received view on the theory of computation is
if it came directly from God himself. They cannot begin to imagine
the tiniest little trace of any error what-so-ever in the current
received view.
Because, for a given formal system, the initial definitions ARE like "God himself".
Your problem is you don't like that "God" has defined things different than what you want.
As has been pointed out, you are perfectly free to create your own system, you just need to take on the responsibilities to TOTALLY CREATE IT.
It really is not even any change to the view of deciders
to know that they compute the mapping from their finite
string input to their own accept or reject state on the
basis of a semantic or syntactic property of this string.
>
It does seems to be a change to how this semantic property
is string understood when applied to the halting problem proof.
>
The point is that a Turing machine can only compute syntactic properties.
>
No that is not the actual point. That is only the current
received view not an infallible ruling. Rice's theorem is
accepted as true. That is not the same as it actually being
true.
No, that is what the definitions show. Until you define what you actually mean as a full alternate system, you are stuck with the "received view"
From what I recall Rice can always be reduced to the HP.
This means refuting the HP proofs can be construed as
refuting Rice.
No, Rice is a generalization of the Halting Problem. It may be that
Everyone here seems to think that the semantic property of
this finite string is not the actual behavior that this finite
string actually specifies.
>
In order to get a specification of anything the string must be
interpreted.
Yes.
void DDD()
{
HHH(DDD);
return;
}
Thus when HHH is a C interpreter both HHH and DDD
eventually crash due to out-of-memory error.
But C programs aren't allowed to "call" the "C interpreter",
And the C interpreter isn't defined to do the same thing that your HHH is defined to do.
You don't seem to fundamentally understand what a "Decider" is supposed to be. If HHH is a decider, it isn't a pure interpreter/emulator/simulator and to think of it as such is just an error.
A behaviour is not a finite string so a Turing machine
cannot see it.
>
When this TM is a UTM then this UTM can see the behavior
specified by the string as a subset of its own state
transitions.
And if it aborts, it never was a UTM.
Instead of the actual behavior they construe it as the idealized
behavior that would occur if DDD was not calling its own termination
analyzer.
>
No, most participant of these discussions understand that the
halting problem asks about the actual behaviour of the actual
Turing machine with the actual input.
>
We are still miles away from beginning to talk about
the halting problem. We must first establish mutual
agreement on this.
void XXX()
{
YYY(DDD);
return;
}
_XXX()
[000020a2] 55 push ebp ; housekeeping
[000020a3] 8bec mov ebp,esp ; housekeeping
[000020a5] 68a2200000 push 000020a2 ; push XXX
[000020aa] e8f3f9ffff call 00001aa2 ; call H0
[000020af] 83c404 add esp,+04 ; housekeeping
[000020b2] 5d pop ebp ; housekeeping
[000020b3] c3 ret ; never gets here
Size in bytes:(0018) [000020b3]
DDD emulated by HHH according to the semantics of the x86
language cannot possibly reach its own "return" instruction
whether or not any HHH ever aborts its emulation of DDD.
Your code and statements rare just inconsistant here, You are just getting sloppy. We will apply "autocorrect" and assume the normal program and code for the question.
It is a fact that DDD can not be emuated by HHH (or anything else) according to the sematics of th x86 language until you include the code of HHH that it calls. Therefore your claimed "finite-string" input is insufficient, but MUST include the code of HHH, and thus you can not "change" that code to do you operation, and thus any imagined HHH must look at the DDD that calls the original HHH not the newly imagined one.
Once that is fixed, we need to handle your equivocation in the sentence.
Are you talking about the behavior of the program DDD, the one that HHH is going to partially emulate, or
Are you talking about the behivor of the partial emulation of DDD done by HHH
Until you answer, your claim is just an equivocation.
In other case what I am doing is called
isolating the independent variable.
>
You may call it that way. It does not look like that.
>
The program under test is DDD.
HHH is NOT the program under test it is the tester.
>
So far is good. But the halting problem demands that every Turng machine
can be put to the test.
>
DDD emulated by HHH according to the semantics of the x86
language cannot possibly reach its own "return" instruction
whether or not any HHH ever aborts its emulation of DDD.
>
It is not 100% impossible to construe this as the reject criteria.
It is merely unconventional.
>
More importan is whther it is correct. If a terminating computation
is rejected as non-terminating then at least one of the criteria is
incorrect.
>
HHH does compute the mapping from its input DDD
to the actual behavior that DDD specifies and this
DOES INCLUDE HHH emulating itself emulating DDD.
No, it computes *A* Mapping, the one created by it, and it only contains HHH partially emulating HHH partially emulating DDD
HHH1 does compute the mapping from its input DDD
to the actual behavior that DDD specifies and this
DOES NOT INCLUDE HHH1 emulating itself emulating DDD.
But the correct emualtion of DDD would never need for it to do so.
This is what makes it impossible for HHH to do the correct emulation, but allows HHH1 to do so.
It seems ridiculously stupid for everyone here to simply
ignore how pathological self-reference DOES IN FACT
change the behavior of DDD.
No, the problem is that YOU ignore how the "pathological self-reference" makes it just impossible for HHH to acheive its requirments, to actually correctly emulate the input in finite time.
Impossiblity does not yield the right to be incorrect, but may require being incorrect as a necessity.
You just don't understand how requirements work.
The philosophy of computation reformulates existing ideas on a new basis ---
Re: The philosophy of computation reformulates existing ideas on a new basis ---