Re: Define an antisymmetric function
- To: mathgroup at smc.vnet.net
- Subject: [mg107402] Re: Define an antisymmetric function
- From: Szabolcs Horvát <szhorvat at gmail.com>
- Date: Thu, 11 Feb 2010 08:07:23 -0500 (EST)
- References: <hl0r36$uu$1@smc.vnet.net>
On 2010.02.11. 12:53, Torsten Schoenfeld wrote:
> I'd like to define an antisymmetric function by giving its value on a
> set of known objects. I'm having trouble enforcing antisymmetry. Say I
> want to define G[_, _] on the objects {a, b, c}:
>
> G[a, b] := f[a, b]
> G[a, c] := g[a, c]
> G[b, c] := h[b, c]
>
> If I now enforce antisymmetry simply by
>
> G[x_, y_] := -G[y, x]
>
> then it mostly works (e.g., G[b, a] evaluates to -f[a, b]). But if I
> apply G to something that is not in {a, b, c}, then I run into an
> infinite loop: G[a, f[b]] yields "$RecursionLimit::reclim: Recursion
> depth of 256 exceeded."
>
> Ideally, I would like applications to unknown input to stay unevaluated
> (e.g., G[a, f[b]] just yields G[a, f[b]]). How can I achieve that while
> also enforcing antisymmetry?
>
Hello Torsten,
I do not think that it is possible to do this in a general way. It
might, however, be possible to make it work for the special cases that
you need.
The reason why it is not possible to implement it in a completely
general way is this:
Suppose we input G[a,b], and suppose that there is no definition
associated with G that would allow computing the value of G[a,b]. Now
we need to check if G[b,a] can be computed, and if so, then use the
value -G[b,a] for G[a,b]. But how can we check if G[b,a] "can be
computed", that is, if it evaluates to something different than itself?
If we aim for complete generality, this is only possible by trying to
evaluate G[b,a], which will then trigger the antisymmetry definition
again, and lead to infinite recursion...
So, let's not aim for completely generality. Instead, let's just check
if an *explicit* definition exists for G[b,a] (i.e. for the explicit
values b and a):
G[x_, y_] := -G[y, x] /; hasValue[G[y,x]]
hasValue[f_[args___]] :=
MemberQ[First /@ DownValues[f], Verbatim@HoldPattern[f[args]]]
This will work for simple cases, but it is neither pretty, nor robust.
I hope someone will post a better suggestion.
One more thing that needs to be mentioned is that there is already a
function similar to hasValue[] built into Mathematica: ValueQ[].
However, it cannot be used here because for non-atomic arguments
(anything more complicated than a symbol) it determines if it has a
value by evaluating it and checking whether it has changed. So the
infinite recursion still wouldn't be avoided.
I hope this helps,
Szabolcs
- Follow-Ups:
- Re: Re: Define an antisymmetric function
- From: Leonid Shifrin <lshifr@gmail.com>
- Re: Define an antisymmetric function
- From: Szabolcs <szhorvat@gmail.com>
- Re: Re: Define an antisymmetric function
- From: Leonid Shifrin <lshifr@gmail.com>
- Re: Re: Define an antisymmetric function