On 3/11/2024 1:17 AM, Richard Damon wrote:
On 3/10/24 10:40 PM, olcott wrote:
On 3/11/2024 12:07 AM, Richard Damon wrote:
On 3/10/24 9:33 PM, olcott wrote:
On 3/10/2024 10:07 PM, Richard Damon wrote:
On 3/10/24 7:47 PM, olcott wrote:
On 3/10/2024 9:08 PM, Richard Damon wrote:
On 3/10/24 5:32 PM, olcott wrote:
On 3/10/2024 2:16 PM, immibis wrote:
On 10/03/24 19:32, olcott wrote:
On 3/10/2024 1:08 PM, immibis wrote:
On 10/03/24 18:17, olcott wrote:
ZFC simply tossed out the Russell's Paradox question as unsound.
>
So you are saying that some Turing machines are not sound?
>
Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
(a) Their input halts H.qy
(b) Their input fails to halt or has a pathological
relationship to itself H.qn.
>
But the "Pathological Relationship" is ALLOWED.
>
ZFC simply tossed out the Russell's Paradox question as unsound
expressly disallowing the "Pathological Relationship".
>
So you are saying that some Turing machines are not real Turing machines?
>
I am only claiming that both H and Ĥ.H correctly say YES
when their input halts and correctly say NOT YES otherwise.
>
well the halting problem requires them to correctly say NO, so you haven't solved it
>
All decision problem instances of program/input such that both
yes and no are the wrong answer toss out the input as invalid.
>
I noticed that you gave up on Olcott machines and now you are back to your old bullshit ways of pretending that the same machine can produce two different execution traces on the same input. Why don't you show us an execution trace where that happens? Both traces must show the first instruction that is different in both traces and I recommend showing 20 more instructions after that, but you can abort one after that time, if it doesn't halt, to prevent the trace getting infinitely long.
>
Turing Machines and Olcott machines cannot properly implement
H1(D,D) and H(D,D) that know their own machine address.
>
My C code proves these two have different behavior:
(a) H1(D,D) + H1_machine_address
(b) H(D,D) + H_machine_address
>
Because they are different computations they are
not required to have the same behavior.
>
Right, but it also means that since the dfference is because of a "Hidden" input none of them qualify as a Halt Decider.
>
>
The key input (the machines own address) is not hidden
merely unavailable to Turing machine and Olcott machines.
>
And if it isn't hidden, then the other copies that take use a different address become different computations and can't claim to fill in for THE H.
>
You then prove each copy wrong by giving it the version of H^/D that is built on it, which it will get wrong.
>
All the other ones might get it right, showing that there IS a correct answer.
>
>
>
H(D,D) immediately sees the first time it calls itself
with its same inputs.
>
H1(D,D) never sees it call itself with its same inputs.
>
Full Execution trace of H1(D,D)
(a) main() invokes H1(D,D)
(b) H1(D,D) simulates D(D)
(c) Simulated D(D) calls simulated H(D,D)
(d) Simulated H(D,D) simulates another D(D)
(e) Simulated H(D,D) aborts this D(D) when it would call itself
(f) Simulated H(D,D) returns 0 to simulated caller D(D)
(g) Simulated caller D(D) returns to H1(D,D)
(h) H1(D,D) returns 1 to main()
>
They cannot be implemented as Turing Machines or Olcott
Machines. They can be implemented as RASP machines proven
by the fact that they are implemented as C functions.
>
>
Right, which proves your C functions also were never the required computation, as they has an extra "hidden" input. As has been told to you many times in the past.
>
When I specify that every machine can know its own machine address
in x86 machines and (possibly augmented) RASP machines then it is
not hidden and an explicitly part of the input to the computation.
>
And if it isn't hidden, then the other copies that take use a different address become different computations and can't claim to fill in for THE H.
>
You then prove each copy wrong by giving it the version of H^/D that is built on it, which it will get wrong.
>
All the other ones might get it right, showing that there IS a correct answer.
>
>
>
So, you just admitted that you hae just been lying for all these years, and you are no closer to your fantasy goal then you ever were.
>
Sorry, you just don't know enough to do this problem.
>
I just admitted that it took me about two years to translate my
intuitions into words that address your objections.
>
For these two years you and many other people claimed that H1(D,D)
could not possibly do what it actually did actually do. This has
always been the same thing as disagreeing with arithmetic.
>
>
It can't do it and be the SAME COMPUTATION as H, which is what you were claiming.
>
>
It did actually do exactly what I claimed and everyone wanted
to stick to their opinion and deny the actual facts that it
did actually do what I said.
>
It might have done what you THOUGHT you were saying, but it doesn't do what you ACTUALLY SAID.
>
>
I always claimed that H1(D,D) returns 1 and H(D,D) returns 0 and you
always said it was impossible even though that is what actual code
actually did. The code always discloses that H and H1 have their own address.
No, we said it was impossible if they were the COMPUTATIONS you were claiming them to be.
I never ever claimed that they were the same computation.
That was expalined, and you ignored it, so it wasn't an "Honest Mistake", but a willful disreguard for the truth, and thus a LIE.
You never ever bothered to look at the code proving that it was correct.
You apparently STILL don't understand that term, and seam to prefer just wasting. you time spinning your wheels on falsehoods, then being willing to spend justa bit of time to learn the meaning of the basic words of the thing you are claiming to be making novel discoveries in, that are just crappy lies.
>
u32 H1(ptr P, ptr I)
{
u32 Address_of_H1 = (u32)H1; // 2022-08-15
>
>
u32 H(ptr P, ptr I)
{
u32 Address_of_H = (u32)H;
>
>
THe problem is you MISUSED technical terms, because you didn't, and apparently still don't, understand what they mean.
>
Either you have a sever learning disability, or you are just being willfully ignorant (or both).
>
It was clearly asked, and yoyu confirmed, that H and H1 were claimed to be the same COMPUTATION,
>
I never sad anything like that.
I always claimed that H1(D,D) returns 1 and H(D,D) returns 0 and you
always said it was impossible even though that is what actual code
actually did.
Nope, you confirmed that they were copies of the same compuation, and that is what makes it impossible.
I never claimed that.
I claimed that they has essentially identical code and they do.
Yes, you made it clear that you didn;t know the meaning of the words, but you also showed that it seemed you prefered to be a stupid liar that was wasting his time then wanting to learn what things actually meant.
You never ever bothered to look at the code proving that it was correct.
>
which means they are only a function of there declaired inputs, and the exact same algorithm, and neither H nor H1 take their address as a declared input, but somehow (we know how) manage to do different things based on that value.
>
I showed use the execution trace two dozen times and in
each case it was clear that the machines had their own
machine address.
Which never show the actual behavior IN H.
*I always showed that Address_of_H is used right here*
u32 Decide_Halting(char* Halt_Decider_Name,
u32* execution_trace,
Decoded_Line_Of_Code** decoded,
u32 code_end,
Registers** master_state,
Registers** slave_state,
u32** slave_stack,
u32 Address_of_H, u32 P, u32 I)
>
That mean, you DID LIE, and refusing it now, just makes it another LIE showing your final destination.
>
>
You are now admitting you were lying all that time, and really owe an appology to everyone yYOU said were lying when they were telling you they weren't the same computation.
>
I never ever lied about any of these things.
It took me a long time to get to closure because
>
You lied, perhaps because of ignorance,
*THAT IS NOT HOW LIES WORK*
*THAT IS NOT HOW LIES WORK*
*THAT IS NOT HOW LIES WORK*
*THAT IS NOT HOW LIES WORK*
*THAT IS NOT HOW LIES WORK*
*THAT IS NOT HOW LIES WORK*
*THAT IS NOT HOW LIES WORK*
Yes it is. That makes them PATHOLOGICAL LIES or LIES of INDIFFERENCE.
Lies are intentional falsehoods with the intent to deceive.
A lie is a statement not in accordance with the mind
of the speaker, made with the intention of deceiving.
https://www.oxfordreference.com/display/10.1093/oi/authority.20110803100120405They are not "Honest Mistakes".
>
>
but that ignorance when well past the ability to be called an "Honest Mistake" and became a wanton disreguard for the truth.
>
>
I tolerated the [change the subject] form of
rebuttal that wasted 15 years with Ben Bacarisse.
>
Once I stopped tolerating this closure was achieved
on several points.
>
Of course, since you now admit they are different, that means that H1 can get H out of the jam. D will call the one instance of H, that one particular computation, that it is designed to make wrong, and since the other copies are different computations, they don't rescue that one, or even show that the question is subjective.
>
That they used their own machine address as part of their computation
was explicitly provided for years. Don't blame me for lying when the
real issue is that you didn't bother to pay attention.
>
But you still claimed they were the same computation.
I never said that, you only assumed that.
I always claimed that H1(D,D) returns 1 and H(D,D) returns 0.
You were asked, and you agreed.
You never looked as the execution trace proving that both
H1(D,D) == 1 and H(D,D) == 0 were correct.
I asked you to do this many many times and you persisted in
your ignorance because you refused to look at the code that
prove that H1(D,D) == 1 and H(D,D) == 1 are both correct.
>
You always said this was impossible even though you could look
at my code and see the code does that.
yes, we KNEW you were lying, but that doesn't make it right, just shows you to be STUPID.
H1(D,D) == 1 and H(D,D) == 0 <are> correct.
You persisted in your ignorance because you refused to
look at the code proving that they bot <are> correct.
*It never was my deception it always was your willful ignorance*
*It never was my deception it always was your willful ignorance*
*It never was my deception it always was your willful ignorance*
>
>
Admitting you are lying while you are lying is still lying.
>
>
H1: Begin Simulation Execution Trace Stored at:113095
*Address_of_H1:1442*
[00001d12][00113081][00113085] 55 push ebp ; begin D
[00001d13][00113081][00113085] 8bec mov ebp,esp
[00001d15][0011307d][00103051] 51 push ecx
[00001d16][0011307d][00103051] 8b4508 mov eax,[ebp+08]
[00001d19][00113079][00001d12] 50 push eax ; push D
[00001d1a][00113079][00001d12] 8b4d08 mov ecx,[ebp+08]
[00001d1d][00113075][00001d12] 51 push ecx ; push D
[00001d1e][00113071][00001d23] e81ff8ffff *call 00001542* ; call H(D,D)
>
H: Begin Simulation Execution Trace Stored at:15dabd
*Address_of_H:1542*
[00001d12][0015daa9][0015daad] 55 push ebp ; begin D
[00001d13][0015daa9][0015daad] 8bec mov ebp,esp
[00001d15][0015daa5][0014da79] 51 push ecx
[00001d16][0015daa5][0014da79] 8b4508 mov eax,[ebp+08]
[00001d19][0015daa1][00001d12] 50 push eax ; push D
[00001d1a][0015daa1][00001d12] 8b4d08 mov ecx,[ebp+08]
[00001d1d][0015da9d][00001d12] 51 push ecx ; push D
[00001d1e][0015da99][00001d23] e81ff8ffff *call 00001542* ; call H(D,D)
H: Recursive Simulation Detected Simulation Stopped (return 0 to caller)
>
>
>
You are just proving you don't know or understand enough about any of the things you talk about to be taken seriously.
>
If that was true then you would not make so many mistakes in your
critique of my work. You continue to fail to correctly understand
the sets that are defined by the Linz templates.
>
*The key property that belongs to every this set is*
>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
*Every implementation of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer*
>
And if you had a brain cell, you would see that Linz is talking about a specific (but arbitray) example out of the set, not the set as a whole, until he wraps up.
No he is not. He never was. He was always saying:
*Every implementation of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer*
Having proved that you can show any arbitrary decider to have an input it gets wrong, you can prove that no decider that gets all input right exists.
That <is> this:
*Every implementation of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer*
It only gets the wrong answer when we expect Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
to report on the behavior of Ĥ ⟨Ĥ⟩.
Since this <is not> the behavior that it sees it is incorrect
to expect Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to report on this behavior.
Yes, Every Implementation of H gets the question about the H^ built on it worng, but that input has a correct answer.
When we expect a halt decider to report on behavior other
than the behavior it actually sees then our expectations
are out-o-f-sync with reality.
Thus Halting is a valid question (every instance has an answer) but uncomputable (there is no machine that can compute all the values correctly).
You seem afraid of stuff not being knowable. That is a bad phobia to have, seems to have made you a bit insane and robbed you of your ability to think, and you start to fill things with lies you want to make true so you think you can know everything.
LP = "This sentence is not true."
Boolean True(English, LP) is false
Boolean True(English, ~LP) is false
That the foundation of logic determines that there is no
such thing as coherent analytical truth proves that this
foundation is incorrect.
Outline of a Theory of Truth Saul Kripke (1975)
https://www.impan.pl/~kz/truthseminar/Kripke_Outline.pdfI had forgotten that Kripke did have the right idea all along.
My paraphrase is that an ungrounded expression is an expression
that has no sequence of inference steps from known truths that
derive this expression.
Best answer to that is to admit your lies and learn about what you don't know.
It is true that the current received view of the foundation
of analytical truth is incorrect.
There is a proverb that the smartest man knows what he doesn't know, and the dumbest man thinks he knows what he doesn't know.
You fit that latter to the T.
I originated the term "ignorance squared" in 1998.
One does not know that they do not know.
Someone that has specific knowledge can see what the
other one is missing because they have this knowledge
to contrast with the other ones frame-of-reference.
Because the other one lacks this knowledge they have
nothing to contrast it with, thus they perceive their
own gap of knowledge as mere disagreement with the one
that has this missing knowledge.
*Only philosophers of logic care about its foundations*
Everyone else takes these foundations as "given"
*This is what causes them to have persistent gaps in their*
*knowledge of the inconsistency of the foundations of logic*
-- Copyright 2024 Olcott "Talent hits a target no one else can hit; Geniushits a target no one else can see." Arthur Schopenhauer
Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior