Re: Re: how to explain this weird effect? Integrate
- To: mathgroup at smc.vnet.net
- Subject: [mg46435] Re: [mg46411] Re: how to explain this weird effect? Integrate
- From: withoff at wolfram.com
- Date: Wed, 18 Feb 2004 00:37:00 -0500 (EST)
- References: <c0qjgq$ka6$1@smc.vnet.net> <200402171205.HAA02452@smc.vnet.net>
- Sender: owner-wri-mathgroup at wolfram.com
> I wanted Mathematica to act as if it was a
> human. (A very smart human at that).
>
> The way I look at it, is that when I tell a computer algebra program
> to solve X, then I expect the program to do what it can and apply
> any number of different steps and 'tricks' to solve X.
>
> I do not have to tell it to do step 1 first, then step 2, then if it
> can't do step 2, then try this trick first, and then do step 2, etc...
>
> All what iam saying is that taking the limit in this case is NOT an
> additional step becuase it would have lead to the solution I wanted.
>
> I guess it is a design issue. Some folks here do not seem to agree
> with this, but I think this is how a computer algebra system should
> work. So, may be we should drop this subject and leave it at that.
> We agree to diagree.
>
> regards,
> Steve
The topic raised here illustrates a prominent concern
in the design of almost anything, not just computer algebra
systems. Even if the topic is restricted to computer
programming, a history of the people who have raised concerns
just like this one, and of efforts to address those concerns,
would form the better part of the entire history of artificial
intelligence, computer software design, and efforts to get a
machine to behave like a human.
As others have already pointed out, the direct mathematical
response here is that the computer did exactly what it was
asked to do, and furthermore that there is nothing
mathematically wrong with what it did and no unique alternative
behavior that would always be either correct or desirable.
So that part of the issue is rather like the question of whether
or not 2+2 is 4, which be interesting in some other setting,
but it won't get anywhere as a design suggestion.
There is nevertheless an interesting design question here.
One way to explore the broader design issues is to look
up "DWIM" on the internet or in a jargon dictionary.
When I did that I found:
DWIM; Acronym for `Do What I Mean': Adjective meaning able
to guess, sometimes even correctly, the result intended when
bogus input was provided; Of a person, someone whose directions
are incomprehensible and vague, but who nevertheless has the
expectation that you will solve the problem using the specific
method he/she has in mind. See 'hairy'.
This is precisely where the topic becomes interesting as a
design question. That is, the design question becomes interesting
with the speculation that, as a practical matter, most users in
realistic situations might expect the software to behavior in some
particular way that was not explicitly specified in the input, and
that the computer should therefore choose that alternate behavior
by default.
In this particular case the suggestion might be that if I
substitute a value into an expression and the result turns out
to be indeterminate, the computer should recognize that this
is probably not what I wanted and should automatically try
computing a corresponding limit.
One problem with this suggestion is that, as a practical matter,
probably about 999 times out of 1000 when a result is
indeterminate it is because it really is indeterminate, and
not a removeable singularity or anything else that would change
by computing a limit. In those 999 cases the not insubstantial
time needed to compute the limit would be wasted, and so for
every user who might like such a change there will be 999 who
probably will not.
There is also a problem, as has already been pointed out, that
the limiting result may not even be the correct or intended
value, and open questions about what to do with something like
(x-Sqrt[x^2])/x /. x->0 where the limit depends on direction,
and other issues that would need to be resolved in order to
implement such a suggestion.
In my own use of computer software many of the most annoying
problems come up when the software designer has tried to guess
what I wanted, and for example has arranged for a limit to be
computed when that is quite emphatically not what I want, and I
spend hours looking for a way to get the computer to do what
I asked it to do.
On the other hand, there are other design questions, many of them
in Mathematica, where DWIM design is probably a good idea, and
the computer should probably do something automatically even
though the input, if taken literally, was ambiguous or may even
have specified something else entirely.
A lot of very smart people have thought about these issues for
a very long time, and in this particular example have so far
uniformly come to the conclusion that although it would sometimes
be desirable for a computer algebra system to automatically
compute a limit when a substition leads to an indeterminate
result, there is no viable design in which the computer could
guess with any useful degree of reliability when to do that
and when not to do that.
Of course the fact that a lot of very smart people think that
your suggestion is unimplementable does not mean that a suitable
design doesn't exist. If you think you can come up with a
viable suggestion you could certainly give it a try. The
artificial intelligence community has been doing that sort of
thing for decades, occasionally with a fair degree of success.
Dave, WRI
- References:
- Re: how to explain this weird effect? Integrate
- From: nma124@hotmail.com (steve_H)
- Re: how to explain this weird effect? Integrate