XPost: sci.logic
On 3/5/24 11:13 AM, olcott wrote:
On 3/5/2024 3:59 AM, Mikko wrote:
On 2024-03-04 16:53:10 +0000, olcott said:
On 3/4/2024 8:46 AM, Mikko wrote:
On 2024-03-02 18:06:01 +0000, olcott said:
On 3/2/2024 5:24 AM, Mikko wrote:
On 2024-03-01 17:09:46 +0000, olcott said:
On 3/1/2024 5:27 AM, Mikko wrote:
On 2024-03-01 03:32:44 +0000, olcott said:
The simple way around this is to understand that
self-contradictory inputs are invalid.
They are not unless the problem statements say so. What is or is >>>>>>>> not a valid input is specified in the problem statement. Your
opinions don't matter.
The correct philosophical foundation of the notion of truth
itself proves that epistemological antinomies have no truth
value because they are not truth bearers proves that they are
outside of the domain of decision problems.
That does not contradict what I said above.
Yes it does. it is generically the case that every input
to a decision problem either has a correct yes/no answer
or this input is outside of the domain of this decider.
No, it doesn't. It is generically the case that the domain
is what the problem specification says. If you leave anything
out of the domain you will have at most a partial solution,
not the solution of the problem.
I have reversed my position on this.
Have you already updated your web page?
I have many papers on Researchgate here is my most recent one: https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
Termination Analyzer H is Not Fooled by Pathological Input D https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
I may update that one with the algorithm suggested by Mike
and anchor it better in the Linz Halting problem proof.
The key most important discovery is that it is the combination
of H/D that forms the single counter-example input to H1.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
In other words H/D is isomorphic to Linz Ĥ and H1 is
isomorphic to Linz H. Actual Turing machines do not
call other Turing Machines instead they embed these
machines within themselves. That most texts on the
halting problem have D calling H lead me astray for
may years.
Except that shows you must be lying, as Linz H^ is built on Linz-H, but
in your model it is built on something that gives a different answer,
thus can't be the same computation.
Because of this I reversed my position and no longer claim
that H(D,D) reports on the behavior specified by its input
(it does, but this is unconventional). When it is construed
that H must report on the behavior of the direct execution
of its input it does get the wrong answer yet only because
the combination of H/D is self-contradictory.
In other words the halting problem only proves that an
otherwise correct halt decider H can be caused to report
incorrectly by embedding it as Ĥ.Hq0 in another machine
Ĥ that contradicts every value that it returns.
And thus it isn't a "Correct Halt Decider". PERIOD.
Again, you are just LYING.
That this has no actual effect on the original H is
apparently too difficult for many people to understand.
But if the exact copy doesn't match behavior, then H never was a
computaiton and you are again admitting that you have been LYING.
It is as easy as first grade arithmetic to me because
I fully understand all of the details of how this works.
Nope, you THINK you do, but you have totally misunderstood it.
My H1(D,D) machine versus my H(D,D) machine conclusively
proves that when two otherwise identical machine are
at different locations in memory then when each is applied
to the same input they can correctly derived different results.
It just proves you don't know what it means for two machines to be
identical, and thus, you are caught in another LIE.
They correctly derive different results because these machine
are at different locations in memory only one of these two machines
has its return value contradicted and the other does not.
And thus you have LIED that they are computation of just the description
of the COmputation to decide on
People that disagree with this are disagreeing with empirically
verified facts. The x86 execution race clearly proves that H(D,D)
does meet its "abort simulation" criteria and H1(D,D) does not
meet this criteria.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
Richard has agreed that Ĥ.H must transition to Ĥ.Hqn
to prevent its own infinite execution and this causes
Ĥ to halt.
*This entails that H ⟨Ĥ⟩ ⟨Ĥ⟩ would be correct to transition to H.qy*
Except that means it contradicts itself, since you also haveH^.H (H^)
(H^) going to qn and claiming there are the same Turing Machine Equivalent.
So, you are lying again, because you have made yourself totally ignorant
of the actual properties of a Turing Machine.
So I have shown that a correct halt status for the counter-example
input <is> possible and Richard's last remaining rebuttal to this
is that he doesn't think that H is is smart enough to do this.
*When H ⟨Ĥ⟩ ⟨Ĥ⟩ uses the exact same criteria as Ĥ.H*
Both H and Ĥ.H transition to their NO state when a correct and
complete simulation of their input would cause their own infinite
execution and otherwise transition to their YES state.
When they both apply this criteria correctly then
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to NO and H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to YES.
Simply not believing that they can do this is not really
any actual rebuttal at all.
No, you have shown yourself to be an ignorant pathological liar.
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)