Re: Linz's proofs and other undecidable decision problems --- Key feedback from Mike Terry

On 5/25/24 11:53 PM, olcott wrote:

On 3/1/2024 12:41 PM, Mike Terry wrote:

On 01/03/2024 17:55, olcott wrote:

On 3/1/2024 11:42 AM, Mike Terry wrote:

On 01/03/2024 06:14, olcott wrote:

On 2/29/2024 10:18 PM, Richard Damon wrote:

On 2/29/24 10:42 PM, olcott wrote:

On 2/29/2024 8:28 PM, Richard Damon wrote:

On 2/29/24 5:29 PM, olcott wrote:

On 2/29/2024 4:24 PM, wij wrote:

On Thu, 2024-02-29 at 16:13 -0600, olcott wrote:

On 2/29/2024 4:06 PM, wij wrote:

On Thu, 2024-02-29 at 15:59 -0600, olcott wrote:

On 2/29/2024 3:50 PM, wij wrote:

On Thu, 2024-02-29 at 15:27 -0600, olcott wrote:

On 2/29/2024 3:15 PM, wij wrote:

On Thu, 2024-02-29 at 15:07 -0600, olcott wrote:

On 2/29/2024 3:00 PM, wij wrote:

On Thu, 2024-02-29 at 14:51 -0600, olcott wrote:

On 2/29/2024 2:48 PM, wij wrote:

On Thu, 2024-02-29 at 13:46 -0600, olcott wrote:

On 2/29/2024 1:37 PM, Mikko wrote:

On 2024-02-29 15:51:56 +0000, olcott said:
>

H ⟨Ĥ⟩ ⟨Ĥ⟩ (in a separate memory space) merely needs to report on

>
A Turing machine is not in any memory space.
>

>
That no memory space is specified because Turing machines
are imaginary fictions does not entail that they have no
memory space. The actual memory space of actual Turing
machines is the human memory where these ideas are located.
>
The entire notion of undecidability when it depends on
epistemological antinomies is incoherent.
>
People that learn these things by rote never notice this.
Philosophers that examine these things looking for
incoherence find it.
>
...14 Every epistemological antinomy can likewise be used
for a similar undecidability proof...(Gödel 1931:43)
>

>
So, do you agree what GUR says?
>
People believes GUR. Why struggle so painfully, playing idiot everyday ?
Give in, my friend.

>
Graphical User Robots?
The survival of the species depends on a correct understanding of truth.

>
People believes GUR are going to survive.
People does not believe GUR are going to vanish.

>
What the Hell is GUR ?

>
Selective memory?
https://groups.google.com/g/comp.theory/c/_tbCYyMox9M/m/XgvkLGOQAwAJ
>
Basically, GUR says that no one even your god can defy that HP is undecidable.

>
I simplify that down to this.
>
...14 Every epistemological antinomy can likewise be used for
a similar undecidability proof...(Gödel 1931:43)
>
The general notion of decision problem undecidability is fundamentally
flawed in all of those cases where a decider is required to correctly
answer a self-contradictory (thus incorrect) question.
>
When we account for this then epistemological antinomies are always
excluded from the domain of every decision problem making all of
these decision problems decidable.
>

>
It seems you try to change what the halting problem again.
>
https://en.wikipedia.org/wiki/Halting_problem
In computability theory, the halting problem is the problem of determining, from a description
of
an
arbitrary computer program and an input, whether the program will finish running, or continue
to
run
forever....
>
This wiki definition had been shown many times. But, since your English is
terrible, you often read it as something else (actually, deliberately
interpreted it differently, so called 'lie')
>
If you want to refute Halting Problem, you must first understand what the
problem is about, right? You never hit the target that every one can see, but POOP.
>
>

>

>
Note: My email was delivered strangely. It swapped to sci.logic !!!
>

If we have the decision problem that no one can answer this question:
Is this sentence true or false: "What time is it?"

>
This is not the halting problem.
>

Someone has to point out that there is something wrong with it.
>

>
This is another problem (not the HP neither)
>

>
The halting problem is one of many problems that is
only "undecidable" because the notion of decidability
incorrectly requires a correct answer to a self-contradictory
(thus incorrect) question.
>

>
What is the 'correct answer' to all HP like problems ?
>

>
The correct answer to all undecidable decision problems
that rely on self-contradictory input to determine
undecidability is to reject this input as outside of the
domain of any and all decision problems. This applies
to the Halting Problem and many others.
>

>
>
In other words, just define that some Turing Machines aren't actually Turing Machines, or aren't Turing Machines if they are given certain inputs.
>

>
No not at all simply make a Turing Machine that does this:
>
LP = "This sentence is not true."
Boolean True(English, LP)  is false
Boolean True(English, ~LP) is false

>
In other words, you are admitting that you havve absolutly NO idea what a Turing Machine is, and what it can do.
>

>
Not at all this is the high level architectural design of
a system that could be implemented as a Turing machine.
>

You don't even seem to understand what you need to do to program something.

>
That is proven to be ridiculous by my fully operational code.
that created the x86utm operating system entirely out of an
excellent x86 emulator. It was very tricky to get HH to simulate
itself to an arbitrary recursive depth.

>
BUT....  Your HH code is completely broken!
>
It uses static variables like execution_trace shared across simulations.  The effect of this is that nested simulations see (and actively examine as part of their decision logic) trace entries from parent simulators.  A valid simulation cannot do that - your program logic is Wrong.

>
(1) This is moot.
(2) A UTM can share a portion of its own tape with the machine that it
is simulating so that it can see this machines own internal data.
>

I thought you had claimed to have fixed that problem, and you certainly never corrected me when I mentioned that I thought you had fixed it in an earlier post.  It seems you never fixed it, SO IT'S STILL BROKEN.
>

>
H is able to correctly determine that D is calling itself thus
no need for the UTM to share a portion of its own tape with
the machine that it is simulating.
>

What you did instead, it seems, was change from using HH to using H, the latter not requiring nested simulation to work as intended.  And yet you still throw out references to your "HH using nested simulation" and "arbitrary recursive depth" as though you had actually fixed it - very dishonest of you.
>

>
Not the slightest little bit. The original H was renamed to HH.
Because a UTM actually can share a portion of its own tape with
the machine it is simulating HH may actually be the preferred version.

>
Obviously a simulator has access to the internal state (tape contents etc.) of the simulated machine.  No problem there.
>

 I waited for more than two years for this one crucial point to
be confirmed. My whole proof ultimately depended on this one
unconfirmed point.
 *The above point is so crucial because it confirms this*
*The above point is so crucial because it confirms this*
*The above point is so crucial because it confirms this*
 That means that every detail of every state change of each of the
simulated machines is directly available to the outermost directly
executed machine immediately before these state changes occur. This
remains true no matter how deep the recursive simulation goes.
 This was the one key point about Turing computability that I
only had intuition about until Mike Terry confirmed that this
intuition is correct.
 *It seems self-evident now. All of the internal simulations*
*driven by the directly executed simulator are mere changes*
*to the data of this directly executed simulator*
 

What isn't allowed is the simulated machine altering its own behaviour by accessing data outside of its own state.  (I.e. accessing data from its parent simulators state.)
>

 There never was any actual need for that.
As long as the outermost directly executed simulator can see each and
every state change of its simulations (no matter what the recursive
depth of these recursive simulations are) then my proof has this key
element that it would fail without.
 *The above is most of STEP THREE of my four step proof*
 

Gee, elsewhere you say it is a FIVE step proof.
The point you seem to be missing is that program you are thinking of and trying to work with doesn't show what you want it to show.
It might show that your POOP is solvable, or at least not proven impossible by a proof just like the Linz/Sipser one, but it doesn't say anything about the halting problem, because it uses logic based on assumptions contradictory to that problem.
That is why we need to handle the implications of your definitions.