Re: Linz's proofs and other undecidable decision problems [LP as basis] [Mike Terry]

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.
 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.)
 While an "active-simulator" [my own term] is at liberty to combine straight simulation with add-on "enhancements" that extend the functionality of the simulated machine,

in doing so it would no longer be a simulator in the sense you need it to be.  So you mustn't do this!
 

*You did not provide complete reasoning justifying this proclamation*
*You did not provide complete reasoning justifying this proclamation*
*You did not provide complete reasoning justifying this proclamation*
Because the simulator must perform every detail of the simulation of
the underlying machine it can watch every single state change of this
underlying machine and this does not change the behavior of the
simulated input AT ALL (relative to not watching the state changes).

You need the simulator to prove claims you are making about the logic of Linz's proof being faulty. More directly, you want to say that
a)  your H/H^ "follow the pattern of Linz's proof",
b)  so that the logic in Linz's proof informs us that H should decide input (H^,H^) incorrectly
c)  yet YOUR H actually decides input (H^,H^) CORRECTLY.
d)  [so Linz's logic is wrong, somewhere]
But the Linz proof relies on the copy of H within H^ [let's call that Hcopy] faithfully mirroring the computation and result produced by H, for any given input.  That's obvious (although apparently not to you!) when applied to TMs, which is all Linz is concerned with.
 IF you make your "simulation" into an "active-simulation" where the simulator changes the computation dynamically in AMY way [e.g. by leaking external data into the simulation], then the "faithful mirroring" Linz assumption will be broken, so the Linz conclusion need not apply in your environments.  But you NEED the Li^nz logic to apply otherwise you can't conclude that logic is wrong in (d) above.  If the Linz logic /doesn't apply/ then your H/H^ is not a counter-example because it is not "counter" to Linz.
 It is not a question of whether a TM "actively" simulating something can dynamically amend the "simulation" behaviour - the point is that Hcopy within H^ is NOT SUCH AN "ENHANCED" SIMULATION - it is an "exact copy" of H logic, up to the two final H states.
 I appreciate all the above is rather "abstract" for you.  But anyhow, rather than trying to argue the problem away, why not just code it correctly in the first place?  And meanwhile stop claiming anything about your HH handling "arbitrary recursive depth" and the like.
 

>

The "examination of traces from nested simulations" was one of the trickier coding problems you faced in creating x86utm, and you FAILED at that challenge.

>
Not at all. I found out the the reason these x86 emulations
were crashing is the each instance required its own stack.
>

The funny thing is, the problem was actually not that hard at all [i.e. hours work rather than days/weeks], and I would expect practically everyone on this group woud have come up with a correct working approach where you messed it up.
>
>
Mike.
>

>
I think that I correctly rebutted your rebuttal yet here
is why your rebuttal is moot.
>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn     // Ĥ applied to ⟨Ĥ⟩ does not halt
>
Ĥ contradicts Ĥ.H and does not contradict H, thus H
is able to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.
>
As long as some computable criteria exists for Ĥ.H to transition
to Ĥ.Hqy or Ĥ.Hqn, then H has its basis to correctly decide ⟨Ĥ⟩ ⟨Ĥ⟩.
>
H simply looks for whatever wrong answer that Ĥ.H returns and
reports on the halting or not halting behavior of that.

 Dude!  :(
 Can you really not see what's wrong with your suggestion???
 Well, if really not, then I guess you can quickly amend your x86utm project to implement a new version of H that works exactly as your suggesting.  Please post the usual traces showing such an H in action!  [..and you will quickly see why your idea doesn't work.]
 Mike.
 

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