Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #24585 > unrolled thread
| Started by | Graham Cooper <grahamcooper7@gmail.com> |
|---|---|
| First post | 2020-10-28 17:36 -0700 |
| Last post | 2020-10-29 13:09 -0700 |
| Articles | 19 on this page of 39 — 6 participants |
Back to article view | Back to comp.theory
SOLUTION TO THE HALTING PROBLEM! Graham Cooper <grahamcooper7@gmail.com> - 2020-10-28 17:36 -0700
Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-28 20:24 -0500
Re: SOLUTION TO THE HALTING PROBLEM! Graham Cooper <grahamcooper7@gmail.com> - 2020-10-28 19:44 -0700
Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-28 22:17 -0500
Re: SOLUTION TO THE HALTING PROBLEM! Graham Cooper <grahamcooper7@gmail.com> - 2020-10-28 23:13 -0700
Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-29 07:14 -0500
Re: SOLUTION TO THE HALTING PROBLEM! Graham Cooper <grahamcooper7@gmail.com> - 2020-10-29 05:49 -0700
Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-29 07:57 -0500
Re: SOLUTION TO THE HALTING PROBLEM! Richard Damon <Richard@Damon-Family.org> - 2020-10-29 08:51 -0400
Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-29 08:04 -0500
Re: SOLUTION TO THE HALTING PROBLEM! Richard Damon <Richard@Damon-Family.org> - 2020-10-29 09:22 -0400
Re: SOLUTION TO THE HALTING PROBLEM! Graham Cooper <grahamcooper7@gmail.com> - 2020-10-29 10:22 -0700
Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-29 15:39 -0500
Re: SOLUTION TO THE HALTING PROBLEM! Richard Damon <Richard@Damon-Family.org> - 2020-10-30 00:13 -0400
Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-29 23:51 -0500
Re: SOLUTION TO THE HALTING PROBLEM! Richard Damon <Richard@Damon-Family.org> - 2020-10-30 09:12 -0400
Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-30 11:05 -0500
Re: SOLUTION TO THE HALTING PROBLEM! Richard Damon <Richard@Damon-Family.org> - 2020-10-30 16:27 -0400
Re: SOLUTION TO THE HALTING PROBLEM! Graham Cooper <grahamcooper7@gmail.com> - 2020-10-30 14:44 -0700
Re: SOLUTION TO THE HALTING PROBLEM! Richard Damon <Richard@Damon-Family.org> - 2020-10-30 18:50 -0400
Re: SOLUTION TO THE HALTING PROBLEM! Graham Cooper <grahamcooper7@gmail.com> - 2020-10-30 16:04 -0700
Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-30 16:58 -0500
Re: SOLUTION TO THE HALTING PROBLEM! Richard Damon <Richard@Damon-Family.org> - 2020-10-30 18:43 -0400
Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-30 19:00 -0500
Re: SOLUTION TO THE HALTING PROBLEM! Graham Cooper <grahamcooper7@gmail.com> - 2020-10-30 17:07 -0700
Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-30 19:14 -0500
Re: SOLUTION TO THE HALTING PROBLEM! Graham Cooper <grahamcooper7@gmail.com> - 2020-10-30 17:29 -0700
Re: SOLUTION TO THE HALTING PROBLEM! Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-10-31 01:26 +0000
Re: SOLUTION TO THE HALTING PROBLEM! Richard Damon <Richard@Damon-Family.org> - 2020-10-30 22:46 -0400
Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-30 22:14 -0500
Re: SOLUTION TO THE HALTING PROBLEM! Graham Cooper <grahamcooper7@gmail.com> - 2020-10-30 20:25 -0700
Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-30 22:41 -0500
Re: SOLUTION TO THE HALTING PROBLEM! Graham Cooper <grahamcooper7@gmail.com> - 2020-10-30 23:30 -0700
Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-29 23:56 -0500
Stop crossposting you imbecil spammer (Was: SOLUTION TO THE HALTING PROBLEM!) Mostowski Collapse <janburse@fastmail.fm> - 2020-10-29 14:01 +0100
Re: Stop crossposting you imbecil spammer (Re: SOLUTION TO THE HALTING PROBLEM! Mostowski Collapse <janburse@fastmail.fm> - 2020-10-29 19:39 +0100
Re: Stop crossposting you imbecil spammer (Re: SOLUTION TO THE HALTING PROBLEM! olcott <NoOne@NoWhere.com> - 2020-10-29 13:43 -0500
Re: SOLUTION TO THE HALTING PROBLEM! Mostowski Collapse <janburse@fastmail.fm> - 2020-10-29 20:49 +0100
Re: SOLUTION TO THE HALTING PROBLEM! Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2020-10-29 13:09 -0700
Page 2 of 2 — ← Prev page 1 [2]
| From | Graham Cooper <grahamcooper7@gmail.com> |
|---|---|
| Date | 2020-10-30 16:04 -0700 |
| Message-ID | <80dfcfb3-3ab5-42cc-9ec5-d84b16ff7679n@googlegroups.com> |
| In reply to | #24693 |
On Saturday, October 31, 2020 at 8:51:01 AM UTC+10, Richard Damon wrote: > On 10/30/20 5:44 PM, Graham Cooper wrote: > > On Saturday, October 31, 2020 at 6:27:42 AM UTC+10, Richard Damon wrote: > >> > >> As others have said, there are many other proofs that the creation of a > >> universal halt detector is impossible, based on many different factors. > >> I am pretty sure that these other proofs would also show that even if we > >> relax the requirements on H, that it doesn't need to be able to work on > >> other Turing Machines that include H as a part of their machine, that it > > > > but is PARTIALLY WORKS! the counter example also HANGS which is detectable > > > > > > > > > >> is still impossible to create such an H. This means that negating Linz > >> isn't a game changer in the field of Mathematics. > >> > > > > It probably POSSIBLE to create H but it has an exponential search so it would only work on small models. > > > > Negating LINZ *IS* a game changer. > > > > CHATIANS OMEGA wouldnt exist, so neither would UNCOMPUTABLE REALS, UNCOMPUTABLE FUNCTIONS > > CANTORS BIGGER THAN INFINITY! > > > > We merely REDEFINE COMPUTE > > > > COMPUTE( function , input ) = output > > OR > > COMPUTE ( function , input ) == HANGS > > > > as a COMPUTABLE RESULT! > > > > This is sufficient to debunk CHAITANS' OMEGA (a REAL NUMBER composed of halt values) > > > > as you could increasingly compute C.A. > > > > > > If you have a ROUGH IDEA that halt should take 2-3 seconds to run on a similar program/input size to other quick examples > > and it takes HALF AN HOUR atleast for halt to run, then you "KNOW" the program(input) HANGS too! > > > Note, I am only saying that THIS particular proof of non-existance of a > halt detector doesn't work. There are others, so we still don't have > halt detectors to let us compute the uncomputable. Actually MICROSOFT wrote CODE CHECKERS that tested for a HANG on 3rd party drivers. Remember around 2005 the BLUE SCREEN, most of the hangs were from 3rd party drivers and MICROSOFT wrote "halt software" that eliminated them. UNCOMPUTABLE doesnt exist! it all stems from TURINGS ERROR in the HALT PROOF! EG BUSY BEAVER FUNCTION is computable if HALT is computable!
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-30 16:58 -0500 |
| Message-ID | <VP-dndHkLJb3EQHCnZ2dnUU7-SHNnZ2d@giganews.com> |
| In reply to | #24687 |
On 10/30/2020 3:27 PM, Richard Damon wrote:
> On 10/30/20 12:05 PM, olcott wrote:
>> On 10/30/2020 8:12 AM, Richard Damon wrote:
>>> On 10/30/20 12:51 AM, olcott wrote:
>>>> On 10/29/2020 11:13 PM, Richard Damon wrote:
>>>>> On 10/29/20 4:39 PM, olcott wrote:
>>>>>> On 10/29/2020 7:51 AM, Richard Damon wrote:
>>>>>>> On 10/29/20 8:14 AM, olcott wrote:
>>>>>>>> I spent a man year developing the x86utm operating system so that I
>>>>>>>> could show every single detailed step of exactly how and why the
>>>>>>>> Linz
>>>>>>>> halt decider halts in its ((qn)) state.
>>>>>>>>
>>>>>>>> x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
>>>>>>>>
>>>>>>>> The reason that a halt decider can actually decide that the Linz
>>>>>>>> H_Hat
>>>>>>>> does not halt is based on the fact that it gets stuck in infinite
>>>>>>>> recursion before it ever reaches its undecidable states. We can tell
>>>>>>>> that it gets stuck in infinite recursion because it invokes the halt
>>>>>>>> decider a second time from the same machine address without any
>>>>>>>> conditional instructions in its execution trace in-between that
>>>>>>>> would
>>>>>>>> terminate this otherwise infinite recursion. I derived this solution
>>>>>>>> 2018-12-13 @ 7:00 PM.
>>>>>>>
>>>>>>> The amount of time you wasted on this isn't the issue. It is that
>>>>>>> fact
>>>>>>> that you still get the answer wrong. HOW the halt decider works isn't
>>>>>>> really interesting, it is the answer it gives.
>>>>>>>
>>>>>>> Let us look at a slight variation of Linz, that has a clear answer,
>>>>>>>
>>>>>>> H_Hat2(N) does the same replication has H_Hat, calls H(N, N) like
>>>>>>> H_Hat,
>>>>>>> but then halts whether H says halts or not. Clearly H_Hat2 halts, it
>>>>>>> has
>>>>>>> no choice other than that. Simple inspection makes it clear that it
>>>>>>> MUST
>>>>>>> halt (as H by its definition must have finite execution), and
>>>>>>> there is
>>>>>>> no loops outside of H.
>>>>>>>
>>>>>>
>>>>>> void H_Hat2(u32 P)
>>>>>> {
>>>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
>>>>>> HALT
>>>>>> else
>>>>>> HALT
>>>>>> }
>>>>>>
>>>>>> OK great you are putting in an effort for a sincere dialogue for the
>>>>>> purpose of achieving mutual understanding.
>>>>>>
>>>>>> As with all of the conventional self-referential halting problem
>>>>>> proofs
>>>>>> the infinite recursion is at the first step so that none of the
>>>>>> subsequent steps are ever reached. The execution of H(H_Hat2, H_Hat2)
>>>>>> must be aborted.
>>>>>>
>>>>>
>>>>> But, You should be able to admit, that by a simple inspection of the
>>>>> code, including the specifiation on H, that H_Hat2 must clearly
>>>>> halt, so
>>>>> a proper Halt Decider doesn't need to any simulation of the program, so
>>>>> never hits the recursive trap.
>>>>
>>>>
>>>> Definition 12.1 and Figure 12.1 on pages 317-318
>>>> H.q0 wMw ⊢* H.qy
>>>> H.q0 wMw ⊢* H.qn
>>>> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>>>>
>>>> Not at all. Not in the least little bit. To say that H_Hat2() halts
>>>> presumes the contents of the unspecified wildcard state transitions: ⊢*
>>>
>>> It presumes the guaranteed semantics of H, that it is a decider and thus
>>> will give some answer after a finite execution. Because H_Hat2 doesn't
>>> care which output H gives, it can be safe in presuming that this is
>>> finite, as can anyone/thing looking at H_Hat2 to see if it will halt.
>>>
>>
>> The only reason why H() always halts is that it always aborts any
>> non-halting behavior of its inputs. H() even has to abort itself when it
>> has itself as input.
>>
>> void H(u32 P, u32 I)
>> {
>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
>> MOV_EAX_1 // Execution of P(I) has been aborted
>> else
>> MOV_EAX_0 // P(I) has halted
>> HALT
>> }
>>
>> int main()
>> {
>> u32 P = (u32)H;
>> H(P, P);
>> HALT
>> }
>>
>>
>>> For example, in mathematics, if we have 0*f(x), where f(x) is known to
>>> be finite for all x in the domain of the problem, we don't need to
>>> evaluate f(x) for all x to determine the value of the expression, we
>>> know it to be 0. H_Hat2 is sort of like that, we know H must be finite,
>>> so H_Hat2 will halt.
>>>
>>>>
>>>> The non-halting decider that I defined accepts any and all non-halting
>>>> inputs and rejects any and all halting inputs. To do this it stipulates
>>>> the definition of the otherwise unspecified wildcard states.
>>>>
>>>> Within this definition
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
>>>> returns true.
>>>>
>>>> So when we get 100% totally specific and do not leave anything to
>>>> intuition not only is H_Hat and H_Hat2 proved to be decidable all the
>>>> steps of making this decision will soon be explicitly shown.
>>>
>>> Except that you have declared that it will get the wrong answer for
>>> H_Hat2.
>>
>> I proved that you are having a hard time of understanding why the answer
>> that it provides is correct. Until you understand how and why both H_Hat
>> and H_Hat2 are decided correctly everything else remains moot.
>>
>>> The big point isn't 'decidable', it is 'rightly decidable', your
>>> apparent structure is claimed to always give an answer (but I am not so
>>> sure if it will work on infinite non-repeating machines), but giving
>>> wrong answers because it hit its own limitations.
>>>>
>>>> It is the exact same 2018-12-13 @ 7:00 PM solution of detecting that the
>>>> halt decider is invoked two times from the same machine address without
>>>> any conditional instructions in the execution trace of H_Hat or H_Hat2
>>>> that would terminate this otherwise infinite recursion.
>>>>
>>>>> It is the defect in H, which makes the claim that it is a universal
>>>>> halt
>>>>> decider, that causes the need for aborting, not a problem with H_Hat2.
>>>>
>>>> The halting decision is exactly as I described above for both H_Hat and
>>>> H_Hat2. All of the rest of what you say is moot until you first
>>>> understand the above.
>>>>
>>>>
>>> Maybe you can give the 'right' answer but to the 'wrong' question, but
>>> you are not giving the right answer to the question that the real halt
>>> decider is being asked. You have added a condition, somewhat disguised,
>>> that you use as an out to attempt to give a wrong answer for. While
>>> maybe H_Hat itself isn't an interesting problem, but it is a mininimal
>>> example that shows that the domain space of Turning Machines is big and
>>> complicated enough that we hit the problems of correct decidablity.
>>>
>>
>>
>
> Please read and tell me where I am off.
>
> So, we start with the question does a Machine M with input N halt or
> not. This IS the original question we want the answer to, RIGHT?
Yes.
> We presume that we can make a Turing Machine H, that is supposedly able
> to answer the question. The stated requirements are that H will, being
> given a representation for machine M with input N, will in a finite
> amount of time, end up in one of two states, dependent on the answer to
> the above question. RIGHT?
Yes.
> We have a machine, H_Hat2, which by simple inspection, WILL halt,
No. If you want to make a machine that definitely halts you can do
something like this:
u32 Add(u32 X, u32 Y)
{
u32 Z = X + Y;
return Z;
}
> the
> only way it can't halt is if H doesn't met its requirements. RIGHT?
The only way it can halt is that:
bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
aborted the first instance of H_Hat2.
> From this, the answer to the original question, is clearly HALTS. RIGHT?
>
void H_Hat2(u32 P)
{
if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
MOV_EAX_1 // Execution of P(P) has been aborted
else
{
MOV_EAX_0 // P(P) has halted
HERE: goto HERE;
}
HALT
}
When P = H_Hat2, then this line specifies:
if (Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2))
which is is infinite recursion unless the above function aborts its
execution trace of H_Hat2.
H_Hat2 only halts because it is forced to halt.
> You are arguing, that because of how you implemented H, it is ok for it
> to give a different answer, that it had to abort the machine because H
> couldn't see pass the recursion. RIGHT?
No. Not at all. Not in the least. There is no seeing past the recursion.
Either this function aborts the recursion:
bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
or the recursion never ceases.
> Thus, by you, the answer to a question about M(N) is at least as much a
> function of the machine H that is answering it. RIGHT?
In every conventional halting problem proof counter-example the halting
decider's decision is the basis for the input program's behavior. This
is the key thing that has previously been construed as making the
halting problem undecidable.
Once we break this cause-and-effect chain and only make the halting
decision upon the termination of the input the halting problem can no
longer be shown to be undecidable.
> This last part seems strange, that the question about a Turing Machine
> isn't just about the machine, but about the tool used to measure that
> machine. RIGHT?
Once the input program's behavior is not allowed to be effected by the halt
decider's decision the halting problem becomes decidable.
> The purpose of the Halting Machine, isn't just to get 'an answer' but to
> get information about the true behavior of a machine. Your modification
> destroys that information.
No, not at all, not in the least little bit.
The rest of what you say strays from the key prerequistite point.
Until you fully understand how and why this is decided correctly:
bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
You have gaps in your reasoning that need to be filled.
> As others have said, there are many other proofs that the creation of a
> universal halt detector is impossible, based on many different factors.
> I am pretty sure that these other proofs would also show that even if we
> relax the requirements on H, that it doesn't need to be able to work on
> other Turing Machines that include H as a part of their machine, that it
> is still impossible to create such an H. This means that negating Linz
> isn't a game changer in the field of Mathematics.
>
> On the other hand, pulling in from a number of things that you have said
> here in various threads, I get the feeling you have a hard time dealing
> with some of the resutls of Logic System that grow to be able to
> 'infinities', and some of the results that come out of that, like the
> limits of computations and the limits of what can be proven by various
> means. This isn't really anything to be ashamed of, infinity IS a
> strange concept and it turns out that when you get into the mathematics
> of infinity, some things that seem obvious when you are dealing with
> finites no longer hold.
>
>
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-10-30 18:43 -0400 |
| Message-ID | <BG0nH.97951$Ml5.89653@fx24.iad> |
| In reply to | #24689 |
On 10/30/20 5:58 PM, olcott wrote:
> On 10/30/2020 3:27 PM, Richard Damon wrote:
>> Please read and tell me where I am off.
>>
>> So, we start with the question does a Machine M with input N halt or
>> not. This IS the original question we want the answer to, RIGHT?
>
> Yes.
>
>> We presume that we can make a Turing Machine H, that is supposedly able
>> to answer the question. The stated requirements are that H will, being
>> given a representation for machine M with input N, will in a finite
>> amount of time, end up in one of two states, dependent on the answer to
>> the above question. RIGHT?
>
> Yes.
>
>> We have a machine, H_Hat2, which by simple inspection, WILL halt,
>
> No. If you want to make a machine that definitely halts you can do
> something like this:
We KNOW H must halt, because it is defined to do so. Where is there
possible non-halting behavior, GIVEN that H is defined to work in finite
time. If H has a problem in working in finite time, it says that H
doesn't meet its requirements.
>
> u32 Add(u32 X, u32 Y)
> {
> u32 Z = X + Y;
> return Z;
> }
and the function
u32 testFun(u32 X, u32 Y)
{
doSomethingFinite();
return 0;
}
will also be sure to halt, if we know that doSomethingFinite() is going
to return in finite time.
>
>> the
>> only way it can't halt is if H doesn't met its requirements. RIGHT?
>
> The only way it can halt is that:
> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
> aborted the first instance of H_Hat2.
THERE IS NO REQUIREMENT THAT H EVEN HAVE such a function.
One conceivable method is H detects that the machine is recursively
calling H, and then sees what happens in the two cases. If either of
them agrees with that trial, then that is the answer. One then needs to
decide how to handle the 'trick' case of Linz's H_Hat, but that is a
different issue. Note, you should only be able to try this out if it
really is the case that the machine is being contrary.
You still have the problem of detecting non-Halting behavior in the
unbounded non-halting machine, but this program (nor H_Hat) exihibits
that problem.
>
>> From this, the answer to the original question, is clearly HALTS. RIGHT?
>>
>
> void H_Hat2(u32 P)
> {
> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
> MOV_EAX_1 // Execution of P(P) has been aborted
> else
> {
> MOV_EAX_0 // P(P) has halted
> HERE: goto HERE;
> }
> HALT
> }
>
> When P = H_Hat2, then this line specifies:
> if (Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2))
> which is is infinite recursion unless the above function aborts its
> execution trace of H_Hat2.
>
> H_Hat2 only halts because it is forced to halt.
>
>> You are arguing, that because of how you implemented H, it is ok for it
>> to give a different answer, that it had to abort the machine because H
>> couldn't see pass the recursion. RIGHT?
>
> No. Not at all. Not in the least. There is no seeing past the recursion.
YES THERE IS, see above.
>
> Either this function aborts the recursion:
> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
> or the recursion never ceases.
The mere idea that emulation is THE solution is wrong.
>
>> Thus, by you, the answer to a question about M(N) is at least as much a
>> function of the machine H that is answering it. RIGHT?
>
> In every conventional halting problem proof counter-example the halting
> decider's decision is the basis for the input program's behavior. This
> is the key thing that has previously been construed as making the
> halting problem undecidable.
>
> Once we break this cause-and-effect chain and only make the halting
> decision upon the termination of the input the halting problem can no
> longer be shown to be undecidable.
While I will admit that this is getting out of my area of expertise, I
do know that there are a number of different proofs that show that there
can not be a universal halting decider. In part becaue the existence of
a truely universal halt decider would make some things that have been
shown to be uncomputable would then have a method to compute them in
finite time.
>
>> This last part seems strange, that the question about a Turing Machine
>> isn't just about the machine, but about the tool used to measure that
>> machine. RIGHT?
>
> Once the input program's behavior is not allowed to be effected by the halt
> decider's decision the halting problem becomes decidable.
The data input was never in control of the halt decider. It is only a
flaw in the Halt decider if the input makes the halt decider misbehave.
The decider's job is to figure out what the input would do, but it is
always in control.
>
>> The purpose of the Halting Machine, isn't just to get 'an answer' but to
>> get information about the true behavior of a machine. Your modification
>> destroys that information.
>
> No, not at all, not in the least little bit.
> The rest of what you say strays from the key prerequistite point.
>
> Until you fully understand how and why this is decided correctly:
> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
> You have gaps in your reasoning that need to be filled.
So you DO think that how the halting decider works is more important
than the problem that it was put on??
Does that mean that there is more than one right answer to the question
does M(N) halt?
>
>> As others have said, there are many other proofs that the creation of a
>> universal halt detector is impossible, based on many different factors.
>> I am pretty sure that these other proofs would also show that even if we
>> relax the requirements on H, that it doesn't need to be able to work on
>> other Turing Machines that include H as a part of their machine, that it
>> is still impossible to create such an H. This means that negating Linz
>> isn't a game changer in the field of Mathematics.
>>
>> On the other hand, pulling in from a number of things that you have said
>> here in various threads, I get the feeling you have a hard time dealing
>> with some of the resutls of Logic System that grow to be able to
>> 'infinities', and some of the results that come out of that, like the
>> limits of computations and the limits of what can be proven by various
>> means. This isn't really anything to be ashamed of, infinity IS a
>> strange concept and it turns out that when you get into the mathematics
>> of infinity, some things that seem obvious when you are dealing with
>> finites no longer hold.
>>
>>
>
>
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-30 19:00 -0500 |
| Message-ID | <8bOdnWNsDbi_NAHCnZ2dnUU7-RHNnZ2d@giganews.com> |
| In reply to | #24692 |
On 10/30/2020 5:43 PM, Richard Damon wrote:
> On 10/30/20 5:58 PM, olcott wrote:
>> On 10/30/2020 3:27 PM, Richard Damon wrote:
>
>>> Please read and tell me where I am off.
>>>
>>> So, we start with the question does a Machine M with input N halt or
>>> not. This IS the original question we want the answer to, RIGHT?
>>
>> Yes.
>>
>>> We presume that we can make a Turing Machine H, that is supposedly able
>>> to answer the question. The stated requirements are that H will, being
>>> given a representation for machine M with input N, will in a finite
>>> amount of time, end up in one of two states, dependent on the answer to
>>> the above question. RIGHT?
>>
>> Yes.
>>
>>> We have a machine, H_Hat2, which by simple inspection, WILL halt,
>>
>> No. If you want to make a machine that definitely halts you can do
>> something like this:
>
> We KNOW H must halt, because it is defined to do so. Where is there
> possible non-halting behavior, GIVEN that H is defined to work in finite
> time. If H has a problem in working in finite time, it says that H
> doesn't meet its requirements.
>
>>
>> u32 Add(u32 X, u32 Y)
>> {
>> u32 Z = X + Y;
>> return Z;
>> }
>
> and the function
>
> u32 testFun(u32 X, u32 Y)
> {
> doSomethingFinite();
> return 0;
> }
>
> will also be sure to halt, if we know that doSomethingFinite() is going
> to return in finite time.
>
>>
>>> the
>>> only way it can't halt is if H doesn't met its requirements. RIGHT?
>>
>> The only way it can halt is that:
>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
>> aborted the first instance of H_Hat2.
>
>
> THERE IS NO REQUIREMENT THAT H EVEN HAVE such a function.
>
> One conceivable method is H detects that the machine is recursively
> calling H, and then sees what happens in the two cases. If either of
> them agrees with that trial, then that is the answer. One then needs to
> decide how to handle the 'trick' case of Linz's H_Hat, but that is a
> different issue. Note, you should only be able to try this out if it
> really is the case that the machine is being contrary.
>
> You still have the problem of detecting non-Halting behavior in the
> unbounded non-halting machine, but this program (nor H_Hat) exihibits
> that problem.
>
>>
>>> From this, the answer to the original question, is clearly HALTS. RIGHT?
>>>
>>
>> void H_Hat2(u32 P)
>> {
>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
>> MOV_EAX_1 // Execution of P(P) has been aborted
>> else
>> {
>> MOV_EAX_0 // P(P) has halted
>> HERE: goto HERE;
>> }
>> HALT
>> }
>>
>> When P = H_Hat2, then this line specifies:
>> if (Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2))
>> which is is infinite recursion unless the above function aborts its
>> execution trace of H_Hat2.
>>
>> H_Hat2 only halts because it is forced to halt.
>>
>>> You are arguing, that because of how you implemented H, it is ok for it
>>> to give a different answer, that it had to abort the machine because H
>>> couldn't see pass the recursion. RIGHT?
>>
>> No. Not at all. Not in the least. There is no seeing past the recursion.
>
> YES THERE IS, see above.
>
>>
>> Either this function aborts the recursion:
>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
>> or the recursion never ceases.
>
> The mere idea that emulation is THE solution is wrong.
>>
>>> Thus, by you, the answer to a question about M(N) is at least as much a
>>> function of the machine H that is answering it. RIGHT?
>>
>> In every conventional halting problem proof counter-example the halting
>> decider's decision is the basis for the input program's behavior. This
>> is the key thing that has previously been construed as making the
>> halting problem undecidable.
>>
>> Once we break this cause-and-effect chain and only make the halting
>> decision upon the termination of the input the halting problem can no
>> longer be shown to be undecidable.
>
> While I will admit that this is getting out of my area of expertise, I
> do know that there are a number of different proofs that show that there
> can not be a universal halting decider. In part becaue the existence of
> a truely universal halt decider would make some things that have been
> shown to be uncomputable would then have a method to compute them in
> finite time.
>
>>
>>> This last part seems strange, that the question about a Turing Machine
>>> isn't just about the machine, but about the tool used to measure that
>>> machine. RIGHT?
>>
>> Once the input program's behavior is not allowed to be effected by the halt
>> decider's decision the halting problem becomes decidable.
>
> The data input was never in control of the halt decider. It is only a
> flaw in the Halt decider if the input makes the halt decider misbehave.
>
> The decider's job is to figure out what the input would do, but it is
> always in control.
>>
>>> The purpose of the Halting Machine, isn't just to get 'an answer' but to
>>> get information about the true behavior of a machine. Your modification
>>> destroys that information.
>>
>> No, not at all, not in the least little bit.
>> The rest of what you say strays from the key prerequistite point.
>>
>> Until you fully understand how and why this is decided correctly:
>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
>> You have gaps in your reasoning that need to be filled.
>
> So you DO think that how the halting decider works is more important
> than the problem that it was put on??
>
> Does that mean that there is more than one right answer to the question
> does M(N) halt?
>
It looks like I have to backup to the gist of the idea.
The conventional idea of a halt decider can be fooled by simply making
the input program do the opposite of whatever the halt decider decides.
When the halt decider only makes its decision after the input program
has stopped running it cannot possibly do the opposite of whatever the
halt decider decides.
This simple little change makes the halting problem decidable.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Graham Cooper <grahamcooper7@gmail.com> |
|---|---|
| Date | 2020-10-30 17:07 -0700 |
| Message-ID | <5a2b4415-169f-4664-ab94-f3859027daeen@googlegroups.com> |
| In reply to | #24700 |
On Saturday, October 31, 2020 at 10:00:41 AM UTC+10, olcott wrote:
> On 10/30/2020 5:43 PM, Richard Damon wrote:
> > On 10/30/20 5:58 PM, olcott wrote:
> >> On 10/30/2020 3:27 PM, Richard Damon wrote:
> >
> >>> Please read and tell me where I am off.
> >>>
> >>> So, we start with the question does a Machine M with input N halt or
> >>> not. This IS the original question we want the answer to, RIGHT?
> >>
> >> Yes.
> >>
> >>> We presume that we can make a Turing Machine H, that is supposedly able
> >>> to answer the question. The stated requirements are that H will, being
> >>> given a representation for machine M with input N, will in a finite
> >>> amount of time, end up in one of two states, dependent on the answer to
> >>> the above question. RIGHT?
> >>
> >> Yes.
> >>
> >>> We have a machine, H_Hat2, which by simple inspection, WILL halt,
> >>
> >> No. If you want to make a machine that definitely halts you can do
> >> something like this:
> >
> > We KNOW H must halt, because it is defined to do so. Where is there
> > possible non-halting behavior, GIVEN that H is defined to work in finite
> > time. If H has a problem in working in finite time, it says that H
> > doesn't meet its requirements.
> >
> >>
> >> u32 Add(u32 X, u32 Y)
> >> {
> >> u32 Z = X + Y;
> >> return Z;
> >> }
> >
> > and the function
> >
> > u32 testFun(u32 X, u32 Y)
> > {
> > doSomethingFinite();
> > return 0;
> > }
> >
> > will also be sure to halt, if we know that doSomethingFinite() is going
> > to return in finite time.
> >
> >>
> >>> the
> >>> only way it can't halt is if H doesn't met its requirements. RIGHT?
> >>
> >> The only way it can halt is that:
> >> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
> >> aborted the first instance of H_Hat2.
> >
> >
> > THERE IS NO REQUIREMENT THAT H EVEN HAVE such a function.
> >
> > One conceivable method is H detects that the machine is recursively
> > calling H, and then sees what happens in the two cases. If either of
> > them agrees with that trial, then that is the answer. One then needs to
> > decide how to handle the 'trick' case of Linz's H_Hat, but that is a
> > different issue. Note, you should only be able to try this out if it
> > really is the case that the machine is being contrary.
> >
> > You still have the problem of detecting non-Halting behavior in the
> > unbounded non-halting machine, but this program (nor H_Hat) exihibits
> > that problem.
> >
> >>
> >>> From this, the answer to the original question, is clearly HALTS. RIGHT?
> >>>
> >>
> >> void H_Hat2(u32 P)
> >> {
> >> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
> >> MOV_EAX_1 // Execution of P(P) has been aborted
> >> else
> >> {
> >> MOV_EAX_0 // P(P) has halted
> >> HERE: goto HERE;
> >> }
> >> HALT
> >> }
> >>
> >> When P = H_Hat2, then this line specifies:
> >> if (Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2))
> >> which is is infinite recursion unless the above function aborts its
> >> execution trace of H_Hat2.
> >>
> >> H_Hat2 only halts because it is forced to halt.
> >>
> >>> You are arguing, that because of how you implemented H, it is ok for it
> >>> to give a different answer, that it had to abort the machine because H
> >>> couldn't see pass the recursion. RIGHT?
> >>
> >> No. Not at all. Not in the least. There is no seeing past the recursion.
> >
> > YES THERE IS, see above.
> >
> >>
> >> Either this function aborts the recursion:
> >> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
> >> or the recursion never ceases.
> >
> > The mere idea that emulation is THE solution is wrong.
> >>
> >>> Thus, by you, the answer to a question about M(N) is at least as much a
> >>> function of the machine H that is answering it. RIGHT?
> >>
> >> In every conventional halting problem proof counter-example the halting
> >> decider's decision is the basis for the input program's behavior. This
> >> is the key thing that has previously been construed as making the
> >> halting problem undecidable.
> >>
> >> Once we break this cause-and-effect chain and only make the halting
> >> decision upon the termination of the input the halting problem can no
> >> longer be shown to be undecidable.
> >
> > While I will admit that this is getting out of my area of expertise, I
> > do know that there are a number of different proofs that show that there
> > can not be a universal halting decider. In part becaue the existence of
> > a truely universal halt decider would make some things that have been
> > shown to be uncomputable would then have a method to compute them in
> > finite time.
> >
> >>
> >>> This last part seems strange, that the question about a Turing Machine
> >>> isn't just about the machine, but about the tool used to measure that
> >>> machine. RIGHT?
> >>
> >> Once the input program's behavior is not allowed to be effected by the halt
> >> decider's decision the halting problem becomes decidable.
> >
> > The data input was never in control of the halt decider. It is only a
> > flaw in the Halt decider if the input makes the halt decider misbehave.
> >
> > The decider's job is to figure out what the input would do, but it is
> > always in control.
> >>
> >>> The purpose of the Halting Machine, isn't just to get 'an answer' but to
> >>> get information about the true behavior of a machine. Your modification
> >>> destroys that information.
> >>
> >> No, not at all, not in the least little bit.
> >> The rest of what you say strays from the key prerequistite point.
> >>
> >> Until you fully understand how and why this is decided correctly:
> >> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
> >> You have gaps in your reasoning that need to be filled.
> >
> > So you DO think that how the halting decider works is more important
> > than the problem that it was put on??
> >
> > Does that mean that there is more than one right answer to the question
> > does M(N) halt?
> >
> It looks like I have to backup to the gist of the idea.
> The conventional idea of a halt decider can be fooled by simply making
> the input program do the opposite of whatever the halt decider decides.
>
> When the halt decider only makes its decision after the input program
> has stopped running it cannot possibly do the opposite of whatever the
> halt decider decides.
>
> This simple little change makes the halting problem decidable.
A/ HALT(prog,inp) doesnt RUN prog(inp)
B/ if HALT waits for prog(inp) to halt it wouldnt return an answer
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-30 19:14 -0500 |
| Message-ID | <tuadnZJJ9uzXMQHCnZ2dnUU7-InNnZ2d@giganews.com> |
| In reply to | #24702 |
On 10/30/2020 7:07 PM, Graham Cooper wrote:
> On Saturday, October 31, 2020 at 10:00:41 AM UTC+10, olcott wrote:
>> On 10/30/2020 5:43 PM, Richard Damon wrote:
>>> On 10/30/20 5:58 PM, olcott wrote:
>>>> On 10/30/2020 3:27 PM, Richard Damon wrote:
>>>
>>>>> Please read and tell me where I am off.
>>>>>
>>>>> So, we start with the question does a Machine M with input N halt or
>>>>> not. This IS the original question we want the answer to, RIGHT?
>>>>
>>>> Yes.
>>>>
>>>>> We presume that we can make a Turing Machine H, that is supposedly able
>>>>> to answer the question. The stated requirements are that H will, being
>>>>> given a representation for machine M with input N, will in a finite
>>>>> amount of time, end up in one of two states, dependent on the answer to
>>>>> the above question. RIGHT?
>>>>
>>>> Yes.
>>>>
>>>>> We have a machine, H_Hat2, which by simple inspection, WILL halt,
>>>>
>>>> No. If you want to make a machine that definitely halts you can do
>>>> something like this:
>>>
>>> We KNOW H must halt, because it is defined to do so. Where is there
>>> possible non-halting behavior, GIVEN that H is defined to work in finite
>>> time. If H has a problem in working in finite time, it says that H
>>> doesn't meet its requirements.
>>>
>>>>
>>>> u32 Add(u32 X, u32 Y)
>>>> {
>>>> u32 Z = X + Y;
>>>> return Z;
>>>> }
>>>
>>> and the function
>>>
>>> u32 testFun(u32 X, u32 Y)
>>> {
>>> doSomethingFinite();
>>> return 0;
>>> }
>>>
>>> will also be sure to halt, if we know that doSomethingFinite() is going
>>> to return in finite time.
>>>
>>>>
>>>>> the
>>>>> only way it can't halt is if H doesn't met its requirements. RIGHT?
>>>>
>>>> The only way it can halt is that:
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
>>>> aborted the first instance of H_Hat2.
>>>
>>>
>>> THERE IS NO REQUIREMENT THAT H EVEN HAVE such a function.
>>>
>>> One conceivable method is H detects that the machine is recursively
>>> calling H, and then sees what happens in the two cases. If either of
>>> them agrees with that trial, then that is the answer. One then needs to
>>> decide how to handle the 'trick' case of Linz's H_Hat, but that is a
>>> different issue. Note, you should only be able to try this out if it
>>> really is the case that the machine is being contrary.
>>>
>>> You still have the problem of detecting non-Halting behavior in the
>>> unbounded non-halting machine, but this program (nor H_Hat) exihibits
>>> that problem.
>>>
>>>>
>>>>> From this, the answer to the original question, is clearly HALTS. RIGHT?
>>>>>
>>>>
>>>> void H_Hat2(u32 P)
>>>> {
>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
>>>> MOV_EAX_1 // Execution of P(P) has been aborted
>>>> else
>>>> {
>>>> MOV_EAX_0 // P(P) has halted
>>>> HERE: goto HERE;
>>>> }
>>>> HALT
>>>> }
>>>>
>>>> When P = H_Hat2, then this line specifies:
>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2))
>>>> which is is infinite recursion unless the above function aborts its
>>>> execution trace of H_Hat2.
>>>>
>>>> H_Hat2 only halts because it is forced to halt.
>>>>
>>>>> You are arguing, that because of how you implemented H, it is ok for it
>>>>> to give a different answer, that it had to abort the machine because H
>>>>> couldn't see pass the recursion. RIGHT?
>>>>
>>>> No. Not at all. Not in the least. There is no seeing past the recursion.
>>>
>>> YES THERE IS, see above.
>>>
>>>>
>>>> Either this function aborts the recursion:
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
>>>> or the recursion never ceases.
>>>
>>> The mere idea that emulation is THE solution is wrong.
>>>>
>>>>> Thus, by you, the answer to a question about M(N) is at least as much a
>>>>> function of the machine H that is answering it. RIGHT?
>>>>
>>>> In every conventional halting problem proof counter-example the halting
>>>> decider's decision is the basis for the input program's behavior. This
>>>> is the key thing that has previously been construed as making the
>>>> halting problem undecidable.
>>>>
>>>> Once we break this cause-and-effect chain and only make the halting
>>>> decision upon the termination of the input the halting problem can no
>>>> longer be shown to be undecidable.
>>>
>>> While I will admit that this is getting out of my area of expertise, I
>>> do know that there are a number of different proofs that show that there
>>> can not be a universal halting decider. In part becaue the existence of
>>> a truely universal halt decider would make some things that have been
>>> shown to be uncomputable would then have a method to compute them in
>>> finite time.
>>>
>>>>
>>>>> This last part seems strange, that the question about a Turing Machine
>>>>> isn't just about the machine, but about the tool used to measure that
>>>>> machine. RIGHT?
>>>>
>>>> Once the input program's behavior is not allowed to be effected by the halt
>>>> decider's decision the halting problem becomes decidable.
>>>
>>> The data input was never in control of the halt decider. It is only a
>>> flaw in the Halt decider if the input makes the halt decider misbehave.
>>>
>>> The decider's job is to figure out what the input would do, but it is
>>> always in control.
>>>>
>>>>> The purpose of the Halting Machine, isn't just to get 'an answer' but to
>>>>> get information about the true behavior of a machine. Your modification
>>>>> destroys that information.
>>>>
>>>> No, not at all, not in the least little bit.
>>>> The rest of what you say strays from the key prerequistite point.
>>>>
>>>> Until you fully understand how and why this is decided correctly:
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
>>>> You have gaps in your reasoning that need to be filled.
>>>
>>> So you DO think that how the halting decider works is more important
>>> than the problem that it was put on??
>>>
>>> Does that mean that there is more than one right answer to the question
>>> does M(N) halt?
>>>
>> It looks like I have to backup to the gist of the idea.
>> The conventional idea of a halt decider can be fooled by simply making
>> the input program do the opposite of whatever the halt decider decides.
>>
>> When the halt decider only makes its decision after the input program
>> has stopped running it cannot possibly do the opposite of whatever the
>> halt decider decides.
>>
>> This simple little change makes the halting problem decidable.
>
> A/ HALT(prog,inp) doesnt RUN prog(inp)
If the goal it to create a halt decider that:
Accepts any and all non-halting inputs and Rejects any and all halting
inputs, then making a halt decider that runs its inputs until it detects
that they would not halt does the trick.
> B/ if HALT waits for prog(inp) to halt it wouldnt return an answer
It doesn't simply wait it watches a single step debug trace of its input
and as soon as it detects non-halting behavior it stops the debug trace
and reports non-halting.
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Graham Cooper <grahamcooper7@gmail.com> |
|---|---|
| Date | 2020-10-30 17:29 -0700 |
| Message-ID | <51be1412-47c9-45e0-ac88-84b356bde2efn@googlegroups.com> |
| In reply to | #24703 |
On Saturday, October 31, 2020 at 10:14:10 AM UTC+10, olcott wrote:
> On 10/30/2020 7:07 PM, Graham Cooper wrote:
> > On Saturday, October 31, 2020 at 10:00:41 AM UTC+10, olcott wrote:
> >> On 10/30/2020 5:43 PM, Richard Damon wrote:
> >>> On 10/30/20 5:58 PM, olcott wrote:
> >>>> On 10/30/2020 3:27 PM, Richard Damon wrote:
> >>>
> >>>>> Please read and tell me where I am off.
> >>>>>
> >>>>> So, we start with the question does a Machine M with input N halt or
> >>>>> not. This IS the original question we want the answer to, RIGHT?
> >>>>
> >>>> Yes.
> >>>>
> >>>>> We presume that we can make a Turing Machine H, that is supposedly able
> >>>>> to answer the question. The stated requirements are that H will, being
> >>>>> given a representation for machine M with input N, will in a finite
> >>>>> amount of time, end up in one of two states, dependent on the answer to
> >>>>> the above question. RIGHT?
> >>>>
> >>>> Yes.
> >>>>
> >>>>> We have a machine, H_Hat2, which by simple inspection, WILL halt,
> >>>>
> >>>> No. If you want to make a machine that definitely halts you can do
> >>>> something like this:
> >>>
> >>> We KNOW H must halt, because it is defined to do so. Where is there
> >>> possible non-halting behavior, GIVEN that H is defined to work in finite
> >>> time. If H has a problem in working in finite time, it says that H
> >>> doesn't meet its requirements.
> >>>
> >>>>
> >>>> u32 Add(u32 X, u32 Y)
> >>>> {
> >>>> u32 Z = X + Y;
> >>>> return Z;
> >>>> }
> >>>
> >>> and the function
> >>>
> >>> u32 testFun(u32 X, u32 Y)
> >>> {
> >>> doSomethingFinite();
> >>> return 0;
> >>> }
> >>>
> >>> will also be sure to halt, if we know that doSomethingFinite() is going
> >>> to return in finite time.
> >>>
> >>>>
> >>>>> the
> >>>>> only way it can't halt is if H doesn't met its requirements. RIGHT?
> >>>>
> >>>> The only way it can halt is that:
> >>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
> >>>> aborted the first instance of H_Hat2.
> >>>
> >>>
> >>> THERE IS NO REQUIREMENT THAT H EVEN HAVE such a function.
> >>>
> >>> One conceivable method is H detects that the machine is recursively
> >>> calling H, and then sees what happens in the two cases. If either of
> >>> them agrees with that trial, then that is the answer. One then needs to
> >>> decide how to handle the 'trick' case of Linz's H_Hat, but that is a
> >>> different issue. Note, you should only be able to try this out if it
> >>> really is the case that the machine is being contrary.
> >>>
> >>> You still have the problem of detecting non-Halting behavior in the
> >>> unbounded non-halting machine, but this program (nor H_Hat) exihibits
> >>> that problem.
> >>>
> >>>>
> >>>>> From this, the answer to the original question, is clearly HALTS. RIGHT?
> >>>>>
> >>>>
> >>>> void H_Hat2(u32 P)
> >>>> {
> >>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
> >>>> MOV_EAX_1 // Execution of P(P) has been aborted
> >>>> else
> >>>> {
> >>>> MOV_EAX_0 // P(P) has halted
> >>>> HERE: goto HERE;
> >>>> }
> >>>> HALT
> >>>> }
> >>>>
> >>>> When P = H_Hat2, then this line specifies:
> >>>> if (Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2))
> >>>> which is is infinite recursion unless the above function aborts its
> >>>> execution trace of H_Hat2.
> >>>>
> >>>> H_Hat2 only halts because it is forced to halt.
> >>>>
> >>>>> You are arguing, that because of how you implemented H, it is ok for it
> >>>>> to give a different answer, that it had to abort the machine because H
> >>>>> couldn't see pass the recursion. RIGHT?
> >>>>
> >>>> No. Not at all. Not in the least. There is no seeing past the recursion.
> >>>
> >>> YES THERE IS, see above.
> >>>
> >>>>
> >>>> Either this function aborts the recursion:
> >>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
> >>>> or the recursion never ceases.
> >>>
> >>> The mere idea that emulation is THE solution is wrong.
> >>>>
> >>>>> Thus, by you, the answer to a question about M(N) is at least as much a
> >>>>> function of the machine H that is answering it. RIGHT?
> >>>>
> >>>> In every conventional halting problem proof counter-example the halting
> >>>> decider's decision is the basis for the input program's behavior. This
> >>>> is the key thing that has previously been construed as making the
> >>>> halting problem undecidable.
> >>>>
> >>>> Once we break this cause-and-effect chain and only make the halting
> >>>> decision upon the termination of the input the halting problem can no
> >>>> longer be shown to be undecidable.
> >>>
> >>> While I will admit that this is getting out of my area of expertise, I
> >>> do know that there are a number of different proofs that show that there
> >>> can not be a universal halting decider. In part becaue the existence of
> >>> a truely universal halt decider would make some things that have been
> >>> shown to be uncomputable would then have a method to compute them in
> >>> finite time.
> >>>
> >>>>
> >>>>> This last part seems strange, that the question about a Turing Machine
> >>>>> isn't just about the machine, but about the tool used to measure that
> >>>>> machine. RIGHT?
> >>>>
> >>>> Once the input program's behavior is not allowed to be effected by the halt
> >>>> decider's decision the halting problem becomes decidable.
> >>>
> >>> The data input was never in control of the halt decider. It is only a
> >>> flaw in the Halt decider if the input makes the halt decider misbehave.
> >>>
> >>> The decider's job is to figure out what the input would do, but it is
> >>> always in control.
> >>>>
> >>>>> The purpose of the Halting Machine, isn't just to get 'an answer' but to
> >>>>> get information about the true behavior of a machine. Your modification
> >>>>> destroys that information.
> >>>>
> >>>> No, not at all, not in the least little bit.
> >>>> The rest of what you say strays from the key prerequistite point.
> >>>>
> >>>> Until you fully understand how and why this is decided correctly:
> >>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
> >>>> You have gaps in your reasoning that need to be filled.
> >>>
> >>> So you DO think that how the halting decider works is more important
> >>> than the problem that it was put on??
> >>>
> >>> Does that mean that there is more than one right answer to the question
> >>> does M(N) halt?
> >>>
> >> It looks like I have to backup to the gist of the idea.
> >> The conventional idea of a halt decider can be fooled by simply making
> >> the input program do the opposite of whatever the halt decider decides.
> >>
> >> When the halt decider only makes its decision after the input program
> >> has stopped running it cannot possibly do the opposite of whatever the
> >> halt decider decides.
> >>
> >> This simple little change makes the halting problem decidable.
> >
> > A/ HALT(prog,inp) doesnt RUN prog(inp)
> If the goal it to create a halt decider that:
>
> Accepts any and all non-halting inputs and Rejects any and all halting
> inputs, then making a halt decider that runs its inputs until it detects
> that they would not halt does the trick.
> > B/ if HALT waits for prog(inp) to halt it wouldnt return an answer
> It doesn't simply wait it watches a single step debug trace of its input
> and as soon as it detects non-halting behavior it stops the debug trace
> and reports non-halting.
and THEN
loops(loops)
if halt(loops,loops) then HANG
loops(loops)
if FALSE then HANG
TERMINATES!
HALT got it WRONG!
The only CONSISTENT system is for HALT to HANG itself, then loops(loops) HANGS
which is atleast detectable
Another CONSISTENT system is for HALT to randomly output true or false and tally the results.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-10-31 01:26 +0000 |
| Message-ID | <871rhfxk1h.fsf@bsb.me.uk> |
| In reply to | #24700 |
olcott <NoOne@NoWhere.com> writes: > When the halt decider only makes its decision after the input program > has stopped running it cannot possibly do the opposite of whatever the > halt decider decides. And it can only report "halts". There is no "after" for a never ending computation. As usual I can't tell if the problem is that you meant what you said, or if you can't say what you mean. (You probably meant "after the input computation has been stopped".) -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2020-10-30 22:46 -0400 |
| Message-ID | <Ud4nH.249495$d95.157166@fx06.iad> |
| In reply to | #24700 |
On 10/30/20 8:00 PM, olcott wrote:
> On 10/30/2020 5:43 PM, Richard Damon wrote:
>> On 10/30/20 5:58 PM, olcott wrote:
>>> On 10/30/2020 3:27 PM, Richard Damon wrote:
>>
>>>> Please read and tell me where I am off.
>>>>
>>>> So, we start with the question does a Machine M with input N halt or
>>>> not. This IS the original question we want the answer to, RIGHT?
>>>
>>> Yes.
>>>
>>>> We presume that we can make a Turing Machine H, that is supposedly able
>>>> to answer the question. The stated requirements are that H will, being
>>>> given a representation for machine M with input N, will in a finite
>>>> amount of time, end up in one of two states, dependent on the answer to
>>>> the above question. RIGHT?
>>>
>>> Yes.
>>>
>>>> We have a machine, H_Hat2, which by simple inspection, WILL halt,
>>>
>>> No. If you want to make a machine that definitely halts you can do
>>> something like this:
>>
>> We KNOW H must halt, because it is defined to do so. Where is there
>> possible non-halting behavior, GIVEN that H is defined to work in finite
>> time. If H has a problem in working in finite time, it says that H
>> doesn't meet its requirements.
>>
>>>
>>> u32 Add(u32 X, u32 Y)
>>> {
>>> u32 Z = X + Y;
>>> return Z;
>>> }
>>
>> and the function
>>
>> u32 testFun(u32 X, u32 Y)
>> {
>> doSomethingFinite();
>> return 0;
>> }
>>
>> will also be sure to halt, if we know that doSomethingFinite() is going
>> to return in finite time.
>>
>>>
>>>> the
>>>> only way it can't halt is if H doesn't met its requirements. RIGHT?
>>>
>>> The only way it can halt is that:
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
>>> aborted the first instance of H_Hat2.
>>
>>
>> THERE IS NO REQUIREMENT THAT H EVEN HAVE such a function.
>>
>> One conceivable method is H detects that the machine is recursively
>> calling H, and then sees what happens in the two cases. If either of
>> them agrees with that trial, then that is the answer. One then needs to
>> decide how to handle the 'trick' case of Linz's H_Hat, but that is a
>> different issue. Note, you should only be able to try this out if it
>> really is the case that the machine is being contrary.
>>
>> You still have the problem of detecting non-Halting behavior in the
>> unbounded non-halting machine, but this program (nor H_Hat) exihibits
>> that problem.
>>
>>>
>>>> From this, the answer to the original question, is clearly HALTS.
>>>> RIGHT?
>>>>
>>>
>>> void H_Hat2(u32 P)
>>> {
>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
>>> MOV_EAX_1 // Execution of P(P) has been aborted
>>> else
>>> {
>>> MOV_EAX_0 // P(P) has halted
>>> HERE: goto HERE;
>>> }
>>> HALT
>>> }
>>>
>>> When P = H_Hat2, then this line specifies:
>>> if (Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2))
>>> which is is infinite recursion unless the above function aborts its
>>> execution trace of H_Hat2.
>>>
>>> H_Hat2 only halts because it is forced to halt.
>>>
>>>> You are arguing, that because of how you implemented H, it is ok for it
>>>> to give a different answer, that it had to abort the machine because H
>>>> couldn't see pass the recursion. RIGHT?
>>>
>>> No. Not at all. Not in the least. There is no seeing past the
>>> recursion.
>>
>> YES THERE IS, see above.
>>
>>>
>>> Either this function aborts the recursion:
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
>>> or the recursion never ceases.
>>
>> The mere idea that emulation is THE solution is wrong.
>>>
>>>> Thus, by you, the answer to a question about M(N) is at least as much a
>>>> function of the machine H that is answering it. RIGHT?
>>>
>>> In every conventional halting problem proof counter-example the halting
>>> decider's decision is the basis for the input program's behavior. This
>>> is the key thing that has previously been construed as making the
>>> halting problem undecidable.
>>>
>>> Once we break this cause-and-effect chain and only make the halting
>>> decision upon the termination of the input the halting problem can no
>>> longer be shown to be undecidable.
>>
>> While I will admit that this is getting out of my area of expertise, I
>> do know that there are a number of different proofs that show that there
>> can not be a universal halting decider. In part becaue the existence of
>> a truely universal halt decider would make some things that have been
>> shown to be uncomputable would then have a method to compute them in
>> finite time.
>>
>>>
>>>> This last part seems strange, that the question about a Turing Machine
>>>> isn't just about the machine, but about the tool used to measure that
>>>> machine. RIGHT?
>>>
>>> Once the input program's behavior is not allowed to be effected by
>>> the halt
>>> decider's decision the halting problem becomes decidable.
>>
>> The data input was never in control of the halt decider. It is only a
>> flaw in the Halt decider if the input makes the halt decider misbehave.
>>
>> The decider's job is to figure out what the input would do, but it is
>> always in control.
>>>
>>>> The purpose of the Halting Machine, isn't just to get 'an answer'
>>>> but to
>>>> get information about the true behavior of a machine. Your modification
>>>> destroys that information.
>>>
>>> No, not at all, not in the least little bit.
>>> The rest of what you say strays from the key prerequistite point.
>>>
>>> Until you fully understand how and why this is decided correctly:
>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
>>> You have gaps in your reasoning that need to be filled.
>>
>> So you DO think that how the halting decider works is more important
>> than the problem that it was put on??
>>
>> Does that mean that there is more than one right answer to the question
>> does M(N) halt?
>>
>
> It looks like I have to backup to the gist of the idea.
> The conventional idea of a halt decider can be fooled by simply making
> the input program do the opposite of whatever the halt decider decides.
>
> When the halt decider only makes its decision after the input program
> has stopped running it cannot possibly do the opposite of whatever the
> halt decider decides.
>
> This simple little change makes the halting problem decidable.
>
>
Except that ypu don't run the program until non-halting behavior in the
input program is detected. Sometimes it seems that you halt the program
because non-halting behavior was detected in the halt-detection logic
(which you ar3 terming recurssion), but either the halt detector failed
its requirement to be always halting (negating its ability to be a
refutal to the proof) or it includes code that made it stop the infinite
execution, thus the halt detector isn't working on itself properly, and
is calling its own apparent non-halt (but actually halting) behavior as
non-halting.
This is causing your H to misdetect the proper operation of H_Hat2.
Note, since I described a working methodology for handling H_Hat2 in a
halt detector, you can't claim that the error in inevitable, it only
comes from a flaw in the design of YOU version of H.
Now, yes, if you are going to totally redefine the question so it is
really about what H did, and not about what the machine M(N) will do,
then yes, you can make all sorts of claims, but in doing so you have
left the realm of being anywhere useful to answer the question being put
to the Halt Decider in Linz, and thus you have no impact on it.
You are going to need to make a decision about what track you want to
make. Either you are going to make you statements be applicable to Linz,
in which case the results really need to be about M(N), and hot about
internal details of a particular H(), which will mean you need to be
able to get the right answer for H_Hat2, which is clearly Halting (so
not needing to be aborted).
The other option is to continue to talk about this particular H you are
defining with a LOT of work (but still sounds like you haven't figured
out the really hard part of how to detect the non-halting behavior), and
forgo that it is actually applicable to Linz, but see if this decider is
userul for anything.
Maybe you can build an arguement that it is ok for H to get wrong the
exceptional cases where it can be shown that the M(N) is using H(M, N)
to act contrary to it, but to be similar to the H in Linz, it MUST get
all other Turing Machines right. Maybe this machine needs 3 terminal
states, the Turing Machine will Halt, the Turning Machine will never
Halt, and the Turing Machine is going to be Contradictory. If you can
actually make or even describe how to build such a machine it would be
fantastic and change mathematics. If you can even show that it is
plausable that such a machine could be made, but there are a few issue
that need details worked out, woudl be good. Even describing how you
will detect the Contrary case (fully) might be an accomplishment, but if
you try, be prepared for people to be throwing cases at you that you
didn't think of.
My first guess is that even this modified halt detector would be shown
to be impossible by some of the other halt decider proofs.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-30 22:14 -0500 |
| Message-ID | <GNadnZINrb8LSwHCnZ2dnUU7-KHNnZ2d@giganews.com> |
| In reply to | #24714 |
On 10/30/2020 9:46 PM, Richard Damon wrote:
> On 10/30/20 8:00 PM, olcott wrote:
>> On 10/30/2020 5:43 PM, Richard Damon wrote:
>>> On 10/30/20 5:58 PM, olcott wrote:
>>>> On 10/30/2020 3:27 PM, Richard Damon wrote:
>>>
>>>>> Please read and tell me where I am off.
>>>>>
>>>>> So, we start with the question does a Machine M with input N halt or
>>>>> not. This IS the original question we want the answer to, RIGHT?
>>>>
>>>> Yes.
>>>>
>>>>> We presume that we can make a Turing Machine H, that is supposedly able
>>>>> to answer the question. The stated requirements are that H will, being
>>>>> given a representation for machine M with input N, will in a finite
>>>>> amount of time, end up in one of two states, dependent on the answer to
>>>>> the above question. RIGHT?
>>>>
>>>> Yes.
>>>>
>>>>> We have a machine, H_Hat2, which by simple inspection, WILL halt,
>>>>
>>>> No. If you want to make a machine that definitely halts you can do
>>>> something like this:
>>>
>>> We KNOW H must halt, because it is defined to do so. Where is there
>>> possible non-halting behavior, GIVEN that H is defined to work in finite
>>> time. If H has a problem in working in finite time, it says that H
>>> doesn't meet its requirements.
>>>
>>>>
>>>> u32 Add(u32 X, u32 Y)
>>>> {
>>>> u32 Z = X + Y;
>>>> return Z;
>>>> }
>>>
>>> and the function
>>>
>>> u32 testFun(u32 X, u32 Y)
>>> {
>>> doSomethingFinite();
>>> return 0;
>>> }
>>>
>>> will also be sure to halt, if we know that doSomethingFinite() is going
>>> to return in finite time.
>>>
>>>>
>>>>> the
>>>>> only way it can't halt is if H doesn't met its requirements. RIGHT?
>>>>
>>>> The only way it can halt is that:
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
>>>> aborted the first instance of H_Hat2.
>>>
>>>
>>> THERE IS NO REQUIREMENT THAT H EVEN HAVE such a function.
>>>
>>> One conceivable method is H detects that the machine is recursively
>>> calling H, and then sees what happens in the two cases. If either of
>>> them agrees with that trial, then that is the answer. One then needs to
>>> decide how to handle the 'trick' case of Linz's H_Hat, but that is a
>>> different issue. Note, you should only be able to try this out if it
>>> really is the case that the machine is being contrary.
>>>
>>> You still have the problem of detecting non-Halting behavior in the
>>> unbounded non-halting machine, but this program (nor H_Hat) exihibits
>>> that problem.
>>>
>>>>
>>>>> From this, the answer to the original question, is clearly HALTS.
>>>>> RIGHT?
>>>>>
>>>>
>>>> void H_Hat2(u32 P)
>>>> {
>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
>>>> MOV_EAX_1 // Execution of P(P) has been aborted
>>>> else
>>>> {
>>>> MOV_EAX_0 // P(P) has halted
>>>> HERE: goto HERE;
>>>> }
>>>> HALT
>>>> }
>>>>
>>>> When P = H_Hat2, then this line specifies:
>>>> if (Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2))
>>>> which is is infinite recursion unless the above function aborts its
>>>> execution trace of H_Hat2.
>>>>
>>>> H_Hat2 only halts because it is forced to halt.
>>>>
>>>>> You are arguing, that because of how you implemented H, it is ok for it
>>>>> to give a different answer, that it had to abort the machine because H
>>>>> couldn't see pass the recursion. RIGHT?
>>>>
>>>> No. Not at all. Not in the least. There is no seeing past the
>>>> recursion.
>>>
>>> YES THERE IS, see above.
>>>
>>>>
>>>> Either this function aborts the recursion:
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
>>>> or the recursion never ceases.
>>>
>>> The mere idea that emulation is THE solution is wrong.
>>>>
>>>>> Thus, by you, the answer to a question about M(N) is at least as much a
>>>>> function of the machine H that is answering it. RIGHT?
>>>>
>>>> In every conventional halting problem proof counter-example the halting
>>>> decider's decision is the basis for the input program's behavior. This
>>>> is the key thing that has previously been construed as making the
>>>> halting problem undecidable.
>>>>
>>>> Once we break this cause-and-effect chain and only make the halting
>>>> decision upon the termination of the input the halting problem can no
>>>> longer be shown to be undecidable.
>>>
>>> While I will admit that this is getting out of my area of expertise, I
>>> do know that there are a number of different proofs that show that there
>>> can not be a universal halting decider. In part becaue the existence of
>>> a truely universal halt decider would make some things that have been
>>> shown to be uncomputable would then have a method to compute them in
>>> finite time.
>>>
>>>>
>>>>> This last part seems strange, that the question about a Turing Machine
>>>>> isn't just about the machine, but about the tool used to measure that
>>>>> machine. RIGHT?
>>>>
>>>> Once the input program's behavior is not allowed to be effected by
>>>> the halt
>>>> decider's decision the halting problem becomes decidable.
>>>
>>> The data input was never in control of the halt decider. It is only a
>>> flaw in the Halt decider if the input makes the halt decider misbehave.
>>>
>>> The decider's job is to figure out what the input would do, but it is
>>> always in control.
>>>>
>>>>> The purpose of the Halting Machine, isn't just to get 'an answer'
>>>>> but to
>>>>> get information about the true behavior of a machine. Your modification
>>>>> destroys that information.
>>>>
>>>> No, not at all, not in the least little bit.
>>>> The rest of what you say strays from the key prerequistite point.
>>>>
>>>> Until you fully understand how and why this is decided correctly:
>>>> bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
>>>> You have gaps in your reasoning that need to be filled.
>>>
>>> So you DO think that how the halting decider works is more important
>>> than the problem that it was put on??
>>>
>>> Does that mean that there is more than one right answer to the question
>>> does M(N) halt?
>>>
>>
>> It looks like I have to backup to the gist of the idea.
>> The conventional idea of a halt decider can be fooled by simply making
>> the input program do the opposite of whatever the halt decider decides.
>>
>> When the halt decider only makes its decision after the input program
>> has stopped running it cannot possibly do the opposite of whatever the
>> halt decider decides.
>>
>> This simple little change makes the halting problem decidable.
>>
>>
>
> Except that ypu don't run the program until non-halting behavior in the
> input program is detected.
That you do not understand that I do this that proves that you simply
don't understand.
I have already elaborated all of this in complete detail many times.
Maybe this much detail was overwhelming. Here is the same explanation
with a little less detail:
void H_Hat(u32 P)
{
if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
MOV_EAX_1 // Execution of P(P) has been aborted
else
{
MOV_EAX_0 // P(P) has halted
HERE: goto HERE;
}
HALT
}
void H(u32 P, u32 I)
{
if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
MOV_EAX_1 // Execution of P(I) has been aborted
else
MOV_EAX_0 // P(I) has halted
HALT
}
int main()
{
u32 P = (u32)H_Hat;
H(P, P); // MOV_EAX_0
HALT
}
The above code specifies one instance of H()
two instances of H_Hat() and two instances of
bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, 32 I)
Each instance is in its own process context with its own memory and its
own stack. The outermost instance of the above function has seen a
longer execution trace than the inner instance. This allows the outer
instance to decide halting before the inner intance has a chance to
decide halting.
The outermost instance (the one called in in H) of this function:
bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, 32 I)
returns true for its first parameter, in this case that is the outermost
instance of H_Hat.
2018-12-13 @ 7:00 PM solution.
The halt decider detects the non-halting behavior of the Linz H_Hat
equivalent when it calls the halt decider from the same machine address
a second time and there are no conditional branches in the H_Hat
execution trace that would terminate this otherwise infinite recursion.
x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
Stops executing and Accepts any and all non-halting inputs and Rejects
any and all halting inputs.
> Sometimes it seems that you halt the program
> because non-halting behavior was detected in the halt-detection logic
> (which you ar3 terming recurssion), but either the halt detector failed
> its requirement to be always halting (negating its ability to be a
> refutal to the proof) or it includes code that made it stop the infinite
> execution, thus the halt detector isn't working on itself properly, and
> is calling its own apparent non-halt (but actually halting) behavior as
> non-halting.
>
> This is causing your H to misdetect the proper operation of H_Hat2.
> Note, since I described a working methodology for handling H_Hat2 in a
> halt detector, you can't claim that the error in inevitable, it only
> comes from a flaw in the design of YOU version of H.
>
> Now, yes, if you are going to totally redefine the question so it is
> really about what H did, and not about what the machine M(N) will do,
> then yes, you can make all sorts of claims, but in doing so you have
> left the realm of being anywhere useful to answer the question being put
> to the Halt Decider in Linz, and thus you have no impact on it.
>
> You are going to need to make a decision about what track you want to
> make. Either you are going to make you statements be applicable to Linz,
> in which case the results really need to be about M(N), and hot about
> internal details of a particular H(), which will mean you need to be
> able to get the right answer for H_Hat2, which is clearly Halting (so
> not needing to be aborted).
>
> The other option is to continue to talk about this particular H you are
> defining with a LOT of work (but still sounds like you haven't figured
> out the really hard part of how to detect the non-halting behavior), and
> forgo that it is actually applicable to Linz, but see if this decider is
> userul for anything.
>
> Maybe you can build an arguement that it is ok for H to get wrong the
> exceptional cases where it can be shown that the M(N) is using H(M, N)
> to act contrary to it, but to be similar to the H in Linz, it MUST get
> all other Turing Machines right. Maybe this machine needs 3 terminal
> states, the Turing Machine will Halt, the Turning Machine will never
> Halt, and the Turing Machine is going to be Contradictory. If you can
> actually make or even describe how to build such a machine it would be
> fantastic and change mathematics. If you can even show that it is
> plausable that such a machine could be made, but there are a few issue
> that need details worked out, woudl be good. Even describing how you
> will detect the Contrary case (fully) might be an accomplishment, but if
> you try, be prepared for people to be throwing cases at you that you
> didn't think of.
>
> My first guess is that even this modified halt detector would be shown
> to be impossible by some of the other halt decider proofs.
>
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Graham Cooper <grahamcooper7@gmail.com> |
|---|---|
| Date | 2020-10-30 20:25 -0700 |
| Message-ID | <0693f701-f156-4bd8-a498-b73ba863b8f4n@googlegroups.com> |
| In reply to | #24716 |
On Saturday, October 31, 2020 at 1:14:38 PM UTC+10, olcott wrote:
> void H_Hat(u32 P)
> {
> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
> MOV_EAX_1 // Execution of P(P) has been aborted
> else
> {
> MOV_EAX_0 // P(P) has halted
> HERE: goto HERE;
> }
> HALT
> }
that looks RIGHT!
Im not going through the Rest
youve made a POINT (after 5000 man hours of ppls time)
> void H(u32 P, u32 I)
> {
> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
> MOV_EAX_1 // Execution of P(I) has been aborted
> else
> MOV_EAX_0 // P(I) has halted
> HALT
> }
>
>
> int main()
> {
> u32 P = (u32)H_Hat;
> H(P, P); // MOV_EAX_0
> HALT
> }
>
> The above code specifies one instance of H()
> two instances of H_Hat() and two instances of
> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, 32 I)
>
> Each instance is in its own process context with its own memory and its
> own stack. The outermost instance of the above function has seen a
> longer execution trace than the inner instance. This allows the outer
> instance to decide halting before the inner intance has a chance to
> decide halting.
>
> The outermost instance (the one called in in H) of this function:
> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, 32 I)
> returns true for its first parameter, in this case that is the outermost
> instance of H_Hat.
>
> 2018-12-13 @ 7:00 PM solution.
> The halt decider detects the non-halting behavior of the Linz H_Hat
> equivalent when it calls the halt decider from the same machine address
> a second time and there are no conditional branches in the H_Hat
> execution trace that would terminate this otherwise infinite recursion.
> x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
> Stops executing and Accepts any and all non-halting inputs and Rejects
> any and all halting inputs.
> > Sometimes it seems that you halt the program
> > because non-halting behavior was detected in the halt-detection logic
> > (which you ar3 terming recurssion), but either the halt detector failed
> > its requirement to be always halting (negating its ability to be a
> > refutal to the proof) or it includes code that made it stop the infinite
> > execution, thus the halt detector isn't working on itself properly, and
> > is calling its own apparent non-halt (but actually halting) behavior as
> > non-halting.
> >
> > This is causing your H to misdetect the proper operation of H_Hat2.
> > Note, since I described a working methodology for handling H_Hat2 in a
> > halt detector, you can't claim that the error in inevitable, it only
> > comes from a flaw in the design of YOU version of H.
> >
> > Now, yes, if you are going to totally redefine the question so it is
> > really about what H did, and not about what the machine M(N) will do,
> > then yes, you can make all sorts of claims, but in doing so you have
> > left the realm of being anywhere useful to answer the question being put
> > to the Halt Decider in Linz, and thus you have no impact on it.
> >
> > You are going to need to make a decision about what track you want to
> > make. Either you are going to make you statements be applicable to Linz,
> > in which case the results really need to be about M(N), and hot about
> > internal details of a particular H(), which will mean you need to be
> > able to get the right answer for H_Hat2, which is clearly Halting (so
> > not needing to be aborted).
> >
> > The other option is to continue to talk about this particular H you are
> > defining with a LOT of work (but still sounds like you haven't figured
> > out the really hard part of how to detect the non-halting behavior), and
> > forgo that it is actually applicable to Linz, but see if this decider is
> > userul for anything.
> >
> > Maybe you can build an arguement that it is ok for H to get wrong the
> > exceptional cases where it can be shown that the M(N) is using H(M, N)
> > to act contrary to it, but to be similar to the H in Linz, it MUST get
> > all other Turing Machines right. Maybe this machine needs 3 terminal
> > states, the Turing Machine will Halt, the Turning Machine will never
> > Halt, and the Turing Machine is going to be Contradictory. If you can
> > actually make or even describe how to build such a machine it would be
> > fantastic and change mathematics. If you can even show that it is
> > plausable that such a machine could be made, but there are a few issue
> > that need details worked out, woudl be good. Even describing how you
> > will detect the Contrary case (fully) might be an accomplishment, but if
> > you try, be prepared for people to be throwing cases at you that you
> > didn't think of.
> >
> > My first guess is that even this modified halt detector would be shown
> > to be impossible by some of the other halt decider proofs.
> >
> --
> Copyright 2020 Pete Olcott
http://minibase.com/index.php?q=look++_
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-30 22:41 -0500 |
| Message-ID | <I5KdnSxGodF0QQHCnZ2dnUU7-RPNnZ2d@giganews.com> |
| In reply to | #24717 |
On 10/30/2020 10:25 PM, Graham Cooper wrote:
> On Saturday, October 31, 2020 at 1:14:38 PM UTC+10, olcott wrote:
>
>> void H_Hat(u32 P)
>> {
>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
>> MOV_EAX_1 // Execution of P(P) has been aborted
>> else
>> {
>> MOV_EAX_0 // P(P) has halted
>> HERE: goto HERE;
>> }
>> HALT
>> }
>
>
> that looks RIGHT!
>
> Im not going through the Rest
>
> youve made a POINT (after 5000 man hours of ppls time)
Yes. I have been working on this since 2004 and there are 11,679
messages from me in this group since then.
I finally have the essence of the proof so simple that a bright high
school student knowing nothing about computer science can understand it.
I had to create a whole x86utm operating system to make sure that every
detail of my understanding could be empirically validated.
It is a system that executes UTM equivalent virtual machines that have
the x86 language as their machine description language.
x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
As soon as I fix one little bug in the OS I can finally write the actual
halt deciding code that implements my 2018-12-13 @ 7:00 PM virtual
machine for deciding the Peter Linz H_Hat().
>> void H(u32 P, u32 I)
>> {
>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, I))
>> MOV_EAX_1 // Execution of P(I) has been aborted
>> else
>> MOV_EAX_0 // P(I) has halted
>> HALT
>> }
>>
>>
>> int main()
>> {
>> u32 P = (u32)H_Hat;
>> H(P, P); // MOV_EAX_0
>> HALT
>> }
>>
>> The above code specifies one instance of H()
>> two instances of H_Hat() and two instances of
>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, 32 I)
>>
>> Each instance is in its own process context with its own memory and its
>> own stack. The outermost instance of the above function has seen a
>> longer execution trace than the inner instance. This allows the outer
>> instance to decide halting before the inner intance has a chance to
>> decide halting.
>>
>> The outermost instance (the one called in in H) of this function:
>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, 32 I)
>> returns true for its first parameter, in this case that is the outermost
>> instance of H_Hat.
>>
>> 2018-12-13 @ 7:00 PM solution.
>> The halt decider detects the non-halting behavior of the Linz H_Hat
>> equivalent when it calls the halt decider from the same machine address
>> a second time and there are no conditional branches in the H_Hat
>> execution trace that would terminate this otherwise infinite recursion.
>> x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
>> bool Aborted_Because_Non_Halting_Behavior_Detected(u32 P, u32 I);
>> Stops executing and Accepts any and all non-halting inputs and Rejects
>> any and all halting inputs.
>>> Sometimes it seems that you halt the program
>>> because non-halting behavior was detected in the halt-detection logic
>>> (which you ar3 terming recurssion), but either the halt detector failed
>>> its requirement to be always halting (negating its ability to be a
>>> refutal to the proof) or it includes code that made it stop the infinite
>>> execution, thus the halt detector isn't working on itself properly, and
>>> is calling its own apparent non-halt (but actually halting) behavior as
>>> non-halting.
>>>
>>> This is causing your H to misdetect the proper operation of H_Hat2.
>>> Note, since I described a working methodology for handling H_Hat2 in a
>>> halt detector, you can't claim that the error in inevitable, it only
>>> comes from a flaw in the design of YOU version of H.
>>>
>>> Now, yes, if you are going to totally redefine the question so it is
>>> really about what H did, and not about what the machine M(N) will do,
>>> then yes, you can make all sorts of claims, but in doing so you have
>>> left the realm of being anywhere useful to answer the question being put
>>> to the Halt Decider in Linz, and thus you have no impact on it.
>>>
>>> You are going to need to make a decision about what track you want to
>>> make. Either you are going to make you statements be applicable to Linz,
>>> in which case the results really need to be about M(N), and hot about
>>> internal details of a particular H(), which will mean you need to be
>>> able to get the right answer for H_Hat2, which is clearly Halting (so
>>> not needing to be aborted).
>>>
>>> The other option is to continue to talk about this particular H you are
>>> defining with a LOT of work (but still sounds like you haven't figured
>>> out the really hard part of how to detect the non-halting behavior), and
>>> forgo that it is actually applicable to Linz, but see if this decider is
>>> userul for anything.
>>>
>>> Maybe you can build an arguement that it is ok for H to get wrong the
>>> exceptional cases where it can be shown that the M(N) is using H(M, N)
>>> to act contrary to it, but to be similar to the H in Linz, it MUST get
>>> all other Turing Machines right. Maybe this machine needs 3 terminal
>>> states, the Turing Machine will Halt, the Turning Machine will never
>>> Halt, and the Turing Machine is going to be Contradictory. If you can
>>> actually make or even describe how to build such a machine it would be
>>> fantastic and change mathematics. If you can even show that it is
>>> plausable that such a machine could be made, but there are a few issue
>>> that need details worked out, woudl be good. Even describing how you
>>> will detect the Contrary case (fully) might be an accomplishment, but if
>>> you try, be prepared for people to be throwing cases at you that you
>>> didn't think of.
>>>
>>> My first guess is that even this modified halt detector would be shown
>>> to be impossible by some of the other halt decider proofs.
>>>
>> --
>> Copyright 2020 Pete Olcott
>
>
>
> http://minibase.com/index.php?q=look++_
>
>
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Graham Cooper <grahamcooper7@gmail.com> |
|---|---|
| Date | 2020-10-30 23:30 -0700 |
| Message-ID | <8ba41139-6259-477c-8191-41467aedc83fn@googlegroups.com> |
| In reply to | #24718 |
On Saturday, October 31, 2020 at 1:41:37 PM UTC+10, olcott wrote:
> On 10/30/2020 10:25 PM, Graham Cooper wrote:
> > On Saturday, October 31, 2020 at 1:14:38 PM UTC+10, olcott wrote:
> >
> >> void H_Hat(u32 P)
> >> {
> >> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
> >> MOV_EAX_1 // Execution of P(P) has been aborted
> >> else
> >> {
> >> MOV_EAX_0 // P(P) has halted
> >> HERE: goto HERE;
> >> }
> >> HALT
> >> }
> >
> >
> > that looks RIGHT!
> >
> > Im not going through the Rest
> >
> > youve made a POINT (after 5000 man hours of ppls time)
> Yes. I have been working on this since 2004 and there are 11,679
> messages from me in this group since then.
>
> I finally have the essence of the proof so simple that a bright high
> school student knowing nothing about computer science can understand it.
>
> I had to create a whole x86utm operating system to make sure that every
> detail of my understanding could be empirically validated.
>
> It is a system that executes UTM equivalent virtual machines that have
> the x86 language as their machine description language.
> x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
> As soon as I fix one little bug in the OS I can finally write the actual
> halt deciding code that implements my 2018-12-13 @ 7:00 PM virtual
> machine for deciding the Peter Linz H_Hat().
halt( p , i )
{
if refers_to_haltPI( p , i )
haltval = emulate(p, i, true/[halt(p i)] )
if haltval == true
echo 'true'
else
{
haltval = emulate(p, i, false/[halt(p i)] )
if haltval == false
echo 'false'
}
else
HERE: GOTO HERE
else
echo calcHaltval( p i )
}
This should solve some of the examples that refer to its own halt value
emulate(p, i, true/[halt(p i)] )
tests giving it TRUE for halt(loops loops)
and if it behaves correctly and halts returns TRUE
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-29 23:56 -0500 |
| Message-ID | <b4CdncRzUN9-AQbCnZ2dnUU7-QVQAAAA@giganews.com> |
| In reply to | #24665 |
On 10/29/2020 11:13 PM, Richard Damon wrote:
> On 10/29/20 4:39 PM, olcott wrote:
>> On 10/29/2020 7:51 AM, Richard Damon wrote:
>>> On 10/29/20 8:14 AM, olcott wrote:
>>>> I spent a man year developing the x86utm operating system so that I
>>>> could show every single detailed step of exactly how and why the Linz
>>>> halt decider halts in its ((qn)) state.
>>>>
>>>> x86 language ≡ von Neumann architecture ≡ UTM ≡ RASP Machine
>>>>
>>>> The reason that a halt decider can actually decide that the Linz H_Hat
>>>> does not halt is based on the fact that it gets stuck in infinite
>>>> recursion before it ever reaches its undecidable states. We can tell
>>>> that it gets stuck in infinite recursion because it invokes the halt
>>>> decider a second time from the same machine address without any
>>>> conditional instructions in its execution trace in-between that would
>>>> terminate this otherwise infinite recursion. I derived this solution
>>>> 2018-12-13 @ 7:00 PM.
>>>
>>> The amount of time you wasted on this isn't the issue. It is that fact
>>> that you still get the answer wrong. HOW the halt decider works isn't
>>> really interesting, it is the answer it gives.
>>>
>>> Let us look at a slight variation of Linz, that has a clear answer,
>>>
>>> H_Hat2(N) does the same replication has H_Hat, calls H(N, N) like H_Hat,
>>> but then halts whether H says halts or not. Clearly H_Hat2 halts, it has
>>> no choice other than that. Simple inspection makes it clear that it MUST
>>> halt (as H by its definition must have finite execution), and there is
>>> no loops outside of H.
>>>
>>
>> void H_Hat2(u32 P)
>> {
>> if (Aborted_Because_Non_Halting_Behavior_Detected(P, P))
>> HALT
>> else
>> HALT
>> }
>>
>> OK great you are putting in an effort for a sincere dialogue for the
>> purpose of achieving mutual understanding.
>>
>> As with all of the conventional self-referential halting problem proofs
>> the infinite recursion is at the first step so that none of the
>> subsequent steps are ever reached. The execution of H(H_Hat2, H_Hat2)
>> must be aborted.
>>
>
> But, You should be able to admit, that by a simple inspection of the
> code, including the specifiation on H, that H_Hat2 must clearly halt, so
> a proper Halt Decider doesn't need to any simulation of the program, so
> never hits the recursive trap.
Definition 12.1 and Figure 12.1 on pages 317-318
H.q0 wMw ⊢* H.qy
H.q0 wMw ⊢* H.qn
http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
Not at all. Not in the least little bit. To say that H_Hat2() halts
presumes the contents of the unspecified wildcard state transitions: ⊢*
The non-halting decider that I defined accepts any and all non-halting
inputs and rejects any and all halting inputs. To do this it stipulates
the definition of the otherwise unspecified wildcard states.
Within this definition
bool Aborted_Because_Non_Halting_Behavior_Detected(H_Hat2, H_Hat2)
returns true.
So when we get 100% totally specific and do not leave anything to
intuition not only is H_Hat and H_Hat2 proved to be decidable all the
steps of making this decision will soon be explicitly shown.
It is the exact same 2018-12-13 @ 7:00 PM solution of detecting that the
halt decider is invoked two times from the same machine address without
any conditional instructions in the execution trace of H_Hat or H_Hat2
that would terminate this otherwise infinite recursion.
> It is the defect in H, which makes the claim that it is a universal halt
> decider, that causes the need for aborting, not a problem with H_Hat2.
The halting decision is exactly as I described above for both H_Hat and
H_Hat2. All of the rest of what you say is moot until you first
understand the above.
> Then you run into the problem that emulation CAN'T work as a universal
> halt detector (without some other magic sauce, which if can be found
> like eliminates the whole need for emulation) as the classic way of
> deteccting non-halting with emulation is looking for a repeated state,
> but due to the nature of Turing Machine, it is quite easy to come up
> with a large number (infinite) of machines that grow unbounded over time
> and never halt and also never repeat a state.
>
> So, you have created a proposed solution that, barring some other break
> through proof, is strictly limited to being a partial decider, and which
> chokes on this type of recursive definitions. Your ruse to claim that
> there is something illegal about the Linz machine, is also the thing
> that make it so you can't be a universal decider.
>
> Also, by changing the problem statement, your answer loses the utility
> that the sought for halt detector would provide.
>
> Yes, maybe you can make the statement that you can show that the Linz
> proof that there can be no universal halt detetecor doesn't apply to
> your differing proposition of a detector that is allowed to declare a
> problem too hard or maybe defective, but this modified proposition
> doesn't seem to be nearly as interesting of a proposition, and in fact
> seems like well trodden ground.
>
>
> One other thing to note, you seem to want to focus on what your abort
> detector did in deciding, while the answer that is REALLY wanted, is
> what will happen to the describe machine when it is run.
>
> It should be clear, that for the case of H_Hat2, that it will ALWAYS
> halt, and IT was never aborted. Your Abort detector, WILL have a problem
> with emulating it from the input, and will decide to abort the
> emulation. The key thing that you seem to forget is no one cares about
> what H did to get the answer, they are only interested in the answer,
> and that it actually gives one, and that it is correct.
>
> Only you seem to care that your method abort the emulation so that you
> could meet the finite execution time. That isn't what people are really
> interested in. It is as I have said elsewhere, like claiming to trisect
> and angle by bisecting it twice.
>
> You seem to want to come up with some sort of decider that is 'close
> enough' to what Linz was talking about, to some how make him wrong, but
> you seem to have no understanding of what the real use is of a halt
> decider. It isn't a way to test out Turing machines that should halt,
> but if we make a mistake and the fall into an infinite loop, we want
> them to be stopped. Turing machines are a way of expressing the
> computability of things. The limits of what Turing Machines can do show
> us the limits of rote, mechanical calculation. The fact that you CAN'T
> make a halting decider, shows that some things are not computable and
> that leads to some things not being provable (these things happen when
> you pass a certain threshold of domain complexity, getting into the
> right kings of infinite).
>
> Your Abort detector, because of its problems with handling the infinite,
> restricts it to being only useful to smaller spaces, and thus doesn't
> help answer question that deal with the infinite, which can be as simple
> as the counting numbers.
>
--
Copyright 2020 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mostowski Collapse <janburse@fastmail.fm> |
|---|---|
| Date | 2020-10-29 14:01 +0100 |
| Subject | Stop crossposting you imbecil spammer (Was: SOLUTION TO THE HALTING PROBLEM!) |
| Message-ID | <rneefj$d0j$4@solani.org> |
| In reply to | #24594 |
For gods sacke stop cross posting on 4 newsgroups. Especially comp.lang.prolog doesn't make much sense. RAM/RASP is probably best housed on comp.theory. olcott schrieb: > I am a complete imbecial spammer
[toc] | [prev] | [next] | [standalone]
| From | Mostowski Collapse <janburse@fastmail.fm> |
|---|---|
| Date | 2020-10-29 19:39 +0100 |
| Subject | Re: Stop crossposting you imbecil spammer (Re: SOLUTION TO THE HALTING PROBLEM! |
| Message-ID | <rnf299$u35$1@solani.org> |
| In reply to | #24594 |
For gods sacke stop cross posting on 4 newsgroups. Especially comp.lang.prolog doesn't make much sense. RAM/RASP is probably best housed on comp.theory. olcott schrieb: > On 10/29/2020 1:13 AM, Graham Cooper wrote: > I am a brainless mud turtle
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-10-29 13:43 -0500 |
| Subject | Re: Stop crossposting you imbecil spammer (Re: SOLUTION TO THE HALTING PROBLEM! |
| Message-ID | <E5qdnefPYtDLkAbCnZ2dnUU7-IGdnZ2d@giganews.com> |
| In reply to | #24633 |
On 10/29/2020 1:39 PM, Mostowski Collapse wrote: > For gods sacke stop cross posting on 4 newsgroups. > > Especially comp.lang.prolog doesn't make much sense. > > RAM/RASP is probably best housed on comp.theory. Yes I agree yet this is the final culmination of my life's work and I have stage III cancer so I have to take some shortcuts. > > olcott schrieb: >> On 10/29/2020 1:13 AM, Graham Cooper wrote: >> I am a brainless mud turtle -- Copyright 2020 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mostowski Collapse <janburse@fastmail.fm> |
|---|---|
| Date | 2020-10-29 20:49 +0100 |
| Message-ID | <rnf6cv$24j$1@solani.org> |
| In reply to | #24594 |
Hey guys, I never use side channels and usenet at the same time. So this is my response to KT: ------------ cut here ---------------------- There is nevertheless a point in using usenet. Because now you use side channels and covert communication, which makes results non reproducible or implausible. Keith Thompson schrieb: > There was no point in posting my message on the newsgroup when it was > directed only at you. > > On Thu, Oct 29, 2020 at 12:10 PM j4n bur53 wrote: >> its unusal to send personal email, when you >> can offer your opinion on usenet. >> >> Keith Thompson schrieb: >>> Mostowski Collapse <janburse@fastmail.fm> writes: >>>> For gods sacke stop cross posting on 4 newsgroups. >>>> >>>> Especially comp.lang.prolog doesn't make much sense. >>>> >>>> RAM/RASP is probably best housed on comp.theory. >>>> >>>> olcott schrieb: >>>>> I am a complete imbecial spammer >>> You're not helping. olcott has made it clear that he's going to >>> continue cross-posting. Posting *in the same groups* isn't going >>> to change his mind. It only annoys the rest of us.
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <Keith.S.Thompson+u@gmail.com> |
|---|---|
| Date | 2020-10-29 13:09 -0700 |
| Message-ID | <87a6w4u73e.fsf@nosuchdomain.example.com> |
| In reply to | #24644 |
Mostowski Collapse <janburse@fastmail.fm> writes:
> Hey guys, I never use side channels and usenet
> at the same time. So this is my response to KT:
>
> ------------ cut here ----------------------
>
> There is nevertheless a point in using usenet.
> Because now you use side channels and covert
>
> communication, which makes results non
> reproducible or implausible.
>
> Keith Thompson schrieb:
>> There was no point in posting my message on the newsgroup when it was
>> directed only at you.
[snip]
I sent you an email message. I did not intend it to be public. You
chose to quote and reply to it publicly, something I didn't ask you to
do and would have preferred that you hadn't.
Your response to olcott's inappropriate cross-posting has simply made
the situation worse. Please drop this.
PLONK.
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
[toc] | [prev] | [standalone]
Page 2 of 2 — ← Prev page 1 [2]
Back to top | Article view | comp.theory
csiph-web