On 6/27/2023 6:52 AM, Richard Damon wrote:
> On 6/26/23 11:34 PM, olcott wrote:
>> On 6/26/2023 9:13 PM, Richard Damon wrote:
>>> On 6/26/23 9:13 PM, olcott wrote:
>>>> On 6/26/2023 7:20 PM, Richard Damon wrote:
>>>>> On 6/26/23 8:05 PM, olcott wrote:
>>>>>> On 6/26/2023 6:18 PM, Richard Damon wrote:
>>>>>>> On 6/26/23 5:52 PM, olcott wrote:
>>>>>>>> On 6/25/2023 6:33 AM, Richard Damon wrote:
>>>>>>>>> On 6/24/23 11:24 PM, olcott wrote:
>>>>>>>>>> On 6/24/2023 6:51 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/24/23 7:11 PM, olcott wrote:
>>>>>>>>>>>> On 6/24/2023 6:02 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 6/24/23 5:39 PM, olcott wrote:
>>>>>>>>>>>>>> On 6/24/2023 4:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 6/24/23 4:59 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 6/24/2023 3:41 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 6/24/23 4:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 6/24/2023 2:31 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 6/24/23 3:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 6/24/2023 1:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 6/24/23 1:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 6/24/2023 12:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 6/24/23 1:01 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 6/24/2023 11:37 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 6/24/23 11:57 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/24/2023 10:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/24/23 9:53 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/24/2023 6:16 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/23/23 10:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/23/2023 9:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/23/23 9:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/23/2023 8:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every TMD2 defines a correct answer, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the question is valid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus the question: "Are you a little
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> girl?" must be false for everyone
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because the exact same word-for-word
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question is false for you.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nooe, because THAT question uses a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pronoun to reference what it is talking
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about, so the question veries based on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> who it is said to.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Referring every element of the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set of {TM1, TMD2} pairs such that TMD2
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does the opposite of whatever Boolean
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> value that TMD2 returns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Is the reason why no TM1 element of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> set returns a value that corresponds to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior of its TMD2 input that each
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TMD2 element does the opposite of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> value that this TM1 element returns.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which means that you have proven it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible to make a correct Halt Decider,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not that the Halting Question is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that since TMD2 changes in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the set, there isn't a single instance of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the question in view.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> I asked you a tautology and you disagreed.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You asked a Red Herring, and I pointed it out.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I asked a tautology and you denied it.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> WHERE did I say that your statement was
>>>>>>>>>>>>>>>>>>>>>>>>> factually wrong verse point out that it doesn't
>>>>>>>>>>>>>>>>>>>>>>>>> prove what you want it to?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I think you don't understand what you read and
>>>>>>>>>>>>>>>>>>>>>>>>> write.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Also, how do you "ASK" a tautology. A Tautology
>>>>>>>>>>>>>>>>>>>>>>>>> isn't a QUESTION, but a STATEMENT.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You seem to have category errors built into
>>>>>>>>>>>>>>>>>>>>>>>>> your brain.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I asked you if a tautology is true and you
>>>>>>>>>>>>>>>>>>>>>>>> denied it.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It is like I asked you if all of the black cats
>>>>>>>>>>>>>>>>>>>>>>>> in Australia are black
>>>>>>>>>>>>>>>>>>>>>>>> and you said you don't know you have to check
>>>>>>>>>>>>>>>>>>>>>>>> them one at a time.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So, still unable to provide refernce to show you
>>>>>>>>>>>>>>>>>>>>>>> statements which are just lies.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>  >>>>>>>> Referring every element of the infinite
>>>>>>>>>>>>>>>>>>>>>> set of {TM1, TMD2}
>>>>>>>>>>>>>>>>>>>>>>  >>>>>>>> pairs such that TMD2 does the opposite
>>>>>>>>>>>>>>>>>>>>>> of whatever Boolean
>>>>>>>>>>>>>>>>>>>>>>  >>>>>>>> value that TMD2 returns.
>>>>>>>>>>>>>>>>>>>>>>  >>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>  >>>>>>>> Is the reason why no TM1 element of this
>>>>>>>>>>>>>>>>>>>>>> set returns a value
>>>>>>>>>>>>>>>>>>>>>>  >>>>>>>> that corresponds to the behavior of its
>>>>>>>>>>>>>>>>>>>>>> TMD2 input that each
>>>>>>>>>>>>>>>>>>>>>>  >>>>>>>> TMD2 element does the opposite of the
>>>>>>>>>>>>>>>>>>>>>> value that this TM1
>>>>>>>>>>>>>>>>>>>>>>  >>>>>>>> element returns.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Are all the black cats in Australia black?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So, what is the "Tautology" there? There is no
>>>>>>>>>>>>>>>>>>>>> STATEMENT that is always true in every situation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So you disagree that all of the black cats in
>>>>>>>>>>>>>>>>>>>> Australia are black?
>>>>>>>>>>>>>>>>>>>> Maybe some of the black cats in Australia are white
>>>>>>>>>>>>>>>>>>>> dogs?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Thats just bad logic speaking a Strawmen.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Every member of set X that has property P and property
>>>>>>>>>>>>>>>>>> Q has property P.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I didn't disagree that every element of the set has a
>>>>>>>>>>>>>>>>> TMD2 that does the opposite of what TMD1 says. I
>>>>>>>>>>>>>>>>> disagreed that this mean the Halting Question, i.e, the
>>>>>>>>>>>>>>>>> question of the behaivor of TMD2 has a problem. The
>>>>>>>>>>>>>>>>> Halting Question ALWAYS has a correct answer, it is
>>>>>>>>>>>>>>>>> just that TMD1 never gives it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Why is it that TM1 cannot provide a Boolean value that
>>>>>>>>>>>>>>>> corresponds to the actual behavior of TMD2?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That a problem with the programmer,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In other words the only reason that halting cannot be
>>>>>>>>>>>>>> solved is
>>>>>>>>>>>>>> that every programmer in the universe is simply too stupid?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, because it is mathematically shown not be computable
>>>>>>>>>>>>> (see below)
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> or the fact that the function being asked for isn't
>>>>>>>>>>>>>>> computable.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In other words it can't be done simply because it just
>>>>>>>>>>>>>> can't be done, no circular reasoning here.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It can't be done because the "pathological" program is a
>>>>>>>>>>>>> valid program.
>>>>>>>>>>>>
>>>>>>>>>>>> Syntactically valid is not the same as semantically valid.
>>>>>>>>>>>
>>>>>>>>>>> There is no "Semantic" limitation in the requirement of ALL
>>>>>>>>>>> PROGRAMS.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Every polar (yes/no) question that contradicts both answers
>>>>>>>>>>>> is an
>>>>>>>>>>>> incorrect question. Likewise for inputs to a decider.
>>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Can any decider X possibly correctly return any Boolean value
>>>>>>>>>> to any input Y that does the opposite of whatever Boolean
>>>>>>>>>> value that X returns?
>>>>>>>>>> (a) Yes
>>>>>>>>>> (b) No
>>>>>>>>>> (c) Richard is a Troll
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, If I understand your poorly defined question, if decider X
>>>>>>>>> is trying to decide on property P of input Y, and Y is designed
>>>>>>>>> to use decider X and crates a value of property P opposite of
>>>>>>>>> what X says.
>>>>>>>>>
>>>>>>>>
>>>>>>>> How would you say the question more clearly?
>>>>>>>
>>>>>>> Actually be clear in what you say. Since you mis-use so many
>>>>>>> words, clearifying what I mean by them sometimes is needed.
>>>>>>>
>>>>>>
>>>>>> So you believe that it is unclear yet have no idea how it could be
>>>>>> said more clearly.
>>>>>>
>>>>>
>>>>> The problem is you misuse words so often, the only way you could be
>>>>> clearer is to stop doing that.
>>>>>
>>>>> You also "invent" words that don't have accpted meanings without
>>>>> definit=ng them.
>>>>
>>>> Any idiot can be a mere naysayer:
>>>> Which woulds would you use to make my question more clear?
>>>
>>> A world where you never uses improper definitions.
>>>
>>> Like, your later talking about "{Halting Problem Instance}" as
>>> something that is some how like but not like a "{Halting Decider}" or
>>> that you can change the value of a return statement in a program, but
>>> still have the "same" program.
>>>
>>> You have burned that bridge.
>>>
>>>>
>>>>>>>>
>>>>>>>>> Note, X may be able to decide on many other inputs that
>>>>>>>>> property correctly, but can not do so for this particular one.
>>>>>>>>>
>>>>>>>>> Note, since the decider was defined to take ANY program as
>>>>>>>>> input, this sort of property becomes undecidable.
>>>>>>>>>
>>>>>>>>
>>>>>>>> H does correctly determine that its input has a pathological
>>>>>>>> relationship to H and specifically rejects its input on this basis.
>>>>>>>
>>>>>>> Only because it restricts its input to a non-turing complete set
>>>>>>> of inputs. Remeber, you have defined that H can not be copied
>>>>>>> into D, for "reasons", which shows that the input set isn't
>>>>>>> Turing Complete.
>>>>>>>
>>>>>>
>>>>>> This limitation is not actually required. The alternative
>>>>>> requires inline_H to have very messy inline assembly language
>>>>>> that forces all function calls to be at an absolute rather than
>>>>>> relative machine address.
>>>>>
>>>>> Nope, the key point is that an actual Decider that accepts inputs
>>>>> that can define copies of itself can't actually recognize when a
>>>>> program calls a copy of itself as a "pathological" call to itself.
>>>>>
>>>>> When I pointed this out to you before, you answer was that it was
>>>>> impossible to create a "copy" of your H.
>>>>>
>>>>> Why does the copy of H need some messy inline assembly when the
>>>>> original one didn't? Why can't we just copy the actual code of H?
>>>>
>>>> Even if I made a single ten page long function that is both D and H
>>>> it still needs to call other functions that are part of the operating
>>>> system otherwise H cannot do output and such.
>>>>
>>>
>>> Remember, Turing Machines don't have "operating Systems", so that
>>> isn't a issue. Yes, in a Turing Complete language, you might have
>>> some "built ins" that act like "instructions" that are simple calls,
>>> to do things like I/O. The key is that without the OS providing that
>>> as a basic function, the "user" code COULD just do that operation.
>>>
>>> A "Halt Decider" isn't such a primitive.
>>>
>>>> Every function call uses relative addressing so a copy of the function
>>>> would call into the middle of garbage. I can override this with very
>>>> cumbersome embedded assembly language. No sense doing that. If people
>>>> can't understand a ten line C function a 600 line function with lots
>>>> of embedded assembly language won't help.
>>>
>>> But a program can know which function are "system" functions that
>>> have fixed location, and don't get relative addressing, so not an issue.
>>>
>>
>> I wrote this operating system and the simulated code must call a
>> function template in its own code in order for the operating system to
>> intercept this call and forward the call to itself.
>
> No, UTM86 isn't really an operating system in the classic sense, since
> itself runs under an operating system. It provide ZERO hardware support
> itself.
>
>
>
>>
>>> Maybe you haven't had to do PIC before (Position Independent Code).
>>
>> Is there a C compiler that generates a COFF file of this?
>
> I haven't look, but I think GCC can generate COFF, and I know it can
> generate PIC. I think you can also convert the normal ELF output to
> COFF. (And what's so special about COFF except that it is what Microsoft
> uses?)
>
>>
>>>>
>>>>>>
>>>>>>>>
>>>>>>>>> This is the basis of Rice's Theorem. Note, your configuration
>>>>>>>>> where Y is made within the address space of X, and must
>>>>>>>>> directly call the deciding X and not able to use another copy
>>>>>>>>> of it
>>>>>>>>
>>>>>>>> It took me the last two days to solve this issue in a better
>>>>>>>> way than the way that took me six months to derive. I also
>>>>>>>> reiterated and simplified my original method.
>>>>>>>>
>>>>>>>> This effort was not actually required because my simpler
>>>>>>>> form of the halting problem instance commonly understood
>>>>>>>> to be a halting problem instance.
>>>>>>>>
>>>>>>>
>>>>>>> But it isn't actually one, so it isn't. You are just lying and
>>>>>>> serving Strawman.
>>>>>
>>>>> Since your H can't take in ALL programs as an input, the partial
>>>>> solution is just a strawman.
>>>>>
>>>>>>>
>>>>>>>> A halting problem instance only requires that an input D do
>>>>>>>> the opposite of whatever Boolean value that any corresponding
>>>>>>>> H could possibly return.
>>>>>>>
>>>>>>> No, a Halting Decider
>>>>>>
>>>>>> I am defining {halting problem instance} not {halt decider}.
>>>>>> By defining {halting problem instance} I prove that H/D is a
>>>>>> {halting problem instance}. Thus no actual need for additional
>>>>>> more convoluted cases that copy their input.
>>>>>
>>>>> So, either your {Halting Problem Instance} uses an ACTUAL {Halt
>>>>> Decider} or it is just a strawman.
>>>>
>>>> H is a termination analyzer.
>>>
>>> So, are you admitting it doesn't meet the requirements of a "Halt
>>> Decider"? (and thus doesn't mean anything to the Halting Theorem)
>>>
>>>>
>>>>> There is nothing in the Halting Theory that says you can't build a
>>>>> decider that decides on SOME cases.
>>>>>>
>>>>>>> needs to CORRECT answer about the HALTING PROPERTY, which is
>>>>>>> about the actual behavior of the machine described by the input.
>>>>>>>
>>>>>>
>>>>>> H is a decidability decider for itself with its input.
>>>>>> Rice's theorem says this is impossible.
>>>>>
>>>>> But the problem is your input isn't from a Turing Complete
>>>>> programming environmenet, so Rice doesn't apply.
>>>>>
>>>>
>>>> Did you know that not every algorithm actually required unlimited
>>>> memory? H need not at all be Turing complete.
>>>
>>> Not talking about unlimited memory. I am talking about being able to
>>> give an arbitary but finite program. You don't seem to understand that.
>>>
>>
>> https://en.wikipedia.org/wiki/Turing_completeness
>> A finite program could require a googolplex^ googolplex
>> more bytes than atoms in the universe.
>
> Yes, in ultra-precise usage, full Turing Completeness is impossible to
> build, but in practical terms, the memory limit can be waived when
> looking at physical machines as that normally doesn't come out to be the
> actual issue.
>
> If an architecture could theoretically be expanded to any arbitrary
> finite amount of memory by upgrading the address space, or allows the
> mounting of additional "external" memory, a thus an unbounded amount of
> memory could theoretically be presented, then such an architecture is
> generally considered "Turing Complete" if it meets the other
> requirements, which you don't seem to understand.
>
> So, the C programming language is strictly Turing Complete, as the
> language itself doesn't provide an upper bound on the memory that the
> program could access (even though any actual implementation will have
> one since the sizeof the variable will be finite.
>
> The x86 assembly language is considered practically Turing Complete, as
> the instruction set is powerful enough, and if the direct memory
> accessible isn't enough for a given problem, we can, in theory, either
> define a new version with wider registers, or extend memory with some
> from of external store that we "page" into parts of the memory.
>
> Your system fails this, as for some reason "H" can't be copied.
>
> Note, a "Proper" decider H, should be given as an input the description
> of a COMPLETE program, which would be an input which has ALL of its code
> (and thus for D, it would include its own copy of H). The H in D needs
> to be an independent instance from the instance of the decider.
>
>>
>>>>
>>>>> Until you show how H can take a truly arbitrary program, including
>>>>> one that has its own copy of your decider, then you haven't met the
>>>>> requirements to try to invoke Rice.
>>>>>
>>>>
>>>> I will never convince you of anything because your primary goal is
>>>> rebuttal.
>>>
>>> No, muy primary goal it TRUTH. When you state a falsehood. I correct
>>> it. You don't seem to have such a goal, as you don't try to point out
>>> what the error is in what I say, you just repeat your ERROR and say
>>> it should be obvious.
>>>
>>
>> If your primary goal is truth you would agree with the true
>> things that I say.
>
> Except you rarely say True things. The issue seeems to be that you
> fundamentally don't understand what is Truth, or what is actually valid
> logic, so you season everything you say with untruth, and just a timy
> bit of untruth makes a statement untrue.
>
>
>>
>>> The only obvious thing is that you don't actually have a way to
>>> really prove what you are saying, since you bottom out at the level
>>> you can discuss things, and below that just needs to be taken a true
>>> without proof, as if you do try to go more definitive the errors
>>> become too obvious to try to hinde.
>>>
>>
>> It is true that H can be slightly adapted such that it recognizes
>> and rejects inputs that do the opposite of whatever their termination
>> analyzer returns and accepts the rest.
>
> Then DO IT. Note, a "slightly adapted" program is no longer the same
> program by computational analysis criterea.
>
>>
>> To the best of my knowledge This <is> a breakthrough that
>> no one else has ever had.
>
> Except you can't show what you claim, so even you don't have it. You may
> show something that matches part of what you claim, but then when you
> apply it to the actual Halting Problem, it falls apart as it was based
> on incorrect definitions.
>
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> Except if embedded_H isn't an exact equivalent to H, that result in
> meaningless.
>

The Peter Linz proof stipulates that embedded_H is a verbatim
identical copy of H.

> If embedded_H IS identical to H, then to be a decicer, it MUST get to
> one of the output states, and if it goes to the top output state, that
> is saying the decider will say the input halts, when it doesn't, and if
> it goes to the bottom output state, it says that the input never halts
> when it does.
>

You keep getting confused between Bill and his identical twin brother
Sam. embedded_H is embedded within Bill and Bill halts. His identical
twin brother Sam cannot possibly reach ⟨Ĥ.qy⟩ of ⟨Ĥ.qn⟩, thus Sam does
not halt even though Bill does halt.

It is incorrect to convict Sam of a crime that eye witnessed saw
Sam do when they were actually seeing Bill do it.

> So, it is wrong in all cases.
>
> Only in your imagination where embedded_H is a "copy" of H, but can
> behave differently, "because of reasons" (unexplained) do you get the
> right answer.
>

It is easy to see that Sam keeps calling embedded_H so that Sam
cannot possibly reach ⟨Ĥ.qy⟩ of ⟨Ĥ.qn⟩. The only way that I can see
that you don't see this is that you do see it and lie.

> So, you need to show the step in the execution of embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
> that differs from the execution of H ⟨Ĥ⟩ ⟨Ĥ⟩ even though they have the
> exact same code, based just on the "context" of the usage, when Turing
> Machine behavior doesn't have such a concept.

The behavior of D simulated by H is different than the behavior of
the directly executed D(D) because these two are out-of-sync by one
invocation. D simulated by H is before H aborts its simulation of D.
The directly executed D(D) is after H has aborted its simulation of D.

It is dead obvious that from the frame-of-reference of H that D does
not halt otherwise H would not have to abort its simulation of D to
prevent its own infinite execution.

>>
>> *Another breakthrough that no one else has ever had* is that when
>> ⟨Ĥ⟩ ⟨Ĥ⟩ is simulated by embedded_H it cannot possibly reach its own
>> simulated ⟨Ĥ.qn⟩ or ⟨Ĥ.qy⟩ in any finite number of simulated steps.
>
> So? The question isn't about a partial simulation done by a decider, but
> about the behavior of the actual machine, and for the "proof program",
> it uses a copy of the actual decider that is claimed to correctly decide
> it.
>
>>
>> *One more that I had 19 years ago, although I did not word it as well*
>> When the halting problem is construed as requiring a correct yes/no
>> answer to a contradictory question it cannot be solved. Any input D
>> defined to do the opposite of whatever Boolean value that its
>> termination analyzer H returns is a contradictory input relative to H.
>>
>
> No, HALTING of ANY SPECIFIC PROGRAM is ALWAYS defined.

Not from the frame-of-reference of some termination analyzer /
input pairs.

*YOU ALREADY ADMITTED (a paraphrase of) THIS*
The question does D halt on its input? is contradictory for every
termination analyzer H on input D where D does the opposite of
whatever Boolean value that H returns.

> The problem you
> run into is you neglect to actually fully defined H, so you can't fully
> define H^/P/D, so you don't have an actual program to decide on.
>

H/D {halting problem instance pairs} are every termination
analyzer H such that input D does the opposite of whatever
Boolean value that H returns.

In this case H can range from simply ignoring its input and
returning either True or False to the most sophisticated
termination analyzer that can possibly exist having encoded
within it the sum total of all human general knowledge about
every subject known to man.

*A limited subset of such a system already agreed*

*ChatGPT*
Therefore, based on the understanding that self-contradictory
questions lack a correct answer and are deemed incorrect, one
could argue that the halting problem's pathological input D can
be categorized as an incorrect question when posed to the halting
decider H.
https://www.liarparadox.org/ChatGPT_HP.pdf

From the frame-of-reference of H (the full context of the question)
input D is merely a contradictory thus incorrect question.
This is true for all of the halting problem instance pairs.

The only counter-argument changes the subject to a different set
of (termination analyzer / input) pairs thus is an example of the
strawman error of reasoning.

> You don't seem to understand that H will do what it does and that is
> fixed by what it is and its program. There is no "Get the Right Answer"
> instruction, so H can't use it.
>

If H is based on deep learning technology then the computation
is not fixed yet can vary from one instance to the the next as
H learns more from practice.

As can be seen a much smarter H understands that input D to
termination analyzer H is simply an incorrect question from
the frame-of-reference of H.

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