Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

lp1 on fire -- One of the more obfuscated kernel messages

computers / comp.ai.philosophy / Re: Termination Analyzer H correctly prevents Denial of Service attacks

SubjectAuthor
* Re: Termination Analyzer H correctly prevents Denial of Serviceolcott
`* Re: Termination Analyzer H correctly prevents Denial of ServiceRichard Damon
 `* Re: Termination Analyzer H correctly prevents Denial of Serviceolcott
  `* Re: Termination Analyzer H correctly prevents Denial of ServiceRichard Damon
   `* Re: Termination Analyzer H correctly prevents Denial of Serviceolcott
    `* Re: Termination Analyzer H correctly prevents Denial of ServiceRichard Damon
     `* Re: Termination Analyzer H correctly prevents Denial of Serviceolcott
      `* Re: Termination Analyzer H correctly prevents Denial of ServiceRichard Damon
       `* Re: Termination Analyzer H correctly prevents Denial of Serviceolcott
        `- Re: Termination Analyzer H correctly prevents Denial of ServiceRichard Damon

1
Re: Termination Analyzer H correctly prevents Denial of Service attacks

<u6dl33$5c39$1@dont-email.me>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=11305&group=comp.ai.philosophy#11305

  copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
Subject: Re: Termination Analyzer H correctly prevents Denial of Service
attacks
Date: Wed, 14 Jun 2023 19:13:21 -0500
Organization: A noiseless patient Spider
Lines: 275
Message-ID: <u6dl33$5c39$1@dont-email.me>
References: <u6a1ac$3klfk$3@dont-email.me> <686iM.5048$SaD4.4456@fx39.iad>
<u6arsr$3o1o8$1@dont-email.me> <Sv6iM.3959$Yxn4.2146@fx38.iad>
<u6b09r$3oj1r$1@dont-email.me> <1l8iM.34944$AF%b.10982@fx12.iad>
<u6b9nf$3t9u1$1@dont-email.me> <t2aiM.19350$F2qf.3997@fx48.iad>
<u6bb6d$3teta$1@dont-email.me> <LjaiM.19351$F2qf.4750@fx48.iad>
<u6bc4s$3teta$2@dont-email.me> <8ChiM.8534$%6L8.5147@fx04.iad>
<u6cji6$1tjb$1@dont-email.me> <HnriM.1615$Vpga.1473@fx09.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 15 Jun 2023 00:13:23 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="fb9d20887a3ce8d0fd7f66c3017e22ca";
logging-data="176233"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19pp2AOpi+669ea16Y+MOTR"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.11.2
Cancel-Lock: sha1:tniGkDxxKmV54PyBuXMYxcy5T1g=
Content-Language: en-US
In-Reply-To: <HnriM.1615$Vpga.1473@fx09.iad>
 by: olcott - Thu, 15 Jun 2023 00:13 UTC

On 6/14/2023 5:42 PM, Richard Damon wrote:
> On 6/14/23 10:41 AM, olcott wrote:
>> On 6/14/2023 6:35 AM, Richard Damon wrote:
>>> On 6/13/23 11:28 PM, olcott wrote:
>>>> On 6/13/2023 10:18 PM, Richard Damon wrote:
>>>>> On 6/13/23 11:12 PM, olcott wrote:
>>>>>> On 6/13/2023 9:59 PM, Richard Damon wrote:
>>>>>>> On 6/13/23 10:47 PM, olcott wrote:
>>>>>>>> On 6/13/2023 8:02 PM, Richard Damon wrote:
>>>>>>>>> On 6/13/23 8:06 PM, olcott wrote:
>>>>>>>>>> On 6/13/2023 5:57 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/13/23 6:51 PM, olcott wrote:
>>>>>>>>>>>> On 6/13/2023 5:32 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 6/13/23 11:17 AM, olcott wrote:
>>>>>>>>>>>>>> The purpose of solving the halting problem is to determine
>>>>>>>>>>>>>> non-halting
>>>>>>>>>>>>>> bugs and non-halting malevolent software. My system
>>>>>>>>>>>>>> achieves that
>>>>>>>>>>>>>> purpose for the halting problem's otherwise impossible input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is only when the halting problem is construed as
>>>>>>>>>>>>>> providing a correct
>>>>>>>>>>>>>> yes/no answer to a self-contradictory question that the
>>>>>>>>>>>>>> halting problem
>>>>>>>>>>>>>> cannot be solved.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> // The following is written in C
>>>>>>>>>>>>>> //
>>>>>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate
>>>>>>>>>>>>>> its input
>>>>>>>>>>>>>> 03
>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>> 14   D(D);
>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Execution Trace
>>>>>>>>>>>>>> Line 14: main() invokes D(D)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> keeps repeating (unless aborted)
>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Simulation invariant:
>>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach its own
>>>>>>>>>>>>>> line 09.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When termination analyzer H is intended to prevent denial
>>>>>>>>>>>>>> of service
>>>>>>>>>>>>>> attacks is presented with an input D that has been defined
>>>>>>>>>>>>>> to have a
>>>>>>>>>>>>>> pathological relationship to this termination analyzer, it
>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>> aborts the simulation of this input that would have
>>>>>>>>>>>>>> otherwise caused H
>>>>>>>>>>>>>> to never terminate until system resources have been
>>>>>>>>>>>>>> exhausted, crashing
>>>>>>>>>>>>>> the system.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *The halting problem is an issue with denial of service
>>>>>>>>>>>>>> attacks*
>>>>>>>>>>>>>> https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The whole system is right here:
>>>>>>>>>>>>>> https://github.com/plolcott/x86utm
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It compiles with the 2017 version of the Community Edition
>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except that preventing "Denial of Service Attacks" is part
>>>>>>>>>>>>> of the requirement, just as giving the right answer. It
>>>>>>>>>>>>> needs to do BOTH, and the right answer isn't based on its
>>>>>>>>>>>>> simulation, but the actual behavior of the machine. Thus,
>>>>>>>>>>>>> trying to excuse the wrong answer as being due to a
>>>>>>>>>>>>> prevention of a "Denial of Service" is just an admissioon
>>>>>>>>>>>>> that the problem actually is IMPOSSIBLE.
>>>>>>>>>>>> When denial of service attacks define a pathological input
>>>>>>>>>>>> that would
>>>>>>>>>>>> otherwise cause the denial of service attack detector to eat
>>>>>>>>>>>> up system
>>>>>>>>>>>> resources and crash the system H detects this attempt and
>>>>>>>>>>>> thwarts it.
>>>>>>>>>>>> *This conclusively proves that H is correct*
>>>>>>>>>>>>
>>>>>>>>>>>> *How pathological inputs are currently handled*
>>>>>>>>>>>>   If a set of instructions ( in the smart contract) is
>>>>>>>>>>>> executed on the
>>>>>>>>>>>>   Ethereum Virtual Machine, it cannot predict how long these
>>>>>>>>>>>> will run
>>>>>>>>>>>>   for, at the beginning. If a set of instructions run
>>>>>>>>>>>> forever, they can
>>>>>>>>>>>>   freeze this blockchain and use up all the resources. This
>>>>>>>>>>>> is similar to
>>>>>>>>>>>>   a DoS (Denial of Service) attack. Each computation on the
>>>>>>>>>>>> Ethereum
>>>>>>>>>>>>   Virtual Machine requires some predetermined amount of gas
>>>>>>>>>>>> (which one
>>>>>>>>>>>>   has to buy with real money).
>>>>>>>>>>>>
>>>>>>>>>>>> (https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d)
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope. The decider is responsible to handle possible "Denial
>>>>>>>>>>> of Service Attacks", and the presence of them just points out
>>>>>>>>>>> the FUNDAMENTAL problem with your solution method. It has
>>>>>>>>>>> long been know that just relying on "Simulation" has
>>>>>>>>>>> significant issues for halt deciding, but since you have
>>>>>>>>>>> chosen to not look at history, you are just making the same
>>>>>>>>>>> mistakes made long ago.
>>>>>>>>>>>
>>>>>>>>>>> The CORRECT answer is ALWAYS the behavior of the Actual
>>>>>>>>>>> Machine, which in this case Halts.
>>>>>>>>>>>
>>>>>>>>>>> Therefore, H(D,D) saying that D(D) doesn't halt is just
>>>>>>>>>>> making H wrong.
>>>>>>>>>>>
>>>>>>>>>>> Claiming the wrong answer is right is just a LIE.
>>>>>>>>>>>
>>>>>>>>>> When simulating termination analyzer H is presented with an
>>>>>>>>>> input the
>>>>>>>>>> right answer is always: Must the simulation of the input be
>>>>>>>>>> aborted to
>>>>>>>>>> prevent the infinite execution of H? Yes is the correct answer.
>>>>>>>>>
>>>>>>>>> So, I guess you are admitting that a simulationg termination
>>>>>>>>> analyzer isn't a "Halting Decider" per the Computabilty Theory,
>>>>>>>>> since for those, the correct answer is always based on the
>>>>>>>>> actual behavior of the machine/input described by the input to
>>>>>>>>> the decider.
>>>>>>>>>
>>>>>>>>> You KNOW that fact, as you have quoted that defintion, though
>>>>>>>>> admittedly, while you blaim others for just quoting "learned by
>>>>>>>>> rote" statements, the statements you quote are probably just
>>>>>>>>> quoted by rote without ever actually learning what they mean.
>>>>>>>>>
>>>>>>>>> But, with your admission that your machine uses the WRONG
>>>>>>>>> criteria, you have just proven that you have been lying for the
>>>>>>>>> past decade that you have actually been working on the ACTUAL
>>>>>>>>> Halting Problem of Computation Theory as discussed by Turing,
>>>>>>>>> Linz, et all.
>>>>>>>>>
>>>>>>>>> All you have done is proved that you are the Hypocritical
>>>>>>>>> Ignorant Pathological Lying Idiot that you are. Perhaps even
>>>>>>>>> Insane, as you seem to think that by just repeating your lies
>>>>>>>>> that eventually someone will belive them.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The alternative answer (remaining stuck in recursive
>>>>>>>>>> simulation until
>>>>>>>>>> the system crashes) is so utterly moronic that I don't believe
>>>>>>>>>> that you
>>>>>>>>>> believe it.
>>>>>>>>>
>>>>>>>>> Except that isn't what H does, it aborts its simulation and
>>>>>>>>> gives the WRONG answer.
>>>>>>>>>
>>>>>>>>> You are the MORON to think that an incorrect answer must be
>>>>>>>>> right because you don't know any other possible answer. IT is
>>>>>>>>> YOU how doesn't actually understand the Liar's Paradox.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> We could downgrade the answer to my answer from 15 years ago,
>>>>>>>>>> H aborts
>>>>>>>>>> the simulation and return BAD_INPUT.
>>>>>>>>>>
>>>>>>>>>> Even this downgrade is (to the best of my knowledge) better
>>>>>>>>>> than anyone
>>>>>>>>>> else has ever done because it provides the exact criterion
>>>>>>>>>> measure for
>>>>>>>>>> this return value that cannot be fooled by Rice's theorem.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And you show that you totally don't understand anything about
>>>>>>>>> logic.
>>>>>>>>>
>>>>>>>>> You just don't understand any of the basics of that which you
>>>>>>>>> talk about.
>>>>>>>>
>>>>>>>> Because H(D,D) would remain stuck in recursive simulation unless it
>>>>>>>> aborts this simulation and in this case H is a termination
>>>>>>>> analyzer used
>>>>>>>> to detect Denial of Service attacks what do you think that H
>>>>>>>> should do
>>>>>>>> with input D?
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Then it would fail to be a decider.
>>>>>>>
>>>>>>> Once H is programmed to abort its simulation, it needs to analyze
>>>>>>> calls to H as if that call will also abort its simulation, since
>>>>>>> it will.
>>>>>>>
>>>>>> Okay then you are saying that H should return 1 and then H would
>>>>>> be correct.
>>>>>>
>>>>>>
>>>>>
>>>>> H SHOULD have returned 1, but if you change H to do that, you now
>>>>> have a new D and for that one (the one built on an H that returns 1
>>>>> for H(D,D)) D(D) will be non-halting, so that H should have
>>>>> returned 0.
>>>>>
>>>> In other words (from H's point of view) the halt status of D is a self-
>>>> contradictory question even though it is not self-contradictory
>>>> within other contexts. A question is not complete unless the context is
>>>> included.
>>>>
>>>
>>> It doesn't matter what it is "from H's point of view", what matters
>>> is what it actually is, which is measured by what happens when the
>>> actual machine is actually run.
>>>
>>> Yes, the context matters, and every H creates a DIFFERENT context, so
>>> every H needs to take ITSELF into consideration, and not assume that
>>> D calls some other variation of H, because it doesn't, not if this H
>>> is the one that you want to claim is correct.
>>>
>>> Your problem is you are stuck in a world of make-believe. You presume
>>> things that are not true, and show that in such a fantasy world, your
>>> machine is correct. The problem is, that isn't how Truth actually
>>> works. You need to start from actual established facts when you
>>> reason about things.
>>>
>>
>> When computer science theory diverges from the reality of software
>> engineering it is the reality that take precedence and the theory that
>> is out of touch with reality.
>
> So, you are admitting that you aren't followong the actual Theory,
>
> Thus you are admitting that you have been lying that you have been, for
> DECADES.
>
> You just don't understand the nature of the problem, or many of the
> things you talk about, because you don't understand the nature of Truth
> or Logic.
>
>>
>> When both Boolean return values are the wrong answer then this proves
>> that the question itself is incorrect.
>>
>
> Nope, because the question isn't What answer should H return to be
> correct, but what is the behavior of the machine at the input.


Click here to read the complete article
Re: Termination Analyzer H correctly prevents Denial of Service attacks

<wctiM.2$I68a.1@fx43.iad>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=11306&group=comp.ai.philosophy#11306

  copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!diablo1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx43.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:102.0)
Gecko/20100101 Thunderbird/102.11.2
Subject: Re: Termination Analyzer H correctly prevents Denial of Service
attacks
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
References: <u6a1ac$3klfk$3@dont-email.me> <686iM.5048$SaD4.4456@fx39.iad>
<u6arsr$3o1o8$1@dont-email.me> <Sv6iM.3959$Yxn4.2146@fx38.iad>
<u6b09r$3oj1r$1@dont-email.me> <1l8iM.34944$AF%b.10982@fx12.iad>
<u6b9nf$3t9u1$1@dont-email.me> <t2aiM.19350$F2qf.3997@fx48.iad>
<u6bb6d$3teta$1@dont-email.me> <LjaiM.19351$F2qf.4750@fx48.iad>
<u6bc4s$3teta$2@dont-email.me> <8ChiM.8534$%6L8.5147@fx04.iad>
<u6cji6$1tjb$1@dont-email.me> <HnriM.1615$Vpga.1473@fx09.iad>
<u6dl33$5c39$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <u6dl33$5c39$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 319
Message-ID: <wctiM.2$I68a.1@fx43.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 14 Jun 2023 20:47:23 -0400
X-Received-Bytes: 15469
 by: Richard Damon - Thu, 15 Jun 2023 00:47 UTC

On 6/14/23 8:13 PM, olcott wrote:
> On 6/14/2023 5:42 PM, Richard Damon wrote:
>> On 6/14/23 10:41 AM, olcott wrote:
>>> On 6/14/2023 6:35 AM, Richard Damon wrote:
>>>> On 6/13/23 11:28 PM, olcott wrote:
>>>>> On 6/13/2023 10:18 PM, Richard Damon wrote:
>>>>>> On 6/13/23 11:12 PM, olcott wrote:
>>>>>>> On 6/13/2023 9:59 PM, Richard Damon wrote:
>>>>>>>> On 6/13/23 10:47 PM, olcott wrote:
>>>>>>>>> On 6/13/2023 8:02 PM, Richard Damon wrote:
>>>>>>>>>> On 6/13/23 8:06 PM, olcott wrote:
>>>>>>>>>>> On 6/13/2023 5:57 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/13/23 6:51 PM, olcott wrote:
>>>>>>>>>>>>> On 6/13/2023 5:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/13/23 11:17 AM, olcott wrote:
>>>>>>>>>>>>>>> The purpose of solving the halting problem is to
>>>>>>>>>>>>>>> determine non-halting
>>>>>>>>>>>>>>> bugs and non-halting malevolent software. My system
>>>>>>>>>>>>>>> achieves that
>>>>>>>>>>>>>>> purpose for the halting problem's otherwise impossible
>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is only when the halting problem is construed as
>>>>>>>>>>>>>>> providing a correct
>>>>>>>>>>>>>>> yes/no answer to a self-contradictory question that the
>>>>>>>>>>>>>>> halting problem
>>>>>>>>>>>>>>> cannot be solved.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> // The following is written in C
>>>>>>>>>>>>>>> //
>>>>>>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate
>>>>>>>>>>>>>>> its input
>>>>>>>>>>>>>>> 03
>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>> 14   D(D);
>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Execution Trace
>>>>>>>>>>>>>>> Line 14: main() invokes D(D)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> keeps repeating (unless aborted)
>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Simulation invariant:
>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach its own
>>>>>>>>>>>>>>> line 09.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When termination analyzer H is intended to prevent denial
>>>>>>>>>>>>>>> of service
>>>>>>>>>>>>>>> attacks is presented with an input D that has been
>>>>>>>>>>>>>>> defined to have a
>>>>>>>>>>>>>>> pathological relationship to this termination analyzer,
>>>>>>>>>>>>>>> it correctly
>>>>>>>>>>>>>>> aborts the simulation of this input that would have
>>>>>>>>>>>>>>> otherwise caused H
>>>>>>>>>>>>>>> to never terminate until system resources have been
>>>>>>>>>>>>>>> exhausted, crashing
>>>>>>>>>>>>>>> the system.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *The halting problem is an issue with denial of service
>>>>>>>>>>>>>>> attacks*
>>>>>>>>>>>>>>> https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The whole system is right here:
>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It compiles with the 2017 version of the Community Edition
>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except that preventing "Denial of Service Attacks" is part
>>>>>>>>>>>>>> of the requirement, just as giving the right answer. It
>>>>>>>>>>>>>> needs to do BOTH, and the right answer isn't based on its
>>>>>>>>>>>>>> simulation, but the actual behavior of the machine. Thus,
>>>>>>>>>>>>>> trying to excuse the wrong answer as being due to a
>>>>>>>>>>>>>> prevention of a "Denial of Service" is just an admissioon
>>>>>>>>>>>>>> that the problem actually is IMPOSSIBLE.
>>>>>>>>>>>>> When denial of service attacks define a pathological input
>>>>>>>>>>>>> that would
>>>>>>>>>>>>> otherwise cause the denial of service attack detector to
>>>>>>>>>>>>> eat up system
>>>>>>>>>>>>> resources and crash the system H detects this attempt and
>>>>>>>>>>>>> thwarts it.
>>>>>>>>>>>>> *This conclusively proves that H is correct*
>>>>>>>>>>>>>
>>>>>>>>>>>>> *How pathological inputs are currently handled*
>>>>>>>>>>>>>   If a set of instructions ( in the smart contract) is
>>>>>>>>>>>>> executed on the
>>>>>>>>>>>>>   Ethereum Virtual Machine, it cannot predict how long
>>>>>>>>>>>>> these will run
>>>>>>>>>>>>>   for, at the beginning. If a set of instructions run
>>>>>>>>>>>>> forever, they can
>>>>>>>>>>>>>   freeze this blockchain and use up all the resources. This
>>>>>>>>>>>>> is similar to
>>>>>>>>>>>>>   a DoS (Denial of Service) attack. Each computation on the
>>>>>>>>>>>>> Ethereum
>>>>>>>>>>>>>   Virtual Machine requires some predetermined amount of gas
>>>>>>>>>>>>> (which one
>>>>>>>>>>>>>   has to buy with real money).
>>>>>>>>>>>>>
>>>>>>>>>>>>> (https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d)
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope. The decider is responsible to handle possible "Denial
>>>>>>>>>>>> of Service Attacks", and the presence of them just points
>>>>>>>>>>>> out the FUNDAMENTAL problem with your solution method. It
>>>>>>>>>>>> has long been know that just relying on "Simulation" has
>>>>>>>>>>>> significant issues for halt deciding, but since you have
>>>>>>>>>>>> chosen to not look at history, you are just making the same
>>>>>>>>>>>> mistakes made long ago.
>>>>>>>>>>>>
>>>>>>>>>>>> The CORRECT answer is ALWAYS the behavior of the Actual
>>>>>>>>>>>> Machine, which in this case Halts.
>>>>>>>>>>>>
>>>>>>>>>>>> Therefore, H(D,D) saying that D(D) doesn't halt is just
>>>>>>>>>>>> making H wrong.
>>>>>>>>>>>>
>>>>>>>>>>>> Claiming the wrong answer is right is just a LIE.
>>>>>>>>>>>>
>>>>>>>>>>> When simulating termination analyzer H is presented with an
>>>>>>>>>>> input the
>>>>>>>>>>> right answer is always: Must the simulation of the input be
>>>>>>>>>>> aborted to
>>>>>>>>>>> prevent the infinite execution of H? Yes is the correct answer.
>>>>>>>>>>
>>>>>>>>>> So, I guess you are admitting that a simulationg termination
>>>>>>>>>> analyzer isn't a "Halting Decider" per the Computabilty
>>>>>>>>>> Theory, since for those, the correct answer is always based on
>>>>>>>>>> the actual behavior of the machine/input described by the
>>>>>>>>>> input to the decider.
>>>>>>>>>>
>>>>>>>>>> You KNOW that fact, as you have quoted that defintion, though
>>>>>>>>>> admittedly, while you blaim others for just quoting "learned
>>>>>>>>>> by rote" statements, the statements you quote are probably
>>>>>>>>>> just quoted by rote without ever actually learning what they
>>>>>>>>>> mean.
>>>>>>>>>>
>>>>>>>>>> But, with your admission that your machine uses the WRONG
>>>>>>>>>> criteria, you have just proven that you have been lying for
>>>>>>>>>> the past decade that you have actually been working on the
>>>>>>>>>> ACTUAL Halting Problem of Computation Theory as discussed by
>>>>>>>>>> Turing, Linz, et all.
>>>>>>>>>>
>>>>>>>>>> All you have done is proved that you are the Hypocritical
>>>>>>>>>> Ignorant Pathological Lying Idiot that you are. Perhaps even
>>>>>>>>>> Insane, as you seem to think that by just repeating your lies
>>>>>>>>>> that eventually someone will belive them.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The alternative answer (remaining stuck in recursive
>>>>>>>>>>> simulation until
>>>>>>>>>>> the system crashes) is so utterly moronic that I don't
>>>>>>>>>>> believe that you
>>>>>>>>>>> believe it.
>>>>>>>>>>
>>>>>>>>>> Except that isn't what H does, it aborts its simulation and
>>>>>>>>>> gives the WRONG answer.
>>>>>>>>>>
>>>>>>>>>> You are the MORON to think that an incorrect answer must be
>>>>>>>>>> right because you don't know any other possible answer. IT is
>>>>>>>>>> YOU how doesn't actually understand the Liar's Paradox.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> We could downgrade the answer to my answer from 15 years ago,
>>>>>>>>>>> H aborts
>>>>>>>>>>> the simulation and return BAD_INPUT.
>>>>>>>>>>>
>>>>>>>>>>> Even this downgrade is (to the best of my knowledge) better
>>>>>>>>>>> than anyone
>>>>>>>>>>> else has ever done because it provides the exact criterion
>>>>>>>>>>> measure for
>>>>>>>>>>> this return value that cannot be fooled by Rice's theorem.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And you show that you totally don't understand anything about
>>>>>>>>>> logic.
>>>>>>>>>>
>>>>>>>>>> You just don't understand any of the basics of that which you
>>>>>>>>>> talk about.
>>>>>>>>>
>>>>>>>>> Because H(D,D) would remain stuck in recursive simulation
>>>>>>>>> unless it
>>>>>>>>> aborts this simulation and in this case H is a termination
>>>>>>>>> analyzer used
>>>>>>>>> to detect Denial of Service attacks what do you think that H
>>>>>>>>> should do
>>>>>>>>> with input D?
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Then it would fail to be a decider.
>>>>>>>>
>>>>>>>> Once H is programmed to abort its simulation, it needs to
>>>>>>>> analyze calls to H as if that call will also abort its
>>>>>>>> simulation, since it will.
>>>>>>>>
>>>>>>> Okay then you are saying that H should return 1 and then H would
>>>>>>> be correct.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> H SHOULD have returned 1, but if you change H to do that, you now
>>>>>> have a new D and for that one (the one built on an H that returns
>>>>>> 1 for H(D,D)) D(D) will be non-halting, so that H should have
>>>>>> returned 0.
>>>>>>
>>>>> In other words (from H's point of view) the halt status of D is a
>>>>> self-
>>>>> contradictory question even though it is not self-contradictory
>>>>> within other contexts. A question is not complete unless the
>>>>> context is
>>>>> included.
>>>>>
>>>>
>>>> It doesn't matter what it is "from H's point of view", what matters
>>>> is what it actually is, which is measured by what happens when the
>>>> actual machine is actually run.
>>>>
>>>> Yes, the context matters, and every H creates a DIFFERENT context,
>>>> so every H needs to take ITSELF into consideration, and not assume
>>>> that D calls some other variation of H, because it doesn't, not if
>>>> this H is the one that you want to claim is correct.
>>>>
>>>> Your problem is you are stuck in a world of make-believe. You
>>>> presume things that are not true, and show that in such a fantasy
>>>> world, your machine is correct. The problem is, that isn't how Truth
>>>> actually works. You need to start from actual established facts when
>>>> you reason about things.
>>>>
>>>
>>> When computer science theory diverges from the reality of software
>>> engineering it is the reality that take precedence and the theory that
>>> is out of touch with reality.
>>
>> So, you are admitting that you aren't followong the actual Theory,
>>
>> Thus you are admitting that you have been lying that you have been,
>> for DECADES.
>>
>> You just don't understand the nature of the problem, or many of the
>> things you talk about, because you don't understand the nature of
>> Truth or Logic.
>>
>>>
>>> When both Boolean return values are the wrong answer then this proves
>>> that the question itself is incorrect.
>>>
>>
>> Nope, because the question isn't What answer should H return to be
>> correct, but what is the behavior of the machine at the input.
>
> When the input to H is defined to do the opposite of whatever H says it
> will do then the halt status question posed to H is self-contradictory
> even if it is not self-contradictory when posed to any other termination
> analyzer.


Click here to read the complete article
Re: Termination Analyzer H correctly prevents Denial of Service attacks

<u6dok6$5lv4$1@dont-email.me>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=11307&group=comp.ai.philosophy#11307

  copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
Subject: Re: Termination Analyzer H correctly prevents Denial of Service
attacks
Date: Wed, 14 Jun 2023 20:13:41 -0500
Organization: A noiseless patient Spider
Lines: 311
Message-ID: <u6dok6$5lv4$1@dont-email.me>
References: <u6a1ac$3klfk$3@dont-email.me> <686iM.5048$SaD4.4456@fx39.iad>
<u6arsr$3o1o8$1@dont-email.me> <Sv6iM.3959$Yxn4.2146@fx38.iad>
<u6b09r$3oj1r$1@dont-email.me> <1l8iM.34944$AF%b.10982@fx12.iad>
<u6b9nf$3t9u1$1@dont-email.me> <t2aiM.19350$F2qf.3997@fx48.iad>
<u6bb6d$3teta$1@dont-email.me> <LjaiM.19351$F2qf.4750@fx48.iad>
<u6bc4s$3teta$2@dont-email.me> <8ChiM.8534$%6L8.5147@fx04.iad>
<u6cji6$1tjb$1@dont-email.me> <HnriM.1615$Vpga.1473@fx09.iad>
<u6dl33$5c39$1@dont-email.me> <wctiM.2$I68a.1@fx43.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 15 Jun 2023 01:13:43 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="fb9d20887a3ce8d0fd7f66c3017e22ca";
logging-data="186340"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18Ercbx4oiwLuO0r61vOmcr"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.11.2
Cancel-Lock: sha1:86IXl9xtsq0kerd+67sXI/wAOtM=
Content-Language: en-US
In-Reply-To: <wctiM.2$I68a.1@fx43.iad>
 by: olcott - Thu, 15 Jun 2023 01:13 UTC

On 6/14/2023 7:47 PM, Richard Damon wrote:
> On 6/14/23 8:13 PM, olcott wrote:
>> On 6/14/2023 5:42 PM, Richard Damon wrote:
>>> On 6/14/23 10:41 AM, olcott wrote:
>>>> On 6/14/2023 6:35 AM, Richard Damon wrote:
>>>>> On 6/13/23 11:28 PM, olcott wrote:
>>>>>> On 6/13/2023 10:18 PM, Richard Damon wrote:
>>>>>>> On 6/13/23 11:12 PM, olcott wrote:
>>>>>>>> On 6/13/2023 9:59 PM, Richard Damon wrote:
>>>>>>>>> On 6/13/23 10:47 PM, olcott wrote:
>>>>>>>>>> On 6/13/2023 8:02 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/13/23 8:06 PM, olcott wrote:
>>>>>>>>>>>> On 6/13/2023 5:57 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 6/13/23 6:51 PM, olcott wrote:
>>>>>>>>>>>>>> On 6/13/2023 5:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 6/13/23 11:17 AM, olcott wrote:
>>>>>>>>>>>>>>>> The purpose of solving the halting problem is to
>>>>>>>>>>>>>>>> determine non-halting
>>>>>>>>>>>>>>>> bugs and non-halting malevolent software. My system
>>>>>>>>>>>>>>>> achieves that
>>>>>>>>>>>>>>>> purpose for the halting problem's otherwise impossible
>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is only when the halting problem is construed as
>>>>>>>>>>>>>>>> providing a correct
>>>>>>>>>>>>>>>> yes/no answer to a self-contradictory question that the
>>>>>>>>>>>>>>>> halting problem
>>>>>>>>>>>>>>>> cannot be solved.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> // The following is written in C
>>>>>>>>>>>>>>>> //
>>>>>>>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to
>>>>>>>>>>>>>>>> simulate its input
>>>>>>>>>>>>>>>> 03
>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>> 14   D(D);
>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Execution Trace
>>>>>>>>>>>>>>>> Line 14: main() invokes D(D)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> keeps repeating (unless aborted)
>>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Simulation invariant:
>>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach its own
>>>>>>>>>>>>>>>> line 09.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When termination analyzer H is intended to prevent
>>>>>>>>>>>>>>>> denial of service
>>>>>>>>>>>>>>>> attacks is presented with an input D that has been
>>>>>>>>>>>>>>>> defined to have a
>>>>>>>>>>>>>>>> pathological relationship to this termination analyzer,
>>>>>>>>>>>>>>>> it correctly
>>>>>>>>>>>>>>>> aborts the simulation of this input that would have
>>>>>>>>>>>>>>>> otherwise caused H
>>>>>>>>>>>>>>>> to never terminate until system resources have been
>>>>>>>>>>>>>>>> exhausted, crashing
>>>>>>>>>>>>>>>> the system.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *The halting problem is an issue with denial of service
>>>>>>>>>>>>>>>> attacks*
>>>>>>>>>>>>>>>> https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The whole system is right here:
>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It compiles with the 2017 version of the Community Edition
>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that preventing "Denial of Service Attacks" is
>>>>>>>>>>>>>>> part of the requirement, just as giving the right answer.
>>>>>>>>>>>>>>> It needs to do BOTH, and the right answer isn't based on
>>>>>>>>>>>>>>> its simulation, but the actual behavior of the machine.
>>>>>>>>>>>>>>> Thus, trying to excuse the wrong answer as being due to a
>>>>>>>>>>>>>>> prevention of a "Denial of Service" is just an admissioon
>>>>>>>>>>>>>>> that the problem actually is IMPOSSIBLE.
>>>>>>>>>>>>>> When denial of service attacks define a pathological input
>>>>>>>>>>>>>> that would
>>>>>>>>>>>>>> otherwise cause the denial of service attack detector to
>>>>>>>>>>>>>> eat up system
>>>>>>>>>>>>>> resources and crash the system H detects this attempt and
>>>>>>>>>>>>>> thwarts it.
>>>>>>>>>>>>>> *This conclusively proves that H is correct*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *How pathological inputs are currently handled*
>>>>>>>>>>>>>>   If a set of instructions ( in the smart contract) is
>>>>>>>>>>>>>> executed on the
>>>>>>>>>>>>>>   Ethereum Virtual Machine, it cannot predict how long
>>>>>>>>>>>>>> these will run
>>>>>>>>>>>>>>   for, at the beginning. If a set of instructions run
>>>>>>>>>>>>>> forever, they can
>>>>>>>>>>>>>>   freeze this blockchain and use up all the resources.
>>>>>>>>>>>>>> This is similar to
>>>>>>>>>>>>>>   a DoS (Denial of Service) attack. Each computation on
>>>>>>>>>>>>>> the Ethereum
>>>>>>>>>>>>>>   Virtual Machine requires some predetermined amount of
>>>>>>>>>>>>>> gas (which one
>>>>>>>>>>>>>>   has to buy with real money).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope. The decider is responsible to handle possible "Denial
>>>>>>>>>>>>> of Service Attacks", and the presence of them just points
>>>>>>>>>>>>> out the FUNDAMENTAL problem with your solution method. It
>>>>>>>>>>>>> has long been know that just relying on "Simulation" has
>>>>>>>>>>>>> significant issues for halt deciding, but since you have
>>>>>>>>>>>>> chosen to not look at history, you are just making the same
>>>>>>>>>>>>> mistakes made long ago.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The CORRECT answer is ALWAYS the behavior of the Actual
>>>>>>>>>>>>> Machine, which in this case Halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Therefore, H(D,D) saying that D(D) doesn't halt is just
>>>>>>>>>>>>> making H wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Claiming the wrong answer is right is just a LIE.
>>>>>>>>>>>>>
>>>>>>>>>>>> When simulating termination analyzer H is presented with an
>>>>>>>>>>>> input the
>>>>>>>>>>>> right answer is always: Must the simulation of the input be
>>>>>>>>>>>> aborted to
>>>>>>>>>>>> prevent the infinite execution of H? Yes is the correct answer.
>>>>>>>>>>>
>>>>>>>>>>> So, I guess you are admitting that a simulationg termination
>>>>>>>>>>> analyzer isn't a "Halting Decider" per the Computabilty
>>>>>>>>>>> Theory, since for those, the correct answer is always based
>>>>>>>>>>> on the actual behavior of the machine/input described by the
>>>>>>>>>>> input to the decider.
>>>>>>>>>>>
>>>>>>>>>>> You KNOW that fact, as you have quoted that defintion, though
>>>>>>>>>>> admittedly, while you blaim others for just quoting "learned
>>>>>>>>>>> by rote" statements, the statements you quote are probably
>>>>>>>>>>> just quoted by rote without ever actually learning what they
>>>>>>>>>>> mean.
>>>>>>>>>>>
>>>>>>>>>>> But, with your admission that your machine uses the WRONG
>>>>>>>>>>> criteria, you have just proven that you have been lying for
>>>>>>>>>>> the past decade that you have actually been working on the
>>>>>>>>>>> ACTUAL Halting Problem of Computation Theory as discussed by
>>>>>>>>>>> Turing, Linz, et all.
>>>>>>>>>>>
>>>>>>>>>>> All you have done is proved that you are the Hypocritical
>>>>>>>>>>> Ignorant Pathological Lying Idiot that you are. Perhaps even
>>>>>>>>>>> Insane, as you seem to think that by just repeating your lies
>>>>>>>>>>> that eventually someone will belive them.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The alternative answer (remaining stuck in recursive
>>>>>>>>>>>> simulation until
>>>>>>>>>>>> the system crashes) is so utterly moronic that I don't
>>>>>>>>>>>> believe that you
>>>>>>>>>>>> believe it.
>>>>>>>>>>>
>>>>>>>>>>> Except that isn't what H does, it aborts its simulation and
>>>>>>>>>>> gives the WRONG answer.
>>>>>>>>>>>
>>>>>>>>>>> You are the MORON to think that an incorrect answer must be
>>>>>>>>>>> right because you don't know any other possible answer. IT is
>>>>>>>>>>> YOU how doesn't actually understand the Liar's Paradox.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> We could downgrade the answer to my answer from 15 years
>>>>>>>>>>>> ago, H aborts
>>>>>>>>>>>> the simulation and return BAD_INPUT.
>>>>>>>>>>>>
>>>>>>>>>>>> Even this downgrade is (to the best of my knowledge) better
>>>>>>>>>>>> than anyone
>>>>>>>>>>>> else has ever done because it provides the exact criterion
>>>>>>>>>>>> measure for
>>>>>>>>>>>> this return value that cannot be fooled by Rice's theorem.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And you show that you totally don't understand anything about
>>>>>>>>>>> logic.
>>>>>>>>>>>
>>>>>>>>>>> You just don't understand any of the basics of that which you
>>>>>>>>>>> talk about.
>>>>>>>>>>
>>>>>>>>>> Because H(D,D) would remain stuck in recursive simulation
>>>>>>>>>> unless it
>>>>>>>>>> aborts this simulation and in this case H is a termination
>>>>>>>>>> analyzer used
>>>>>>>>>> to detect Denial of Service attacks what do you think that H
>>>>>>>>>> should do
>>>>>>>>>> with input D?
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Then it would fail to be a decider.
>>>>>>>>>
>>>>>>>>> Once H is programmed to abort its simulation, it needs to
>>>>>>>>> analyze calls to H as if that call will also abort its
>>>>>>>>> simulation, since it will.
>>>>>>>>>
>>>>>>>> Okay then you are saying that H should return 1 and then H would
>>>>>>>> be correct.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> H SHOULD have returned 1, but if you change H to do that, you now
>>>>>>> have a new D and for that one (the one built on an H that returns
>>>>>>> 1 for H(D,D)) D(D) will be non-halting, so that H should have
>>>>>>> returned 0.
>>>>>>>
>>>>>> In other words (from H's point of view) the halt status of D is a
>>>>>> self-
>>>>>> contradictory question even though it is not self-contradictory
>>>>>> within other contexts. A question is not complete unless the
>>>>>> context is
>>>>>> included.
>>>>>>
>>>>>
>>>>> It doesn't matter what it is "from H's point of view", what matters
>>>>> is what it actually is, which is measured by what happens when the
>>>>> actual machine is actually run.
>>>>>
>>>>> Yes, the context matters, and every H creates a DIFFERENT context,
>>>>> so every H needs to take ITSELF into consideration, and not assume
>>>>> that D calls some other variation of H, because it doesn't, not if
>>>>> this H is the one that you want to claim is correct.
>>>>>
>>>>> Your problem is you are stuck in a world of make-believe. You
>>>>> presume things that are not true, and show that in such a fantasy
>>>>> world, your machine is correct. The problem is, that isn't how
>>>>> Truth actually works. You need to start from actual established
>>>>> facts when you reason about things.
>>>>>
>>>>
>>>> When computer science theory diverges from the reality of software
>>>> engineering it is the reality that take precedence and the theory that
>>>> is out of touch with reality.
>>>
>>> So, you are admitting that you aren't followong the actual Theory,
>>>
>>> Thus you are admitting that you have been lying that you have been,
>>> for DECADES.
>>>
>>> You just don't understand the nature of the problem, or many of the
>>> things you talk about, because you don't understand the nature of
>>> Truth or Logic.
>>>
>>>>
>>>> When both Boolean return values are the wrong answer then this proves
>>>> that the question itself is incorrect.
>>>>
>>>
>>> Nope, because the question isn't What answer should H return to be
>>> correct, but what is the behavior of the machine at the input.
>>
>> When the input to H is defined to do the opposite of whatever H says it
>> will do then the halt status question posed to H is self-contradictory
>> even if it is not self-contradictory when posed to any other termination
>> analyzer.
>
> Nope, because the program H must exist before the program D does, so the
> pnly self-contradictory question is how to design H to succeed. This is
> what makes a correct H impossible.
>
> I think part of your problem is you don't even understand what an actual
> program/machine is. It isn't just some nebulous definition of desired
> behavior, but needs to be actual detailed step-by-step instructions of
> what is going to happen based on the input.
>
> Your "Hypothetical" H that both correctly simulates its input, but also
> stops and gives an answer just isn't possible to do in an actual
> program. You have been given the challenge to show how it does both, and
> have ducked that, persumably because you know it is impossible.
>
> Once you define your H as an actual machine, then the answer to the
> behavor of D is well defined, easily determined, and it will be the
> opposite of whatever H gives as an answer.
>
>>
>> Furthermore it is an easily verified fact that H does correctly thwart a
>> denial of service (DOS) attack by the halting problem's pathological
>> input. This proves that the halting problem issue has been overcome in
>> at least this one case.
>>
>>
>
> It may "thwart" a denial of service attack (cause by bad code in H), but
> it doesn't give the correct answer. It convicted an innocent party.
It is an easily verified fact that H does correctly abort its simulation
of D (that specifically targets H) because the alternative is that D
causes the system to exhaust its resources and crash.


Click here to read the complete article
Re: Termination Analyzer H correctly prevents Denial of Service attacks

<IPtiM.5$33q9.2@fx35.iad>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=11308&group=comp.ai.philosophy#11308

  copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!diablo1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx35.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:102.0)
Gecko/20100101 Thunderbird/102.11.2
Subject: Re: Termination Analyzer H correctly prevents Denial of Service
attacks
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
References: <u6a1ac$3klfk$3@dont-email.me> <686iM.5048$SaD4.4456@fx39.iad>
<u6arsr$3o1o8$1@dont-email.me> <Sv6iM.3959$Yxn4.2146@fx38.iad>
<u6b09r$3oj1r$1@dont-email.me> <1l8iM.34944$AF%b.10982@fx12.iad>
<u6b9nf$3t9u1$1@dont-email.me> <t2aiM.19350$F2qf.3997@fx48.iad>
<u6bb6d$3teta$1@dont-email.me> <LjaiM.19351$F2qf.4750@fx48.iad>
<u6bc4s$3teta$2@dont-email.me> <8ChiM.8534$%6L8.5147@fx04.iad>
<u6cji6$1tjb$1@dont-email.me> <HnriM.1615$Vpga.1473@fx09.iad>
<u6dl33$5c39$1@dont-email.me> <wctiM.2$I68a.1@fx43.iad>
<u6dok6$5lv4$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <u6dok6$5lv4$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 338
Message-ID: <IPtiM.5$33q9.2@fx35.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 14 Jun 2023 21:29:11 -0400
X-Received-Bytes: 16997
 by: Richard Damon - Thu, 15 Jun 2023 01:29 UTC

On 6/14/23 9:13 PM, olcott wrote:
> On 6/14/2023 7:47 PM, Richard Damon wrote:
>> On 6/14/23 8:13 PM, olcott wrote:
>>> On 6/14/2023 5:42 PM, Richard Damon wrote:
>>>> On 6/14/23 10:41 AM, olcott wrote:
>>>>> On 6/14/2023 6:35 AM, Richard Damon wrote:
>>>>>> On 6/13/23 11:28 PM, olcott wrote:
>>>>>>> On 6/13/2023 10:18 PM, Richard Damon wrote:
>>>>>>>> On 6/13/23 11:12 PM, olcott wrote:
>>>>>>>>> On 6/13/2023 9:59 PM, Richard Damon wrote:
>>>>>>>>>> On 6/13/23 10:47 PM, olcott wrote:
>>>>>>>>>>> On 6/13/2023 8:02 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/13/23 8:06 PM, olcott wrote:
>>>>>>>>>>>>> On 6/13/2023 5:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/13/23 6:51 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/13/2023 5:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 6/13/23 11:17 AM, olcott wrote:
>>>>>>>>>>>>>>>>> The purpose of solving the halting problem is to
>>>>>>>>>>>>>>>>> determine non-halting
>>>>>>>>>>>>>>>>> bugs and non-halting malevolent software. My system
>>>>>>>>>>>>>>>>> achieves that
>>>>>>>>>>>>>>>>> purpose for the halting problem's otherwise impossible
>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is only when the halting problem is construed as
>>>>>>>>>>>>>>>>> providing a correct
>>>>>>>>>>>>>>>>> yes/no answer to a self-contradictory question that the
>>>>>>>>>>>>>>>>> halting problem
>>>>>>>>>>>>>>>>> cannot be solved.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> // The following is written in C
>>>>>>>>>>>>>>>>> //
>>>>>>>>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to
>>>>>>>>>>>>>>>>> simulate its input
>>>>>>>>>>>>>>>>> 03
>>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>>> 14   D(D);
>>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Execution Trace
>>>>>>>>>>>>>>>>> Line 14: main() invokes D(D)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> keeps repeating (unless aborted)
>>>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Simulation invariant:
>>>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach its
>>>>>>>>>>>>>>>>> own line 09.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When termination analyzer H is intended to prevent
>>>>>>>>>>>>>>>>> denial of service
>>>>>>>>>>>>>>>>> attacks is presented with an input D that has been
>>>>>>>>>>>>>>>>> defined to have a
>>>>>>>>>>>>>>>>> pathological relationship to this termination analyzer,
>>>>>>>>>>>>>>>>> it correctly
>>>>>>>>>>>>>>>>> aborts the simulation of this input that would have
>>>>>>>>>>>>>>>>> otherwise caused H
>>>>>>>>>>>>>>>>> to never terminate until system resources have been
>>>>>>>>>>>>>>>>> exhausted, crashing
>>>>>>>>>>>>>>>>> the system.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *The halting problem is an issue with denial of service
>>>>>>>>>>>>>>>>> attacks*
>>>>>>>>>>>>>>>>> https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The whole system is right here:
>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It compiles with the 2017 version of the Community Edition
>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except that preventing "Denial of Service Attacks" is
>>>>>>>>>>>>>>>> part of the requirement, just as giving the right
>>>>>>>>>>>>>>>> answer. It needs to do BOTH, and the right answer isn't
>>>>>>>>>>>>>>>> based on its simulation, but the actual behavior of the
>>>>>>>>>>>>>>>> machine. Thus, trying to excuse the wrong answer as
>>>>>>>>>>>>>>>> being due to a prevention of a "Denial of Service" is
>>>>>>>>>>>>>>>> just an admissioon that the problem actually is IMPOSSIBLE.
>>>>>>>>>>>>>>> When denial of service attacks define a pathological
>>>>>>>>>>>>>>> input that would
>>>>>>>>>>>>>>> otherwise cause the denial of service attack detector to
>>>>>>>>>>>>>>> eat up system
>>>>>>>>>>>>>>> resources and crash the system H detects this attempt and
>>>>>>>>>>>>>>> thwarts it.
>>>>>>>>>>>>>>> *This conclusively proves that H is correct*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *How pathological inputs are currently handled*
>>>>>>>>>>>>>>>   If a set of instructions ( in the smart contract) is
>>>>>>>>>>>>>>> executed on the
>>>>>>>>>>>>>>>   Ethereum Virtual Machine, it cannot predict how long
>>>>>>>>>>>>>>> these will run
>>>>>>>>>>>>>>>   for, at the beginning. If a set of instructions run
>>>>>>>>>>>>>>> forever, they can
>>>>>>>>>>>>>>>   freeze this blockchain and use up all the resources.
>>>>>>>>>>>>>>> This is similar to
>>>>>>>>>>>>>>>   a DoS (Denial of Service) attack. Each computation on
>>>>>>>>>>>>>>> the Ethereum
>>>>>>>>>>>>>>>   Virtual Machine requires some predetermined amount of
>>>>>>>>>>>>>>> gas (which one
>>>>>>>>>>>>>>>   has to buy with real money).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope. The decider is responsible to handle possible
>>>>>>>>>>>>>> "Denial of Service Attacks", and the presence of them just
>>>>>>>>>>>>>> points out the FUNDAMENTAL problem with your solution
>>>>>>>>>>>>>> method. It has long been know that just relying on
>>>>>>>>>>>>>> "Simulation" has significant issues for halt deciding, but
>>>>>>>>>>>>>> since you have chosen to not look at history, you are just
>>>>>>>>>>>>>> making the same mistakes made long ago.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The CORRECT answer is ALWAYS the behavior of the Actual
>>>>>>>>>>>>>> Machine, which in this case Halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Therefore, H(D,D) saying that D(D) doesn't halt is just
>>>>>>>>>>>>>> making H wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Claiming the wrong answer is right is just a LIE.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> When simulating termination analyzer H is presented with an
>>>>>>>>>>>>> input the
>>>>>>>>>>>>> right answer is always: Must the simulation of the input be
>>>>>>>>>>>>> aborted to
>>>>>>>>>>>>> prevent the infinite execution of H? Yes is the correct
>>>>>>>>>>>>> answer.
>>>>>>>>>>>>
>>>>>>>>>>>> So, I guess you are admitting that a simulationg termination
>>>>>>>>>>>> analyzer isn't a "Halting Decider" per the Computabilty
>>>>>>>>>>>> Theory, since for those, the correct answer is always based
>>>>>>>>>>>> on the actual behavior of the machine/input described by the
>>>>>>>>>>>> input to the decider.
>>>>>>>>>>>>
>>>>>>>>>>>> You KNOW that fact, as you have quoted that defintion,
>>>>>>>>>>>> though admittedly, while you blaim others for just quoting
>>>>>>>>>>>> "learned by rote" statements, the statements you quote are
>>>>>>>>>>>> probably just quoted by rote without ever actually learning
>>>>>>>>>>>> what they mean.
>>>>>>>>>>>>
>>>>>>>>>>>> But, with your admission that your machine uses the WRONG
>>>>>>>>>>>> criteria, you have just proven that you have been lying for
>>>>>>>>>>>> the past decade that you have actually been working on the
>>>>>>>>>>>> ACTUAL Halting Problem of Computation Theory as discussed by
>>>>>>>>>>>> Turing, Linz, et all.
>>>>>>>>>>>>
>>>>>>>>>>>> All you have done is proved that you are the Hypocritical
>>>>>>>>>>>> Ignorant Pathological Lying Idiot that you are. Perhaps even
>>>>>>>>>>>> Insane, as you seem to think that by just repeating your
>>>>>>>>>>>> lies that eventually someone will belive them.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The alternative answer (remaining stuck in recursive
>>>>>>>>>>>>> simulation until
>>>>>>>>>>>>> the system crashes) is so utterly moronic that I don't
>>>>>>>>>>>>> believe that you
>>>>>>>>>>>>> believe it.
>>>>>>>>>>>>
>>>>>>>>>>>> Except that isn't what H does, it aborts its simulation and
>>>>>>>>>>>> gives the WRONG answer.
>>>>>>>>>>>>
>>>>>>>>>>>> You are the MORON to think that an incorrect answer must be
>>>>>>>>>>>> right because you don't know any other possible answer. IT
>>>>>>>>>>>> is YOU how doesn't actually understand the Liar's Paradox.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> We could downgrade the answer to my answer from 15 years
>>>>>>>>>>>>> ago, H aborts
>>>>>>>>>>>>> the simulation and return BAD_INPUT.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Even this downgrade is (to the best of my knowledge) better
>>>>>>>>>>>>> than anyone
>>>>>>>>>>>>> else has ever done because it provides the exact criterion
>>>>>>>>>>>>> measure for
>>>>>>>>>>>>> this return value that cannot be fooled by Rice's theorem.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And you show that you totally don't understand anything
>>>>>>>>>>>> about logic.
>>>>>>>>>>>>
>>>>>>>>>>>> You just don't understand any of the basics of that which
>>>>>>>>>>>> you talk about.
>>>>>>>>>>>
>>>>>>>>>>> Because H(D,D) would remain stuck in recursive simulation
>>>>>>>>>>> unless it
>>>>>>>>>>> aborts this simulation and in this case H is a termination
>>>>>>>>>>> analyzer used
>>>>>>>>>>> to detect Denial of Service attacks what do you think that H
>>>>>>>>>>> should do
>>>>>>>>>>> with input D?
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Then it would fail to be a decider.
>>>>>>>>>>
>>>>>>>>>> Once H is programmed to abort its simulation, it needs to
>>>>>>>>>> analyze calls to H as if that call will also abort its
>>>>>>>>>> simulation, since it will.
>>>>>>>>>>
>>>>>>>>> Okay then you are saying that H should return 1 and then H
>>>>>>>>> would be correct.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> H SHOULD have returned 1, but if you change H to do that, you
>>>>>>>> now have a new D and for that one (the one built on an H that
>>>>>>>> returns 1 for H(D,D)) D(D) will be non-halting, so that H should
>>>>>>>> have returned 0.
>>>>>>>>
>>>>>>> In other words (from H's point of view) the halt status of D is a
>>>>>>> self-
>>>>>>> contradictory question even though it is not self-contradictory
>>>>>>> within other contexts. A question is not complete unless the
>>>>>>> context is
>>>>>>> included.
>>>>>>>
>>>>>>
>>>>>> It doesn't matter what it is "from H's point of view", what
>>>>>> matters is what it actually is, which is measured by what happens
>>>>>> when the actual machine is actually run.
>>>>>>
>>>>>> Yes, the context matters, and every H creates a DIFFERENT context,
>>>>>> so every H needs to take ITSELF into consideration, and not assume
>>>>>> that D calls some other variation of H, because it doesn't, not if
>>>>>> this H is the one that you want to claim is correct.
>>>>>>
>>>>>> Your problem is you are stuck in a world of make-believe. You
>>>>>> presume things that are not true, and show that in such a fantasy
>>>>>> world, your machine is correct. The problem is, that isn't how
>>>>>> Truth actually works. You need to start from actual established
>>>>>> facts when you reason about things.
>>>>>>
>>>>>
>>>>> When computer science theory diverges from the reality of software
>>>>> engineering it is the reality that take precedence and the theory that
>>>>> is out of touch with reality.
>>>>
>>>> So, you are admitting that you aren't followong the actual Theory,
>>>>
>>>> Thus you are admitting that you have been lying that you have been,
>>>> for DECADES.
>>>>
>>>> You just don't understand the nature of the problem, or many of the
>>>> things you talk about, because you don't understand the nature of
>>>> Truth or Logic.
>>>>
>>>>>
>>>>> When both Boolean return values are the wrong answer then this proves
>>>>> that the question itself is incorrect.
>>>>>
>>>>
>>>> Nope, because the question isn't What answer should H return to be
>>>> correct, but what is the behavior of the machine at the input.
>>>
>>> When the input to H is defined to do the opposite of whatever H says it
>>> will do then the halt status question posed to H is self-contradictory
>>> even if it is not self-contradictory when posed to any other termination
>>> analyzer.
>>
>> Nope, because the program H must exist before the program D does, so
>> the pnly self-contradictory question is how to design H to succeed.
>> This is what makes a correct H impossible.
>>
>> I think part of your problem is you don't even understand what an
>> actual program/machine is. It isn't just some nebulous definition of
>> desired behavior, but needs to be actual detailed step-by-step
>> instructions of what is going to happen based on the input.
>>
>> Your "Hypothetical" H that both correctly simulates its input, but
>> also stops and gives an answer just isn't possible to do in an actual
>> program. You have been given the challenge to show how it does both,
>> and have ducked that, persumably because you know it is impossible.
>>
>> Once you define your H as an actual machine, then the answer to the
>> behavor of D is well defined, easily determined, and it will be the
>> opposite of whatever H gives as an answer.
>>
>>>
>>> Furthermore it is an easily verified fact that H does correctly thwart a
>>> denial of service (DOS) attack by the halting problem's pathological
>>> input. This proves that the halting problem issue has been overcome in
>>> at least this one case.
>>>
>>>
>>
>> It may "thwart" a denial of service attack (cause by bad code in H),
>> but it doesn't give the correct answer. It convicted an innocent party.
> It is an easily verified fact that H does correctly abort its simulation
> of D (that specifically targets H) because the alternative is that D
> causes the system to exhaust its resources and crash.


Click here to read the complete article
Re: Termination Analyzer H correctly prevents Denial of Service attacks

<u6dq7h$5pop$1@dont-email.me>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=11309&group=comp.ai.philosophy#11309

  copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
Subject: Re: Termination Analyzer H correctly prevents Denial of Service
attacks
Date: Wed, 14 Jun 2023 20:41:04 -0500
Organization: A noiseless patient Spider
Lines: 333
Message-ID: <u6dq7h$5pop$1@dont-email.me>
References: <u6a1ac$3klfk$3@dont-email.me> <686iM.5048$SaD4.4456@fx39.iad>
<u6arsr$3o1o8$1@dont-email.me> <Sv6iM.3959$Yxn4.2146@fx38.iad>
<u6b09r$3oj1r$1@dont-email.me> <1l8iM.34944$AF%b.10982@fx12.iad>
<u6b9nf$3t9u1$1@dont-email.me> <t2aiM.19350$F2qf.3997@fx48.iad>
<u6bb6d$3teta$1@dont-email.me> <LjaiM.19351$F2qf.4750@fx48.iad>
<u6bc4s$3teta$2@dont-email.me> <8ChiM.8534$%6L8.5147@fx04.iad>
<u6cji6$1tjb$1@dont-email.me> <HnriM.1615$Vpga.1473@fx09.iad>
<u6dl33$5c39$1@dont-email.me> <wctiM.2$I68a.1@fx43.iad>
<u6dok6$5lv4$1@dont-email.me> <IPtiM.5$33q9.2@fx35.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 15 Jun 2023 01:41:05 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="fb9d20887a3ce8d0fd7f66c3017e22ca";
logging-data="190233"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19EH8Cl5IoeQT4DHMwyGfgf"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.11.2
Cancel-Lock: sha1:zkmgGS6nfkdrYxxirz6EU2zYQ5E=
Content-Language: en-US
In-Reply-To: <IPtiM.5$33q9.2@fx35.iad>
 by: olcott - Thu, 15 Jun 2023 01:41 UTC

On 6/14/2023 8:29 PM, Richard Damon wrote:
> On 6/14/23 9:13 PM, olcott wrote:
>> On 6/14/2023 7:47 PM, Richard Damon wrote:
>>> On 6/14/23 8:13 PM, olcott wrote:
>>>> On 6/14/2023 5:42 PM, Richard Damon wrote:
>>>>> On 6/14/23 10:41 AM, olcott wrote:
>>>>>> On 6/14/2023 6:35 AM, Richard Damon wrote:
>>>>>>> On 6/13/23 11:28 PM, olcott wrote:
>>>>>>>> On 6/13/2023 10:18 PM, Richard Damon wrote:
>>>>>>>>> On 6/13/23 11:12 PM, olcott wrote:
>>>>>>>>>> On 6/13/2023 9:59 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/13/23 10:47 PM, olcott wrote:
>>>>>>>>>>>> On 6/13/2023 8:02 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 6/13/23 8:06 PM, olcott wrote:
>>>>>>>>>>>>>> On 6/13/2023 5:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 6/13/23 6:51 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 6/13/2023 5:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 6/13/23 11:17 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> The purpose of solving the halting problem is to
>>>>>>>>>>>>>>>>>> determine non-halting
>>>>>>>>>>>>>>>>>> bugs and non-halting malevolent software. My system
>>>>>>>>>>>>>>>>>> achieves that
>>>>>>>>>>>>>>>>>> purpose for the halting problem's otherwise impossible
>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is only when the halting problem is construed as
>>>>>>>>>>>>>>>>>> providing a correct
>>>>>>>>>>>>>>>>>> yes/no answer to a self-contradictory question that
>>>>>>>>>>>>>>>>>> the halting problem
>>>>>>>>>>>>>>>>>> cannot be solved.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> // The following is written in C
>>>>>>>>>>>>>>>>>> //
>>>>>>>>>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to
>>>>>>>>>>>>>>>>>> simulate its input
>>>>>>>>>>>>>>>>>> 03
>>>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>>>> 14   D(D);
>>>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Execution Trace
>>>>>>>>>>>>>>>>>> Line 14: main() invokes D(D)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> keeps repeating (unless aborted)
>>>>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Simulation invariant:
>>>>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach its
>>>>>>>>>>>>>>>>>> own line 09.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When termination analyzer H is intended to prevent
>>>>>>>>>>>>>>>>>> denial of service
>>>>>>>>>>>>>>>>>> attacks is presented with an input D that has been
>>>>>>>>>>>>>>>>>> defined to have a
>>>>>>>>>>>>>>>>>> pathological relationship to this termination
>>>>>>>>>>>>>>>>>> analyzer, it correctly
>>>>>>>>>>>>>>>>>> aborts the simulation of this input that would have
>>>>>>>>>>>>>>>>>> otherwise caused H
>>>>>>>>>>>>>>>>>> to never terminate until system resources have been
>>>>>>>>>>>>>>>>>> exhausted, crashing
>>>>>>>>>>>>>>>>>> the system.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *The halting problem is an issue with denial of
>>>>>>>>>>>>>>>>>> service attacks*
>>>>>>>>>>>>>>>>>> https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The whole system is right here:
>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It compiles with the 2017 version of the Community
>>>>>>>>>>>>>>>>>> Edition
>>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except that preventing "Denial of Service Attacks" is
>>>>>>>>>>>>>>>>> part of the requirement, just as giving the right
>>>>>>>>>>>>>>>>> answer. It needs to do BOTH, and the right answer isn't
>>>>>>>>>>>>>>>>> based on its simulation, but the actual behavior of the
>>>>>>>>>>>>>>>>> machine. Thus, trying to excuse the wrong answer as
>>>>>>>>>>>>>>>>> being due to a prevention of a "Denial of Service" is
>>>>>>>>>>>>>>>>> just an admissioon that the problem actually is
>>>>>>>>>>>>>>>>> IMPOSSIBLE.
>>>>>>>>>>>>>>>> When denial of service attacks define a pathological
>>>>>>>>>>>>>>>> input that would
>>>>>>>>>>>>>>>> otherwise cause the denial of service attack detector to
>>>>>>>>>>>>>>>> eat up system
>>>>>>>>>>>>>>>> resources and crash the system H detects this attempt
>>>>>>>>>>>>>>>> and thwarts it.
>>>>>>>>>>>>>>>> *This conclusively proves that H is correct*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *How pathological inputs are currently handled*
>>>>>>>>>>>>>>>>   If a set of instructions ( in the smart contract) is
>>>>>>>>>>>>>>>> executed on the
>>>>>>>>>>>>>>>>   Ethereum Virtual Machine, it cannot predict how long
>>>>>>>>>>>>>>>> these will run
>>>>>>>>>>>>>>>>   for, at the beginning. If a set of instructions run
>>>>>>>>>>>>>>>> forever, they can
>>>>>>>>>>>>>>>>   freeze this blockchain and use up all the resources.
>>>>>>>>>>>>>>>> This is similar to
>>>>>>>>>>>>>>>>   a DoS (Denial of Service) attack. Each computation on
>>>>>>>>>>>>>>>> the Ethereum
>>>>>>>>>>>>>>>>   Virtual Machine requires some predetermined amount of
>>>>>>>>>>>>>>>> gas (which one
>>>>>>>>>>>>>>>>   has to buy with real money).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope. The decider is responsible to handle possible
>>>>>>>>>>>>>>> "Denial of Service Attacks", and the presence of them
>>>>>>>>>>>>>>> just points out the FUNDAMENTAL problem with your
>>>>>>>>>>>>>>> solution method. It has long been know that just relying
>>>>>>>>>>>>>>> on "Simulation" has significant issues for halt deciding,
>>>>>>>>>>>>>>> but since you have chosen to not look at history, you are
>>>>>>>>>>>>>>> just making the same mistakes made long ago.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The CORRECT answer is ALWAYS the behavior of the Actual
>>>>>>>>>>>>>>> Machine, which in this case Halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Therefore, H(D,D) saying that D(D) doesn't halt is just
>>>>>>>>>>>>>>> making H wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Claiming the wrong answer is right is just a LIE.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When simulating termination analyzer H is presented with
>>>>>>>>>>>>>> an input the
>>>>>>>>>>>>>> right answer is always: Must the simulation of the input
>>>>>>>>>>>>>> be aborted to
>>>>>>>>>>>>>> prevent the infinite execution of H? Yes is the correct
>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, I guess you are admitting that a simulationg
>>>>>>>>>>>>> termination analyzer isn't a "Halting Decider" per the
>>>>>>>>>>>>> Computabilty Theory, since for those, the correct answer is
>>>>>>>>>>>>> always based on the actual behavior of the machine/input
>>>>>>>>>>>>> described by the input to the decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You KNOW that fact, as you have quoted that defintion,
>>>>>>>>>>>>> though admittedly, while you blaim others for just quoting
>>>>>>>>>>>>> "learned by rote" statements, the statements you quote are
>>>>>>>>>>>>> probably just quoted by rote without ever actually learning
>>>>>>>>>>>>> what they mean.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But, with your admission that your machine uses the WRONG
>>>>>>>>>>>>> criteria, you have just proven that you have been lying for
>>>>>>>>>>>>> the past decade that you have actually been working on the
>>>>>>>>>>>>> ACTUAL Halting Problem of Computation Theory as discussed
>>>>>>>>>>>>> by Turing, Linz, et all.
>>>>>>>>>>>>>
>>>>>>>>>>>>> All you have done is proved that you are the Hypocritical
>>>>>>>>>>>>> Ignorant Pathological Lying Idiot that you are. Perhaps
>>>>>>>>>>>>> even Insane, as you seem to think that by just repeating
>>>>>>>>>>>>> your lies that eventually someone will belive them.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The alternative answer (remaining stuck in recursive
>>>>>>>>>>>>>> simulation until
>>>>>>>>>>>>>> the system crashes) is so utterly moronic that I don't
>>>>>>>>>>>>>> believe that you
>>>>>>>>>>>>>> believe it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except that isn't what H does, it aborts its simulation and
>>>>>>>>>>>>> gives the WRONG answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You are the MORON to think that an incorrect answer must be
>>>>>>>>>>>>> right because you don't know any other possible answer. IT
>>>>>>>>>>>>> is YOU how doesn't actually understand the Liar's Paradox.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> We could downgrade the answer to my answer from 15 years
>>>>>>>>>>>>>> ago, H aborts
>>>>>>>>>>>>>> the simulation and return BAD_INPUT.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Even this downgrade is (to the best of my knowledge)
>>>>>>>>>>>>>> better than anyone
>>>>>>>>>>>>>> else has ever done because it provides the exact criterion
>>>>>>>>>>>>>> measure for
>>>>>>>>>>>>>> this return value that cannot be fooled by Rice's theorem.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And you show that you totally don't understand anything
>>>>>>>>>>>>> about logic.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You just don't understand any of the basics of that which
>>>>>>>>>>>>> you talk about.
>>>>>>>>>>>>
>>>>>>>>>>>> Because H(D,D) would remain stuck in recursive simulation
>>>>>>>>>>>> unless it
>>>>>>>>>>>> aborts this simulation and in this case H is a termination
>>>>>>>>>>>> analyzer used
>>>>>>>>>>>> to detect Denial of Service attacks what do you think that H
>>>>>>>>>>>> should do
>>>>>>>>>>>> with input D?
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Then it would fail to be a decider.
>>>>>>>>>>>
>>>>>>>>>>> Once H is programmed to abort its simulation, it needs to
>>>>>>>>>>> analyze calls to H as if that call will also abort its
>>>>>>>>>>> simulation, since it will.
>>>>>>>>>>>
>>>>>>>>>> Okay then you are saying that H should return 1 and then H
>>>>>>>>>> would be correct.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> H SHOULD have returned 1, but if you change H to do that, you
>>>>>>>>> now have a new D and for that one (the one built on an H that
>>>>>>>>> returns 1 for H(D,D)) D(D) will be non-halting, so that H
>>>>>>>>> should have returned 0.
>>>>>>>>>
>>>>>>>> In other words (from H's point of view) the halt status of D is
>>>>>>>> a self-
>>>>>>>> contradictory question even though it is not self-contradictory
>>>>>>>> within other contexts. A question is not complete unless the
>>>>>>>> context is
>>>>>>>> included.
>>>>>>>>
>>>>>>>
>>>>>>> It doesn't matter what it is "from H's point of view", what
>>>>>>> matters is what it actually is, which is measured by what happens
>>>>>>> when the actual machine is actually run.
>>>>>>>
>>>>>>> Yes, the context matters, and every H creates a DIFFERENT
>>>>>>> context, so every H needs to take ITSELF into consideration, and
>>>>>>> not assume that D calls some other variation of H, because it
>>>>>>> doesn't, not if this H is the one that you want to claim is correct.
>>>>>>>
>>>>>>> Your problem is you are stuck in a world of make-believe. You
>>>>>>> presume things that are not true, and show that in such a fantasy
>>>>>>> world, your machine is correct. The problem is, that isn't how
>>>>>>> Truth actually works. You need to start from actual established
>>>>>>> facts when you reason about things.
>>>>>>>
>>>>>>
>>>>>> When computer science theory diverges from the reality of software
>>>>>> engineering it is the reality that take precedence and the theory
>>>>>> that
>>>>>> is out of touch with reality.
>>>>>
>>>>> So, you are admitting that you aren't followong the actual Theory,
>>>>>
>>>>> Thus you are admitting that you have been lying that you have been,
>>>>> for DECADES.
>>>>>
>>>>> You just don't understand the nature of the problem, or many of the
>>>>> things you talk about, because you don't understand the nature of
>>>>> Truth or Logic.
>>>>>
>>>>>>
>>>>>> When both Boolean return values are the wrong answer then this proves
>>>>>> that the question itself is incorrect.
>>>>>>
>>>>>
>>>>> Nope, because the question isn't What answer should H return to be
>>>>> correct, but what is the behavior of the machine at the input.
>>>>
>>>> When the input to H is defined to do the opposite of whatever H says it
>>>> will do then the halt status question posed to H is self-contradictory
>>>> even if it is not self-contradictory when posed to any other
>>>> termination
>>>> analyzer.
>>>
>>> Nope, because the program H must exist before the program D does, so
>>> the pnly self-contradictory question is how to design H to succeed.
>>> This is what makes a correct H impossible.
>>>
>>> I think part of your problem is you don't even understand what an
>>> actual program/machine is. It isn't just some nebulous definition of
>>> desired behavior, but needs to be actual detailed step-by-step
>>> instructions of what is going to happen based on the input.
>>>
>>> Your "Hypothetical" H that both correctly simulates its input, but
>>> also stops and gives an answer just isn't possible to do in an actual
>>> program. You have been given the challenge to show how it does both,
>>> and have ducked that, persumably because you know it is impossible.
>>>
>>> Once you define your H as an actual machine, then the answer to the
>>> behavor of D is well defined, easily determined, and it will be the
>>> opposite of whatever H gives as an answer.
>>>
>>>>
>>>> Furthermore it is an easily verified fact that H does correctly
>>>> thwart a
>>>> denial of service (DOS) attack by the halting problem's pathological
>>>> input. This proves that the halting problem issue has been overcome in
>>>> at least this one case.
>>>>
>>>>
>>>
>>> It may "thwart" a denial of service attack (cause by bad code in H),
>>> but it doesn't give the correct answer. It convicted an innocent party.


Click here to read the complete article
Re: Termination Analyzer H correctly prevents Denial of Service attacks

<pCuiM.5$EuDd.4@fx02.iad>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=11310&group=comp.ai.philosophy#11310

  copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!usenet.blueworldhosting.com!diablo1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx02.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:102.0)
Gecko/20100101 Thunderbird/102.11.2
Subject: Re: Termination Analyzer H correctly prevents Denial of Service
attacks
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
References: <u6a1ac$3klfk$3@dont-email.me> <686iM.5048$SaD4.4456@fx39.iad>
<u6arsr$3o1o8$1@dont-email.me> <Sv6iM.3959$Yxn4.2146@fx38.iad>
<u6b09r$3oj1r$1@dont-email.me> <1l8iM.34944$AF%b.10982@fx12.iad>
<u6b9nf$3t9u1$1@dont-email.me> <t2aiM.19350$F2qf.3997@fx48.iad>
<u6bb6d$3teta$1@dont-email.me> <LjaiM.19351$F2qf.4750@fx48.iad>
<u6bc4s$3teta$2@dont-email.me> <8ChiM.8534$%6L8.5147@fx04.iad>
<u6cji6$1tjb$1@dont-email.me> <HnriM.1615$Vpga.1473@fx09.iad>
<u6dl33$5c39$1@dont-email.me> <wctiM.2$I68a.1@fx43.iad>
<u6dok6$5lv4$1@dont-email.me> <IPtiM.5$33q9.2@fx35.iad>
<u6dq7h$5pop$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <u6dq7h$5pop$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 372
Message-ID: <pCuiM.5$EuDd.4@fx02.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 14 Jun 2023 22:23:16 -0400
X-Received-Bytes: 18940
 by: Richard Damon - Thu, 15 Jun 2023 02:23 UTC

On 6/14/23 9:41 PM, olcott wrote:
> On 6/14/2023 8:29 PM, Richard Damon wrote:
>> On 6/14/23 9:13 PM, olcott wrote:
>>> On 6/14/2023 7:47 PM, Richard Damon wrote:
>>>> On 6/14/23 8:13 PM, olcott wrote:
>>>>> On 6/14/2023 5:42 PM, Richard Damon wrote:
>>>>>> On 6/14/23 10:41 AM, olcott wrote:
>>>>>>> On 6/14/2023 6:35 AM, Richard Damon wrote:
>>>>>>>> On 6/13/23 11:28 PM, olcott wrote:
>>>>>>>>> On 6/13/2023 10:18 PM, Richard Damon wrote:
>>>>>>>>>> On 6/13/23 11:12 PM, olcott wrote:
>>>>>>>>>>> On 6/13/2023 9:59 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/13/23 10:47 PM, olcott wrote:
>>>>>>>>>>>>> On 6/13/2023 8:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/13/23 8:06 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/13/2023 5:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 6/13/23 6:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 6/13/2023 5:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 6/13/23 11:17 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> The purpose of solving the halting problem is to
>>>>>>>>>>>>>>>>>>> determine non-halting
>>>>>>>>>>>>>>>>>>> bugs and non-halting malevolent software. My system
>>>>>>>>>>>>>>>>>>> achieves that
>>>>>>>>>>>>>>>>>>> purpose for the halting problem's otherwise
>>>>>>>>>>>>>>>>>>> impossible input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is only when the halting problem is construed as
>>>>>>>>>>>>>>>>>>> providing a correct
>>>>>>>>>>>>>>>>>>> yes/no answer to a self-contradictory question that
>>>>>>>>>>>>>>>>>>> the halting problem
>>>>>>>>>>>>>>>>>>> cannot be solved.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> // The following is written in C
>>>>>>>>>>>>>>>>>>> //
>>>>>>>>>>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>>>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to
>>>>>>>>>>>>>>>>>>> simulate its input
>>>>>>>>>>>>>>>>>>> 03
>>>>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>>>>> 14   D(D);
>>>>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Execution Trace
>>>>>>>>>>>>>>>>>>> Line 14: main() invokes D(D)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> keeps repeating (unless aborted)
>>>>>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Simulation invariant:
>>>>>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach its
>>>>>>>>>>>>>>>>>>> own line 09.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When termination analyzer H is intended to prevent
>>>>>>>>>>>>>>>>>>> denial of service
>>>>>>>>>>>>>>>>>>> attacks is presented with an input D that has been
>>>>>>>>>>>>>>>>>>> defined to have a
>>>>>>>>>>>>>>>>>>> pathological relationship to this termination
>>>>>>>>>>>>>>>>>>> analyzer, it correctly
>>>>>>>>>>>>>>>>>>> aborts the simulation of this input that would have
>>>>>>>>>>>>>>>>>>> otherwise caused H
>>>>>>>>>>>>>>>>>>> to never terminate until system resources have been
>>>>>>>>>>>>>>>>>>> exhausted, crashing
>>>>>>>>>>>>>>>>>>> the system.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *The halting problem is an issue with denial of
>>>>>>>>>>>>>>>>>>> service attacks*
>>>>>>>>>>>>>>>>>>> https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The whole system is right here:
>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It compiles with the 2017 version of the Community
>>>>>>>>>>>>>>>>>>> Edition
>>>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Except that preventing "Denial of Service Attacks" is
>>>>>>>>>>>>>>>>>> part of the requirement, just as giving the right
>>>>>>>>>>>>>>>>>> answer. It needs to do BOTH, and the right answer
>>>>>>>>>>>>>>>>>> isn't based on its simulation, but the actual behavior
>>>>>>>>>>>>>>>>>> of the machine. Thus, trying to excuse the wrong
>>>>>>>>>>>>>>>>>> answer as being due to a prevention of a "Denial of
>>>>>>>>>>>>>>>>>> Service" is just an admissioon that the problem
>>>>>>>>>>>>>>>>>> actually is IMPOSSIBLE.
>>>>>>>>>>>>>>>>> When denial of service attacks define a pathological
>>>>>>>>>>>>>>>>> input that would
>>>>>>>>>>>>>>>>> otherwise cause the denial of service attack detector
>>>>>>>>>>>>>>>>> to eat up system
>>>>>>>>>>>>>>>>> resources and crash the system H detects this attempt
>>>>>>>>>>>>>>>>> and thwarts it.
>>>>>>>>>>>>>>>>> *This conclusively proves that H is correct*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *How pathological inputs are currently handled*
>>>>>>>>>>>>>>>>>   If a set of instructions ( in the smart contract) is
>>>>>>>>>>>>>>>>> executed on the
>>>>>>>>>>>>>>>>>   Ethereum Virtual Machine, it cannot predict how long
>>>>>>>>>>>>>>>>> these will run
>>>>>>>>>>>>>>>>>   for, at the beginning. If a set of instructions run
>>>>>>>>>>>>>>>>> forever, they can
>>>>>>>>>>>>>>>>>   freeze this blockchain and use up all the resources.
>>>>>>>>>>>>>>>>> This is similar to
>>>>>>>>>>>>>>>>>   a DoS (Denial of Service) attack. Each computation on
>>>>>>>>>>>>>>>>> the Ethereum
>>>>>>>>>>>>>>>>>   Virtual Machine requires some predetermined amount of
>>>>>>>>>>>>>>>>> gas (which one
>>>>>>>>>>>>>>>>>   has to buy with real money).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope. The decider is responsible to handle possible
>>>>>>>>>>>>>>>> "Denial of Service Attacks", and the presence of them
>>>>>>>>>>>>>>>> just points out the FUNDAMENTAL problem with your
>>>>>>>>>>>>>>>> solution method. It has long been know that just relying
>>>>>>>>>>>>>>>> on "Simulation" has significant issues for halt
>>>>>>>>>>>>>>>> deciding, but since you have chosen to not look at
>>>>>>>>>>>>>>>> history, you are just making the same mistakes made long
>>>>>>>>>>>>>>>> ago.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The CORRECT answer is ALWAYS the behavior of the Actual
>>>>>>>>>>>>>>>> Machine, which in this case Halts.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Therefore, H(D,D) saying that D(D) doesn't halt is just
>>>>>>>>>>>>>>>> making H wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Claiming the wrong answer is right is just a LIE.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When simulating termination analyzer H is presented with
>>>>>>>>>>>>>>> an input the
>>>>>>>>>>>>>>> right answer is always: Must the simulation of the input
>>>>>>>>>>>>>>> be aborted to
>>>>>>>>>>>>>>> prevent the infinite execution of H? Yes is the correct
>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, I guess you are admitting that a simulationg
>>>>>>>>>>>>>> termination analyzer isn't a "Halting Decider" per the
>>>>>>>>>>>>>> Computabilty Theory, since for those, the correct answer
>>>>>>>>>>>>>> is always based on the actual behavior of the
>>>>>>>>>>>>>> machine/input described by the input to the decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You KNOW that fact, as you have quoted that defintion,
>>>>>>>>>>>>>> though admittedly, while you blaim others for just quoting
>>>>>>>>>>>>>> "learned by rote" statements, the statements you quote are
>>>>>>>>>>>>>> probably just quoted by rote without ever actually
>>>>>>>>>>>>>> learning what they mean.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But, with your admission that your machine uses the WRONG
>>>>>>>>>>>>>> criteria, you have just proven that you have been lying
>>>>>>>>>>>>>> for the past decade that you have actually been working on
>>>>>>>>>>>>>> the ACTUAL Halting Problem of Computation Theory as
>>>>>>>>>>>>>> discussed by Turing, Linz, et all.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> All you have done is proved that you are the Hypocritical
>>>>>>>>>>>>>> Ignorant Pathological Lying Idiot that you are. Perhaps
>>>>>>>>>>>>>> even Insane, as you seem to think that by just repeating
>>>>>>>>>>>>>> your lies that eventually someone will belive them.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The alternative answer (remaining stuck in recursive
>>>>>>>>>>>>>>> simulation until
>>>>>>>>>>>>>>> the system crashes) is so utterly moronic that I don't
>>>>>>>>>>>>>>> believe that you
>>>>>>>>>>>>>>> believe it.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except that isn't what H does, it aborts its simulation
>>>>>>>>>>>>>> and gives the WRONG answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are the MORON to think that an incorrect answer must
>>>>>>>>>>>>>> be right because you don't know any other possible answer.
>>>>>>>>>>>>>> IT is YOU how doesn't actually understand the Liar's Paradox.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> We could downgrade the answer to my answer from 15 years
>>>>>>>>>>>>>>> ago, H aborts
>>>>>>>>>>>>>>> the simulation and return BAD_INPUT.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Even this downgrade is (to the best of my knowledge)
>>>>>>>>>>>>>>> better than anyone
>>>>>>>>>>>>>>> else has ever done because it provides the exact
>>>>>>>>>>>>>>> criterion measure for
>>>>>>>>>>>>>>> this return value that cannot be fooled by Rice's theorem.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And you show that you totally don't understand anything
>>>>>>>>>>>>>> about logic.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You just don't understand any of the basics of that which
>>>>>>>>>>>>>> you talk about.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because H(D,D) would remain stuck in recursive simulation
>>>>>>>>>>>>> unless it
>>>>>>>>>>>>> aborts this simulation and in this case H is a termination
>>>>>>>>>>>>> analyzer used
>>>>>>>>>>>>> to detect Denial of Service attacks what do you think that
>>>>>>>>>>>>> H should do
>>>>>>>>>>>>> with input D?
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Then it would fail to be a decider.
>>>>>>>>>>>>
>>>>>>>>>>>> Once H is programmed to abort its simulation, it needs to
>>>>>>>>>>>> analyze calls to H as if that call will also abort its
>>>>>>>>>>>> simulation, since it will.
>>>>>>>>>>>>
>>>>>>>>>>> Okay then you are saying that H should return 1 and then H
>>>>>>>>>>> would be correct.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> H SHOULD have returned 1, but if you change H to do that, you
>>>>>>>>>> now have a new D and for that one (the one built on an H that
>>>>>>>>>> returns 1 for H(D,D)) D(D) will be non-halting, so that H
>>>>>>>>>> should have returned 0.
>>>>>>>>>>
>>>>>>>>> In other words (from H's point of view) the halt status of D is
>>>>>>>>> a self-
>>>>>>>>> contradictory question even though it is not self-contradictory
>>>>>>>>> within other contexts. A question is not complete unless the
>>>>>>>>> context is
>>>>>>>>> included.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It doesn't matter what it is "from H's point of view", what
>>>>>>>> matters is what it actually is, which is measured by what
>>>>>>>> happens when the actual machine is actually run.
>>>>>>>>
>>>>>>>> Yes, the context matters, and every H creates a DIFFERENT
>>>>>>>> context, so every H needs to take ITSELF into consideration, and
>>>>>>>> not assume that D calls some other variation of H, because it
>>>>>>>> doesn't, not if this H is the one that you want to claim is
>>>>>>>> correct.
>>>>>>>>
>>>>>>>> Your problem is you are stuck in a world of make-believe. You
>>>>>>>> presume things that are not true, and show that in such a
>>>>>>>> fantasy world, your machine is correct. The problem is, that
>>>>>>>> isn't how Truth actually works. You need to start from actual
>>>>>>>> established facts when you reason about things.
>>>>>>>>
>>>>>>>
>>>>>>> When computer science theory diverges from the reality of software
>>>>>>> engineering it is the reality that take precedence and the theory
>>>>>>> that
>>>>>>> is out of touch with reality.
>>>>>>
>>>>>> So, you are admitting that you aren't followong the actual Theory,
>>>>>>
>>>>>> Thus you are admitting that you have been lying that you have
>>>>>> been, for DECADES.
>>>>>>
>>>>>> You just don't understand the nature of the problem, or many of
>>>>>> the things you talk about, because you don't understand the nature
>>>>>> of Truth or Logic.
>>>>>>
>>>>>>>
>>>>>>> When both Boolean return values are the wrong answer then this
>>>>>>> proves
>>>>>>> that the question itself is incorrect.
>>>>>>>
>>>>>>
>>>>>> Nope, because the question isn't What answer should H return to be
>>>>>> correct, but what is the behavior of the machine at the input.
>>>>>
>>>>> When the input to H is defined to do the opposite of whatever H
>>>>> says it
>>>>> will do then the halt status question posed to H is self-contradictory
>>>>> even if it is not self-contradictory when posed to any other
>>>>> termination
>>>>> analyzer.
>>>>
>>>> Nope, because the program H must exist before the program D does, so
>>>> the pnly self-contradictory question is how to design H to succeed.
>>>> This is what makes a correct H impossible.
>>>>
>>>> I think part of your problem is you don't even understand what an
>>>> actual program/machine is. It isn't just some nebulous definition of
>>>> desired behavior, but needs to be actual detailed step-by-step
>>>> instructions of what is going to happen based on the input.
>>>>
>>>> Your "Hypothetical" H that both correctly simulates its input, but
>>>> also stops and gives an answer just isn't possible to do in an
>>>> actual program. You have been given the challenge to show how it
>>>> does both, and have ducked that, persumably because you know it is
>>>> impossible.
>>>>
>>>> Once you define your H as an actual machine, then the answer to the
>>>> behavor of D is well defined, easily determined, and it will be the
>>>> opposite of whatever H gives as an answer.
>>>>
>>>>>
>>>>> Furthermore it is an easily verified fact that H does correctly
>>>>> thwart a
>>>>> denial of service (DOS) attack by the halting problem's pathological
>>>>> input. This proves that the halting problem issue has been overcome in
>>>>> at least this one case.
>>>>>
>>>>>
>>>>
>>>> It may "thwart" a denial of service attack (cause by bad code in H),
>>>> but it doesn't give the correct answer. It convicted an innocent party.
>
>>> It is an easily verified fact that H does correctly abort its simulation
>>> of D (that specifically targets H) because the alternative is that D
>>> causes the system to exhaust its resources and crash.
>>
>> You have the problem wrong, since H DOES abort is simulation, D Halts
>> so H, after aborting its simulation needed to return 1.
>>
>> You just don't understand how programs work.
>>
> You must be a bot you are stuck on old arguments that do not apply to
> the current issue.
>
> When H is a termination analyzer that prevents denial or service attacks
> H correctly detects that D specifically targets H in its denial of
> service attack on H. Then H correctly thwarts this DOS attack.
>
> Now that I have every detail boiled down to 100% entirely verified facts
> no rebuttal can possibly work. Anyone attempting such a rebuttal will
> look increasingly more foolish.
>


Click here to read the complete article
Re: Termination Analyzer H correctly prevents Denial of Service attacks

<u6e14c$9vuq$2@dont-email.me>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=11311&group=comp.ai.philosophy#11311

  copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
Subject: Re: Termination Analyzer H correctly prevents Denial of Service
attacks
Date: Wed, 14 Jun 2023 22:38:51 -0500
Organization: A noiseless patient Spider
Lines: 369
Message-ID: <u6e14c$9vuq$2@dont-email.me>
References: <u6a1ac$3klfk$3@dont-email.me> <686iM.5048$SaD4.4456@fx39.iad>
<u6arsr$3o1o8$1@dont-email.me> <Sv6iM.3959$Yxn4.2146@fx38.iad>
<u6b09r$3oj1r$1@dont-email.me> <1l8iM.34944$AF%b.10982@fx12.iad>
<u6b9nf$3t9u1$1@dont-email.me> <t2aiM.19350$F2qf.3997@fx48.iad>
<u6bb6d$3teta$1@dont-email.me> <LjaiM.19351$F2qf.4750@fx48.iad>
<u6bc4s$3teta$2@dont-email.me> <8ChiM.8534$%6L8.5147@fx04.iad>
<u6cji6$1tjb$1@dont-email.me> <HnriM.1615$Vpga.1473@fx09.iad>
<u6dl33$5c39$1@dont-email.me> <wctiM.2$I68a.1@fx43.iad>
<u6dok6$5lv4$1@dont-email.me> <IPtiM.5$33q9.2@fx35.iad>
<u6dq7h$5pop$1@dont-email.me> <pCuiM.5$EuDd.4@fx02.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 15 Jun 2023 03:38:52 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="fb9d20887a3ce8d0fd7f66c3017e22ca";
logging-data="327642"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19bnRgog1oCrBiaqU/8Vbwg"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.11.2
Cancel-Lock: sha1:afqwvKoYmdCQ3ocPOyXIZzWJgpk=
In-Reply-To: <pCuiM.5$EuDd.4@fx02.iad>
Content-Language: en-US
 by: olcott - Thu, 15 Jun 2023 03:38 UTC

On 6/14/2023 9:23 PM, Richard Damon wrote:
> On 6/14/23 9:41 PM, olcott wrote:
>> On 6/14/2023 8:29 PM, Richard Damon wrote:
>>> On 6/14/23 9:13 PM, olcott wrote:
>>>> On 6/14/2023 7:47 PM, Richard Damon wrote:
>>>>> On 6/14/23 8:13 PM, olcott wrote:
>>>>>> On 6/14/2023 5:42 PM, Richard Damon wrote:
>>>>>>> On 6/14/23 10:41 AM, olcott wrote:
>>>>>>>> On 6/14/2023 6:35 AM, Richard Damon wrote:
>>>>>>>>> On 6/13/23 11:28 PM, olcott wrote:
>>>>>>>>>> On 6/13/2023 10:18 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/13/23 11:12 PM, olcott wrote:
>>>>>>>>>>>> On 6/13/2023 9:59 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 6/13/23 10:47 PM, olcott wrote:
>>>>>>>>>>>>>> On 6/13/2023 8:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 6/13/23 8:06 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 6/13/2023 5:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 6/13/23 6:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 6/13/2023 5:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 6/13/23 11:17 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> The purpose of solving the halting problem is to
>>>>>>>>>>>>>>>>>>>> determine non-halting
>>>>>>>>>>>>>>>>>>>> bugs and non-halting malevolent software. My system
>>>>>>>>>>>>>>>>>>>> achieves that
>>>>>>>>>>>>>>>>>>>> purpose for the halting problem's otherwise
>>>>>>>>>>>>>>>>>>>> impossible input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is only when the halting problem is construed as
>>>>>>>>>>>>>>>>>>>> providing a correct
>>>>>>>>>>>>>>>>>>>> yes/no answer to a self-contradictory question that
>>>>>>>>>>>>>>>>>>>> the halting problem
>>>>>>>>>>>>>>>>>>>> cannot be solved.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> // The following is written in C
>>>>>>>>>>>>>>>>>>>> //
>>>>>>>>>>>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>>>>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to
>>>>>>>>>>>>>>>>>>>> simulate its input
>>>>>>>>>>>>>>>>>>>> 03
>>>>>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>>>>>> 14   D(D);
>>>>>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Execution Trace
>>>>>>>>>>>>>>>>>>>> Line 14: main() invokes D(D)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> keeps repeating (unless aborted)
>>>>>>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D)
>>>>>>>>>>>>>>>>>>>> that simulates D(D)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Simulation invariant:
>>>>>>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach its
>>>>>>>>>>>>>>>>>>>> own line 09.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When termination analyzer H is intended to prevent
>>>>>>>>>>>>>>>>>>>> denial of service
>>>>>>>>>>>>>>>>>>>> attacks is presented with an input D that has been
>>>>>>>>>>>>>>>>>>>> defined to have a
>>>>>>>>>>>>>>>>>>>> pathological relationship to this termination
>>>>>>>>>>>>>>>>>>>> analyzer, it correctly
>>>>>>>>>>>>>>>>>>>> aborts the simulation of this input that would have
>>>>>>>>>>>>>>>>>>>> otherwise caused H
>>>>>>>>>>>>>>>>>>>> to never terminate until system resources have been
>>>>>>>>>>>>>>>>>>>> exhausted, crashing
>>>>>>>>>>>>>>>>>>>> the system.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *The halting problem is an issue with denial of
>>>>>>>>>>>>>>>>>>>> service attacks*
>>>>>>>>>>>>>>>>>>>> https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The whole system is right here:
>>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It compiles with the 2017 version of the Community
>>>>>>>>>>>>>>>>>>>> Edition
>>>>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Except that preventing "Denial of Service Attacks" is
>>>>>>>>>>>>>>>>>>> part of the requirement, just as giving the right
>>>>>>>>>>>>>>>>>>> answer. It needs to do BOTH, and the right answer
>>>>>>>>>>>>>>>>>>> isn't based on its simulation, but the actual
>>>>>>>>>>>>>>>>>>> behavior of the machine. Thus, trying to excuse the
>>>>>>>>>>>>>>>>>>> wrong answer as being due to a prevention of a
>>>>>>>>>>>>>>>>>>> "Denial of Service" is just an admissioon that the
>>>>>>>>>>>>>>>>>>> problem actually is IMPOSSIBLE.
>>>>>>>>>>>>>>>>>> When denial of service attacks define a pathological
>>>>>>>>>>>>>>>>>> input that would
>>>>>>>>>>>>>>>>>> otherwise cause the denial of service attack detector
>>>>>>>>>>>>>>>>>> to eat up system
>>>>>>>>>>>>>>>>>> resources and crash the system H detects this attempt
>>>>>>>>>>>>>>>>>> and thwarts it.
>>>>>>>>>>>>>>>>>> *This conclusively proves that H is correct*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *How pathological inputs are currently handled*
>>>>>>>>>>>>>>>>>>   If a set of instructions ( in the smart contract) is
>>>>>>>>>>>>>>>>>> executed on the
>>>>>>>>>>>>>>>>>>   Ethereum Virtual Machine, it cannot predict how long
>>>>>>>>>>>>>>>>>> these will run
>>>>>>>>>>>>>>>>>>   for, at the beginning. If a set of instructions run
>>>>>>>>>>>>>>>>>> forever, they can
>>>>>>>>>>>>>>>>>>   freeze this blockchain and use up all the resources.
>>>>>>>>>>>>>>>>>> This is similar to
>>>>>>>>>>>>>>>>>>   a DoS (Denial of Service) attack. Each computation
>>>>>>>>>>>>>>>>>> on the Ethereum
>>>>>>>>>>>>>>>>>>   Virtual Machine requires some predetermined amount
>>>>>>>>>>>>>>>>>> of gas (which one
>>>>>>>>>>>>>>>>>>   has to buy with real money).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope. The decider is responsible to handle possible
>>>>>>>>>>>>>>>>> "Denial of Service Attacks", and the presence of them
>>>>>>>>>>>>>>>>> just points out the FUNDAMENTAL problem with your
>>>>>>>>>>>>>>>>> solution method. It has long been know that just
>>>>>>>>>>>>>>>>> relying on "Simulation" has significant issues for halt
>>>>>>>>>>>>>>>>> deciding, but since you have chosen to not look at
>>>>>>>>>>>>>>>>> history, you are just making the same mistakes made
>>>>>>>>>>>>>>>>> long ago.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The CORRECT answer is ALWAYS the behavior of the Actual
>>>>>>>>>>>>>>>>> Machine, which in this case Halts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Therefore, H(D,D) saying that D(D) doesn't halt is just
>>>>>>>>>>>>>>>>> making H wrong.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Claiming the wrong answer is right is just a LIE.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When simulating termination analyzer H is presented with
>>>>>>>>>>>>>>>> an input the
>>>>>>>>>>>>>>>> right answer is always: Must the simulation of the input
>>>>>>>>>>>>>>>> be aborted to
>>>>>>>>>>>>>>>> prevent the infinite execution of H? Yes is the correct
>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So, I guess you are admitting that a simulationg
>>>>>>>>>>>>>>> termination analyzer isn't a "Halting Decider" per the
>>>>>>>>>>>>>>> Computabilty Theory, since for those, the correct answer
>>>>>>>>>>>>>>> is always based on the actual behavior of the
>>>>>>>>>>>>>>> machine/input described by the input to the decider.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You KNOW that fact, as you have quoted that defintion,
>>>>>>>>>>>>>>> though admittedly, while you blaim others for just
>>>>>>>>>>>>>>> quoting "learned by rote" statements, the statements you
>>>>>>>>>>>>>>> quote are probably just quoted by rote without ever
>>>>>>>>>>>>>>> actually learning what they mean.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But, with your admission that your machine uses the WRONG
>>>>>>>>>>>>>>> criteria, you have just proven that you have been lying
>>>>>>>>>>>>>>> for the past decade that you have actually been working
>>>>>>>>>>>>>>> on the ACTUAL Halting Problem of Computation Theory as
>>>>>>>>>>>>>>> discussed by Turing, Linz, et all.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> All you have done is proved that you are the Hypocritical
>>>>>>>>>>>>>>> Ignorant Pathological Lying Idiot that you are. Perhaps
>>>>>>>>>>>>>>> even Insane, as you seem to think that by just repeating
>>>>>>>>>>>>>>> your lies that eventually someone will belive them.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The alternative answer (remaining stuck in recursive
>>>>>>>>>>>>>>>> simulation until
>>>>>>>>>>>>>>>> the system crashes) is so utterly moronic that I don't
>>>>>>>>>>>>>>>> believe that you
>>>>>>>>>>>>>>>> believe it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that isn't what H does, it aborts its simulation
>>>>>>>>>>>>>>> and gives the WRONG answer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are the MORON to think that an incorrect answer must
>>>>>>>>>>>>>>> be right because you don't know any other possible
>>>>>>>>>>>>>>> answer. IT is YOU how doesn't actually understand the
>>>>>>>>>>>>>>> Liar's Paradox.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> We could downgrade the answer to my answer from 15 years
>>>>>>>>>>>>>>>> ago, H aborts
>>>>>>>>>>>>>>>> the simulation and return BAD_INPUT.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Even this downgrade is (to the best of my knowledge)
>>>>>>>>>>>>>>>> better than anyone
>>>>>>>>>>>>>>>> else has ever done because it provides the exact
>>>>>>>>>>>>>>>> criterion measure for
>>>>>>>>>>>>>>>> this return value that cannot be fooled by Rice's theorem.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And you show that you totally don't understand anything
>>>>>>>>>>>>>>> about logic.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You just don't understand any of the basics of that which
>>>>>>>>>>>>>>> you talk about.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Because H(D,D) would remain stuck in recursive simulation
>>>>>>>>>>>>>> unless it
>>>>>>>>>>>>>> aborts this simulation and in this case H is a termination
>>>>>>>>>>>>>> analyzer used
>>>>>>>>>>>>>> to detect Denial of Service attacks what do you think that
>>>>>>>>>>>>>> H should do
>>>>>>>>>>>>>> with input D?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then it would fail to be a decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Once H is programmed to abort its simulation, it needs to
>>>>>>>>>>>>> analyze calls to H as if that call will also abort its
>>>>>>>>>>>>> simulation, since it will.
>>>>>>>>>>>>>
>>>>>>>>>>>> Okay then you are saying that H should return 1 and then H
>>>>>>>>>>>> would be correct.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> H SHOULD have returned 1, but if you change H to do that, you
>>>>>>>>>>> now have a new D and for that one (the one built on an H that
>>>>>>>>>>> returns 1 for H(D,D)) D(D) will be non-halting, so that H
>>>>>>>>>>> should have returned 0.
>>>>>>>>>>>
>>>>>>>>>> In other words (from H's point of view) the halt status of D
>>>>>>>>>> is a self-
>>>>>>>>>> contradictory question even though it is not self-contradictory
>>>>>>>>>> within other contexts. A question is not complete unless the
>>>>>>>>>> context is
>>>>>>>>>> included.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It doesn't matter what it is "from H's point of view", what
>>>>>>>>> matters is what it actually is, which is measured by what
>>>>>>>>> happens when the actual machine is actually run.
>>>>>>>>>
>>>>>>>>> Yes, the context matters, and every H creates a DIFFERENT
>>>>>>>>> context, so every H needs to take ITSELF into consideration,
>>>>>>>>> and not assume that D calls some other variation of H, because
>>>>>>>>> it doesn't, not if this H is the one that you want to claim is
>>>>>>>>> correct.
>>>>>>>>>
>>>>>>>>> Your problem is you are stuck in a world of make-believe. You
>>>>>>>>> presume things that are not true, and show that in such a
>>>>>>>>> fantasy world, your machine is correct. The problem is, that
>>>>>>>>> isn't how Truth actually works. You need to start from actual
>>>>>>>>> established facts when you reason about things.
>>>>>>>>>
>>>>>>>>
>>>>>>>> When computer science theory diverges from the reality of software
>>>>>>>> engineering it is the reality that take precedence and the
>>>>>>>> theory that
>>>>>>>> is out of touch with reality.
>>>>>>>
>>>>>>> So, you are admitting that you aren't followong the actual Theory,
>>>>>>>
>>>>>>> Thus you are admitting that you have been lying that you have
>>>>>>> been, for DECADES.
>>>>>>>
>>>>>>> You just don't understand the nature of the problem, or many of
>>>>>>> the things you talk about, because you don't understand the
>>>>>>> nature of Truth or Logic.
>>>>>>>
>>>>>>>>
>>>>>>>> When both Boolean return values are the wrong answer then this
>>>>>>>> proves
>>>>>>>> that the question itself is incorrect.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, because the question isn't What answer should H return to
>>>>>>> be correct, but what is the behavior of the machine at the input.
>>>>>>
>>>>>> When the input to H is defined to do the opposite of whatever H
>>>>>> says it
>>>>>> will do then the halt status question posed to H is
>>>>>> self-contradictory
>>>>>> even if it is not self-contradictory when posed to any other
>>>>>> termination
>>>>>> analyzer.
>>>>>
>>>>> Nope, because the program H must exist before the program D does,
>>>>> so the pnly self-contradictory question is how to design H to
>>>>> succeed. This is what makes a correct H impossible.
>>>>>
>>>>> I think part of your problem is you don't even understand what an
>>>>> actual program/machine is. It isn't just some nebulous definition
>>>>> of desired behavior, but needs to be actual detailed step-by-step
>>>>> instructions of what is going to happen based on the input.
>>>>>
>>>>> Your "Hypothetical" H that both correctly simulates its input, but
>>>>> also stops and gives an answer just isn't possible to do in an
>>>>> actual program. You have been given the challenge to show how it
>>>>> does both, and have ducked that, persumably because you know it is
>>>>> impossible.
>>>>>
>>>>> Once you define your H as an actual machine, then the answer to the
>>>>> behavor of D is well defined, easily determined, and it will be the
>>>>> opposite of whatever H gives as an answer.
>>>>>
>>>>>>
>>>>>> Furthermore it is an easily verified fact that H does correctly
>>>>>> thwart a
>>>>>> denial of service (DOS) attack by the halting problem's pathological
>>>>>> input. This proves that the halting problem issue has been
>>>>>> overcome in
>>>>>> at least this one case.
>>>>>>
>>>>>>
>>>>>
>>>>> It may "thwart" a denial of service attack (cause by bad code in
>>>>> H), but it doesn't give the correct answer. It convicted an
>>>>> innocent party.
>>
>>>> It is an easily verified fact that H does correctly abort its
>>>> simulation
>>>> of D (that specifically targets H) because the alternative is that D
>>>> causes the system to exhaust its resources and crash.
>>>
>>> You have the problem wrong, since H DOES abort is simulation, D Halts
>>> so H, after aborting its simulation needed to return 1.
>>>
>>> You just don't understand how programs work.
>>>
>> You must be a bot you are stuck on old arguments that do not apply to
>> the current issue.
>>
>> When H is a termination analyzer that prevents denial or service attacks
>> H correctly detects that D specifically targets H in its denial of
>> service attack on H. Then H correctly thwarts this DOS attack.
>>
>> Now that I have every detail boiled down to 100% entirely verified facts
>> no rebuttal can possibly work. Anyone attempting such a rebuttal will
>> look increasingly more foolish.
>>
>
>
> The first fact you fail to verify is that you are even working on the
> right problem, which becomes the source of many of your lies, and that
> seems to be because you have made yourself intentionally ignorant of the
> field you are claiming to be an expert in, but that just makes you the
> Fool.
>
> H might be able to determine that if H doesn't abort its simulation,
> that its simulation will go on forever, but that isn't the question of
> the halting problem, or even "Termination Analysis". Thus, you are just
> working on Strawmen.


Click here to read the complete article
Re: Termination Analyzer H correctly prevents Denial of Service attacks

<FyCiM.4051$LFN7.3640@fx33.iad>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=11312&group=comp.ai.philosophy#11312

  copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!diablo1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx33.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:102.0)
Gecko/20100101 Thunderbird/102.11.2
Subject: Re: Termination Analyzer H correctly prevents Denial of Service
attacks
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
References: <u6a1ac$3klfk$3@dont-email.me> <686iM.5048$SaD4.4456@fx39.iad>
<u6arsr$3o1o8$1@dont-email.me> <Sv6iM.3959$Yxn4.2146@fx38.iad>
<u6b09r$3oj1r$1@dont-email.me> <1l8iM.34944$AF%b.10982@fx12.iad>
<u6b9nf$3t9u1$1@dont-email.me> <t2aiM.19350$F2qf.3997@fx48.iad>
<u6bb6d$3teta$1@dont-email.me> <LjaiM.19351$F2qf.4750@fx48.iad>
<u6bc4s$3teta$2@dont-email.me> <8ChiM.8534$%6L8.5147@fx04.iad>
<u6cji6$1tjb$1@dont-email.me> <HnriM.1615$Vpga.1473@fx09.iad>
<u6dl33$5c39$1@dont-email.me> <wctiM.2$I68a.1@fx43.iad>
<u6dok6$5lv4$1@dont-email.me> <IPtiM.5$33q9.2@fx35.iad>
<u6dq7h$5pop$1@dont-email.me> <pCuiM.5$EuDd.4@fx02.iad>
<u6e14c$9vuq$2@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
Content-Language: en-US
In-Reply-To: <u6e14c$9vuq$2@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 397
Message-ID: <FyCiM.4051$LFN7.3640@fx33.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 15 Jun 2023 07:25:25 -0400
X-Received-Bytes: 20612
 by: Richard Damon - Thu, 15 Jun 2023 11:25 UTC

On 6/14/23 11:38 PM, olcott wrote:
> On 6/14/2023 9:23 PM, Richard Damon wrote:
>> On 6/14/23 9:41 PM, olcott wrote:
>>> On 6/14/2023 8:29 PM, Richard Damon wrote:
>>>> On 6/14/23 9:13 PM, olcott wrote:
>>>>> On 6/14/2023 7:47 PM, Richard Damon wrote:
>>>>>> On 6/14/23 8:13 PM, olcott wrote:
>>>>>>> On 6/14/2023 5:42 PM, Richard Damon wrote:
>>>>>>>> On 6/14/23 10:41 AM, olcott wrote:
>>>>>>>>> On 6/14/2023 6:35 AM, Richard Damon wrote:
>>>>>>>>>> On 6/13/23 11:28 PM, olcott wrote:
>>>>>>>>>>> On 6/13/2023 10:18 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/13/23 11:12 PM, olcott wrote:
>>>>>>>>>>>>> On 6/13/2023 9:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/13/23 10:47 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/13/2023 8:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 6/13/23 8:06 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 6/13/2023 5:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 6/13/23 6:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 6/13/2023 5:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 6/13/23 11:17 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> The purpose of solving the halting problem is to
>>>>>>>>>>>>>>>>>>>>> determine non-halting
>>>>>>>>>>>>>>>>>>>>> bugs and non-halting malevolent software. My system
>>>>>>>>>>>>>>>>>>>>> achieves that
>>>>>>>>>>>>>>>>>>>>> purpose for the halting problem's otherwise
>>>>>>>>>>>>>>>>>>>>> impossible input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It is only when the halting problem is construed as
>>>>>>>>>>>>>>>>>>>>> providing a correct
>>>>>>>>>>>>>>>>>>>>> yes/no answer to a self-contradictory question that
>>>>>>>>>>>>>>>>>>>>> the halting problem
>>>>>>>>>>>>>>>>>>>>> cannot be solved.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> // The following is written in C
>>>>>>>>>>>>>>>>>>>>> //
>>>>>>>>>>>>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>>>>>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to
>>>>>>>>>>>>>>>>>>>>> simulate its input
>>>>>>>>>>>>>>>>>>>>> 03
>>>>>>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>>>>>>> 14   D(D);
>>>>>>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Execution Trace
>>>>>>>>>>>>>>>>>>>>> Line 14: main() invokes D(D)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> keeps repeating (unless aborted)
>>>>>>>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D)
>>>>>>>>>>>>>>>>>>>>> that simulates D(D)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Simulation invariant:
>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach
>>>>>>>>>>>>>>>>>>>>> its own line 09.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When termination analyzer H is intended to prevent
>>>>>>>>>>>>>>>>>>>>> denial of service
>>>>>>>>>>>>>>>>>>>>> attacks is presented with an input D that has been
>>>>>>>>>>>>>>>>>>>>> defined to have a
>>>>>>>>>>>>>>>>>>>>> pathological relationship to this termination
>>>>>>>>>>>>>>>>>>>>> analyzer, it correctly
>>>>>>>>>>>>>>>>>>>>> aborts the simulation of this input that would have
>>>>>>>>>>>>>>>>>>>>> otherwise caused H
>>>>>>>>>>>>>>>>>>>>> to never terminate until system resources have been
>>>>>>>>>>>>>>>>>>>>> exhausted, crashing
>>>>>>>>>>>>>>>>>>>>> the system.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *The halting problem is an issue with denial of
>>>>>>>>>>>>>>>>>>>>> service attacks*
>>>>>>>>>>>>>>>>>>>>> https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The whole system is right here:
>>>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It compiles with the 2017 version of the Community
>>>>>>>>>>>>>>>>>>>>> Edition
>>>>>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Except that preventing "Denial of Service Attacks"
>>>>>>>>>>>>>>>>>>>> is part of the requirement, just as giving the right
>>>>>>>>>>>>>>>>>>>> answer. It needs to do BOTH, and the right answer
>>>>>>>>>>>>>>>>>>>> isn't based on its simulation, but the actual
>>>>>>>>>>>>>>>>>>>> behavior of the machine. Thus, trying to excuse the
>>>>>>>>>>>>>>>>>>>> wrong answer as being due to a prevention of a
>>>>>>>>>>>>>>>>>>>> "Denial of Service" is just an admissioon that the
>>>>>>>>>>>>>>>>>>>> problem actually is IMPOSSIBLE.
>>>>>>>>>>>>>>>>>>> When denial of service attacks define a pathological
>>>>>>>>>>>>>>>>>>> input that would
>>>>>>>>>>>>>>>>>>> otherwise cause the denial of service attack detector
>>>>>>>>>>>>>>>>>>> to eat up system
>>>>>>>>>>>>>>>>>>> resources and crash the system H detects this attempt
>>>>>>>>>>>>>>>>>>> and thwarts it.
>>>>>>>>>>>>>>>>>>> *This conclusively proves that H is correct*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *How pathological inputs are currently handled*
>>>>>>>>>>>>>>>>>>>   If a set of instructions ( in the smart contract)
>>>>>>>>>>>>>>>>>>> is executed on the
>>>>>>>>>>>>>>>>>>>   Ethereum Virtual Machine, it cannot predict how
>>>>>>>>>>>>>>>>>>> long these will run
>>>>>>>>>>>>>>>>>>>   for, at the beginning. If a set of instructions run
>>>>>>>>>>>>>>>>>>> forever, they can
>>>>>>>>>>>>>>>>>>>   freeze this blockchain and use up all the
>>>>>>>>>>>>>>>>>>> resources. This is similar to
>>>>>>>>>>>>>>>>>>>   a DoS (Denial of Service) attack. Each computation
>>>>>>>>>>>>>>>>>>> on the Ethereum
>>>>>>>>>>>>>>>>>>>   Virtual Machine requires some predetermined amount
>>>>>>>>>>>>>>>>>>> of gas (which one
>>>>>>>>>>>>>>>>>>>   has to buy with real money).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope. The decider is responsible to handle possible
>>>>>>>>>>>>>>>>>> "Denial of Service Attacks", and the presence of them
>>>>>>>>>>>>>>>>>> just points out the FUNDAMENTAL problem with your
>>>>>>>>>>>>>>>>>> solution method. It has long been know that just
>>>>>>>>>>>>>>>>>> relying on "Simulation" has significant issues for
>>>>>>>>>>>>>>>>>> halt deciding, but since you have chosen to not look
>>>>>>>>>>>>>>>>>> at history, you are just making the same mistakes made
>>>>>>>>>>>>>>>>>> long ago.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The CORRECT answer is ALWAYS the behavior of the
>>>>>>>>>>>>>>>>>> Actual Machine, which in this case Halts.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Therefore, H(D,D) saying that D(D) doesn't halt is
>>>>>>>>>>>>>>>>>> just making H wrong.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Claiming the wrong answer is right is just a LIE.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When simulating termination analyzer H is presented
>>>>>>>>>>>>>>>>> with an input the
>>>>>>>>>>>>>>>>> right answer is always: Must the simulation of the
>>>>>>>>>>>>>>>>> input be aborted to
>>>>>>>>>>>>>>>>> prevent the infinite execution of H? Yes is the correct
>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, I guess you are admitting that a simulationg
>>>>>>>>>>>>>>>> termination analyzer isn't a "Halting Decider" per the
>>>>>>>>>>>>>>>> Computabilty Theory, since for those, the correct answer
>>>>>>>>>>>>>>>> is always based on the actual behavior of the
>>>>>>>>>>>>>>>> machine/input described by the input to the decider.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You KNOW that fact, as you have quoted that defintion,
>>>>>>>>>>>>>>>> though admittedly, while you blaim others for just
>>>>>>>>>>>>>>>> quoting "learned by rote" statements, the statements you
>>>>>>>>>>>>>>>> quote are probably just quoted by rote without ever
>>>>>>>>>>>>>>>> actually learning what they mean.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But, with your admission that your machine uses the
>>>>>>>>>>>>>>>> WRONG criteria, you have just proven that you have been
>>>>>>>>>>>>>>>> lying for the past decade that you have actually been
>>>>>>>>>>>>>>>> working on the ACTUAL Halting Problem of Computation
>>>>>>>>>>>>>>>> Theory as discussed by Turing, Linz, et all.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> All you have done is proved that you are the
>>>>>>>>>>>>>>>> Hypocritical Ignorant Pathological Lying Idiot that you
>>>>>>>>>>>>>>>> are. Perhaps even Insane, as you seem to think that by
>>>>>>>>>>>>>>>> just repeating your lies that eventually someone will
>>>>>>>>>>>>>>>> belive them.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The alternative answer (remaining stuck in recursive
>>>>>>>>>>>>>>>>> simulation until
>>>>>>>>>>>>>>>>> the system crashes) is so utterly moronic that I don't
>>>>>>>>>>>>>>>>> believe that you
>>>>>>>>>>>>>>>>> believe it.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except that isn't what H does, it aborts its simulation
>>>>>>>>>>>>>>>> and gives the WRONG answer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are the MORON to think that an incorrect answer must
>>>>>>>>>>>>>>>> be right because you don't know any other possible
>>>>>>>>>>>>>>>> answer. IT is YOU how doesn't actually understand the
>>>>>>>>>>>>>>>> Liar's Paradox.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We could downgrade the answer to my answer from 15
>>>>>>>>>>>>>>>>> years ago, H aborts
>>>>>>>>>>>>>>>>> the simulation and return BAD_INPUT.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Even this downgrade is (to the best of my knowledge)
>>>>>>>>>>>>>>>>> better than anyone
>>>>>>>>>>>>>>>>> else has ever done because it provides the exact
>>>>>>>>>>>>>>>>> criterion measure for
>>>>>>>>>>>>>>>>> this return value that cannot be fooled by Rice's theorem.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And you show that you totally don't understand anything
>>>>>>>>>>>>>>>> about logic.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You just don't understand any of the basics of that
>>>>>>>>>>>>>>>> which you talk about.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because H(D,D) would remain stuck in recursive simulation
>>>>>>>>>>>>>>> unless it
>>>>>>>>>>>>>>> aborts this simulation and in this case H is a
>>>>>>>>>>>>>>> termination analyzer used
>>>>>>>>>>>>>>> to detect Denial of Service attacks what do you think
>>>>>>>>>>>>>>> that H should do
>>>>>>>>>>>>>>> with input D?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then it would fail to be a decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Once H is programmed to abort its simulation, it needs to
>>>>>>>>>>>>>> analyze calls to H as if that call will also abort its
>>>>>>>>>>>>>> simulation, since it will.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> Okay then you are saying that H should return 1 and then H
>>>>>>>>>>>>> would be correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> H SHOULD have returned 1, but if you change H to do that,
>>>>>>>>>>>> you now have a new D and for that one (the one built on an H
>>>>>>>>>>>> that returns 1 for H(D,D)) D(D) will be non-halting, so that
>>>>>>>>>>>> H should have returned 0.
>>>>>>>>>>>>
>>>>>>>>>>> In other words (from H's point of view) the halt status of D
>>>>>>>>>>> is a self-
>>>>>>>>>>> contradictory question even though it is not self-contradictory
>>>>>>>>>>> within other contexts. A question is not complete unless the
>>>>>>>>>>> context is
>>>>>>>>>>> included.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It doesn't matter what it is "from H's point of view", what
>>>>>>>>>> matters is what it actually is, which is measured by what
>>>>>>>>>> happens when the actual machine is actually run.
>>>>>>>>>>
>>>>>>>>>> Yes, the context matters, and every H creates a DIFFERENT
>>>>>>>>>> context, so every H needs to take ITSELF into consideration,
>>>>>>>>>> and not assume that D calls some other variation of H, because
>>>>>>>>>> it doesn't, not if this H is the one that you want to claim is
>>>>>>>>>> correct.
>>>>>>>>>>
>>>>>>>>>> Your problem is you are stuck in a world of make-believe. You
>>>>>>>>>> presume things that are not true, and show that in such a
>>>>>>>>>> fantasy world, your machine is correct. The problem is, that
>>>>>>>>>> isn't how Truth actually works. You need to start from actual
>>>>>>>>>> established facts when you reason about things.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> When computer science theory diverges from the reality of software
>>>>>>>>> engineering it is the reality that take precedence and the
>>>>>>>>> theory that
>>>>>>>>> is out of touch with reality.
>>>>>>>>
>>>>>>>> So, you are admitting that you aren't followong the actual Theory,
>>>>>>>>
>>>>>>>> Thus you are admitting that you have been lying that you have
>>>>>>>> been, for DECADES.
>>>>>>>>
>>>>>>>> You just don't understand the nature of the problem, or many of
>>>>>>>> the things you talk about, because you don't understand the
>>>>>>>> nature of Truth or Logic.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> When both Boolean return values are the wrong answer then this
>>>>>>>>> proves
>>>>>>>>> that the question itself is incorrect.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, because the question isn't What answer should H return to
>>>>>>>> be correct, but what is the behavior of the machine at the input.
>>>>>>>
>>>>>>> When the input to H is defined to do the opposite of whatever H
>>>>>>> says it
>>>>>>> will do then the halt status question posed to H is
>>>>>>> self-contradictory
>>>>>>> even if it is not self-contradictory when posed to any other
>>>>>>> termination
>>>>>>> analyzer.
>>>>>>
>>>>>> Nope, because the program H must exist before the program D does,
>>>>>> so the pnly self-contradictory question is how to design H to
>>>>>> succeed. This is what makes a correct H impossible.
>>>>>>
>>>>>> I think part of your problem is you don't even understand what an
>>>>>> actual program/machine is. It isn't just some nebulous definition
>>>>>> of desired behavior, but needs to be actual detailed step-by-step
>>>>>> instructions of what is going to happen based on the input.
>>>>>>
>>>>>> Your "Hypothetical" H that both correctly simulates its input, but
>>>>>> also stops and gives an answer just isn't possible to do in an
>>>>>> actual program. You have been given the challenge to show how it
>>>>>> does both, and have ducked that, persumably because you know it is
>>>>>> impossible.
>>>>>>
>>>>>> Once you define your H as an actual machine, then the answer to
>>>>>> the behavor of D is well defined, easily determined, and it will
>>>>>> be the opposite of whatever H gives as an answer.
>>>>>>
>>>>>>>
>>>>>>> Furthermore it is an easily verified fact that H does correctly
>>>>>>> thwart a
>>>>>>> denial of service (DOS) attack by the halting problem's pathological
>>>>>>> input. This proves that the halting problem issue has been
>>>>>>> overcome in
>>>>>>> at least this one case.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> It may "thwart" a denial of service attack (cause by bad code in
>>>>>> H), but it doesn't give the correct answer. It convicted an
>>>>>> innocent party.
>>>
>>>>> It is an easily verified fact that H does correctly abort its
>>>>> simulation
>>>>> of D (that specifically targets H) because the alternative is that D
>>>>> causes the system to exhaust its resources and crash.
>>>>
>>>> You have the problem wrong, since H DOES abort is simulation, D
>>>> Halts so H, after aborting its simulation needed to return 1.
>>>>
>>>> You just don't understand how programs work.
>>>>
>>> You must be a bot you are stuck on old arguments that do not apply to
>>> the current issue.
>>>
>>> When H is a termination analyzer that prevents denial or service attacks
>>> H correctly detects that D specifically targets H in its denial of
>>> service attack on H. Then H correctly thwarts this DOS attack.
>>>
>>> Now that I have every detail boiled down to 100% entirely verified facts
>>> no rebuttal can possibly work. Anyone attempting such a rebuttal will
>>> look increasingly more foolish.
>>>
>>
>>
>> The first fact you fail to verify is that you are even working on the
>> right problem, which becomes the source of many of your lies, and that
>> seems to be because you have made yourself intentionally ignorant of
>> the field you are claiming to be an expert in, but that just makes you
>> the Fool.
>>
>> H might be able to determine that if H doesn't abort its simulation,
>> that its simulation will go on forever, but that isn't the question of
>> the halting problem, or even "Termination Analysis". Thus, you are
>> just working on Strawmen.
>
> *Termination Analyzer H prevents Denial of Service attacks*


Click here to read the complete article
Re: Termination Analyzer H correctly prevents Denial of Service attacks

<u6f9o2$el1n$1@dont-email.me>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=11313&group=comp.ai.philosophy#11313

  copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
Subject: Re: Termination Analyzer H correctly prevents Denial of Service
attacks
Date: Thu, 15 Jun 2023 10:12:00 -0500
Organization: A noiseless patient Spider
Lines: 401
Message-ID: <u6f9o2$el1n$1@dont-email.me>
References: <u6a1ac$3klfk$3@dont-email.me> <686iM.5048$SaD4.4456@fx39.iad>
<u6arsr$3o1o8$1@dont-email.me> <Sv6iM.3959$Yxn4.2146@fx38.iad>
<u6b09r$3oj1r$1@dont-email.me> <1l8iM.34944$AF%b.10982@fx12.iad>
<u6b9nf$3t9u1$1@dont-email.me> <t2aiM.19350$F2qf.3997@fx48.iad>
<u6bb6d$3teta$1@dont-email.me> <LjaiM.19351$F2qf.4750@fx48.iad>
<u6bc4s$3teta$2@dont-email.me> <8ChiM.8534$%6L8.5147@fx04.iad>
<u6cji6$1tjb$1@dont-email.me> <HnriM.1615$Vpga.1473@fx09.iad>
<u6dl33$5c39$1@dont-email.me> <wctiM.2$I68a.1@fx43.iad>
<u6dok6$5lv4$1@dont-email.me> <IPtiM.5$33q9.2@fx35.iad>
<u6dq7h$5pop$1@dont-email.me> <pCuiM.5$EuDd.4@fx02.iad>
<u6e14c$9vuq$2@dont-email.me> <FyCiM.4051$LFN7.3640@fx33.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 15 Jun 2023 15:12:03 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="fb9d20887a3ce8d0fd7f66c3017e22ca";
logging-data="480311"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+2Dy4X0tCjcTQ79fweOuUj"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
Thunderbird/102.11.2
Cancel-Lock: sha1:gM84w+fzMRNhriV3kOUGKj9Qmsc=
In-Reply-To: <FyCiM.4051$LFN7.3640@fx33.iad>
Content-Language: en-US
 by: olcott - Thu, 15 Jun 2023 15:12 UTC

On 6/15/2023 6:25 AM, Richard Damon wrote:
> On 6/14/23 11:38 PM, olcott wrote:
>> On 6/14/2023 9:23 PM, Richard Damon wrote:
>>> On 6/14/23 9:41 PM, olcott wrote:
>>>> On 6/14/2023 8:29 PM, Richard Damon wrote:
>>>>> On 6/14/23 9:13 PM, olcott wrote:
>>>>>> On 6/14/2023 7:47 PM, Richard Damon wrote:
>>>>>>> On 6/14/23 8:13 PM, olcott wrote:
>>>>>>>> On 6/14/2023 5:42 PM, Richard Damon wrote:
>>>>>>>>> On 6/14/23 10:41 AM, olcott wrote:
>>>>>>>>>> On 6/14/2023 6:35 AM, Richard Damon wrote:
>>>>>>>>>>> On 6/13/23 11:28 PM, olcott wrote:
>>>>>>>>>>>> On 6/13/2023 10:18 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 6/13/23 11:12 PM, olcott wrote:
>>>>>>>>>>>>>> On 6/13/2023 9:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 6/13/23 10:47 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 6/13/2023 8:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 6/13/23 8:06 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 6/13/2023 5:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 6/13/23 6:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 6/13/2023 5:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 6/13/23 11:17 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> The purpose of solving the halting problem is to
>>>>>>>>>>>>>>>>>>>>>> determine non-halting
>>>>>>>>>>>>>>>>>>>>>> bugs and non-halting malevolent software. My
>>>>>>>>>>>>>>>>>>>>>> system achieves that
>>>>>>>>>>>>>>>>>>>>>> purpose for the halting problem's otherwise
>>>>>>>>>>>>>>>>>>>>>> impossible input.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It is only when the halting problem is construed
>>>>>>>>>>>>>>>>>>>>>> as providing a correct
>>>>>>>>>>>>>>>>>>>>>> yes/no answer to a self-contradictory question
>>>>>>>>>>>>>>>>>>>>>> that the halting problem
>>>>>>>>>>>>>>>>>>>>>> cannot be solved.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> // The following is written in C
>>>>>>>>>>>>>>>>>>>>>> //
>>>>>>>>>>>>>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>>>>>>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to
>>>>>>>>>>>>>>>>>>>>>> simulate its input
>>>>>>>>>>>>>>>>>>>>>> 03
>>>>>>>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>>>>>>>> 14   D(D);
>>>>>>>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Execution Trace
>>>>>>>>>>>>>>>>>>>>>> Line 14: main() invokes D(D)
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> keeps repeating (unless aborted)
>>>>>>>>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D)
>>>>>>>>>>>>>>>>>>>>>> that simulates D(D)
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Simulation invariant:
>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach
>>>>>>>>>>>>>>>>>>>>>> its own line 09.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When termination analyzer H is intended to prevent
>>>>>>>>>>>>>>>>>>>>>> denial of service
>>>>>>>>>>>>>>>>>>>>>> attacks is presented with an input D that has been
>>>>>>>>>>>>>>>>>>>>>> defined to have a
>>>>>>>>>>>>>>>>>>>>>> pathological relationship to this termination
>>>>>>>>>>>>>>>>>>>>>> analyzer, it correctly
>>>>>>>>>>>>>>>>>>>>>> aborts the simulation of this input that would
>>>>>>>>>>>>>>>>>>>>>> have otherwise caused H
>>>>>>>>>>>>>>>>>>>>>> to never terminate until system resources have
>>>>>>>>>>>>>>>>>>>>>> been exhausted, crashing
>>>>>>>>>>>>>>>>>>>>>> the system.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *The halting problem is an issue with denial of
>>>>>>>>>>>>>>>>>>>>>> service attacks*
>>>>>>>>>>>>>>>>>>>>>> https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The whole system is right here:
>>>>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It compiles with the 2017 version of the Community
>>>>>>>>>>>>>>>>>>>>>> Edition
>>>>>>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Except that preventing "Denial of Service Attacks"
>>>>>>>>>>>>>>>>>>>>> is part of the requirement, just as giving the
>>>>>>>>>>>>>>>>>>>>> right answer. It needs to do BOTH, and the right
>>>>>>>>>>>>>>>>>>>>> answer isn't based on its simulation, but the
>>>>>>>>>>>>>>>>>>>>> actual behavior of the machine. Thus, trying to
>>>>>>>>>>>>>>>>>>>>> excuse the wrong answer as being due to a
>>>>>>>>>>>>>>>>>>>>> prevention of a "Denial of Service" is just an
>>>>>>>>>>>>>>>>>>>>> admissioon that the problem actually is IMPOSSIBLE.
>>>>>>>>>>>>>>>>>>>> When denial of service attacks define a pathological
>>>>>>>>>>>>>>>>>>>> input that would
>>>>>>>>>>>>>>>>>>>> otherwise cause the denial of service attack
>>>>>>>>>>>>>>>>>>>> detector to eat up system
>>>>>>>>>>>>>>>>>>>> resources and crash the system H detects this
>>>>>>>>>>>>>>>>>>>> attempt and thwarts it.
>>>>>>>>>>>>>>>>>>>> *This conclusively proves that H is correct*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *How pathological inputs are currently handled*
>>>>>>>>>>>>>>>>>>>>   If a set of instructions ( in the smart contract)
>>>>>>>>>>>>>>>>>>>> is executed on the
>>>>>>>>>>>>>>>>>>>>   Ethereum Virtual Machine, it cannot predict how
>>>>>>>>>>>>>>>>>>>> long these will run
>>>>>>>>>>>>>>>>>>>>   for, at the beginning. If a set of instructions
>>>>>>>>>>>>>>>>>>>> run forever, they can
>>>>>>>>>>>>>>>>>>>>   freeze this blockchain and use up all the
>>>>>>>>>>>>>>>>>>>> resources. This is similar to
>>>>>>>>>>>>>>>>>>>>   a DoS (Denial of Service) attack. Each computation
>>>>>>>>>>>>>>>>>>>> on the Ethereum
>>>>>>>>>>>>>>>>>>>>   Virtual Machine requires some predetermined amount
>>>>>>>>>>>>>>>>>>>> of gas (which one
>>>>>>>>>>>>>>>>>>>>   has to buy with real money).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope. The decider is responsible to handle possible
>>>>>>>>>>>>>>>>>>> "Denial of Service Attacks", and the presence of them
>>>>>>>>>>>>>>>>>>> just points out the FUNDAMENTAL problem with your
>>>>>>>>>>>>>>>>>>> solution method. It has long been know that just
>>>>>>>>>>>>>>>>>>> relying on "Simulation" has significant issues for
>>>>>>>>>>>>>>>>>>> halt deciding, but since you have chosen to not look
>>>>>>>>>>>>>>>>>>> at history, you are just making the same mistakes
>>>>>>>>>>>>>>>>>>> made long ago.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The CORRECT answer is ALWAYS the behavior of the
>>>>>>>>>>>>>>>>>>> Actual Machine, which in this case Halts.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Therefore, H(D,D) saying that D(D) doesn't halt is
>>>>>>>>>>>>>>>>>>> just making H wrong.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Claiming the wrong answer is right is just a LIE.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When simulating termination analyzer H is presented
>>>>>>>>>>>>>>>>>> with an input the
>>>>>>>>>>>>>>>>>> right answer is always: Must the simulation of the
>>>>>>>>>>>>>>>>>> input be aborted to
>>>>>>>>>>>>>>>>>> prevent the infinite execution of H? Yes is the
>>>>>>>>>>>>>>>>>> correct answer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So, I guess you are admitting that a simulationg
>>>>>>>>>>>>>>>>> termination analyzer isn't a "Halting Decider" per the
>>>>>>>>>>>>>>>>> Computabilty Theory, since for those, the correct
>>>>>>>>>>>>>>>>> answer is always based on the actual behavior of the
>>>>>>>>>>>>>>>>> machine/input described by the input to the decider.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You KNOW that fact, as you have quoted that defintion,
>>>>>>>>>>>>>>>>> though admittedly, while you blaim others for just
>>>>>>>>>>>>>>>>> quoting "learned by rote" statements, the statements
>>>>>>>>>>>>>>>>> you quote are probably just quoted by rote without ever
>>>>>>>>>>>>>>>>> actually learning what they mean.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But, with your admission that your machine uses the
>>>>>>>>>>>>>>>>> WRONG criteria, you have just proven that you have been
>>>>>>>>>>>>>>>>> lying for the past decade that you have actually been
>>>>>>>>>>>>>>>>> working on the ACTUAL Halting Problem of Computation
>>>>>>>>>>>>>>>>> Theory as discussed by Turing, Linz, et all.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> All you have done is proved that you are the
>>>>>>>>>>>>>>>>> Hypocritical Ignorant Pathological Lying Idiot that you
>>>>>>>>>>>>>>>>> are. Perhaps even Insane, as you seem to think that by
>>>>>>>>>>>>>>>>> just repeating your lies that eventually someone will
>>>>>>>>>>>>>>>>> belive them.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The alternative answer (remaining stuck in recursive
>>>>>>>>>>>>>>>>>> simulation until
>>>>>>>>>>>>>>>>>> the system crashes) is so utterly moronic that I don't
>>>>>>>>>>>>>>>>>> believe that you
>>>>>>>>>>>>>>>>>> believe it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except that isn't what H does, it aborts its simulation
>>>>>>>>>>>>>>>>> and gives the WRONG answer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are the MORON to think that an incorrect answer
>>>>>>>>>>>>>>>>> must be right because you don't know any other possible
>>>>>>>>>>>>>>>>> answer. IT is YOU how doesn't actually understand the
>>>>>>>>>>>>>>>>> Liar's Paradox.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> We could downgrade the answer to my answer from 15
>>>>>>>>>>>>>>>>>> years ago, H aborts
>>>>>>>>>>>>>>>>>> the simulation and return BAD_INPUT.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Even this downgrade is (to the best of my knowledge)
>>>>>>>>>>>>>>>>>> better than anyone
>>>>>>>>>>>>>>>>>> else has ever done because it provides the exact
>>>>>>>>>>>>>>>>>> criterion measure for
>>>>>>>>>>>>>>>>>> this return value that cannot be fooled by Rice's
>>>>>>>>>>>>>>>>>> theorem.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And you show that you totally don't understand anything
>>>>>>>>>>>>>>>>> about logic.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You just don't understand any of the basics of that
>>>>>>>>>>>>>>>>> which you talk about.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Because H(D,D) would remain stuck in recursive
>>>>>>>>>>>>>>>> simulation unless it
>>>>>>>>>>>>>>>> aborts this simulation and in this case H is a
>>>>>>>>>>>>>>>> termination analyzer used
>>>>>>>>>>>>>>>> to detect Denial of Service attacks what do you think
>>>>>>>>>>>>>>>> that H should do
>>>>>>>>>>>>>>>> with input D?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Then it would fail to be a decider.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Once H is programmed to abort its simulation, it needs to
>>>>>>>>>>>>>>> analyze calls to H as if that call will also abort its
>>>>>>>>>>>>>>> simulation, since it will.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Okay then you are saying that H should return 1 and then H
>>>>>>>>>>>>>> would be correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> H SHOULD have returned 1, but if you change H to do that,
>>>>>>>>>>>>> you now have a new D and for that one (the one built on an
>>>>>>>>>>>>> H that returns 1 for H(D,D)) D(D) will be non-halting, so
>>>>>>>>>>>>> that H should have returned 0.
>>>>>>>>>>>>>
>>>>>>>>>>>> In other words (from H's point of view) the halt status of D
>>>>>>>>>>>> is a self-
>>>>>>>>>>>> contradictory question even though it is not self-contradictory
>>>>>>>>>>>> within other contexts. A question is not complete unless the
>>>>>>>>>>>> context is
>>>>>>>>>>>> included.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It doesn't matter what it is "from H's point of view", what
>>>>>>>>>>> matters is what it actually is, which is measured by what
>>>>>>>>>>> happens when the actual machine is actually run.
>>>>>>>>>>>
>>>>>>>>>>> Yes, the context matters, and every H creates a DIFFERENT
>>>>>>>>>>> context, so every H needs to take ITSELF into consideration,
>>>>>>>>>>> and not assume that D calls some other variation of H,
>>>>>>>>>>> because it doesn't, not if this H is the one that you want to
>>>>>>>>>>> claim is correct.
>>>>>>>>>>>
>>>>>>>>>>> Your problem is you are stuck in a world of make-believe. You
>>>>>>>>>>> presume things that are not true, and show that in such a
>>>>>>>>>>> fantasy world, your machine is correct. The problem is, that
>>>>>>>>>>> isn't how Truth actually works. You need to start from actual
>>>>>>>>>>> established facts when you reason about things.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When computer science theory diverges from the reality of
>>>>>>>>>> software
>>>>>>>>>> engineering it is the reality that take precedence and the
>>>>>>>>>> theory that
>>>>>>>>>> is out of touch with reality.
>>>>>>>>>
>>>>>>>>> So, you are admitting that you aren't followong the actual Theory,
>>>>>>>>>
>>>>>>>>> Thus you are admitting that you have been lying that you have
>>>>>>>>> been, for DECADES.
>>>>>>>>>
>>>>>>>>> You just don't understand the nature of the problem, or many of
>>>>>>>>> the things you talk about, because you don't understand the
>>>>>>>>> nature of Truth or Logic.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When both Boolean return values are the wrong answer then this
>>>>>>>>>> proves
>>>>>>>>>> that the question itself is incorrect.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, because the question isn't What answer should H return to
>>>>>>>>> be correct, but what is the behavior of the machine at the input.
>>>>>>>>
>>>>>>>> When the input to H is defined to do the opposite of whatever H
>>>>>>>> says it
>>>>>>>> will do then the halt status question posed to H is
>>>>>>>> self-contradictory
>>>>>>>> even if it is not self-contradictory when posed to any other
>>>>>>>> termination
>>>>>>>> analyzer.
>>>>>>>
>>>>>>> Nope, because the program H must exist before the program D does,
>>>>>>> so the pnly self-contradictory question is how to design H to
>>>>>>> succeed. This is what makes a correct H impossible.
>>>>>>>
>>>>>>> I think part of your problem is you don't even understand what an
>>>>>>> actual program/machine is. It isn't just some nebulous definition
>>>>>>> of desired behavior, but needs to be actual detailed step-by-step
>>>>>>> instructions of what is going to happen based on the input.
>>>>>>>
>>>>>>> Your "Hypothetical" H that both correctly simulates its input,
>>>>>>> but also stops and gives an answer just isn't possible to do in
>>>>>>> an actual program. You have been given the challenge to show how
>>>>>>> it does both, and have ducked that, persumably because you know
>>>>>>> it is impossible.
>>>>>>>
>>>>>>> Once you define your H as an actual machine, then the answer to
>>>>>>> the behavor of D is well defined, easily determined, and it will
>>>>>>> be the opposite of whatever H gives as an answer.
>>>>>>>
>>>>>>>>
>>>>>>>> Furthermore it is an easily verified fact that H does correctly
>>>>>>>> thwart a
>>>>>>>> denial of service (DOS) attack by the halting problem's
>>>>>>>> pathological
>>>>>>>> input. This proves that the halting problem issue has been
>>>>>>>> overcome in
>>>>>>>> at least this one case.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> It may "thwart" a denial of service attack (cause by bad code in
>>>>>>> H), but it doesn't give the correct answer. It convicted an
>>>>>>> innocent party.
>>>>
>>>>>> It is an easily verified fact that H does correctly abort its
>>>>>> simulation
>>>>>> of D (that specifically targets H) because the alternative is that D
>>>>>> causes the system to exhaust its resources and crash.
>>>>>
>>>>> You have the problem wrong, since H DOES abort is simulation, D
>>>>> Halts so H, after aborting its simulation needed to return 1.
>>>>>
>>>>> You just don't understand how programs work.
>>>>>
>>>> You must be a bot you are stuck on old arguments that do not apply to
>>>> the current issue.
>>>>
>>>> When H is a termination analyzer that prevents denial or service
>>>> attacks
>>>> H correctly detects that D specifically targets H in its denial of
>>>> service attack on H. Then H correctly thwarts this DOS attack.
>>>>
>>>> Now that I have every detail boiled down to 100% entirely verified
>>>> facts
>>>> no rebuttal can possibly work. Anyone attempting such a rebuttal will
>>>> look increasingly more foolish.
>>>>
>>>
>>>
>>> The first fact you fail to verify is that you are even working on the
>>> right problem, which becomes the source of many of your lies, and
>>> that seems to be because you have made yourself intentionally
>>> ignorant of the field you are claiming to be an expert in, but that
>>> just makes you the Fool.
>>>
>>> H might be able to determine that if H doesn't abort its simulation,
>>> that its simulation will go on forever, but that isn't the question
>>> of the halting problem, or even "Termination Analysis". Thus, you are
>>> just working on Strawmen.
>>
>> *Termination Analyzer H prevents Denial of Service attacks*
>
> But doesn't get the right answer to the Halting Problem.
>
>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_prevents_Denial_of_Service_attacks
>>
>> It is an easily verified fact that termination analyzer H does correctly
>> thwart what would otherwise be a successful denial of service attack
>> when presented with input D having the halting problem's pathological
>> relationship to H.
>>
>> This proves that the halting problem's pathological input is not an
>> issue for actual software systems.
>>
>
> It might thwart a DOS attack on itself, but the program that it flags,
> if run as an independent program, will HALT, and thus not present a DOS
> attack on the system, so its answer is a FALSE POSITIVE.
>


Click here to read the complete article
Re: Termination Analyzer H correctly prevents Denial of Service attacks

<p7HiM.66$a0G8.8@fx34.iad>

  copy mid

https://www.novabbs.com/computers/article-flat.php?id=11314&group=comp.ai.philosophy#11314

  copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx34.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:102.0)
Gecko/20100101 Thunderbird/102.11.2
Subject: Re: Termination Analyzer H correctly prevents Denial of Service
attacks
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
References: <u6a1ac$3klfk$3@dont-email.me> <686iM.5048$SaD4.4456@fx39.iad>
<u6arsr$3o1o8$1@dont-email.me> <Sv6iM.3959$Yxn4.2146@fx38.iad>
<u6b09r$3oj1r$1@dont-email.me> <1l8iM.34944$AF%b.10982@fx12.iad>
<u6b9nf$3t9u1$1@dont-email.me> <t2aiM.19350$F2qf.3997@fx48.iad>
<u6bb6d$3teta$1@dont-email.me> <LjaiM.19351$F2qf.4750@fx48.iad>
<u6bc4s$3teta$2@dont-email.me> <8ChiM.8534$%6L8.5147@fx04.iad>
<u6cji6$1tjb$1@dont-email.me> <HnriM.1615$Vpga.1473@fx09.iad>
<u6dl33$5c39$1@dont-email.me> <wctiM.2$I68a.1@fx43.iad>
<u6dok6$5lv4$1@dont-email.me> <IPtiM.5$33q9.2@fx35.iad>
<u6dq7h$5pop$1@dont-email.me> <pCuiM.5$EuDd.4@fx02.iad>
<u6e14c$9vuq$2@dont-email.me> <FyCiM.4051$LFN7.3640@fx33.iad>
<u6f9o2$el1n$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <u6f9o2$el1n$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 438
Message-ID: <p7HiM.66$a0G8.8@fx34.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 15 Jun 2023 12:37:40 -0400
X-Received-Bytes: 23240
 by: Richard Damon - Thu, 15 Jun 2023 16:37 UTC

On 6/15/23 11:12 AM, olcott wrote:
> On 6/15/2023 6:25 AM, Richard Damon wrote:
>> On 6/14/23 11:38 PM, olcott wrote:
>>> On 6/14/2023 9:23 PM, Richard Damon wrote:
>>>> On 6/14/23 9:41 PM, olcott wrote:
>>>>> On 6/14/2023 8:29 PM, Richard Damon wrote:
>>>>>> On 6/14/23 9:13 PM, olcott wrote:
>>>>>>> On 6/14/2023 7:47 PM, Richard Damon wrote:
>>>>>>>> On 6/14/23 8:13 PM, olcott wrote:
>>>>>>>>> On 6/14/2023 5:42 PM, Richard Damon wrote:
>>>>>>>>>> On 6/14/23 10:41 AM, olcott wrote:
>>>>>>>>>>> On 6/14/2023 6:35 AM, Richard Damon wrote:
>>>>>>>>>>>> On 6/13/23 11:28 PM, olcott wrote:
>>>>>>>>>>>>> On 6/13/2023 10:18 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/13/23 11:12 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/13/2023 9:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 6/13/23 10:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 6/13/2023 8:02 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 6/13/23 8:06 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 6/13/2023 5:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 6/13/23 6:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 6/13/2023 5:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 6/13/23 11:17 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> The purpose of solving the halting problem is to
>>>>>>>>>>>>>>>>>>>>>>> determine non-halting
>>>>>>>>>>>>>>>>>>>>>>> bugs and non-halting malevolent software. My
>>>>>>>>>>>>>>>>>>>>>>> system achieves that
>>>>>>>>>>>>>>>>>>>>>>> purpose for the halting problem's otherwise
>>>>>>>>>>>>>>>>>>>>>>> impossible input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is only when the halting problem is construed
>>>>>>>>>>>>>>>>>>>>>>> as providing a correct
>>>>>>>>>>>>>>>>>>>>>>> yes/no answer to a self-contradictory question
>>>>>>>>>>>>>>>>>>>>>>> that the halting problem
>>>>>>>>>>>>>>>>>>>>>>> cannot be solved.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> // The following is written in C
>>>>>>>>>>>>>>>>>>>>>>> //
>>>>>>>>>>>>>>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>>>>>>>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to
>>>>>>>>>>>>>>>>>>>>>>> simulate its input
>>>>>>>>>>>>>>>>>>>>>>> 03
>>>>>>>>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>>>>>>>>> 14   D(D);
>>>>>>>>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Execution Trace
>>>>>>>>>>>>>>>>>>>>>>> Line 14: main() invokes D(D)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> keeps repeating (unless aborted)
>>>>>>>>>>>>>>>>>>>>>>> Line 06: simulated D(D) invokes simulated H(D,D)
>>>>>>>>>>>>>>>>>>>>>>> that simulates D(D)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Simulation invariant:
>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach
>>>>>>>>>>>>>>>>>>>>>>> its own line 09.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When termination analyzer H is intended to
>>>>>>>>>>>>>>>>>>>>>>> prevent denial of service
>>>>>>>>>>>>>>>>>>>>>>> attacks is presented with an input D that has
>>>>>>>>>>>>>>>>>>>>>>> been defined to have a
>>>>>>>>>>>>>>>>>>>>>>> pathological relationship to this termination
>>>>>>>>>>>>>>>>>>>>>>> analyzer, it correctly
>>>>>>>>>>>>>>>>>>>>>>> aborts the simulation of this input that would
>>>>>>>>>>>>>>>>>>>>>>> have otherwise caused H
>>>>>>>>>>>>>>>>>>>>>>> to never terminate until system resources have
>>>>>>>>>>>>>>>>>>>>>>> been exhausted, crashing
>>>>>>>>>>>>>>>>>>>>>>> the system.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *The halting problem is an issue with denial of
>>>>>>>>>>>>>>>>>>>>>>> service attacks*
>>>>>>>>>>>>>>>>>>>>>>> https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The whole system is right here:
>>>>>>>>>>>>>>>>>>>>>>> https://github.com/plolcott/x86utm
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It compiles with the 2017 version of the
>>>>>>>>>>>>>>>>>>>>>>> Community Edition
>>>>>>>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Except that preventing "Denial of Service Attacks"
>>>>>>>>>>>>>>>>>>>>>> is part of the requirement, just as giving the
>>>>>>>>>>>>>>>>>>>>>> right answer. It needs to do BOTH, and the right
>>>>>>>>>>>>>>>>>>>>>> answer isn't based on its simulation, but the
>>>>>>>>>>>>>>>>>>>>>> actual behavior of the machine. Thus, trying to
>>>>>>>>>>>>>>>>>>>>>> excuse the wrong answer as being due to a
>>>>>>>>>>>>>>>>>>>>>> prevention of a "Denial of Service" is just an
>>>>>>>>>>>>>>>>>>>>>> admissioon that the problem actually is IMPOSSIBLE.
>>>>>>>>>>>>>>>>>>>>> When denial of service attacks define a
>>>>>>>>>>>>>>>>>>>>> pathological input that would
>>>>>>>>>>>>>>>>>>>>> otherwise cause the denial of service attack
>>>>>>>>>>>>>>>>>>>>> detector to eat up system
>>>>>>>>>>>>>>>>>>>>> resources and crash the system H detects this
>>>>>>>>>>>>>>>>>>>>> attempt and thwarts it.
>>>>>>>>>>>>>>>>>>>>> *This conclusively proves that H is correct*
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *How pathological inputs are currently handled*
>>>>>>>>>>>>>>>>>>>>>   If a set of instructions ( in the smart contract)
>>>>>>>>>>>>>>>>>>>>> is executed on the
>>>>>>>>>>>>>>>>>>>>>   Ethereum Virtual Machine, it cannot predict how
>>>>>>>>>>>>>>>>>>>>> long these will run
>>>>>>>>>>>>>>>>>>>>>   for, at the beginning. If a set of instructions
>>>>>>>>>>>>>>>>>>>>> run forever, they can
>>>>>>>>>>>>>>>>>>>>>   freeze this blockchain and use up all the
>>>>>>>>>>>>>>>>>>>>> resources. This is similar to
>>>>>>>>>>>>>>>>>>>>>   a DoS (Denial of Service) attack. Each
>>>>>>>>>>>>>>>>>>>>> computation on the Ethereum
>>>>>>>>>>>>>>>>>>>>>   Virtual Machine requires some predetermined
>>>>>>>>>>>>>>>>>>>>> amount of gas (which one
>>>>>>>>>>>>>>>>>>>>>   has to buy with real money).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> (https://medium.com/coinmonks/ethereum-what-is-gas-and-why-do-we-need-it-88bcd7fc191d)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope. The decider is responsible to handle possible
>>>>>>>>>>>>>>>>>>>> "Denial of Service Attacks", and the presence of
>>>>>>>>>>>>>>>>>>>> them just points out the FUNDAMENTAL problem with
>>>>>>>>>>>>>>>>>>>> your solution method. It has long been know that
>>>>>>>>>>>>>>>>>>>> just relying on "Simulation" has significant issues
>>>>>>>>>>>>>>>>>>>> for halt deciding, but since you have chosen to not
>>>>>>>>>>>>>>>>>>>> look at history, you are just making the same
>>>>>>>>>>>>>>>>>>>> mistakes made long ago.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The CORRECT answer is ALWAYS the behavior of the
>>>>>>>>>>>>>>>>>>>> Actual Machine, which in this case Halts.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Therefore, H(D,D) saying that D(D) doesn't halt is
>>>>>>>>>>>>>>>>>>>> just making H wrong.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Claiming the wrong answer is right is just a LIE.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When simulating termination analyzer H is presented
>>>>>>>>>>>>>>>>>>> with an input the
>>>>>>>>>>>>>>>>>>> right answer is always: Must the simulation of the
>>>>>>>>>>>>>>>>>>> input be aborted to
>>>>>>>>>>>>>>>>>>> prevent the infinite execution of H? Yes is the
>>>>>>>>>>>>>>>>>>> correct answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So, I guess you are admitting that a simulationg
>>>>>>>>>>>>>>>>>> termination analyzer isn't a "Halting Decider" per the
>>>>>>>>>>>>>>>>>> Computabilty Theory, since for those, the correct
>>>>>>>>>>>>>>>>>> answer is always based on the actual behavior of the
>>>>>>>>>>>>>>>>>> machine/input described by the input to the decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You KNOW that fact, as you have quoted that defintion,
>>>>>>>>>>>>>>>>>> though admittedly, while you blaim others for just
>>>>>>>>>>>>>>>>>> quoting "learned by rote" statements, the statements
>>>>>>>>>>>>>>>>>> you quote are probably just quoted by rote without
>>>>>>>>>>>>>>>>>> ever actually learning what they mean.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But, with your admission that your machine uses the
>>>>>>>>>>>>>>>>>> WRONG criteria, you have just proven that you have
>>>>>>>>>>>>>>>>>> been lying for the past decade that you have actually
>>>>>>>>>>>>>>>>>> been working on the ACTUAL Halting Problem of
>>>>>>>>>>>>>>>>>> Computation Theory as discussed by Turing, Linz, et all.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> All you have done is proved that you are the
>>>>>>>>>>>>>>>>>> Hypocritical Ignorant Pathological Lying Idiot that
>>>>>>>>>>>>>>>>>> you are. Perhaps even Insane, as you seem to think
>>>>>>>>>>>>>>>>>> that by just repeating your lies that eventually
>>>>>>>>>>>>>>>>>> someone will belive them.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The alternative answer (remaining stuck in recursive
>>>>>>>>>>>>>>>>>>> simulation until
>>>>>>>>>>>>>>>>>>> the system crashes) is so utterly moronic that I
>>>>>>>>>>>>>>>>>>> don't believe that you
>>>>>>>>>>>>>>>>>>> believe it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Except that isn't what H does, it aborts its
>>>>>>>>>>>>>>>>>> simulation and gives the WRONG answer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are the MORON to think that an incorrect answer
>>>>>>>>>>>>>>>>>> must be right because you don't know any other
>>>>>>>>>>>>>>>>>> possible answer. IT is YOU how doesn't actually
>>>>>>>>>>>>>>>>>> understand the Liar's Paradox.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> We could downgrade the answer to my answer from 15
>>>>>>>>>>>>>>>>>>> years ago, H aborts
>>>>>>>>>>>>>>>>>>> the simulation and return BAD_INPUT.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Even this downgrade is (to the best of my knowledge)
>>>>>>>>>>>>>>>>>>> better than anyone
>>>>>>>>>>>>>>>>>>> else has ever done because it provides the exact
>>>>>>>>>>>>>>>>>>> criterion measure for
>>>>>>>>>>>>>>>>>>> this return value that cannot be fooled by Rice's
>>>>>>>>>>>>>>>>>>> theorem.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And you show that you totally don't understand
>>>>>>>>>>>>>>>>>> anything about logic.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You just don't understand any of the basics of that
>>>>>>>>>>>>>>>>>> which you talk about.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Because H(D,D) would remain stuck in recursive
>>>>>>>>>>>>>>>>> simulation unless it
>>>>>>>>>>>>>>>>> aborts this simulation and in this case H is a
>>>>>>>>>>>>>>>>> termination analyzer used
>>>>>>>>>>>>>>>>> to detect Denial of Service attacks what do you think
>>>>>>>>>>>>>>>>> that H should do
>>>>>>>>>>>>>>>>> with input D?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Then it would fail to be a decider.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Once H is programmed to abort its simulation, it needs
>>>>>>>>>>>>>>>> to analyze calls to H as if that call will also abort
>>>>>>>>>>>>>>>> its simulation, since it will.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Okay then you are saying that H should return 1 and then
>>>>>>>>>>>>>>> H would be correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H SHOULD have returned 1, but if you change H to do that,
>>>>>>>>>>>>>> you now have a new D and for that one (the one built on an
>>>>>>>>>>>>>> H that returns 1 for H(D,D)) D(D) will be non-halting, so
>>>>>>>>>>>>>> that H should have returned 0.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> In other words (from H's point of view) the halt status of
>>>>>>>>>>>>> D is a self-
>>>>>>>>>>>>> contradictory question even though it is not
>>>>>>>>>>>>> self-contradictory
>>>>>>>>>>>>> within other contexts. A question is not complete unless
>>>>>>>>>>>>> the context is
>>>>>>>>>>>>> included.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It doesn't matter what it is "from H's point of view", what
>>>>>>>>>>>> matters is what it actually is, which is measured by what
>>>>>>>>>>>> happens when the actual machine is actually run.
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, the context matters, and every H creates a DIFFERENT
>>>>>>>>>>>> context, so every H needs to take ITSELF into consideration,
>>>>>>>>>>>> and not assume that D calls some other variation of H,
>>>>>>>>>>>> because it doesn't, not if this H is the one that you want
>>>>>>>>>>>> to claim is correct.
>>>>>>>>>>>>
>>>>>>>>>>>> Your problem is you are stuck in a world of make-believe.
>>>>>>>>>>>> You presume things that are not true, and show that in such
>>>>>>>>>>>> a fantasy world, your machine is correct. The problem is,
>>>>>>>>>>>> that isn't how Truth actually works. You need to start from
>>>>>>>>>>>> actual established facts when you reason about things.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> When computer science theory diverges from the reality of
>>>>>>>>>>> software
>>>>>>>>>>> engineering it is the reality that take precedence and the
>>>>>>>>>>> theory that
>>>>>>>>>>> is out of touch with reality.
>>>>>>>>>>
>>>>>>>>>> So, you are admitting that you aren't followong the actual
>>>>>>>>>> Theory,
>>>>>>>>>>
>>>>>>>>>> Thus you are admitting that you have been lying that you have
>>>>>>>>>> been, for DECADES.
>>>>>>>>>>
>>>>>>>>>> You just don't understand the nature of the problem, or many
>>>>>>>>>> of the things you talk about, because you don't understand the
>>>>>>>>>> nature of Truth or Logic.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> When both Boolean return values are the wrong answer then
>>>>>>>>>>> this proves
>>>>>>>>>>> that the question itself is incorrect.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope, because the question isn't What answer should H return
>>>>>>>>>> to be correct, but what is the behavior of the machine at the
>>>>>>>>>> input.
>>>>>>>>>
>>>>>>>>> When the input to H is defined to do the opposite of whatever H
>>>>>>>>> says it
>>>>>>>>> will do then the halt status question posed to H is
>>>>>>>>> self-contradictory
>>>>>>>>> even if it is not self-contradictory when posed to any other
>>>>>>>>> termination
>>>>>>>>> analyzer.
>>>>>>>>
>>>>>>>> Nope, because the program H must exist before the program D
>>>>>>>> does, so the pnly self-contradictory question is how to design H
>>>>>>>> to succeed. This is what makes a correct H impossible.
>>>>>>>>
>>>>>>>> I think part of your problem is you don't even understand what
>>>>>>>> an actual program/machine is. It isn't just some nebulous
>>>>>>>> definition of desired behavior, but needs to be actual detailed
>>>>>>>> step-by-step instructions of what is going to happen based on
>>>>>>>> the input.
>>>>>>>>
>>>>>>>> Your "Hypothetical" H that both correctly simulates its input,
>>>>>>>> but also stops and gives an answer just isn't possible to do in
>>>>>>>> an actual program. You have been given the challenge to show how
>>>>>>>> it does both, and have ducked that, persumably because you know
>>>>>>>> it is impossible.
>>>>>>>>
>>>>>>>> Once you define your H as an actual machine, then the answer to
>>>>>>>> the behavor of D is well defined, easily determined, and it will
>>>>>>>> be the opposite of whatever H gives as an answer.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Furthermore it is an easily verified fact that H does correctly
>>>>>>>>> thwart a
>>>>>>>>> denial of service (DOS) attack by the halting problem's
>>>>>>>>> pathological
>>>>>>>>> input. This proves that the halting problem issue has been
>>>>>>>>> overcome in
>>>>>>>>> at least this one case.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> It may "thwart" a denial of service attack (cause by bad code in
>>>>>>>> H), but it doesn't give the correct answer. It convicted an
>>>>>>>> innocent party.
>>>>>
>>>>>>> It is an easily verified fact that H does correctly abort its
>>>>>>> simulation
>>>>>>> of D (that specifically targets H) because the alternative is that D
>>>>>>> causes the system to exhaust its resources and crash.
>>>>>>
>>>>>> You have the problem wrong, since H DOES abort is simulation, D
>>>>>> Halts so H, after aborting its simulation needed to return 1.
>>>>>>
>>>>>> You just don't understand how programs work.
>>>>>>
>>>>> You must be a bot you are stuck on old arguments that do not apply to
>>>>> the current issue.
>>>>>
>>>>> When H is a termination analyzer that prevents denial or service
>>>>> attacks
>>>>> H correctly detects that D specifically targets H in its denial of
>>>>> service attack on H. Then H correctly thwarts this DOS attack.
>>>>>
>>>>> Now that I have every detail boiled down to 100% entirely verified
>>>>> facts
>>>>> no rebuttal can possibly work. Anyone attempting such a rebuttal will
>>>>> look increasingly more foolish.
>>>>>
>>>>
>>>>
>>>> The first fact you fail to verify is that you are even working on
>>>> the right problem, which becomes the source of many of your lies,
>>>> and that seems to be because you have made yourself intentionally
>>>> ignorant of the field you are claiming to be an expert in, but that
>>>> just makes you the Fool.
>>>>
>>>> H might be able to determine that if H doesn't abort its simulation,
>>>> that its simulation will go on forever, but that isn't the question
>>>> of the halting problem, or even "Termination Analysis". Thus, you
>>>> are just working on Strawmen.
>>>
>>> *Termination Analyzer H prevents Denial of Service attacks*
>>
>> But doesn't get the right answer to the Halting Problem.
>>
>>> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_prevents_Denial_of_Service_attacks
>>>
>>> It is an easily verified fact that termination analyzer H does correctly
>>> thwart what would otherwise be a successful denial of service attack
>>> when presented with input D having the halting problem's pathological
>>> relationship to H.
>>>
>>> This proves that the halting problem's pathological input is not an
>>> issue for actual software systems.
>>>
>>
>> It might thwart a DOS attack on itself, but the program that it flags,
>> if run as an independent program, will HALT, and thus not present a
>> DOS attack on the system, so its answer is a FALSE POSITIVE.
>>
>
> You keep getting confused by conflating two different levels of
> recursive invocation. When a program input has been specifically
> defined to confuse a termination analyzer it is correct to determine
> that the program behavior is malevolent.
>
> Prior to my work nothing could be done about inputs having a
> pathological relationship to their termination analyzer. Prior to my
> work Rice's theorem prevented this pathological relationship from being
> recognized.
>
> When H(D,D) returns 0 this means that the input does not halt or the
> input has pathological behavior that would otherwise cause the
> termination analyzer to not halt. This means that the program has either
> a non-termination bug or the program has malevolent behavior.
>
NO, YOU have the levels reversed because you think "Fanstasy" is the
Reality,


Click here to read the complete article
1
server_pubkey.txt

rocksolid light 0.9.81
clearnet tor