Re: ZFC solution to incorrect questions: reject them --undecidability decider--

On 3/13/2024 1:03 PM, Richard Damon wrote:

On 3/13/24 9:49 AM, olcott wrote:

On 3/13/2024 11:16 AM, Richard Damon wrote:

On 3/13/24 8:35 AM, olcott wrote:

On 3/13/2024 10:21 AM, Richard Damon wrote:

On 3/13/24 8:01 AM, olcott wrote:

On 3/13/2024 4:44 AM, Mikko wrote:

On 2024-03-13 03:41:18 +0000, olcott said:
>

On 3/12/2024 10:33 PM, Richard Damon wrote:

On 3/12/24 4:56 PM, olcott wrote:

On 3/12/2024 6:38 PM, immibis wrote:

On 13/03/24 00:24, olcott wrote:

On 3/12/2024 6:05 PM, immibis wrote:

On 12/03/24 23:53, olcott wrote:

On 3/12/2024 5:30 PM, Richard Damon wrote:

On 3/12/24 2:34 PM, olcott wrote:

On 3/12/2024 4:23 PM, Richard Damon wrote:

On 3/12/24 1:11 PM, olcott wrote:

Not exactly. A pair of otherwise identical machines that
(that are contained within the above specified set)
only differ by return value will both be wrong on the
same pathological input.

>
You mean a pair of DIFFERENT machines. Any difference is different.

>
Every decider/input pair (referenced in the above set) has a
corresponding decider/input pair that only differs by the return
value of its decider.

>
Nope.
>

∀ H ∈ Turing_Machines_Returning_Boolean
∃ TMD ∈ Turing_Machine_Descriptions  |
Predicted_Behavior(H, TMD) != Actual_Behavior(TMD)
>
Every H/TMD pair (referenced in the above set) has a
corresponding H/TMD pair that only differs by the return
value of its Boolean_TM.
>
That both of these H/TMD pairs get the wrong answer proves that
their question was incorrect because the opposite answer to the
same question is also proven to be incorrect.
>

>
Nobody knows what the fuck you are talking about. You have to actually explain it. The same machine always gives the same return value on the same input.
>

>
It has taken me twenty years to translate my intuitions into
words that can possibly understood.

>
You failed.
>

A pair of Turing Machines that return Boolean that are identical
besides their return value that cannot decide some property of
the same input are being asked the same YES/NO question having
no correct YES/NO answer.

>
https://en.wikipedia.org/wiki/Turing_machine#Formal_definition
A Turing machine is ⟨Q, Γ, b, Σ, δ, q0, F⟩
Show me two ⟨Q, Γ, b, Σ, δ, q0, F⟩ that are identical besides their return value.
You can't because you are talking nonsense. they don't exist.

>
Turing machine descriptions that are identical finite strings
except for the the 1/0 that they write the their exact same
tape relative location.
>

>
So they aren't identical.
>
"Identical except ..." means DIFFERENT.
>
So you LIE

>
Not at all. I did not know these details until

  ...
>
To claim something as truth without knowing it is to lie.
>

That I have acknowledged my mistakes is sufficient reason
to conclude that these mistakes were never known falsehoods
with the intent to deceive.

>
But you still continue to say those statements.
>

>
I have acknowledged several mistakes.
I no longer assert any of those things.
In the future I will assert things as hypotheses.
>

>
The current focus is this can H(D,D) always detect when its
input is calling itself with its same parameters such that
the correctly simulated D(D) would never stop running unless
aborted.
>
*Hypothesis*
I say that if it is detectable then a machine can detect it
and it cannot be undetectable.

>
Then show how it can be done as a Turing Machine.
>

That is not in the hypothesis.

>
Then you aren't taking about Computation Theory!
>

I am currently not talking about computation theory that is limited
to Turing machines. I have broadened the subject to include computable
functions of other models of computation.

 Which Computation Talks about, and ANY other Model of Computation, that actually does "Computations" as defined, can be converted into a Turing Machine.
 

Within the possibly false assumption that Church-Turing is true.

>

Your problem is you don't understand what makes your program not a computation, becuase it is using information or program structure that isn't a computation.
>

H(D,D) is using its own machine address that is directly available
to every virtual machine in the x86 model of computation. If this
makes some aspect of the halting problem decidable for x86 machines
and not for Turing machines then Church-Turing is refuted.

 And in doing so is making it NOT a "Computation" of its input parameters.
 DEFINITION,
 And you prove yourself to be a liar claiming to be working in the definition but ignoring it.
 You don't "refute" Church-Turing by looking at an operation that isn't withing the bounds of a Computation.
 

That it is not within the bounds of Turing computation never
did prove that it was not in the bounds of computation.

>

Like D being in the same "program" as H, instead of a totally independent program.
>

We can analytically determine whether this makes a difference
and what this difference means. H(D,D) cannot currently process
any conditional branch instructions, the x86 emulator cannot
correctly emulate copies of emulated functions unless these
copies are very small.

 So, you are just admitting you design is limited.
 

The design is not limited the implementation is limited.

There SHOULD be few limits in the size of the program being simulated.
 After all, I run a machine that simulates a whole Windows 11 Intel Computer on an ARM chip.
 It may be your ALGORITHM for halt deciding is too inefficient to handle larger programs, but that is the fault of your algorithm.
 

My program is as efficient as possible the emulator also seems
to be very good. It uses a jump table as part of its decoding
process.

>

>

Note, the basis isn't "I Say", the basis is "It can be shown".
>

>
I make a tentative assertion that I call a hypothesis
and it remains possibly true until refuted.
>

Remember, the input is antagonistic to you, and knows what you are doing or planning on doing, and will do everything allowed to thwart your attempts.
>

Yes and it seems to me that thwarting this particular
scenario is categorically impossible. A counter-example
would prove me wrong.

>
So, how do you detect a copy of you that has been morphed is any of a number of ways that hides the original program structure, but keeps the actual algorithmic steps intact?
>

I hypothesize that Ĥ ⟨Ĥ⟩ simply halts when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions
to Ĥ.Hqe for error.

 Which means you don't actually prove anything,
 Note, you can't hypothise RESULTS to prove something is computable, you need to propose a computable algorithm that does it.
 

As long as it cannot be shown to be false the hypothesis
remains possibly true. Church-Turing is only a hypotheis.

>

>

This includes, programatticly editing the description to make an equivalent machine with nodes rearranges or "no-ops" added to the code, to make the description harder to compare.
>

That does not work on H(D,D).
I am focusing on H(D,D).
>
If H(D,D) cannot be thwarted as a computable function
then my hypothesis would seem to be validated.

>
Which means that D needs to be able to use a COPY of H, not the original H.
>

Then I hypothesize that
D(D) simply halts when D.H(D,D) transitions to D.Hqe for error.

 But HOW? You need to say HOW that works.
 

No one has said how it could be defeated.
I cut-off considering making incorrect copies as out-of-scope.

>

If we have D us the original H, then H can't know its address or its object code as matching those breaks the assumption that allowed D to use the original H instead of a copy.
>

>

>
If the above is true then this gives us two things:
(a) An alternative decidable criteria for the halting problem
(b) A way for every machine to correctly decide its own
undecidability on the original halting problem criteria.
>

>
No, it does not get you an "Alternative Decidable Criteria" for the Halting Problem, as it isn't actually EQUIVALENT to the Halting Criteria.
>

If the original criteria are proved to be incorrect then
the new criteria could replace them the same way that ZFC
replaced Naive set theory.

>
But you then need to show that there is some problem with the original criteria.
>

I am working on that in parallel. I have two PhD full professors
of computer science that agree. I simply need to make our shared
reasoning clear enough to be self-evidently true.

 Except that their errors have been pointed out.
 

Not at all. Opinions that they are incorrect or even proofs
that they are incorrect that are based on possibly false
assumptions do not show that they are incorrect.

>

Things being uncomputable isn't considered a problem, and in fact, we KNOW that some things must be uncomputable by a simple counting.
>

That True(L,x) is currently understood to be uncomputable
seems to be causing the death of the planet.

 Nope.
 

(a) Hired climate change deniers are causing the death of the planet.
(b) When True(L,x) is computable then they could be objectively proved
to be liars.
(c) True(L,x) is construed as uncomputable because Tarski did not
understand how it could correctly handle the Liar Paradox.

>

>

It calls some machines DIFFERENTLY, so it is a DIFFERENT mapping.
>
You might be able to claim an alternate Halting Problem based on your alternate criteria, and then you need to show it is useful.
>

If the original criteria are proved to be incorrect the same sort
of way that ZFC replace Naive set theory, then the original halting
problem proofs are nullified.

>
But you haven't shown the origianl criteia to be "incorrect". Just not the results you like.
>

In a way that you can understand is correct.
>

>

After all, there are still other mappings that turn out to be non-computable not based on that pathological pattern, that you still won't handle.

>
One thing at a time.
I cannot afford to tolerate the [change the subject] form of
rebuttal that wasted 15 years with Ben Bacarisse.
>

>
But if you can't show a problem with the original criteria, why would anyone what to change to your new one, that WILL be weaker,
>

I am working on that in parallel.
If undecidability deciders can be made this by itself is progress.
>

 But Undecidability is a property of the Mapping, not the input.
 

Halts(D,D) is an abstraction that indicates the actual behavior of D(D).
H(D,D) correctly detects that it has no mapping to Halts(D,D).

And Mappings are infinites, so can't be given to a Machine to decide on.
 So an Undecidabiiry Decider is a category error.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer