On 9/4/22 6:02 PM, Skep Dick wrote:
> On Sunday, 4 September 2022 at 22:46:44 UTC+2, richar...@gmail.com wrote:
>> On 9/4/22 4:33 PM, Skep Dick wrote:
>>> On Sunday, 4 September 2022 at 22:24:14 UTC+2, richar...@gmail.com wrote:
>>>> On 9/4/22 4:01 PM, Skep Dick wrote:
>>>>> On Sunday, 4 September 2022 at 21:52:16 UTC+2, richar...@gmail.com wrote:
>>>>>> On 9/4/22 3:30 PM, olcott wrote:
>>>>>>> On 9/4/2022 2:21 PM, Richard Damon wrote:
>>>>>>>> On 9/4/22 3:16 PM, olcott wrote:
>>>>>>>>> On 9/4/2022 2:04 PM, Richard Damon wrote:
>>>>>>>>>> On 9/4/22 2:35 PM, olcott wrote:
>>>>>>>>>>> On 9/4/2022 1:07 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/4/22 1:50 PM, olcott wrote:
>>>>>>>>>>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/4/22 12:33 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/3/2022 12:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/3/22 1:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/3/22 12:56 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:03:48 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:50 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 1:43:43 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:00 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:54:54
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you won't go by the oficial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions, your H just isn't a Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the official definitions are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then at least one of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> them must be rejected as incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you are wrong here. The official
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory, in that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible to build anything which meets
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition. This has been proved.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not the way truth works mate. If
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the official definitions are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then I have also had new
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> insight on that another
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aspect of computer science is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you are not disputing that official
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input is guaranteed to derive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input to prevent the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of this input is merely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another way of saying the the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by this SHD would never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When computer science textbooks say that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that a halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must report on is the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine represented by this input and this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior is not the same as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct and complete simulation of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input then the computer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> science textbooks are wrong because they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject the definition of a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (simulator).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I was hoping for more of a yes-or-no type answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When I provide a complete explanation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning behind the answer all those not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding these things cannot simply
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> baselessly disagree. All disagreement is thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required to have a basis. This way people are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not lead astray by a bunch of baseless
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagreement, they see that the disagreement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has no basis and reject it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning, starting from ACCEPTED definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just make wild claims based on your own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding of the words.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the words, no one can help you with your logic.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, Most of the things you are talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HAVE well defined meanings, so you either need
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to use that meaning, or you really need to give
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your idea a new name (maybe basd on the common
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> name with a modifier).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same as the accepted definition, you can call it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PO-Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of course the problem with this is it makes it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clear that you are talking about the PO-Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, with a PO-Halting Decider, so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter example doesn't affect the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, so it is clear you haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven what you claim to have proven.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that the definition is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory. You're not disputing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that proof?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You haven't actually given a proof, since you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are clearly using altered definition that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aren't providing.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You reject the notion of a UTM so you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> starting with an incorrect basis.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM(P,d) by DEFINITION gives the exact same result
>>>>>>>>>>>>>>>>>>>>>>>>>>>> as P(d).
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> When you get a glass of water and dump it on the
>>>>>>>>>>>>>>>>>>>>>>>>>>> floor you cannot truthfully deny that the floor is
>>>>>>>>>>>>>>>>>>>>>>>>>>> wet.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> And I haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correct and complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>> input by H(P,P) would have different behavior than
>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of P(P) this cannot simply be
>>>>>>>>>>>>>>>>>>>>>>>>>>> ignored.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct and complete simulation of the input
>>>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The fact that the simulation by H(P,P) of its input
>>>>>>>>>>>>>>>>>>>>>>>>> never stops running unless H aborts the simulation of
>>>>>>>>>>>>>>>>>>>>>>>>> this input is merely another way of saying that the
>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of this input by H
>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You have bad logic there.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is a tautology:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>>>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of
>>>>>>>>>>>>>>>>>>>>>>> its input would never stop running unless H0 aborts the
>>>>>>>>>>>>>>>>>>>>>>> simulation of this input is merely another way of
>>>>>>>>>>>>>>>>>>>>>>> saying that the correct and complete simulation of this
>>>>>>>>>>>>>>>>>>>>>>> input by H0 never halts.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Strawman.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Fallacy of Proof by Example.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It is only a fallacy by proof of example when a single
>>>>>>>>>>>>>>>>>>>>> example is not representative of the entire class of all
>>>>>>>>>>>>>>>>>>>>> such examples.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Which it isn't, so FAIL.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You are confusing existential quantification with
>>>>>>>>>>>>>>>>>>>>> universal quantification.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No you are, since you are claiming the rule works for ALL
>>>>>>>>>>>>>>>>>>>> inputs (or at least P, which isn't the input you showed it
>>>>>>>>>>>>>>>>>>>> worked for).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> ∀ simulating halt decider H
>>>>>>>>>>>>>>>>>>>>> ∀ machine description P
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You don't seem to know what those words mean.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The fact that the correct simulation of any input P to
>>>>>>>>>>>>>>>>>>>>> any simulating halt decider (SHD) H would never stop
>>>>>>>>>>>>>>>>>>>>> running unless this simulation was aborted by this SHD is
>>>>>>>>>>>>>>>>>>>>> merely another way of saying that the correct and
>>>>>>>>>>>>>>>>>>>>> complete simulation of this input by this SHD would never
>>>>>>>>>>>>>>>>>>>>> stop running.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope, not when the input depends on the behavior of the
>>>>>>>>>>>>>>>>>>>> decider in the way you are doing it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> P was intentionally defined to depend on the behavior of
>>>>>>>>>>>>>>>>>>> its decider *NITWIT*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, but your "example" didn't, and this dependency is the
>>>>>>>>>>>>>>>>>> case that breaks your "proof" and definitions.
>>>>>>>>>>>>>>>>> The correct simulation of the input by H(P,P) is the
>>>>>>>>>>>>>>>>> simulation of this input at the same point in the execution
>>>>>>>>>>>>>>>>> trace where H is invoked.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (2 + 3) * 5 != 2 + (3 * 5) // order matters.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
>>>>>>>>>>>>>>>> irrespective of "where" that simulation is done, at least if H
>>>>>>>>>>>>>>>> is a computation, and if it isn't it can't be a decider.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Although H must be a computation all sequences of
>>>>>>>>>>>>>>> configurations that do not halt are not computations**. The
>>>>>>>>>>>>>>> behavior of H is the same no matter where it is invoked.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time,
>>>>>>>>>>>>>> by the H you claim to be correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The behavior of P need not be (and indeed is not) the same.
>>>>>>>>>>>>>>> When P is invoked from main its behavior depends on the return
>>>>>>>>>>>>>>> value of H. When P is correctly simulated by H the return value
>>>>>>>>>>>>>>> from H is unreachable from every simulated P. This conclusively
>>>>>>>>>>>>>>> proves that the execution of P from main() and the correct
>>>>>>>>>>>>>>> simulation of P by H are not computationally equivalent.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> All of your rebuttals are simply false assumptions and nothing more.
>>>>>>>>>>>>> I claim that
>>>>>>>>>>>>>
>>>>>>>>>>>>> "When P is correctly simulated by H the return value from
>>>>>>>>>>>>> H is unreachable from every simulated P."
>>>>>>>>>>>>
>>>>>>>>>>>> SO? There is no requirement that H is able to see the resuts of
>>>>>>>>>>>> the call inside the input it is simulating.
>>>>>>>>>>>>
>>>>>>>>>>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the
>>>>>>>>>>>> behavior of P(P) or Simulate(P,P). The fact that H can't determine
>>>>>>>>>>>> that is H's fault.
>>>>>>>>>>>>
>>>>>>>>>>>> Do you disagree that the CORRECT answer is based on the ACTUAL
>>>>>>>>>>>> BEHAVIOR of the ACUTAL INPUT?
>>>>>>>>>>>>
>>>>>>>>>>>> H's inability to determine that is WHY it gets the wrong answer,
>>>>>>>>>>>> not an excuse for it to do so.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When you claim that I am incorrect it is merely an empty
>>>>>>>>>>>>> assertion utterly bereft of supporting reasoning.
>>>>>>>>>>>>
>>>>>>>>>>>> No, you LITERALLY are making an empty assertion, as you are
>>>>>>>>>>>> asserting something that never occurs.
>>>>>>>>>>>>
>>>>>>>>>>>> There is NO H that does a complete and correct simulation and
>>>>>>>>>>>> returns an answer. We can even argue that it doesn't do a correct
>>>>>>>>>>>> simulation since the last step of the simulation has an error as
>>>>>>>>>>>> it presumes the wrong behavior of the call to H that it encounter
>>>>>>>>>>>> (you can debate if this is an incorrect simulation or just unsound
>>>>>>>>>>>> logic).
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> A simulating halt decider continues to simulate its input until
>>>>>>>>>>>>> it correctly matches a correct infinite behavior pattern.
>>>>>>>>>>>>
>>>>>>>>>>>> Then why does you H abort too soon, as shown by the fact that the
>>>>>>>>>>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
>>>>>>>>>>>>
>>>>>>>>>>>> Just says that your H doesn't even meet your own definition.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>> {
>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>> return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> In order for me to actually be wrong you must be able to show
>>>>>>>>>>>>> that some simulating halt decider Hx could be defined such that
>>>>>>>>>>>>> its correct simulation of its input Px reaches the final state of
>>>>>>>>>>>>> Px in a finite number of steps.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope. H(P,P) is wrong
>>>>>>>>>>>
>>>>>>>>>>> ..then a mistake could be shown, if no mistake can be shown then it
>>>>>>>>>>> is not wrong.
>>>>>>>>>>
>>>>>>>>>> And it has been.
>>>>>>>>>>
>>>>>>>>>> Even YOU hav published the correct and complete simuliaton of the
>>>>>>>>>> input to H(P,P) being the trace of P(P) and Simulate(P,P)
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I contend that that no simulating halt decider Hx can be defined
>>>>>>>>>>> such that its correctly simulated input Px could reach the final
>>>>>>>>>>> state of this simulated Px in any finite number of steps.
>>>>>>>>>>
>>>>>>>>>> So, that isn't the question.
>>>>>>>>>
>>>>>>>>> *I STIPULATE FOR THIS THREAD THAT IS THE QUESTION*
>>>>>>>>>
>>>>>>>>> Any rebuttal must show all of the steps of exactly how the input to
>>>>>>>>> Hx(Px,Px) correctly simulated by Hx reaches the final state of Px in
>>>>>>>>> a finite number of steps.
>>>>>>>>>
>>>>>>>>> ALTERNATIVELY YOU COULD SIMPLY ADMIT THE TRUTH
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> You don't get to stipulate the test,
>>>>>>>
>>>>>>> In other words you know that my statement is correct and you are too
>>>>>>> dishonest to admit it.
>>>>>>>
>>>>>> Nope, shows you don't understand about requirements.
>>>>> Ultimately, you are a shit for brains fucking idiot because you have admitted unsatisfiable requirements.
>>>>>
>>>>> It is precisely because the requirements are unsatisfiable they amount to nothing other than The bottom/uninhabited type. Falsity.
>>>>>
>>>>> https://en.wikipedia.org/wiki/Bottom_type
>>>> Nope, given an H, the answer is defined , and computabe if we know that
>>>> H does return an answer.
>>> How? There is no H for the pathological P.
>>> Furthermore because the dependencies of P are unsatisfiable (P requires H) there is also no P.
>> Because Olcott has defined what he calls H.
>>
>> Yes, H doesn't meet the requirements, but he claims it does and we are
>> showing that H is incorrect.
> But why are you so concerned with showing that H is incorrect; while being so unconcerned by the fact that the requirements are incorrect?
>
> The requirements amount to falsify!

On Monday, 5 September 2022 at 00:50:31 UTC+2, richar...@gmail.com wrote:
> And proves that his links don't actually mean the thing he is claiming
> they define.

I am calling you out in your bullshit. Again.

What do you mean by “meaning”?
Define “define”.

> As I said, your logic system is worthless, because it doesn't follow its
> on defintions and has no base to stand on.
Perhaps you need a wee bit exposure to some Philoophy and the rule-following paradox?

“ no course of action could be determined by a rule, because any course of action can be made out to accord with the rule.”

For the question “Does action X accord with the rules?” is itself a decision problem.

On 9/4/22 6:51 PM, Skep Dick wrote:
> On Monday, 5 September 2022 at 00:28:53 UTC+2, Ben Bacarisse wrote:
>> Richard Damon <Ric...@Damon-Family.org> writes:
>>
>>> On 9/4/22 4:26 PM, Skep Dick wrote:
>>>> On Sunday, 4 September 2022 at 22:11:41 UTC+2, richar...@gmail.com wrote:
>>>>> On 9/4/22 3:52 PM, Skep Dick wrote:
>>>>>> On Sunday, 4 September 2022 at 18:44:17 UTC+2, richar...@gmail.com wrote:
>>>>>>> On 9/4/22 8:15 AM, Skep Dick wrote:
>>>>>>>> On Sunday, 4 September 2022 at 12:56:47 UTC+2, richar...@gmail.com wrote:
>>>>>>>>> On 9/4/22 3:08 AM, Skep Dick wrote:
>>
>>>>>>>>>> You shit for brains fucking idiot! That is not true.
>>>>>>>>>>
>>>>>>>>>> https://en.wikipedia.org/wiki/Noncommutative_ring
>>>>>>>>>>
>>>>>>>>> Except both are 5 * 5 so the commutative property isn't needed.
>>>>>>>>>
>>>>>>>>> You are just being a DICK.
>>>>>>>> You shit for brains fucking idiot. It is axiomatic THAT x.y != y.x (1)
>>>>>>>
>>>>>>> You axioms seem to be wrong.
>>>>>>>
>>>>>>> Non commutative rings say that x.y MIGHT NOT EQUAL to y.x, not that they
>>>>>>> ARE different.
>>>>>> So they might be equal, or they might be NOT equal!
>>>>>>
>>>>>> Provide a continuous function deciding one of the other.
>>>>>>
>>>>>> Provide a proof.
>>>>> I don't need to.
>>>>>>
>>>>>>> Your logic system is incorrect.
>>>>>> No, it isn’t. It only rejects all of your axioms.
>>>>> No, since YOU system has an AXIOM that says x.y != y.x for ALL x, y
>>>>> (since you didn't limit the domain)
>>>>>
>>>>> The simple counter example of let y = x, the we have by your axiom that
>>>>> x.x != x.x
>>>>>
>>>>> WHich says that . isn't a consistent operator, and thus is a contradition.
>>>>
>>>> What are you on about, idiot?
>>>> That is precisely how you prove negation!
>>>> This is a system in which x=x is not a theorem.
>>>> This is a system in which not(x=x) is a theorem!
>>>
>>> So a system of foolishness.
>> Well, there's that, yes. But don't forget the sheer mendacity of
>> calling you out by posting a wikipedia link -- a link that describes the
>> /usual/ notions of non-commutative rings -- and then later pretending to
>> be using a logic without even conventional equality.
>
> You know, I tried to give you the benefit of the doubt here…
> I went to Google and tried to search for..
> * “conventional equality”
> * “conventional equality” Mathematics
> * “conventional equality” Logic
>
> I couldn’t find anything relevant 🤷‍♂️
>
> Are you sure you are using standard terminology?

Yes, but then conventional terminolgy does vary some based on what rule
set you put yourself in. Most people don't need to use that prefix (so
Google won't find it) because it is assumed.

Learning via Google isn't very relaible.

On 9/4/22 6:58 PM, Skep Dick wrote:
> On Monday, 5 September 2022 at 00:50:31 UTC+2, richar...@gmail.com wrote:
>> And proves that his links don't actually mean the thing he is claiming
>> they define.
>
> I am calling you out in your bullshit. Again.
>
> What do you mean by “meaning”?
> Define “define”.

First Principles, so out of your understanding.

>
>> As I said, your logic system is worthless, because it doesn't follow its
>> on defintions and has no base to stand on.
> Perhaps you need a wee bit exposure to some Philoophy and the rule-following paradox?
>
> “ no course of action could be determined by a rule, because any course of action can be made out to accord with the rule.”
>
> For the question “Does action X accord with the rules?” is itself a decision problem.
>
>

And you do know that the paradox has answers? Many of course require you
to accept that words DO have meaning, so maybe you are out of luck, but
those of use willing to accept definitions can just live with them

On Monday, 5 September 2022 at 00:58:13 UTC+2, richar...@gmail.com wrote:
> On 9/4/22 6:02 PM, Skep Dick wrote:
> > On Sunday, 4 September 2022 at 22:46:44 UTC+2, richar...@gmail.com wrote:
> >> On 9/4/22 4:33 PM, Skep Dick wrote:
> >>> On Sunday, 4 September 2022 at 22:24:14 UTC+2, richar...@gmail.com wrote:
> >>>> On 9/4/22 4:01 PM, Skep Dick wrote:
> >>>>> On Sunday, 4 September 2022 at 21:52:16 UTC+2, richar...@gmail.com wrote:
> >>>>>> On 9/4/22 3:30 PM, olcott wrote:
> >>>>>>> On 9/4/2022 2:21 PM, Richard Damon wrote:
> >>>>>>>> On 9/4/22 3:16 PM, olcott wrote:
> >>>>>>>>> On 9/4/2022 2:04 PM, Richard Damon wrote:
> >>>>>>>>>> On 9/4/22 2:35 PM, olcott wrote:
> >>>>>>>>>>> On 9/4/2022 1:07 PM, Richard Damon wrote:
> >>>>>>>>>>>> On 9/4/22 1:50 PM, olcott wrote:
> >>>>>>>>>>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 9/4/22 12:33 PM, olcott wrote:
> >>>>>>>>>>>>>>> On 9/3/2022 12:24 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>> On 9/3/22 1:18 PM, olcott wrote:
> >>>>>>>>>>>>>>>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>> On 9/3/22 12:56 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>> On 9/3/22 12:32 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:03:48 PM
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:50 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 1:43:43 PM
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:00 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:54:54
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you won't go by the oficial
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions, your H just isn't a Halt
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the official definitions are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then at least one of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> them must be rejected as incorrect.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you are wrong here. The official
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a halt decider is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory, in that it is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible to build anything which meets
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition. This has been proved..
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not the way truth works mate. If
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the official definitions are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then I have also had new
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> insight on that another
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aspect of computer science is incorrect.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you are not disputing that official
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a halt decider is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of an
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input is guaranteed to derive
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior of this input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort the simulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input to prevent the infinite
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of this input is merely
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another way of saying the the correct and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by this SHD would never stop running.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When computer science textbooks say that the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that a halt
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must report on is the behavior of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine represented by this input and this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior is not the same as
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct and complete simulation of this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input then the computer
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> science textbooks are wrong because they
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject the definition of a UTM.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (simulator).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I was hoping for more of a yes-or-no type answer.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When I provide a complete explanation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning behind the answer all those not
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding these things cannot simply
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> baselessly disagree. All disagreement is thus
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required to have a basis. This way people are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not lead astray by a bunch of baseless
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagreement, they see that the disagreement
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has no basis and reject it.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning, starting from ACCEPTED definition.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just make wild claims based on your own
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding of the words.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the words, no one can help you with your logic.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, Most of the things you are talking about
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HAVE well defined meanings, so you either need
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to use that meaning, or you really need to give
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your idea a new name (maybe basd on the common
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> name with a modifier).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same as the accepted definition, you can call it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PO-Halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of course the problem with this is it makes it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clear that you are talking about the PO-Halting
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, with a PO-Halting Decider, so you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter example doesn't affect the actual
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, so it is clear you haven't
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven what you claim to have proven.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that the definition is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory. You're not disputing
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that proof?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You haven't actually given a proof, since you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are clearly using altered definition that you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aren't providing.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> You reject the notion of a UTM so you are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> starting with an incorrect basis.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM(P,d) by DEFINITION gives the exact same result
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> as P(d).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> When you get a glass of water and dump it on the
> >>>>>>>>>>>>>>>>>>>>>>>>>>> floor you cannot truthfully deny that the floor is
> >>>>>>>>>>>>>>>>>>>>>>>>>>> wet.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> And I haven't
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> When the correct and complete simulation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>> input by H(P,P) would have different behavior than
> >>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of P(P) this cannot simply be
> >>>>>>>>>>>>>>>>>>>>>>>>>>> ignored.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> And the correct and complete simulation of the input
> >>>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) Halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> The fact that the simulation by H(P,P) of its input
> >>>>>>>>>>>>>>>>>>>>>>>>> never stops running unless H aborts the simulation of
> >>>>>>>>>>>>>>>>>>>>>>>>> this input is merely another way of saying that the
> >>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of this input by H
> >>>>>>>>>>>>>>>>>>>>>>>>> never halts.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> You have bad logic there.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> It is a tautology:
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
> >>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> >>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
> >>>>>>>>>>>>>>>>>>>>>>> [00001102](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
> >>>>>>>>>>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>> [00001108](01) c3 ret
> >>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of
> >>>>>>>>>>>>>>>>>>>>>>> its input would never stop running unless H0 aborts the
> >>>>>>>>>>>>>>>>>>>>>>> simulation of this input is merely another way of
> >>>>>>>>>>>>>>>>>>>>>>> saying that the correct and complete simulation of this
> >>>>>>>>>>>>>>>>>>>>>>> input by H0 never halts.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Strawman.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Fallacy of Proof by Example.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> It is only a fallacy by proof of example when a single
> >>>>>>>>>>>>>>>>>>>>> example is not representative of the entire class of all
> >>>>>>>>>>>>>>>>>>>>> such examples.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Which it isn't, so FAIL.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> You are confusing existential quantification with
> >>>>>>>>>>>>>>>>>>>>> universal quantification.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> No you are, since you are claiming the rule works for ALL
> >>>>>>>>>>>>>>>>>>>> inputs (or at least P, which isn't the input you showed it
> >>>>>>>>>>>>>>>>>>>> worked for).
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> ∀ simulating halt decider H
> >>>>>>>>>>>>>>>>>>>>> ∀ machine description P
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> You don't seem to know what those words mean.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> The fact that the correct simulation of any input P to
> >>>>>>>>>>>>>>>>>>>>> any simulating halt decider (SHD) H would never stop
> >>>>>>>>>>>>>>>>>>>>> running unless this simulation was aborted by this SHD is
> >>>>>>>>>>>>>>>>>>>>> merely another way of saying that the correct and
> >>>>>>>>>>>>>>>>>>>>> complete simulation of this input by this SHD would never
> >>>>>>>>>>>>>>>>>>>>> stop running.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Nope, not when the input depends on the behavior of the
> >>>>>>>>>>>>>>>>>>>> decider in the way you are doing it.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> P was intentionally defined to depend on the behavior of
> >>>>>>>>>>>>>>>>>>> its decider *NITWIT*
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Right, but your "example" didn't, and this dependency is the
> >>>>>>>>>>>>>>>>>> case that breaks your "proof" and definitions.
> >>>>>>>>>>>>>>>>> The correct simulation of the input by H(P,P) is the
> >>>>>>>>>>>>>>>>> simulation of this input at the same point in the execution
> >>>>>>>>>>>>>>>>> trace where H is invoked.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> (2 + 3) * 5 != 2 + (3 * 5) // order matters.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
> >>>>>>>>>>>>>>>> irrespective of "where" that simulation is done, at least if H
> >>>>>>>>>>>>>>>> is a computation, and if it isn't it can't be a decider.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Although H must be a computation all sequences of
> >>>>>>>>>>>>>>> configurations that do not halt are not computations**. The
> >>>>>>>>>>>>>>> behavior of H is the same no matter where it is invoked.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time,
> >>>>>>>>>>>>>> by the H you claim to be correct.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> The behavior of P need not be (and indeed is not) the same.
> >>>>>>>>>>>>>>> When P is invoked from main its behavior depends on the return
> >>>>>>>>>>>>>>> value of H. When P is correctly simulated by H the return value
> >>>>>>>>>>>>>>> from H is unreachable from every simulated P. This conclusively
> >>>>>>>>>>>>>>> proves that the execution of P from main() and the correct
> >>>>>>>>>>>>>>> simulation of P by H are not computationally equivalent.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> All of your rebuttals are simply false assumptions and nothing more.
> >>>>>>>>>>>>> I claim that
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> "When P is correctly simulated by H the return value from
> >>>>>>>>>>>>> H is unreachable from every simulated P."
> >>>>>>>>>>>>
> >>>>>>>>>>>> SO? There is no requirement that H is able to see the resuts of
> >>>>>>>>>>>> the call inside the input it is simulating.
> >>>>>>>>>>>>
> >>>>>>>>>>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the
> >>>>>>>>>>>> behavior of P(P) or Simulate(P,P). The fact that H can't determine
> >>>>>>>>>>>> that is H's fault.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Do you disagree that the CORRECT answer is based on the ACTUAL
> >>>>>>>>>>>> BEHAVIOR of the ACUTAL INPUT?
> >>>>>>>>>>>>
> >>>>>>>>>>>> H's inability to determine that is WHY it gets the wrong answer,
> >>>>>>>>>>>> not an excuse for it to do so.
> >>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> When you claim that I am incorrect it is merely an empty
> >>>>>>>>>>>>> assertion utterly bereft of supporting reasoning.
> >>>>>>>>>>>>
> >>>>>>>>>>>> No, you LITERALLY are making an empty assertion, as you are
> >>>>>>>>>>>> asserting something that never occurs.
> >>>>>>>>>>>>
> >>>>>>>>>>>> There is NO H that does a complete and correct simulation and
> >>>>>>>>>>>> returns an answer. We can even argue that it doesn't do a correct
> >>>>>>>>>>>> simulation since the last step of the simulation has an error as
> >>>>>>>>>>>> it presumes the wrong behavior of the call to H that it encounter
> >>>>>>>>>>>> (you can debate if this is an incorrect simulation or just unsound
> >>>>>>>>>>>> logic).
> >>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> A simulating halt decider continues to simulate its input until
> >>>>>>>>>>>>> it correctly matches a correct infinite behavior pattern.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Then why does you H abort too soon, as shown by the fact that the
> >>>>>>>>>>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
> >>>>>>>>>>>>
> >>>>>>>>>>>> Just says that your H doesn't even meet your own definition.
> >>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>> {
> >>>>>>>>>>>>> int Halt_Status = Hx(x, x);
> >>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>> return;
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> int main()
> >>>>>>>>>>>>> {
> >>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> In order for me to actually be wrong you must be able to show
> >>>>>>>>>>>>> that some simulating halt decider Hx could be defined such that
> >>>>>>>>>>>>> its correct simulation of its input Px reaches the final state of
> >>>>>>>>>>>>> Px in a finite number of steps.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> Nope. H(P,P) is wrong
> >>>>>>>>>>>
> >>>>>>>>>>> ..then a mistake could be shown, if no mistake can be shown then it
> >>>>>>>>>>> is not wrong.
> >>>>>>>>>>
> >>>>>>>>>> And it has been.
> >>>>>>>>>>
> >>>>>>>>>> Even YOU hav published the correct and complete simuliaton of the
> >>>>>>>>>> input to H(P,P) being the trace of P(P) and Simulate(P,P)
> >>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> I contend that that no simulating halt decider Hx can be defined
> >>>>>>>>>>> such that its correctly simulated input Px could reach the final
> >>>>>>>>>>> state of this simulated Px in any finite number of steps.
> >>>>>>>>>>
> >>>>>>>>>> So, that isn't the question.
> >>>>>>>>>
> >>>>>>>>> *I STIPULATE FOR THIS THREAD THAT IS THE QUESTION*
> >>>>>>>>>
> >>>>>>>>> Any rebuttal must show all of the steps of exactly how the input to
> >>>>>>>>> Hx(Px,Px) correctly simulated by Hx reaches the final state of Px in
> >>>>>>>>> a finite number of steps.
> >>>>>>>>>
> >>>>>>>>> ALTERNATIVELY YOU COULD SIMPLY ADMIT THE TRUTH
> >>>>>>>>>
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> You don't get to stipulate the test,
> >>>>>>>
> >>>>>>> In other words you know that my statement is correct and you are too
> >>>>>>> dishonest to admit it.
> >>>>>>>
> >>>>>> Nope, shows you don't understand about requirements.
> >>>>> Ultimately, you are a shit for brains fucking idiot because you have admitted unsatisfiable requirements.
> >>>>>
> >>>>> It is precisely because the requirements are unsatisfiable they amount to nothing other than The bottom/uninhabited type. Falsity.
> >>>>>
> >>>>> https://en.wikipedia.org/wiki/Bottom_type
> >>>> Nope, given an H, the answer is defined , and computabe if we know that
> >>>> H does return an answer.
> >>> How? There is no H for the pathological P.
> >>> Furthermore because the dependencies of P are unsatisfiable (P requires H) there is also no P.
> >> Because Olcott has defined what he calls H.
> >>
> >> Yes, H doesn't meet the requirements, but he claims it does and we are
> >> showing that H is incorrect.
> > But why are you so concerned with showing that H is incorrect; while being so unconcerned by the fact that the requirements are incorrect?
> >
> > The requirements amount to falsify!
> The requirements are correct, BY DEFINITION, they require what they require.
But the requirements require you to violate the principle you cherish so dearly!

On Monday, 5 September 2022 at 01:19:56 UTC+2, richar...@gmail.com wrote:
> On 9/4/22 6:58 PM, Skep Dick wrote:
> > On Monday, 5 September 2022 at 00:50:31 UTC+2, richar...@gmail.com wrote:
> >> And proves that his links don't actually mean the thing he is claiming
> >> they define.
> >
> > I am calling you out in your bullshit. Again.
> >
> > What do you mean by “meaning”?
> > Define “define”.
> First Principles, so out of your understanding.
Those are questions of first principles, you shit for brains fucking idiot!

From first principles: explain what you mean by “meaning”.
From first principles: define “define”

> >
> And you do know that the paradox has answers? Many of course require you
> to accept that words DO have meaning
OBVIOUSLY I accept that!

That is WHY I am asking you to explain what you mean by “meaning” from first principles!

> so maybe you are out of luck, but
> those of use willing to accept definitions can just live with them
Fine! Accept whatever definitions you want to accept, but can you at least tell us which definition of “definition” you have accepted?

On 9/4/22 7:35 PM, Skep Dick wrote:
> On Monday, 5 September 2022 at 00:58:13 UTC+2, richar...@gmail.com wrote:
>> On 9/4/22 6:02 PM, Skep Dick wrote:
>>> On Sunday, 4 September 2022 at 22:46:44 UTC+2, richar...@gmail.com wrote:
>>>> On 9/4/22 4:33 PM, Skep Dick wrote:
>>>>> On Sunday, 4 September 2022 at 22:24:14 UTC+2, richar...@gmail.com wrote:
>>>>>> On 9/4/22 4:01 PM, Skep Dick wrote:
>>>>>>> On Sunday, 4 September 2022 at 21:52:16 UTC+2, richar...@gmail.com wrote:
>>>>>>>> On 9/4/22 3:30 PM, olcott wrote:
>>>>>>>>> On 9/4/2022 2:21 PM, Richard Damon wrote:
>>>>>>>>>> On 9/4/22 3:16 PM, olcott wrote:
>>>>>>>>>>> On 9/4/2022 2:04 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/4/22 2:35 PM, olcott wrote:
>>>>>>>>>>>>> On 9/4/2022 1:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/4/22 1:50 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/4/22 12:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/3/2022 12:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/3/22 1:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:56 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:03:48 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:50 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 1:43:43 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:00 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:54:54
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you won't go by the oficial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions, your H just isn't a Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the official definitions are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then at least one of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> them must be rejected as incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you are wrong here. The official
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory, in that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible to build anything which meets
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition. This has been proved.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not the way truth works mate. If
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the official definitions are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then I have also had new
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> insight on that another
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aspect of computer science is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you are not disputing that official
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input is guaranteed to derive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input to prevent the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of this input is merely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another way of saying the the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by this SHD would never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When computer science textbooks say that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that a halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must report on is the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine represented by this input and this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior is not the same as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct and complete simulation of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input then the computer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> science textbooks are wrong because they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject the definition of a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (simulator).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I was hoping for more of a yes-or-no type answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When I provide a complete explanation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning behind the answer all those not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding these things cannot simply
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> baselessly disagree. All disagreement is thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required to have a basis. This way people are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not lead astray by a bunch of baseless
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagreement, they see that the disagreement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has no basis and reject it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning, starting from ACCEPTED definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just make wild claims based on your own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding of the words.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the words, no one can help you with your logic.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, Most of the things you are talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HAVE well defined meanings, so you either need
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to use that meaning, or you really need to give
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your idea a new name (maybe basd on the common
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> name with a modifier).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same as the accepted definition, you can call it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PO-Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of course the problem with this is it makes it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clear that you are talking about the PO-Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, with a PO-Halting Decider, so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter example doesn't affect the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, so it is clear you haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven what you claim to have proven.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that the definition is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory. You're not disputing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that proof?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You haven't actually given a proof, since you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are clearly using altered definition that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aren't providing.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You reject the notion of a UTM so you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> starting with an incorrect basis.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM(P,d) by DEFINITION gives the exact same result
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as P(d).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When you get a glass of water and dump it on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> floor you cannot truthfully deny that the floor is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wet.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> And I haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correct and complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by H(P,P) would have different behavior than
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of P(P) this cannot simply be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ignored.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct and complete simulation of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that the simulation by H(P,P) of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running unless H aborts the simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>> this input is merely another way of saying that the
>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of this input by H
>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You have bad logic there.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> It is a tautology:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>>>>>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of
>>>>>>>>>>>>>>>>>>>>>>>>> its input would never stop running unless H0 aborts the
>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input is merely another way of
>>>>>>>>>>>>>>>>>>>>>>>>> saying that the correct and complete simulation of this
>>>>>>>>>>>>>>>>>>>>>>>>> input by H0 never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Strawman.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Fallacy of Proof by Example.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is only a fallacy by proof of example when a single
>>>>>>>>>>>>>>>>>>>>>>> example is not representative of the entire class of all
>>>>>>>>>>>>>>>>>>>>>>> such examples.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Which it isn't, so FAIL.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You are confusing existential quantification with
>>>>>>>>>>>>>>>>>>>>>>> universal quantification.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No you are, since you are claiming the rule works for ALL
>>>>>>>>>>>>>>>>>>>>>> inputs (or at least P, which isn't the input you showed it
>>>>>>>>>>>>>>>>>>>>>> worked for).
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> ∀ simulating halt decider H
>>>>>>>>>>>>>>>>>>>>>>> ∀ machine description P
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You don't seem to know what those words mean.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The fact that the correct simulation of any input P to
>>>>>>>>>>>>>>>>>>>>>>> any simulating halt decider (SHD) H would never stop
>>>>>>>>>>>>>>>>>>>>>>> running unless this simulation was aborted by this SHD is
>>>>>>>>>>>>>>>>>>>>>>> merely another way of saying that the correct and
>>>>>>>>>>>>>>>>>>>>>>> complete simulation of this input by this SHD would never
>>>>>>>>>>>>>>>>>>>>>>> stop running.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Nope, not when the input depends on the behavior of the
>>>>>>>>>>>>>>>>>>>>>> decider in the way you are doing it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> P was intentionally defined to depend on the behavior of
>>>>>>>>>>>>>>>>>>>>> its decider *NITWIT*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Right, but your "example" didn't, and this dependency is the
>>>>>>>>>>>>>>>>>>>> case that breaks your "proof" and definitions.
>>>>>>>>>>>>>>>>>>> The correct simulation of the input by H(P,P) is the
>>>>>>>>>>>>>>>>>>> simulation of this input at the same point in the execution
>>>>>>>>>>>>>>>>>>> trace where H is invoked.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (2 + 3) * 5 != 2 + (3 * 5) // order matters.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
>>>>>>>>>>>>>>>>>> irrespective of "where" that simulation is done, at least if H
>>>>>>>>>>>>>>>>>> is a computation, and if it isn't it can't be a decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Although H must be a computation all sequences of
>>>>>>>>>>>>>>>>> configurations that do not halt are not computations**. The
>>>>>>>>>>>>>>>>> behavior of H is the same no matter where it is invoked.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time,
>>>>>>>>>>>>>>>> by the H you claim to be correct.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The behavior of P need not be (and indeed is not) the same.
>>>>>>>>>>>>>>>>> When P is invoked from main its behavior depends on the return
>>>>>>>>>>>>>>>>> value of H. When P is correctly simulated by H the return value
>>>>>>>>>>>>>>>>> from H is unreachable from every simulated P. This conclusively
>>>>>>>>>>>>>>>>> proves that the execution of P from main() and the correct
>>>>>>>>>>>>>>>>> simulation of P by H are not computationally equivalent.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> All of your rebuttals are simply false assumptions and nothing more.
>>>>>>>>>>>>>>> I claim that
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> "When P is correctly simulated by H the return value from
>>>>>>>>>>>>>>> H is unreachable from every simulated P."
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> SO? There is no requirement that H is able to see the resuts of
>>>>>>>>>>>>>> the call inside the input it is simulating.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the
>>>>>>>>>>>>>> behavior of P(P) or Simulate(P,P). The fact that H can't determine
>>>>>>>>>>>>>> that is H's fault.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Do you disagree that the CORRECT answer is based on the ACTUAL
>>>>>>>>>>>>>> BEHAVIOR of the ACUTAL INPUT?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H's inability to determine that is WHY it gets the wrong answer,
>>>>>>>>>>>>>> not an excuse for it to do so.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When you claim that I am incorrect it is merely an empty
>>>>>>>>>>>>>>> assertion utterly bereft of supporting reasoning.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, you LITERALLY are making an empty assertion, as you are
>>>>>>>>>>>>>> asserting something that never occurs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> There is NO H that does a complete and correct simulation and
>>>>>>>>>>>>>> returns an answer. We can even argue that it doesn't do a correct
>>>>>>>>>>>>>> simulation since the last step of the simulation has an error as
>>>>>>>>>>>>>> it presumes the wrong behavior of the call to H that it encounter
>>>>>>>>>>>>>> (you can debate if this is an incorrect simulation or just unsound
>>>>>>>>>>>>>> logic).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A simulating halt decider continues to simulate its input until
>>>>>>>>>>>>>>> it correctly matches a correct infinite behavior pattern.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then why does you H abort too soon, as shown by the fact that the
>>>>>>>>>>>>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Just says that your H doesn't even meet your own definition.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> In order for me to actually be wrong you must be able to show
>>>>>>>>>>>>>>> that some simulating halt decider Hx could be defined such that
>>>>>>>>>>>>>>> its correct simulation of its input Px reaches the final state of
>>>>>>>>>>>>>>> Px in a finite number of steps.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope. H(P,P) is wrong
>>>>>>>>>>>>>
>>>>>>>>>>>>> ..then a mistake could be shown, if no mistake can be shown then it
>>>>>>>>>>>>> is not wrong.
>>>>>>>>>>>>
>>>>>>>>>>>> And it has been.
>>>>>>>>>>>>
>>>>>>>>>>>> Even YOU hav published the correct and complete simuliaton of the
>>>>>>>>>>>> input to H(P,P) being the trace of P(P) and Simulate(P,P)
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I contend that that no simulating halt decider Hx can be defined
>>>>>>>>>>>>> such that its correctly simulated input Px could reach the final
>>>>>>>>>>>>> state of this simulated Px in any finite number of steps.
>>>>>>>>>>>>
>>>>>>>>>>>> So, that isn't the question.
>>>>>>>>>>>
>>>>>>>>>>> *I STIPULATE FOR THIS THREAD THAT IS THE QUESTION*
>>>>>>>>>>>
>>>>>>>>>>> Any rebuttal must show all of the steps of exactly how the input to
>>>>>>>>>>> Hx(Px,Px) correctly simulated by Hx reaches the final state of Px in
>>>>>>>>>>> a finite number of steps.
>>>>>>>>>>>
>>>>>>>>>>> ALTERNATIVELY YOU COULD SIMPLY ADMIT THE TRUTH
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You don't get to stipulate the test,
>>>>>>>>>
>>>>>>>>> In other words you know that my statement is correct and you are too
>>>>>>>>> dishonest to admit it.
>>>>>>>>>
>>>>>>>> Nope, shows you don't understand about requirements.
>>>>>>> Ultimately, you are a shit for brains fucking idiot because you have admitted unsatisfiable requirements.
>>>>>>>
>>>>>>> It is precisely because the requirements are unsatisfiable they amount to nothing other than The bottom/uninhabited type. Falsity.
>>>>>>>
>>>>>>> https://en.wikipedia.org/wiki/Bottom_type
>>>>>> Nope, given an H, the answer is defined , and computabe if we know that
>>>>>> H does return an answer.
>>>>> How? There is no H for the pathological P.
>>>>> Furthermore because the dependencies of P are unsatisfiable (P requires H) there is also no P.
>>>> Because Olcott has defined what he calls H.
>>>>
>>>> Yes, H doesn't meet the requirements, but he claims it does and we are
>>>> showing that H is incorrect.
>>> But why are you so concerned with showing that H is incorrect; while being so unconcerned by the fact that the requirements are incorrect?
>>>
>>> The requirements amount to falsify!
>> The requirements are correct, BY DEFINITION, they require what they require.
> But the requirements require you to violate the principle you cherish so dearly!
>
> The requirements clash with YOUR principle!

On 9/4/22 7:40 PM, Skep Dick wrote:
> On Monday, 5 September 2022 at 01:19:56 UTC+2, richar...@gmail.com wrote:
>> On 9/4/22 6:58 PM, Skep Dick wrote:
>>> On Monday, 5 September 2022 at 00:50:31 UTC+2, richar...@gmail.com wrote:
>>>> And proves that his links don't actually mean the thing he is claiming
>>>> they define.
>>>
>>> I am calling you out in your bullshit. Again.
>>>
>>> What do you mean by “meaning”?
>>> Define “define”.
>> First Principles, so out of your understanding.
> Those are questions of first principles, you shit for brains fucking idiot!
>
> From first principles: explain what you mean by “meaning”.
> From first principles: define “define”
>

So, you just don't understand what First Princples Are?

From First Principles, we get the definition of "meaning" and "define'

Since you don't see to accept first principles, your stuck in the
problem of trying to define your definitions.

>
>>>
>> And you do know that the paradox has answers? Many of course require you
>> to accept that words DO have meaning
> OBVIOUSLY I accept that!
>
> That is WHY I am asking you to explain what you mean by “meaning” from first principles!

Which is exactly what the acceptance of First Principels gets you.

We get something like: "what is meant by a word, text, concept, or action."

Of course it is recursive, that is the nature of First Principles.

>
>> so maybe you are out of luck, but
>> those of use willing to accept definitions can just live with them
> Fine! Accept whatever definitions you want to accept, but can you at least tell us which definition of “definition” you have accepted?

One Statement:

A definition is a statement of the meaning of a term (a word, phrase, or
other set of symbols). Definitions can be classified into two large
categories: intensional definitions (which try to give the sense of a
term), and extensional definitions (which try to list the objects that a
term describes).

Note, acceptance of the First Principles allows you to refine this as
needed.

On Monday, 5 September 2022 at 01:45:53 UTC+2, richar...@gmail.com wrote:
> On 9/4/22 7:35 PM, Skep Dick wrote:
> > On Monday, 5 September 2022 at 00:58:13 UTC+2, richar...@gmail.com wrote:
> >> On 9/4/22 6:02 PM, Skep Dick wrote:
> >>> On Sunday, 4 September 2022 at 22:46:44 UTC+2, richar...@gmail.com wrote:
> >>>> On 9/4/22 4:33 PM, Skep Dick wrote:
> >>>>> On Sunday, 4 September 2022 at 22:24:14 UTC+2, richar...@gmail.com wrote:
> >>>>>> On 9/4/22 4:01 PM, Skep Dick wrote:
> >>>>>>> On Sunday, 4 September 2022 at 21:52:16 UTC+2, richar...@gmail.com wrote:
> >>>>>>>> On 9/4/22 3:30 PM, olcott wrote:
> >>>>>>>>> On 9/4/2022 2:21 PM, Richard Damon wrote:
> >>>>>>>>>> On 9/4/22 3:16 PM, olcott wrote:
> >>>>>>>>>>> On 9/4/2022 2:04 PM, Richard Damon wrote:
> >>>>>>>>>>>> On 9/4/22 2:35 PM, olcott wrote:
> >>>>>>>>>>>>> On 9/4/2022 1:07 PM, Richard Damon wrote:
> >>>>>>>>>>>>>> On 9/4/22 1:50 PM, olcott wrote:
> >>>>>>>>>>>>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 9/4/22 12:33 PM, olcott wrote:
> >>>>>>>>>>>>>>>>> On 9/3/2022 12:24 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>> On 9/3/22 1:18 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>> On 9/3/22 12:56 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:32 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:03:48 PM
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:50 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 1:43:43 PM
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:00 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:54:54
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you won't go by the oficial
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions, your H just isn't a Halt
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the official definitions are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then at least one of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> them must be rejected as incorrect.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you are wrong here. The official
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a halt decider is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory, in that it is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible to build anything which meets
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition. This has been proved.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not the way truth works mate. If
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the official definitions are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then I have also had new
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> insight on that another
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aspect of computer science is incorrect.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you are not disputing that official
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a halt decider is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of an
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input is guaranteed to derive
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior of this input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort the simulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input to prevent the infinite
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of this input is merely
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another way of saying the the correct and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by this SHD would never stop running.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When computer science textbooks say that the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that a halt
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must report on is the behavior of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine represented by this input and this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior is not the same as
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct and complete simulation of this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input then the computer
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> science textbooks are wrong because they
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject the definition of a UTM.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (simulator).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I was hoping for more of a yes-or-no type answer.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When I provide a complete explanation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning behind the answer all those not
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding these things cannot simply
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> baselessly disagree. All disagreement is thus
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required to have a basis. This way people are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not lead astray by a bunch of baseless
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagreement, they see that the disagreement
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has no basis and reject it.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning, starting from ACCEPTED definition.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just make wild claims based on your own
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding of the words.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the words, no one can help you with your logic.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, Most of the things you are talking about
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HAVE well defined meanings, so you either need
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to use that meaning, or you really need to give
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your idea a new name (maybe basd on the common
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> name with a modifier).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same as the accepted definition, you can call it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PO-Halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of course the problem with this is it makes it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clear that you are talking about the PO-Halting
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, with a PO-Halting Decider, so you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter example doesn't affect the actual
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, so it is clear you haven't
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven what you claim to have proven.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that the definition is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory. You're not disputing
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that proof?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You haven't actually given a proof, since you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are clearly using altered definition that you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aren't providing.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You reject the notion of a UTM so you are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> starting with an incorrect basis.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM(P,d) by DEFINITION gives the exact same result
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as P(d).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> When you get a glass of water and dump it on the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> floor you cannot truthfully deny that the floor is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> wet.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> And I haven't
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correct and complete simulation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by H(P,P) would have different behavior than
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of P(P) this cannot simply be
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ignored.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct and complete simulation of the input
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) Halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that the simulation by H(P,P) of its input
> >>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running unless H aborts the simulation of
> >>>>>>>>>>>>>>>>>>>>>>>>>>> this input is merely another way of saying that the
> >>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of this input by H
> >>>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> You have bad logic there.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> It is a tautology:
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
> >>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> >>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
> >>>>>>>>>>>>>>>>>>>>>>>>> [00001102](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
> >>>>>>>>>>>>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>>>> [00001108](01) c3 ret
> >>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of
> >>>>>>>>>>>>>>>>>>>>>>>>> its input would never stop running unless H0 aborts the
> >>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input is merely another way of
> >>>>>>>>>>>>>>>>>>>>>>>>> saying that the correct and complete simulation of this
> >>>>>>>>>>>>>>>>>>>>>>>>> input by H0 never halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Strawman.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Fallacy of Proof by Example.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> It is only a fallacy by proof of example when a single
> >>>>>>>>>>>>>>>>>>>>>>> example is not representative of the entire class of all
> >>>>>>>>>>>>>>>>>>>>>>> such examples.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Which it isn't, so FAIL.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> You are confusing existential quantification with
> >>>>>>>>>>>>>>>>>>>>>>> universal quantification.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> No you are, since you are claiming the rule works for ALL
> >>>>>>>>>>>>>>>>>>>>>> inputs (or at least P, which isn't the input you showed it
> >>>>>>>>>>>>>>>>>>>>>> worked for).
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> ∀ simulating halt decider H
> >>>>>>>>>>>>>>>>>>>>>>> ∀ machine description P
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> You don't seem to know what those words mean.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> The fact that the correct simulation of any input P to
> >>>>>>>>>>>>>>>>>>>>>>> any simulating halt decider (SHD) H would never stop
> >>>>>>>>>>>>>>>>>>>>>>> running unless this simulation was aborted by this SHD is
> >>>>>>>>>>>>>>>>>>>>>>> merely another way of saying that the correct and
> >>>>>>>>>>>>>>>>>>>>>>> complete simulation of this input by this SHD would never
> >>>>>>>>>>>>>>>>>>>>>>> stop running.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Nope, not when the input depends on the behavior of the
> >>>>>>>>>>>>>>>>>>>>>> decider in the way you are doing it.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> P was intentionally defined to depend on the behavior of
> >>>>>>>>>>>>>>>>>>>>> its decider *NITWIT*
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Right, but your "example" didn't, and this dependency is the
> >>>>>>>>>>>>>>>>>>>> case that breaks your "proof" and definitions.
> >>>>>>>>>>>>>>>>>>> The correct simulation of the input by H(P,P) is the
> >>>>>>>>>>>>>>>>>>> simulation of this input at the same point in the execution
> >>>>>>>>>>>>>>>>>>> trace where H is invoked.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> (2 + 3) * 5 != 2 + (3 * 5) // order matters.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
> >>>>>>>>>>>>>>>>>> irrespective of "where" that simulation is done, at least if H
> >>>>>>>>>>>>>>>>>> is a computation, and if it isn't it can't be a decider.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Although H must be a computation all sequences of
> >>>>>>>>>>>>>>>>> configurations that do not halt are not computations**. The
> >>>>>>>>>>>>>>>>> behavior of H is the same no matter where it is invoked..
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time,
> >>>>>>>>>>>>>>>> by the H you claim to be correct.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> The behavior of P need not be (and indeed is not) the same.
> >>>>>>>>>>>>>>>>> When P is invoked from main its behavior depends on the return
> >>>>>>>>>>>>>>>>> value of H. When P is correctly simulated by H the return value
> >>>>>>>>>>>>>>>>> from H is unreachable from every simulated P. This conclusively
> >>>>>>>>>>>>>>>>> proves that the execution of P from main() and the correct
> >>>>>>>>>>>>>>>>> simulation of P by H are not computationally equivalent..
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> All of your rebuttals are simply false assumptions and nothing more.
> >>>>>>>>>>>>>>> I claim that
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> "When P is correctly simulated by H the return value from
> >>>>>>>>>>>>>>> H is unreachable from every simulated P."
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> SO? There is no requirement that H is able to see the resuts of
> >>>>>>>>>>>>>> the call inside the input it is simulating.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the
> >>>>>>>>>>>>>> behavior of P(P) or Simulate(P,P). The fact that H can't determine
> >>>>>>>>>>>>>> that is H's fault.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Do you disagree that the CORRECT answer is based on the ACTUAL
> >>>>>>>>>>>>>> BEHAVIOR of the ACUTAL INPUT?
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> H's inability to determine that is WHY it gets the wrong answer,
> >>>>>>>>>>>>>> not an excuse for it to do so.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> When you claim that I am incorrect it is merely an empty
> >>>>>>>>>>>>>>> assertion utterly bereft of supporting reasoning.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> No, you LITERALLY are making an empty assertion, as you are
> >>>>>>>>>>>>>> asserting something that never occurs.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> There is NO H that does a complete and correct simulation and
> >>>>>>>>>>>>>> returns an answer. We can even argue that it doesn't do a correct
> >>>>>>>>>>>>>> simulation since the last step of the simulation has an error as
> >>>>>>>>>>>>>> it presumes the wrong behavior of the call to H that it encounter
> >>>>>>>>>>>>>> (you can debate if this is an incorrect simulation or just unsound
> >>>>>>>>>>>>>> logic).
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> A simulating halt decider continues to simulate its input until
> >>>>>>>>>>>>>>> it correctly matches a correct infinite behavior pattern.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Then why does you H abort too soon, as shown by the fact that the
> >>>>>>>>>>>>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Just says that your H doesn't even meet your own definition.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
> >>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
> >>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> In order for me to actually be wrong you must be able to show
> >>>>>>>>>>>>>>> that some simulating halt decider Hx could be defined such that
> >>>>>>>>>>>>>>> its correct simulation of its input Px reaches the final state of
> >>>>>>>>>>>>>>> Px in a finite number of steps.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Nope. H(P,P) is wrong
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> ..then a mistake could be shown, if no mistake can be shown then it
> >>>>>>>>>>>>> is not wrong.
> >>>>>>>>>>>>
> >>>>>>>>>>>> And it has been.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Even YOU hav published the correct and complete simuliaton of the
> >>>>>>>>>>>> input to H(P,P) being the trace of P(P) and Simulate(P,P)
> >>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> I contend that that no simulating halt decider Hx can be defined
> >>>>>>>>>>>>> such that its correctly simulated input Px could reach the final
> >>>>>>>>>>>>> state of this simulated Px in any finite number of steps.
> >>>>>>>>>>>>
> >>>>>>>>>>>> So, that isn't the question.
> >>>>>>>>>>>
> >>>>>>>>>>> *I STIPULATE FOR THIS THREAD THAT IS THE QUESTION*
> >>>>>>>>>>>
> >>>>>>>>>>> Any rebuttal must show all of the steps of exactly how the input to
> >>>>>>>>>>> Hx(Px,Px) correctly simulated by Hx reaches the final state of Px in
> >>>>>>>>>>> a finite number of steps.
> >>>>>>>>>>>
> >>>>>>>>>>> ALTERNATIVELY YOU COULD SIMPLY ADMIT THE TRUTH
> >>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> You don't get to stipulate the test,
> >>>>>>>>>
> >>>>>>>>> In other words you know that my statement is correct and you are too
> >>>>>>>>> dishonest to admit it.
> >>>>>>>>>
> >>>>>>>> Nope, shows you don't understand about requirements.
> >>>>>>> Ultimately, you are a shit for brains fucking idiot because you have admitted unsatisfiable requirements.
> >>>>>>>
> >>>>>>> It is precisely because the requirements are unsatisfiable they amount to nothing other than The bottom/uninhabited type. Falsity.
> >>>>>>>
> >>>>>>> https://en.wikipedia.org/wiki/Bottom_type
> >>>>>> Nope, given an H, the answer is defined , and computabe if we know that
> >>>>>> H does return an answer.
> >>>>> How? There is no H for the pathological P.
> >>>>> Furthermore because the dependencies of P are unsatisfiable (P requires H) there is also no P.
> >>>> Because Olcott has defined what he calls H.
> >>>>
> >>>> Yes, H doesn't meet the requirements, but he claims it does and we are
> >>>> showing that H is incorrect.
> >>> But why are you so concerned with showing that H is incorrect; while being so unconcerned by the fact that the requirements are incorrect?
> >>>
> >>> The requirements amount to falsify!
> >> The requirements are correct, BY DEFINITION, they require what they require.
> > But the requirements require you to violate the principle you cherish so dearly!
> >
> > The requirements clash with YOUR principle!
> What clash?
>
> Remember, H isn't a Halt Decider, it is something some CLAIMS
> (incorrectly) to be a Halt Decider.
Obviously! Because YOU admitted that Halt Deciders don’t exist!

On Monday, 5 September 2022 at 02:17:39 UTC+2, richar...@gmail.com wrote:
> On 9/4/22 7:40 PM, Skep Dick wrote:
> > On Monday, 5 September 2022 at 01:19:56 UTC+2, richar...@gmail.com wrote:
> >> On 9/4/22 6:58 PM, Skep Dick wrote:
> >>> On Monday, 5 September 2022 at 00:50:31 UTC+2, richar...@gmail.com wrote:
> >>>> And proves that his links don't actually mean the thing he is claiming
> >>>> they define.
> >>>
> >>> I am calling you out in your bullshit. Again.
> >>>
> >>> What do you mean by “meaning”?
> >>> Define “define”.
> >> First Principles, so out of your understanding.
> > Those are questions of first principles, you shit for brains fucking idiot!
> >
> > From first principles: explain what you mean by “meaning”.
> > From first principles: define “define”
> >
> So, you just don't understand what First Princples Are?
I know exactly what first principles are. A clean slate.

> From First Principles, we get the definition of "meaning" and "define'
There are no definitions on the clean slate of first principles

That is why I have asked you to put them on the slate.

> Since you don't see to accept first principles, your stuck in the
> problem of trying to define your definitions.
Of course I accept first principles.

I am waiting on you to put something on the clean slate.
I am waiting on you to materialise the objects of “meaning” and “definition” in The Empty Construct.

> >> And you do know that the paradox has answers? Many of course require you
> >> to accept that words DO have meaning
> > OBVIOUSLY I accept that!
> >
> > That is WHY I am asking you to explain what you mean by “meaning” from first principles!
> Which is exactly what the acceptance of First Principels gets you.
That isn’t first principles.

That is second hand principles.

> We get something like: "what is meant by a word, text, concept, or action.."
I know. Which is why I am asking you to tell me what is meant by the words, text and concepts of “meaning” and “definition”.

Surely you understand the concept of function self-application? It is a basic Mathematical idea.

> Of course it is recursive, that is the nature of First Principles.
Recursion is just computation. There are no first principles in the computer.

Unless you put them there.

> >> so maybe you are out of luck, but
> >> those of use willing to accept definitions can just live with them
> > Fine! Accept whatever definitions you want to accept, but can you at least tell us which definition of “definition” you have accepted?
> One Statement:
>
> A definition is a statement of the meaning
Eeeeh! That’s a circular definition. It is using the terms it is trying to define.

You do understand that mutually recursive definitions don’t halt in computational terms, right?

> Note, acceptance of the First Principles allows you to refine this as
> needed.
How do you refine an infinite loop?

On 9/4/22 8:24 PM, Skep Dick wrote:
> On Monday, 5 September 2022 at 01:45:53 UTC+2, richar...@gmail.com wrote:
>> On 9/4/22 7:35 PM, Skep Dick wrote:
>>> On Monday, 5 September 2022 at 00:58:13 UTC+2, richar...@gmail.com wrote:
>>>> On 9/4/22 6:02 PM, Skep Dick wrote:
>>>>> On Sunday, 4 September 2022 at 22:46:44 UTC+2, richar...@gmail.com wrote:
>>>>>> On 9/4/22 4:33 PM, Skep Dick wrote:
>>>>>>> On Sunday, 4 September 2022 at 22:24:14 UTC+2, richar...@gmail.com wrote:
>>>>>>>> On 9/4/22 4:01 PM, Skep Dick wrote:
>>>>>>>>> On Sunday, 4 September 2022 at 21:52:16 UTC+2, richar...@gmail.com wrote:
>>>>>>>>>> On 9/4/22 3:30 PM, olcott wrote:
>>>>>>>>>>> On 9/4/2022 2:21 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/4/22 3:16 PM, olcott wrote:
>>>>>>>>>>>>> On 9/4/2022 2:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/4/22 2:35 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/4/2022 1:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/4/22 1:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 9/4/22 12:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/3/2022 12:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/3/22 1:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:56 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:03:48 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:50 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 1:43:43 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:00 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:54:54
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you won't go by the oficial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions, your H just isn't a Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the official definitions are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then at least one of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> them must be rejected as incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you are wrong here. The official
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory, in that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible to build anything which meets
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition. This has been proved.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not the way truth works mate. If
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the official definitions are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then I have also had new
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> insight on that another
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aspect of computer science is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you are not disputing that official
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input is guaranteed to derive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input to prevent the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of this input is merely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another way of saying the the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by this SHD would never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When computer science textbooks say that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that a halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must report on is the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine represented by this input and this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior is not the same as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct and complete simulation of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input then the computer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> science textbooks are wrong because they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject the definition of a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (simulator).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I was hoping for more of a yes-or-no type answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When I provide a complete explanation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning behind the answer all those not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding these things cannot simply
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> baselessly disagree. All disagreement is thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required to have a basis. This way people are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not lead astray by a bunch of baseless
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagreement, they see that the disagreement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has no basis and reject it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning, starting from ACCEPTED definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just make wild claims based on your own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding of the words.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the words, no one can help you with your logic.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, Most of the things you are talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HAVE well defined meanings, so you either need
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to use that meaning, or you really need to give
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your idea a new name (maybe basd on the common
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> name with a modifier).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same as the accepted definition, you can call it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PO-Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of course the problem with this is it makes it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clear that you are talking about the PO-Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, with a PO-Halting Decider, so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter example doesn't affect the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, so it is clear you haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven what you claim to have proven.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that the definition is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory. You're not disputing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that proof?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You haven't actually given a proof, since you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are clearly using altered definition that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aren't providing.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You reject the notion of a UTM so you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> starting with an incorrect basis.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM(P,d) by DEFINITION gives the exact same result
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as P(d).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When you get a glass of water and dump it on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> floor you cannot truthfully deny that the floor is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wet.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And I haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correct and complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by H(P,P) would have different behavior than
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of P(P) this cannot simply be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ignored.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct and complete simulation of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that the simulation by H(P,P) of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running unless H aborts the simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input is merely another way of saying that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of this input by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have bad logic there.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> It is a tautology:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of
>>>>>>>>>>>>>>>>>>>>>>>>>>> its input would never stop running unless H0 aborts the
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input is merely another way of
>>>>>>>>>>>>>>>>>>>>>>>>>>> saying that the correct and complete simulation of this
>>>>>>>>>>>>>>>>>>>>>>>>>>> input by H0 never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Fallacy of Proof by Example.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> It is only a fallacy by proof of example when a single
>>>>>>>>>>>>>>>>>>>>>>>>> example is not representative of the entire class of all
>>>>>>>>>>>>>>>>>>>>>>>>> such examples.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Which it isn't, so FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You are confusing existential quantification with
>>>>>>>>>>>>>>>>>>>>>>>>> universal quantification.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> No you are, since you are claiming the rule works for ALL
>>>>>>>>>>>>>>>>>>>>>>>> inputs (or at least P, which isn't the input you showed it
>>>>>>>>>>>>>>>>>>>>>>>> worked for).
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> ∀ simulating halt decider H
>>>>>>>>>>>>>>>>>>>>>>>>> ∀ machine description P
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You don't seem to know what those words mean.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The fact that the correct simulation of any input P to
>>>>>>>>>>>>>>>>>>>>>>>>> any simulating halt decider (SHD) H would never stop
>>>>>>>>>>>>>>>>>>>>>>>>> running unless this simulation was aborted by this SHD is
>>>>>>>>>>>>>>>>>>>>>>>>> merely another way of saying that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of this input by this SHD would never
>>>>>>>>>>>>>>>>>>>>>>>>> stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Nope, not when the input depends on the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>> decider in the way you are doing it.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> P was intentionally defined to depend on the behavior of
>>>>>>>>>>>>>>>>>>>>>>> its decider *NITWIT*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Right, but your "example" didn't, and this dependency is the
>>>>>>>>>>>>>>>>>>>>>> case that breaks your "proof" and definitions.
>>>>>>>>>>>>>>>>>>>>> The correct simulation of the input by H(P,P) is the
>>>>>>>>>>>>>>>>>>>>> simulation of this input at the same point in the execution
>>>>>>>>>>>>>>>>>>>>> trace where H is invoked.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> (2 + 3) * 5 != 2 + (3 * 5) // order matters.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
>>>>>>>>>>>>>>>>>>>> irrespective of "where" that simulation is done, at least if H
>>>>>>>>>>>>>>>>>>>> is a computation, and if it isn't it can't be a decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Although H must be a computation all sequences of
>>>>>>>>>>>>>>>>>>> configurations that do not halt are not computations**. The
>>>>>>>>>>>>>>>>>>> behavior of H is the same no matter where it is invoked.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time,
>>>>>>>>>>>>>>>>>> by the H you claim to be correct.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The behavior of P need not be (and indeed is not) the same.
>>>>>>>>>>>>>>>>>>> When P is invoked from main its behavior depends on the return
>>>>>>>>>>>>>>>>>>> value of H. When P is correctly simulated by H the return value
>>>>>>>>>>>>>>>>>>> from H is unreachable from every simulated P. This conclusively
>>>>>>>>>>>>>>>>>>> proves that the execution of P from main() and the correct
>>>>>>>>>>>>>>>>>>> simulation of P by H are not computationally equivalent.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> All of your rebuttals are simply false assumptions and nothing more.
>>>>>>>>>>>>>>>>> I claim that
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> "When P is correctly simulated by H the return value from
>>>>>>>>>>>>>>>>> H is unreachable from every simulated P."
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> SO? There is no requirement that H is able to see the resuts of
>>>>>>>>>>>>>>>> the call inside the input it is simulating.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the
>>>>>>>>>>>>>>>> behavior of P(P) or Simulate(P,P). The fact that H can't determine
>>>>>>>>>>>>>>>> that is H's fault.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Do you disagree that the CORRECT answer is based on the ACTUAL
>>>>>>>>>>>>>>>> BEHAVIOR of the ACUTAL INPUT?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H's inability to determine that is WHY it gets the wrong answer,
>>>>>>>>>>>>>>>> not an excuse for it to do so.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When you claim that I am incorrect it is merely an empty
>>>>>>>>>>>>>>>>> assertion utterly bereft of supporting reasoning.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, you LITERALLY are making an empty assertion, as you are
>>>>>>>>>>>>>>>> asserting something that never occurs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> There is NO H that does a complete and correct simulation and
>>>>>>>>>>>>>>>> returns an answer. We can even argue that it doesn't do a correct
>>>>>>>>>>>>>>>> simulation since the last step of the simulation has an error as
>>>>>>>>>>>>>>>> it presumes the wrong behavior of the call to H that it encounter
>>>>>>>>>>>>>>>> (you can debate if this is an incorrect simulation or just unsound
>>>>>>>>>>>>>>>> logic).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A simulating halt decider continues to simulate its input until
>>>>>>>>>>>>>>>>> it correctly matches a correct infinite behavior pattern.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Then why does you H abort too soon, as shown by the fact that the
>>>>>>>>>>>>>>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Just says that your H doesn't even meet your own definition.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In order for me to actually be wrong you must be able to show
>>>>>>>>>>>>>>>>> that some simulating halt decider Hx could be defined such that
>>>>>>>>>>>>>>>>> its correct simulation of its input Px reaches the final state of
>>>>>>>>>>>>>>>>> Px in a finite number of steps.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope. H(P,P) is wrong
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> ..then a mistake could be shown, if no mistake can be shown then it
>>>>>>>>>>>>>>> is not wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And it has been.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Even YOU hav published the correct and complete simuliaton of the
>>>>>>>>>>>>>> input to H(P,P) being the trace of P(P) and Simulate(P,P)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I contend that that no simulating halt decider Hx can be defined
>>>>>>>>>>>>>>> such that its correctly simulated input Px could reach the final
>>>>>>>>>>>>>>> state of this simulated Px in any finite number of steps.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, that isn't the question.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *I STIPULATE FOR THIS THREAD THAT IS THE QUESTION*
>>>>>>>>>>>>>
>>>>>>>>>>>>> Any rebuttal must show all of the steps of exactly how the input to
>>>>>>>>>>>>> Hx(Px,Px) correctly simulated by Hx reaches the final state of Px in
>>>>>>>>>>>>> a finite number of steps.
>>>>>>>>>>>>>
>>>>>>>>>>>>> ALTERNATIVELY YOU COULD SIMPLY ADMIT THE TRUTH
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You don't get to stipulate the test,
>>>>>>>>>>>
>>>>>>>>>>> In other words you know that my statement is correct and you are too
>>>>>>>>>>> dishonest to admit it.
>>>>>>>>>>>
>>>>>>>>>> Nope, shows you don't understand about requirements.
>>>>>>>>> Ultimately, you are a shit for brains fucking idiot because you have admitted unsatisfiable requirements.
>>>>>>>>>
>>>>>>>>> It is precisely because the requirements are unsatisfiable they amount to nothing other than The bottom/uninhabited type. Falsity.
>>>>>>>>>
>>>>>>>>> https://en.wikipedia.org/wiki/Bottom_type
>>>>>>>> Nope, given an H, the answer is defined , and computabe if we know that
>>>>>>>> H does return an answer.
>>>>>>> How? There is no H for the pathological P.
>>>>>>> Furthermore because the dependencies of P are unsatisfiable (P requires H) there is also no P.
>>>>>> Because Olcott has defined what he calls H.
>>>>>>
>>>>>> Yes, H doesn't meet the requirements, but he claims it does and we are
>>>>>> showing that H is incorrect.
>>>>> But why are you so concerned with showing that H is incorrect; while being so unconcerned by the fact that the requirements are incorrect?
>>>>>
>>>>> The requirements amount to falsify!
>>>> The requirements are correct, BY DEFINITION, they require what they require.
>>> But the requirements require you to violate the principle you cherish so dearly!
>>>
>>> The requirements clash with YOUR principle!
>> What clash?
>>
>> Remember, H isn't a Halt Decider, it is something some CLAIMS
>> (incorrectly) to be a Halt Decider.
> Obviously! Because YOU admitted that Halt Deciders don’t exist!
>
> So what are YOU talking about when you are talking about non-existing entities?!?

On 9/4/22 8:37 PM, Skep Dick wrote:
> On Monday, 5 September 2022 at 02:17:39 UTC+2, richar...@gmail.com wrote:
>> On 9/4/22 7:40 PM, Skep Dick wrote:
>>> On Monday, 5 September 2022 at 01:19:56 UTC+2, richar...@gmail.com wrote:
>>>> On 9/4/22 6:58 PM, Skep Dick wrote:
>>>>> On Monday, 5 September 2022 at 00:50:31 UTC+2, richar...@gmail.com wrote:
>>>>>> And proves that his links don't actually mean the thing he is claiming
>>>>>> they define.
>>>>>
>>>>> I am calling you out in your bullshit. Again.
>>>>>
>>>>> What do you mean by “meaning”?
>>>>> Define “define”.
>>>> First Principles, so out of your understanding.
>>> Those are questions of first principles, you shit for brains fucking idiot!
>>>
>>> From first principles: explain what you mean by “meaning”.
>>> From first principles: define “define”
>>>
>> So, you just don't understand what First Princples Are?
> I know exactly what first principles are. A clean slate.
>
>> From First Principles, we get the definition of "meaning" and "define'
> There are no definitions on the clean slate of first principles
>
> That is why I have asked you to put them on the slate.
>

Then you haven't accepted the First Principles. You don't end up with an
clean/empty slate with First Principles, you start with a slate filled
with them, which include things lie "Meaning" and "Define"

>> Since you don't see to accept first principles, your stuck in the
>> problem of trying to define your definitions.
> Of course I accept first principles.
>
> I am waiting on you to put something on the clean slate.
> I am waiting on you to materialise the objects of “meaning” and “definition” in The Empty Construct.

Then you haven't accepted First Principles.

>
>>>> And you do know that the paradox has answers? Many of course require you
>>>> to accept that words DO have meaning
>>> OBVIOUSLY I accept that!
>>>
>>> That is WHY I am asking you to explain what you mean by “meaning” from first principles!
>> Which is exactly what the acceptance of First Principels gets you.
> That isn’t first principles.
>
> That is second hand principles.

Nope, that is what I define as "First Principles"

Note, part of "First Principles" is that they aren't just yours, so I
guess you can call them second hand.

>
>> We get something like: "what is meant by a word, text, concept, or action."
> I know. Which is why I am asking you to tell me what is meant by the words, text and concepts of “meaning” and “definition”.
>
> Surely you understand the concept of function self-application? It is a basic Mathematical idea.
>

They are emdedded in the concept of First Principles, which you clearly
do not understand.

>> Of course it is recursive, that is the nature of First Principles.
> Recursion is just computation. There are no first principles in the computer.
>
> Unless you put them there.

Not all recursion is computaiton. You are showing your lack of
understanding of the True Meaning of First Principles,.

>
>>>> so maybe you are out of luck, but
>>>> those of use willing to accept definitions can just live with them
>>> Fine! Accept whatever definitions you want to accept, but can you at least tell us which definition of “definition” you have accepted?
>> One Statement:
>>
>> A definition is a statement of the meaning
> Eeeeh! That’s a circular definition. It is using the terms it is trying to define.
>
> You do understand that mutually recursive definitions don’t halt in computational terms, right?

Yep, which is the proble with trying to define things as computations.

I don't try to do it, so have no trouble with it.

>
>> Note, acceptance of the First Principles allows you to refine this as
>> needed.
> How do you refine an infinite loop?

It refines itself.

It is clear you have lost the handle of what First Principles are, which
makes your system ineffective because it has no base.

On Monday, 5 September 2022 at 02:44:04 UTC+2, richar...@gmail.com wrote:
> On 9/4/22 8:24 PM, Skep Dick wrote:
> > On Monday, 5 September 2022 at 01:45:53 UTC+2, richar...@gmail.com wrote:
> >> On 9/4/22 7:35 PM, Skep Dick wrote:
> >>> On Monday, 5 September 2022 at 00:58:13 UTC+2, richar...@gmail.com wrote:
> >>>> On 9/4/22 6:02 PM, Skep Dick wrote:
> >>>>> On Sunday, 4 September 2022 at 22:46:44 UTC+2, richar...@gmail.com wrote:
> >>>>>> On 9/4/22 4:33 PM, Skep Dick wrote:
> >>>>>>> On Sunday, 4 September 2022 at 22:24:14 UTC+2, richar...@gmail.com wrote:
> >>>>>>>> On 9/4/22 4:01 PM, Skep Dick wrote:
> >>>>>>>>> On Sunday, 4 September 2022 at 21:52:16 UTC+2, richar...@gmail.com wrote:
> >>>>>>>>>> On 9/4/22 3:30 PM, olcott wrote:
> >>>>>>>>>>> On 9/4/2022 2:21 PM, Richard Damon wrote:
> >>>>>>>>>>>> On 9/4/22 3:16 PM, olcott wrote:
> >>>>>>>>>>>>> On 9/4/2022 2:04 PM, Richard Damon wrote:
> >>>>>>>>>>>>>> On 9/4/22 2:35 PM, olcott wrote:
> >>>>>>>>>>>>>>> On 9/4/2022 1:07 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>> On 9/4/22 1:50 PM, olcott wrote:
> >>>>>>>>>>>>>>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On 9/4/22 12:33 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>> On 9/3/2022 12:24 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>> On 9/3/22 1:18 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:56 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:32 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:03:48 PM
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:50 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 1:43:43 PM
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:00 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:54:54
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you won't go by the oficial
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions, your H just isn't a Halt
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the official definitions are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then at least one of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> them must be rejected as incorrect.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you are wrong here. The official
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a halt decider is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory, in that it is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible to build anything which meets
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition. This has been proved.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not the way truth works mate. If
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the official definitions are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then I have also had new
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> insight on that another
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aspect of computer science is incorrect.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you are not disputing that official
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a halt decider is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of an
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input is guaranteed to derive
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior of this input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort the simulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input to prevent the infinite
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of this input is merely
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another way of saying the the correct and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by this SHD would never stop running.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When computer science textbooks say that the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that a halt
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must report on is the behavior of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine represented by this input and this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior is not the same as
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct and complete simulation of this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input then the computer
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> science textbooks are wrong because they
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject the definition of a UTM.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (simulator).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I was hoping for more of a yes-or-no type answer.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When I provide a complete explanation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning behind the answer all those not
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding these things cannot simply
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> baselessly disagree. All disagreement is thus
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required to have a basis. This way people are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not lead astray by a bunch of baseless
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagreement, they see that the disagreement
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has no basis and reject it.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning, starting from ACCEPTED definition.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just make wild claims based on your own
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding of the words.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the words, no one can help you with your logic.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, Most of the things you are talking about
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HAVE well defined meanings, so you either need
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to use that meaning, or you really need to give
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your idea a new name (maybe basd on the common
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> name with a modifier).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same as the accepted definition, you can call it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PO-Halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of course the problem with this is it makes it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clear that you are talking about the PO-Halting
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, with a PO-Halting Decider, so you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter example doesn't affect the actual
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, so it is clear you haven't
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven what you claim to have proven.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that the definition is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory. You're not disputing
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that proof?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You haven't actually given a proof, since you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are clearly using altered definition that you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aren't providing.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You reject the notion of a UTM so you are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> starting with an incorrect basis.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM(P,d) by DEFINITION gives the exact same result
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as P(d).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When you get a glass of water and dump it on the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> floor you cannot truthfully deny that the floor is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wet.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And I haven't
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correct and complete simulation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by H(P,P) would have different behavior than
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of P(P) this cannot simply be
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ignored.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct and complete simulation of the input
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) Halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that the simulation by H(P,P) of its input
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running unless H aborts the simulation of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input is merely another way of saying that the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of this input by H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> You have bad logic there.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> It is a tautology:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
> >>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> >>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
> >>>>>>>>>>>>>>>>>>>>>>>>>>> [00001102](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
> >>>>>>>>>>>>>>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>>> [00001108](01) c3 ret
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of
> >>>>>>>>>>>>>>>>>>>>>>>>>>> its input would never stop running unless H0 aborts the
> >>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input is merely another way of
> >>>>>>>>>>>>>>>>>>>>>>>>>>> saying that the correct and complete simulation of this
> >>>>>>>>>>>>>>>>>>>>>>>>>>> input by H0 never halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> Strawman.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> Fallacy of Proof by Example.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> It is only a fallacy by proof of example when a single
> >>>>>>>>>>>>>>>>>>>>>>>>> example is not representative of the entire class of all
> >>>>>>>>>>>>>>>>>>>>>>>>> such examples.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Which it isn't, so FAIL.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> You are confusing existential quantification with
> >>>>>>>>>>>>>>>>>>>>>>>>> universal quantification.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> No you are, since you are claiming the rule works for ALL
> >>>>>>>>>>>>>>>>>>>>>>>> inputs (or at least P, which isn't the input you showed it
> >>>>>>>>>>>>>>>>>>>>>>>> worked for).
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> ∀ simulating halt decider H
> >>>>>>>>>>>>>>>>>>>>>>>>> ∀ machine description P
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> You don't seem to know what those words mean.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> The fact that the correct simulation of any input P to
> >>>>>>>>>>>>>>>>>>>>>>>>> any simulating halt decider (SHD) H would never stop
> >>>>>>>>>>>>>>>>>>>>>>>>> running unless this simulation was aborted by this SHD is
> >>>>>>>>>>>>>>>>>>>>>>>>> merely another way of saying that the correct and
> >>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of this input by this SHD would never
> >>>>>>>>>>>>>>>>>>>>>>>>> stop running.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Nope, not when the input depends on the behavior of the
> >>>>>>>>>>>>>>>>>>>>>>>> decider in the way you are doing it.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> P was intentionally defined to depend on the behavior of
> >>>>>>>>>>>>>>>>>>>>>>> its decider *NITWIT*
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Right, but your "example" didn't, and this dependency is the
> >>>>>>>>>>>>>>>>>>>>>> case that breaks your "proof" and definitions.
> >>>>>>>>>>>>>>>>>>>>> The correct simulation of the input by H(P,P) is the
> >>>>>>>>>>>>>>>>>>>>> simulation of this input at the same point in the execution
> >>>>>>>>>>>>>>>>>>>>> trace where H is invoked.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> (2 + 3) * 5 != 2 + (3 * 5) // order matters.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
> >>>>>>>>>>>>>>>>>>>> irrespective of "where" that simulation is done, at least if H
> >>>>>>>>>>>>>>>>>>>> is a computation, and if it isn't it can't be a decider.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Although H must be a computation all sequences of
> >>>>>>>>>>>>>>>>>>> configurations that do not halt are not computations**. The
> >>>>>>>>>>>>>>>>>>> behavior of H is the same no matter where it is invoked.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time,
> >>>>>>>>>>>>>>>>>> by the H you claim to be correct.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> The behavior of P need not be (and indeed is not) the same.
> >>>>>>>>>>>>>>>>>>> When P is invoked from main its behavior depends on the return
> >>>>>>>>>>>>>>>>>>> value of H. When P is correctly simulated by H the return value
> >>>>>>>>>>>>>>>>>>> from H is unreachable from every simulated P. This conclusively
> >>>>>>>>>>>>>>>>>>> proves that the execution of P from main() and the correct
> >>>>>>>>>>>>>>>>>>> simulation of P by H are not computationally equivalent.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> All of your rebuttals are simply false assumptions and nothing more.
> >>>>>>>>>>>>>>>>> I claim that
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> "When P is correctly simulated by H the return value from
> >>>>>>>>>>>>>>>>> H is unreachable from every simulated P."
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> SO? There is no requirement that H is able to see the resuts of
> >>>>>>>>>>>>>>>> the call inside the input it is simulating.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the
> >>>>>>>>>>>>>>>> behavior of P(P) or Simulate(P,P). The fact that H can't determine
> >>>>>>>>>>>>>>>> that is H's fault.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Do you disagree that the CORRECT answer is based on the ACTUAL
> >>>>>>>>>>>>>>>> BEHAVIOR of the ACUTAL INPUT?
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> H's inability to determine that is WHY it gets the wrong answer,
> >>>>>>>>>>>>>>>> not an excuse for it to do so.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> When you claim that I am incorrect it is merely an empty
> >>>>>>>>>>>>>>>>> assertion utterly bereft of supporting reasoning.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> No, you LITERALLY are making an empty assertion, as you are
> >>>>>>>>>>>>>>>> asserting something that never occurs.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> There is NO H that does a complete and correct simulation and
> >>>>>>>>>>>>>>>> returns an answer. We can even argue that it doesn't do a correct
> >>>>>>>>>>>>>>>> simulation since the last step of the simulation has an error as
> >>>>>>>>>>>>>>>> it presumes the wrong behavior of the call to H that it encounter
> >>>>>>>>>>>>>>>> (you can debate if this is an incorrect simulation or just unsound
> >>>>>>>>>>>>>>>> logic).
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> A simulating halt decider continues to simulate its input until
> >>>>>>>>>>>>>>>>> it correctly matches a correct infinite behavior pattern.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Then why does you H abort too soon, as shown by the fact that the
> >>>>>>>>>>>>>>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Just says that your H doesn't even meet your own definition.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
> >>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
> >>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> In order for me to actually be wrong you must be able to show
> >>>>>>>>>>>>>>>>> that some simulating halt decider Hx could be defined such that
> >>>>>>>>>>>>>>>>> its correct simulation of its input Px reaches the final state of
> >>>>>>>>>>>>>>>>> Px in a finite number of steps.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Nope. H(P,P) is wrong
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> ..then a mistake could be shown, if no mistake can be shown then it
> >>>>>>>>>>>>>>> is not wrong.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> And it has been.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Even YOU hav published the correct and complete simuliaton of the
> >>>>>>>>>>>>>> input to H(P,P) being the trace of P(P) and Simulate(P,P)
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> I contend that that no simulating halt decider Hx can be defined
> >>>>>>>>>>>>>>> such that its correctly simulated input Px could reach the final
> >>>>>>>>>>>>>>> state of this simulated Px in any finite number of steps.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> So, that isn't the question.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> *I STIPULATE FOR THIS THREAD THAT IS THE QUESTION*
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Any rebuttal must show all of the steps of exactly how the input to
> >>>>>>>>>>>>> Hx(Px,Px) correctly simulated by Hx reaches the final state of Px in
> >>>>>>>>>>>>> a finite number of steps.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> ALTERNATIVELY YOU COULD SIMPLY ADMIT THE TRUTH
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> You don't get to stipulate the test,
> >>>>>>>>>>>
> >>>>>>>>>>> In other words you know that my statement is correct and you are too
> >>>>>>>>>>> dishonest to admit it.
> >>>>>>>>>>>
> >>>>>>>>>> Nope, shows you don't understand about requirements.
> >>>>>>>>> Ultimately, you are a shit for brains fucking idiot because you have admitted unsatisfiable requirements.
> >>>>>>>>>
> >>>>>>>>> It is precisely because the requirements are unsatisfiable they amount to nothing other than The bottom/uninhabited type. Falsity.
> >>>>>>>>>
> >>>>>>>>> https://en.wikipedia.org/wiki/Bottom_type
> >>>>>>>> Nope, given an H, the answer is defined , and computabe if we know that
> >>>>>>>> H does return an answer.
> >>>>>>> How? There is no H for the pathological P.
> >>>>>>> Furthermore because the dependencies of P are unsatisfiable (P requires H) there is also no P.
> >>>>>> Because Olcott has defined what he calls H.
> >>>>>>
> >>>>>> Yes, H doesn't meet the requirements, but he claims it does and we are
> >>>>>> showing that H is incorrect.
> >>>>> But why are you so concerned with showing that H is incorrect; while being so unconcerned by the fact that the requirements are incorrect?
> >>>>>
> >>>>> The requirements amount to falsify!
> >>>> The requirements are correct, BY DEFINITION, they require what they require.
> >>> But the requirements require you to violate the principle you cherish so dearly!
> >>>
> >>> The requirements clash with YOUR principle!
> >> What clash?
> >>
> >> Remember, H isn't a Halt Decider, it is something some CLAIMS
> >> (incorrectly) to be a Halt Decider.
> > Obviously! Because YOU admitted that Halt Deciders don’t exist!
> >
> > So what are YOU talking about when you are talking about non-existing entities?!?
> Where did I actually talk about a non-existant entity exist?
Oracles!

Skep Dick <skepdick22@gmail.com> writes:

> Wow… is it just me or is this like the 4th or 5th time you’ve dodged
> my other question also?!?

I've no idea. Why should I answer any of your questions?

--
Ben.

On Monday, 5 September 2022 at 02:54:08 UTC+2, richar...@gmail.com wrote:
> On 9/4/22 8:37 PM, Skep Dick wrote:
> > On Monday, 5 September 2022 at 02:17:39 UTC+2, richar...@gmail.com wrote:
> >> On 9/4/22 7:40 PM, Skep Dick wrote:
> >>> On Monday, 5 September 2022 at 01:19:56 UTC+2, richar...@gmail.com wrote:
> >>>> On 9/4/22 6:58 PM, Skep Dick wrote:
> >>>>> On Monday, 5 September 2022 at 00:50:31 UTC+2, richar...@gmail.com wrote:
> >>>>>> And proves that his links don't actually mean the thing he is claiming
> >>>>>> they define.
> >>>>>
> >>>>> I am calling you out in your bullshit. Again.
> >>>>>
> >>>>> What do you mean by “meaning”?
> >>>>> Define “define”.
> >>>> First Principles, so out of your understanding.
> >>> Those are questions of first principles, you shit for brains fucking idiot!
> >>>
> >>> From first principles: explain what you mean by “meaning”.
> >>> From first principles: define “define”
> >>>
> >> So, you just don't understand what First Princples Are?
> > I know exactly what first principles are. A clean slate.
> >
> >> From First Principles, we get the definition of "meaning" and "define'
> > There are no definitions on the clean slate of first principles
> >
> > That is why I have asked you to put them on the slate.
> >
> Then you haven't accepted the First Principles. You don't end up with an
> clean/empty slate with First Principles, you start with a slate filled
> with them, which include things lie "Meaning" and "Define"
> >> Since you don't see to accept first principles, your stuck in the
> >> problem of trying to define your definitions.
> > Of course I accept first principles.
> >
> > I am waiting on you to put something on the clean slate.
> > I am waiting on you to materialise the objects of “meaning” and “definition” in The Empty Construct.
> Then you haven't accepted First Principles.
Yes, I have. Stop lying.

The First Principle is there are NO principles!
The second principle is to define some principles.

> >>>> And you do know that the paradox has answers? Many of course require you
> >>>> to accept that words DO have meaning
> >>> OBVIOUSLY I accept that!
> >>>
> >>> That is WHY I am asking you to explain what you mean by “meaning” from first principles!
> >> Which is exactly what the acceptance of First Principels gets you.
> > That isn’t first principles.
> >
> > That is second hand principles.
> Nope, that is what I define as "First Principles"
But you haven’t even defined “define”.

> Note, part of "First Principles" is that they aren't just yours, so I
> guess you can call them second hand.
Naaah, this sounds like absolute bullshit!

Where first ever (in the history of all humanity) First Principles thinker obtain their First Principles from?

> They are emdedded in the concept of First Principles, which you clearly
> do not understand.
Obviously I don’t understand! It is a concept you can’t express.

> >> Of course it is recursive, that is the nature of First Principles.
> > Recursion is just computation. There are no first principles in the computer.
> >
> > Unless you put them there.
> Not all recursion is computaiton. You are showing your lack of
> understanding of the True Meaning of First Principles,.
You can capitalise it all you want…. When you start talking about True Meaning I can be assured I am talking to a bullshitter extraordinaire!

What do you mean by “meaning”?
What do you mean by “true”?

> > You do understand that mutually recursive definitions don’t halt in computational terms, right?
> Yep, which is the proble with trying to define things as computations.
Why is it a “problem” ?

Non-halting mutually recursive functions are ubiquitous!

> It is clear you have lost the handle of what First Principles are, which
> makes your system ineffective because it has no base.
Evidently your First Principles are themselves baseless.

On Monday, 5 September 2022 at 03:59:38 UTC+2, Ben Bacarisse wrote:
> Skep Dick <skepd...@gmail.com> writes:
>
> > Wow… is it just me or is this like the 4th or 5th time you’ve dodged
> > my other question also?!?
> I've no idea. Why should I answer any of your questions?

Why shouldn’t you?

You are already making assertions.

Every assertive statement is basically a yes-decider to an yes/no question...

“The sky is blue.” means exactly the same thing as “Is the sky blue? Yes.”
Query languages. Surely you are familiar with the formalisms?

x=x is a question. Not a statement.

On 9/4/2022 8:59 PM, Ben Bacarisse wrote:
> Skep Dick <skepdick22@gmail.com> writes:
>
>> Wow… is it just me or is this like the 4th or 5th time you’ve dodged
>> my other question also?!?
>
> I've no idea. Why should I answer any of your questions?
>

It is a mandatory part of an honest dialogue. If you are aiming for a
dishonest dialogue (on your part) then feel free to dodge questions.

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

On 9/4/22 9:50 PM, Skep Dick wrote:
> On Monday, 5 September 2022 at 02:44:04 UTC+2, richar...@gmail.com wrote:
>> On 9/4/22 8:24 PM, Skep Dick wrote:
>>> On Monday, 5 September 2022 at 01:45:53 UTC+2, richar...@gmail.com wrote:
>>>> On 9/4/22 7:35 PM, Skep Dick wrote:
>>>>> On Monday, 5 September 2022 at 00:58:13 UTC+2, richar...@gmail.com wrote:
>>>>>> On 9/4/22 6:02 PM, Skep Dick wrote:
>>>>>>> On Sunday, 4 September 2022 at 22:46:44 UTC+2, richar...@gmail.com wrote:
>>>>>>>> On 9/4/22 4:33 PM, Skep Dick wrote:
>>>>>>>>> On Sunday, 4 September 2022 at 22:24:14 UTC+2, richar...@gmail.com wrote:
>>>>>>>>>> On 9/4/22 4:01 PM, Skep Dick wrote:
>>>>>>>>>>> On Sunday, 4 September 2022 at 21:52:16 UTC+2, richar...@gmail.com wrote:
>>>>>>>>>>>> On 9/4/22 3:30 PM, olcott wrote:
>>>>>>>>>>>>> On 9/4/2022 2:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/4/22 3:16 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/4/2022 2:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/4/22 2:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/4/2022 1:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/4/22 1:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 9/4/22 12:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 12:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 1:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:56 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:03:48 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:50 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 1:43:43 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:00 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:54:54
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you won't go by the oficial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions, your H just isn't a Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the official definitions are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then at least one of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> them must be rejected as incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you are wrong here. The official
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory, in that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible to build anything which meets
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition. This has been proved.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not the way truth works mate. If
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the official definitions are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then I have also had new
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> insight on that another
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aspect of computer science is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you are not disputing that official
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a halt decider is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input is guaranteed to derive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must abort the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input to prevent the infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of this input is merely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another way of saying the the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by this SHD would never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When computer science textbooks say that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that a halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must report on is the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine represented by this input and this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior is not the same as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct and complete simulation of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input then the computer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> science textbooks are wrong because they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reject the definition of a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (simulator).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I was hoping for more of a yes-or-no type answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When I provide a complete explanation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning behind the answer all those not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding these things cannot simply
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> baselessly disagree. All disagreement is thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required to have a basis. This way people are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not lead astray by a bunch of baseless
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagreement, they see that the disagreement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has no basis and reject it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reasoning, starting from ACCEPTED definition.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just make wild claims based on your own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding of the words.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the words, no one can help you with your logic.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, Most of the things you are talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HAVE well defined meanings, so you either need
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to use that meaning, or you really need to give
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your idea a new name (maybe basd on the common
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> name with a modifier).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same as the accepted definition, you can call it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PO-Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of course the problem with this is it makes it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clear that you are talking about the PO-Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, with a PO-Halting Decider, so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> counter example doesn't affect the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, so it is clear you haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proven what you claim to have proven.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that the definition is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory. You're not disputing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that proof?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You haven't actually given a proof, since you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are clearly using altered definition that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aren't providing.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You reject the notion of a UTM so you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> starting with an incorrect basis.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM(P,d) by DEFINITION gives the exact same result
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as P(d).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When you get a glass of water and dump it on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> floor you cannot truthfully deny that the floor is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wet.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And I haven't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correct and complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by H(P,P) would have different behavior than
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of P(P) this cannot simply be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ignored.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct and complete simulation of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that the simulation by H(P,P) of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running unless H aborts the simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input is merely another way of saying that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of this input by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have bad logic there.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is a tautology:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input would never stop running unless H0 aborts the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input is merely another way of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> saying that the correct and complete simulation of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by H0 never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Strawman.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Fallacy of Proof by Example.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> It is only a fallacy by proof of example when a single
>>>>>>>>>>>>>>>>>>>>>>>>>>> example is not representative of the entire class of all
>>>>>>>>>>>>>>>>>>>>>>>>>>> such examples.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Which it isn't, so FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You are confusing existential quantification with
>>>>>>>>>>>>>>>>>>>>>>>>>>> universal quantification.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> No you are, since you are claiming the rule works for ALL
>>>>>>>>>>>>>>>>>>>>>>>>>> inputs (or at least P, which isn't the input you showed it
>>>>>>>>>>>>>>>>>>>>>>>>>> worked for).
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> ∀ simulating halt decider H
>>>>>>>>>>>>>>>>>>>>>>>>>>> ∀ machine description P
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You don't seem to know what those words mean.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that the correct simulation of any input P to
>>>>>>>>>>>>>>>>>>>>>>>>>>> any simulating halt decider (SHD) H would never stop
>>>>>>>>>>>>>>>>>>>>>>>>>>> running unless this simulation was aborted by this SHD is
>>>>>>>>>>>>>>>>>>>>>>>>>>> merely another way of saying that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of this input by this SHD would never
>>>>>>>>>>>>>>>>>>>>>>>>>>> stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, not when the input depends on the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>> decider in the way you are doing it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> P was intentionally defined to depend on the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>> its decider *NITWIT*
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Right, but your "example" didn't, and this dependency is the
>>>>>>>>>>>>>>>>>>>>>>>> case that breaks your "proof" and definitions.
>>>>>>>>>>>>>>>>>>>>>>> The correct simulation of the input by H(P,P) is the
>>>>>>>>>>>>>>>>>>>>>>> simulation of this input at the same point in the execution
>>>>>>>>>>>>>>>>>>>>>>> trace where H is invoked.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> (2 + 3) * 5 != 2 + (3 * 5) // order matters.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
>>>>>>>>>>>>>>>>>>>>>> irrespective of "where" that simulation is done, at least if H
>>>>>>>>>>>>>>>>>>>>>> is a computation, and if it isn't it can't be a decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Although H must be a computation all sequences of
>>>>>>>>>>>>>>>>>>>>> configurations that do not halt are not computations**. The
>>>>>>>>>>>>>>>>>>>>> behavior of H is the same no matter where it is invoked.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time,
>>>>>>>>>>>>>>>>>>>> by the H you claim to be correct.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The behavior of P need not be (and indeed is not) the same.
>>>>>>>>>>>>>>>>>>>>> When P is invoked from main its behavior depends on the return
>>>>>>>>>>>>>>>>>>>>> value of H. When P is correctly simulated by H the return value
>>>>>>>>>>>>>>>>>>>>> from H is unreachable from every simulated P. This conclusively
>>>>>>>>>>>>>>>>>>>>> proves that the execution of P from main() and the correct
>>>>>>>>>>>>>>>>>>>>> simulation of P by H are not computationally equivalent.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> All of your rebuttals are simply false assumptions and nothing more.
>>>>>>>>>>>>>>>>>>> I claim that
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> "When P is correctly simulated by H the return value from
>>>>>>>>>>>>>>>>>>> H is unreachable from every simulated P."
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> SO? There is no requirement that H is able to see the resuts of
>>>>>>>>>>>>>>>>>> the call inside the input it is simulating.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the
>>>>>>>>>>>>>>>>>> behavior of P(P) or Simulate(P,P). The fact that H can't determine
>>>>>>>>>>>>>>>>>> that is H's fault.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Do you disagree that the CORRECT answer is based on the ACTUAL
>>>>>>>>>>>>>>>>>> BEHAVIOR of the ACUTAL INPUT?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H's inability to determine that is WHY it gets the wrong answer,
>>>>>>>>>>>>>>>>>> not an excuse for it to do so.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When you claim that I am incorrect it is merely an empty
>>>>>>>>>>>>>>>>>>> assertion utterly bereft of supporting reasoning.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, you LITERALLY are making an empty assertion, as you are
>>>>>>>>>>>>>>>>>> asserting something that never occurs.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> There is NO H that does a complete and correct simulation and
>>>>>>>>>>>>>>>>>> returns an answer. We can even argue that it doesn't do a correct
>>>>>>>>>>>>>>>>>> simulation since the last step of the simulation has an error as
>>>>>>>>>>>>>>>>>> it presumes the wrong behavior of the call to H that it encounter
>>>>>>>>>>>>>>>>>> (you can debate if this is an incorrect simulation or just unsound
>>>>>>>>>>>>>>>>>> logic).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A simulating halt decider continues to simulate its input until
>>>>>>>>>>>>>>>>>>> it correctly matches a correct infinite behavior pattern.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Then why does you H abort too soon, as shown by the fact that the
>>>>>>>>>>>>>>>>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Just says that your H doesn't even meet your own definition.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> In order for me to actually be wrong you must be able to show
>>>>>>>>>>>>>>>>>>> that some simulating halt decider Hx could be defined such that
>>>>>>>>>>>>>>>>>>> its correct simulation of its input Px reaches the final state of
>>>>>>>>>>>>>>>>>>> Px in a finite number of steps.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope. H(P,P) is wrong
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> ..then a mistake could be shown, if no mistake can be shown then it
>>>>>>>>>>>>>>>>> is not wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And it has been.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Even YOU hav published the correct and complete simuliaton of the
>>>>>>>>>>>>>>>> input to H(P,P) being the trace of P(P) and Simulate(P,P)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I contend that that no simulating halt decider Hx can be defined
>>>>>>>>>>>>>>>>> such that its correctly simulated input Px could reach the final
>>>>>>>>>>>>>>>>> state of this simulated Px in any finite number of steps.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, that isn't the question.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *I STIPULATE FOR THIS THREAD THAT IS THE QUESTION*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Any rebuttal must show all of the steps of exactly how the input to
>>>>>>>>>>>>>>> Hx(Px,Px) correctly simulated by Hx reaches the final state of Px in
>>>>>>>>>>>>>>> a finite number of steps.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> ALTERNATIVELY YOU COULD SIMPLY ADMIT THE TRUTH
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You don't get to stipulate the test,
>>>>>>>>>>>>>
>>>>>>>>>>>>> In other words you know that my statement is correct and you are too
>>>>>>>>>>>>> dishonest to admit it.
>>>>>>>>>>>>>
>>>>>>>>>>>> Nope, shows you don't understand about requirements.
>>>>>>>>>>> Ultimately, you are a shit for brains fucking idiot because you have admitted unsatisfiable requirements.
>>>>>>>>>>>
>>>>>>>>>>> It is precisely because the requirements are unsatisfiable they amount to nothing other than The bottom/uninhabited type. Falsity.
>>>>>>>>>>>
>>>>>>>>>>> https://en.wikipedia.org/wiki/Bottom_type
>>>>>>>>>> Nope, given an H, the answer is defined , and computabe if we know that
>>>>>>>>>> H does return an answer.
>>>>>>>>> How? There is no H for the pathological P.
>>>>>>>>> Furthermore because the dependencies of P are unsatisfiable (P requires H) there is also no P.
>>>>>>>> Because Olcott has defined what he calls H.
>>>>>>>>
>>>>>>>> Yes, H doesn't meet the requirements, but he claims it does and we are
>>>>>>>> showing that H is incorrect.
>>>>>>> But why are you so concerned with showing that H is incorrect; while being so unconcerned by the fact that the requirements are incorrect?
>>>>>>>
>>>>>>> The requirements amount to falsify!
>>>>>> The requirements are correct, BY DEFINITION, they require what they require.
>>>>> But the requirements require you to violate the principle you cherish so dearly!
>>>>>
>>>>> The requirements clash with YOUR principle!
>>>> What clash?
>>>>
>>>> Remember, H isn't a Halt Decider, it is something some CLAIMS
>>>> (incorrectly) to be a Halt Decider.
>>> Obviously! Because YOU admitted that Halt Deciders don’t exist!
>>>
>>> So what are YOU talking about when you are talking about non-existing entities?!?
>> Where did I actually talk about a non-existant entity exist?
> Oracles!
>
> Is the set of “correct halting deciders” empty, or do oracles belong to that set ?!?

On 9/4/22 10:03 PM, Skep Dick wrote:
> On Monday, 5 September 2022 at 02:54:08 UTC+2, richar...@gmail.com wrote:
>> On 9/4/22 8:37 PM, Skep Dick wrote:
>>> On Monday, 5 September 2022 at 02:17:39 UTC+2, richar...@gmail.com wrote:
>>>> On 9/4/22 7:40 PM, Skep Dick wrote:
>>>>> On Monday, 5 September 2022 at 01:19:56 UTC+2, richar...@gmail.com wrote:
>>>>>> On 9/4/22 6:58 PM, Skep Dick wrote:
>>>>>>> On Monday, 5 September 2022 at 00:50:31 UTC+2, richar...@gmail.com wrote:
>>>>>>>> And proves that his links don't actually mean the thing he is claiming
>>>>>>>> they define.
>>>>>>>
>>>>>>> I am calling you out in your bullshit. Again.
>>>>>>>
>>>>>>> What do you mean by “meaning”?
>>>>>>> Define “define”.
>>>>>> First Principles, so out of your understanding.
>>>>> Those are questions of first principles, you shit for brains fucking idiot!
>>>>>
>>>>> From first principles: explain what you mean by “meaning”.
>>>>> From first principles: define “define”
>>>>>
>>>> So, you just don't understand what First Princples Are?
>>> I know exactly what first principles are. A clean slate.
>>>
>>>> From First Principles, we get the definition of "meaning" and "define'
>>> There are no definitions on the clean slate of first principles
>>>
>>> That is why I have asked you to put them on the slate.
>>>
>> Then you haven't accepted the First Principles. You don't end up with an
>> clean/empty slate with First Principles, you start with a slate filled
>> with them, which include things lie "Meaning" and "Define"
>>>> Since you don't see to accept first principles, your stuck in the
>>>> problem of trying to define your definitions.
>>> Of course I accept first principles.
>>>
>>> I am waiting on you to put something on the clean slate.
>>> I am waiting on you to materialise the objects of “meaning” and “definition” in The Empty Construct.
>> Then you haven't accepted First Principles.
> Yes, I have. Stop lying.
>
> The First Principle is there are NO principles!
> The second principle is to define some principles.

And because you think that, you don't understand First Princples, and
quite likely CAN'T understand them.

>
>>>>>> And you do know that the paradox has answers? Many of course require you
>>>>>> to accept that words DO have meaning
>>>>> OBVIOUSLY I accept that!
>>>>>
>>>>> That is WHY I am asking you to explain what you mean by “meaning” from first principles!
>>>> Which is exactly what the acceptance of First Principels gets you.
>>> That isn’t first principles.
>>>
>>> That is second hand principles.
>> Nope, that is what I define as "First Principles"
> But you haven’t even defined “define”.

It is just part of the First Principle package I use.

>
>> Note, part of "First Principles" is that they aren't just yours, so I
>> guess you can call them second hand.
> Naaah, this sounds like absolute bullshit!
>
> Where first ever (in the history of all humanity) First Principles thinker obtain their First Principles from?

They Didn't. They tend to not come from *A* thinker, but from a group
working together to refine and test the ideas.

>
>> They are emdedded in the concept of First Principles, which you clearly
>> do not understand.
> Obviously I don’t understand! It is a concept you can’t express.

Yes, becaue you reject the concepts.

>
>>>> Of course it is recursive, that is the nature of First Principles.
>>> Recursion is just computation. There are no first principles in the computer.
>>>
>>> Unless you put them there.
>> Not all recursion is computaiton. You are showing your lack of
>> understanding of the True Meaning of First Principles,.
> You can capitalise it all you want…. When you start talking about True Meaning I can be assured I am talking to a bullshitter extraordinaire!
>
> What do you mean by “meaning”?
> What do you mean by “true”?

Since it is clear you don't (and probably can't) understand my concept
of First Principles, I can't explain them to you.

>
>>> You do understand that mutually recursive definitions don’t halt in computational terms, right?
>> Yep, which is the proble with trying to define things as computations.
> Why is it a “problem” ?
>
> Non-halting mutually recursive functions are ubiquitous!

Because computations are only really useful if they halt.

>
>> It is clear you have lost the handle of what First Principles are, which
>> makes your system ineffective because it has no base.
> Evidently your First Principles are themselves baseless.

Nope, just not-understandable by someone who refuses them.

You are just condeming yourself into a lack of meaning because you don't
have anything to start your definitions from.

On 9/4/22 10:20 PM, olcott wrote:
> On 9/4/2022 8:59 PM, Ben Bacarisse wrote:
>> Skep Dick <skepdick22@gmail.com> writes:
>>
>>> Wow… is it just me or is this like the 4th or 5th time you’ve dodged
>>> my other question also?!?
>>
>> I've no idea.  Why should I answer any of your questions?
>>
>
> It is a mandatory part of an honest dialogue. If you are aiming for a
> dishonest dialogue (on your part) then feel free to dodge questions.
>

So, why don't YOU answer any of the questions put to you?

Do you accept the official definition of a Halt Decider, where the
correct answer for H(P,d) is based on the behavior of the computation
that its input represents, P(d).

If Yes?, why do you say H(P,P) == 0 is correct when P(P) Halts if H(P,P)
returns 0.

If No? How do you claim your H is a Correct Halt Decider if it doesn't
meet the definition of a Halt Decider?

On 9/4/22 6:17 PM, Skep Dick wrote:
> On Sunday, 4 September 2022 at 22:50:46 UTC+2, richar...@gmail.com wrote:
>> On 9/4/22 4:26 PM, Skep Dick wrote:
>>> On Sunday, 4 September 2022 at 22:11:41 UTC+2, richar...@gmail.com wrote:
>>>> On 9/4/22 3:52 PM, Skep Dick wrote:
>>>>> On Sunday, 4 September 2022 at 18:44:17 UTC+2, richar...@gmail.com wrote:
>>>>>> On 9/4/22 8:15 AM, Skep Dick wrote:
>>>>>>> On Sunday, 4 September 2022 at 12:56:47 UTC+2, richar...@gmail.com wrote:
>>>>>>>> On 9/4/22 3:08 AM, Skep Dick wrote:
>>>>>>>>> On Saturday, 3 September 2022 at 19:24:40 UTC+2, richar...@gmail.com wrote:
>>>>>>>>>> On 9/3/22 1:18 PM, olcott wrote:
>>>>>>>>>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/3/22 12:56 PM, olcott wrote:
>>>>>>>>>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/3/22 12:32 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:03:48 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:50 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 1:43:43 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/3/2022 7:00 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, September 3, 2022 at 2:54:54 AM UTC+1,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you won't go by the oficial definitions, your H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just isn't a Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the official definitions are self-contradictory
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then at least one of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> them must be rejected as incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you are wrong here. The official definition of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider is self-contradictory, in that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible to build anything which meets the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition. This has been proved.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not the way truth works mate. If the official
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-contradictory then I have also had new insight
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on that another
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aspect of computer science is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you are not disputing that official definition of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider is self-contradictory?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of an input is
>>>>>>>>>>>>>>>>>>>>>>>>>>> guaranteed to derive
>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD) must abort
>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input to prevent the infinite execution of this
>>>>>>>>>>>>>>>>>>>>>>>>>>> input is merely
>>>>>>>>>>>>>>>>>>>>>>>>>>> another way of saying the the correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>> input by this SHD would never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> When computer science textbooks say that the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>> that a halt
>>>>>>>>>>>>>>>>>>>>>>>>>>> decider must report on is the behavior of the direct
>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of the
>>>>>>>>>>>>>>>>>>>>>>>>>>> machine represented by this input and this behavior is
>>>>>>>>>>>>>>>>>>>>>>>>>>> not the same as
>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct and complete simulation of this input then
>>>>>>>>>>>>>>>>>>>>>>>>>>> the computer
>>>>>>>>>>>>>>>>>>>>>>>>>>> science textbooks are wrong because they reject the
>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>>> (simulator).
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I was hoping for more of a yes-or-no type answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When I provide a complete explanation of the reasoning
>>>>>>>>>>>>>>>>>>>>>>>>> behind the answer all those not understanding these
>>>>>>>>>>>>>>>>>>>>>>>>> things cannot simply baselessly disagree. All
>>>>>>>>>>>>>>>>>>>>>>>>> disagreement is thus required to have a basis. This way
>>>>>>>>>>>>>>>>>>>>>>>>> people are not lead astray by a bunch of baseless
>>>>>>>>>>>>>>>>>>>>>>>>> disagreement, they see that the disagreement has no basis
>>>>>>>>>>>>>>>>>>>>>>>>> and reject it.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID reasoning,
>>>>>>>>>>>>>>>>>>>>>>>> starting from ACCEPTED definition.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You just make wild claims based on your own understanding
>>>>>>>>>>>>>>>>>>>>>>>> of the words.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE the words,
>>>>>>>>>>>>>>>>>>>>>>>> no one can help you with your logic.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Note, Most of the things you are talking about HAVE well
>>>>>>>>>>>>>>>>>>>>>>>> defined meanings, so you either need to use that meaning,
>>>>>>>>>>>>>>>>>>>>>>>> or you really need to give your idea a new name (maybe
>>>>>>>>>>>>>>>>>>>>>>>> basd on the common name with a modifier).
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the same as the
>>>>>>>>>>>>>>>>>>>>>>>> accepted definition, you can call it PO-Halting.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Of course the problem with this is it makes it clear that
>>>>>>>>>>>>>>>>>>>>>>>> you are talking about the PO-Halting Problem, with a
>>>>>>>>>>>>>>>>>>>>>>>> PO-Halting Decider, so you counter example doesn't affect
>>>>>>>>>>>>>>>>>>>>>>>> the actual Halting Problem, so it is clear you haven't
>>>>>>>>>>>>>>>>>>>>>>>> proven what you claim to have proven.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the definition is self-contradictory. You're not
>>>>>>>>>>>>>>>>>>>>>>>>>>>> disputing that proof?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You haven't actually given a proof, since you are clearly
>>>>>>>>>>>>>>>>>>>>>>>> using altered definition that you aren't providing.
>>>>>>>>>>>>>>>>>>>>>>> You reject the notion of a UTM so you are starting with an
>>>>>>>>>>>>>>>>>>>>>>> incorrect basis.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d) by
>>>>>>>>>>>>>>>>>>>>>> DEFINITION gives the exact same result as P(d).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When you get a glass of water and dump it on the floor you
>>>>>>>>>>>>>>>>>>>>> cannot truthfully deny that the floor is wet.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And I haven't
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When the correct and complete simulation of the input by
>>>>>>>>>>>>>>>>>>>>> H(P,P) would have different behavior than the direct
>>>>>>>>>>>>>>>>>>>>> execution of P(P) this cannot simply be ignored.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And the correct and complete simulation of the input to H(P,P)
>>>>>>>>>>>>>>>>>>>> Halts.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The fact that the simulation by H(P,P) of its input never stops
>>>>>>>>>>>>>>>>>>> running unless H aborts the simulation of this input is merely
>>>>>>>>>>>>>>>>>>> another way of saying that the correct and complete simulation
>>>>>>>>>>>>>>>>>>> of this input by H never halts.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You have bad logic there.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is a tautology:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of its input
>>>>>>>>>>>>>>>>> would never stop running unless H0 aborts the simulation of this
>>>>>>>>>>>>>>>>> input is merely another way of saying that the correct and
>>>>>>>>>>>>>>>>> complete simulation of this input by H0 never halts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Strawman.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Fallacy of Proof by Example.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is only a fallacy by proof of example when a single example is
>>>>>>>>>>>>>>> not representative of the entire class of all such examples.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Which it isn't, so FAIL.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are confusing existential quantification with universal
>>>>>>>>>>>>>>> quantification.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No you are, since you are claiming the rule works for ALL inputs (or
>>>>>>>>>>>>>> at least P, which isn't the input you showed it worked for).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> ∀ simulating halt decider H
>>>>>>>>>>>>>>> ∀ machine description P
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You don't seem to know what those words mean.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The fact that the correct simulation of any input P to any
>>>>>>>>>>>>>>> simulating halt decider (SHD) H would never stop running unless
>>>>>>>>>>>>>>> this simulation was aborted by this SHD is merely another way of
>>>>>>>>>>>>>>> saying that the correct and complete simulation of this input by
>>>>>>>>>>>>>>> this SHD would never stop running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope, not when the input depends on the behavior of the decider in
>>>>>>>>>>>>>> the way you are doing it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> P was intentionally defined to depend on the behavior of its decider
>>>>>>>>>>>>> *NITWIT*
>>>>>>>>>>>>
>>>>>>>>>>>> Right, but your "example" didn't, and this dependency is the case that
>>>>>>>>>>>> breaks your "proof" and definitions.
>>>>>>>>>>> The correct simulation of the input by H(P,P) is the simulation of this
>>>>>>>>>>> input at the same point in the execution trace where H is invoked.
>>>>>>>>>>>
>>>>>>>>>>> (2 + 3) * 5 != 2 + (3 * 5) // order matters.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
>>>>>>>>>> irrespective of "where" that simulation is done, at least if H is a
>>>>>>>>>> computation, and if it isn't it can't be a decider.
>>>>>>>>>>
>>>>>>>>>> The CORRECT equivalent to the above would be:
>>>>>>>>>>
>>>>>>>>>> Add(2, 3) * 5 == 5 * Add(2, 3)
>>>>>>>>> You shit for brains fucking idiot! That is not true.
>>>>>>>>>
>>>>>>>>> https://en.wikipedia.org/wiki/Noncommutative_ring
>>>>>>>>>
>>>>>>>> Except both are 5 * 5 so the commutative property isn't needed.
>>>>>>>>
>>>>>>>> You are just being a DICK.
>>>>>>> You shit for brains fucking idiot. It is axiomatic THAT x.y != y.x (1)
>>>>>>
>>>>>> You axioms seem to be wrong.
>>>>>>
>>>>>> Non commutative rings say that x.y MIGHT NOT EQUAL to y.x, not that they
>>>>>> ARE different.
>>>>> So they might be equal, or they might be NOT equal!
>>>>>
>>>>> Provide a continuous function deciding one of the other.
>>>>>
>>>>> Provide a proof.
>>>> I don't need to.
>>>>>
>>>>>> Your logic system is incorrect.
>>>>> No, it isn’t. It only rejects all of your axioms.
>>>> No, since YOU system has an AXIOM that says x.y != y.x for ALL x, y
>>>> (since you didn't limit the domain)
>>>>
>>>> The simple counter example of let y = x, the we have by your axiom that
>>>> x.x != x.x
>>>>
>>>> WHich says that . isn't a consistent operator, and thus is a contradition.
>>> What are you on about, idiot?
>>>
>>> That is precisely how you prove negation!
>>>
>>> This is a system in which x=x is not a theorem.
>>> This is a system in which not(x=x) is a theorem!
>> So a system of foolishness.
> “Foolishness” is undecidable.
> not(x=x) Is decidable.
>
>
>>>>>> Seems your logic syste asserts wrong statement by its axioms.
>>>>> No, it doesn’t. It decides precisely P, or not P. Key word - decides.
>>>> Nope, can't since it has a false axiom in it.
>>> No it doesn’t. It has a true negation, not a true falsity.
>>>
>>>>> Double fail.
>>>>>
>>>> Nope, Non-brokenness is undecidable
>>>>
>>>> Brokenness is sometimes demonstratable.
>>>>
>>>> You don't seem to understand what things mean.
>>> You don’t seem to understand what meaning IS.
>> You have abandoned the concept of meaning.
> No, I haven’t. I am using the word/concept of “meaning” - therefore it is meaningful.
>
> Maybe you want to be explicit about what you mean by “meaning”?