FW: Re: Orderless indexed functions

• To: mathgroup at smc.vnet.net
• Subject: [mg20908] FW: [mg20891] Re: [mg20874] Orderless indexed functions
• From: Andrzej Kozlowski <andrzej at tuins.ac.jp>
• Date: Sun, 21 Nov 1999 15:12:51 -0500 (EST)
• Sender: owner-wri-mathgroup at wolfram.com

```This seems to be a very hard problem. All I can suggest at this time is the
following. If you  can be satisfied with defining only a finite number of
f[n]'s with n an integer between, say, 0 and 100 (in principle you could use
a very large number) you could do something like this:

<< Utilities`Notation`

In[2]:=
\!\(\*
RowBox[{"Symbolize", "[",
TagBox[\(f\__\),
NotationBoxTag,
TagStyle->"NotationTemplateStyle"], "]"}]\)

In[3]:=
f[i_] := ToExpression[
"f\[UnderBracket]Subscript\[UnderBracket]" <> ToString[i]]

In[4]:=
Do[SetAttributes[Evaluate[f[i]], Orderless], {i, 1, 100}]
In[5]:=
Do[f[i][x___, f[0][y___]] = f[i][x, y], {i, 1, 100}];

Now you get

In[9]:=
f[5][c, b, f[0][a]]
Out[9]=
f\[UnderBracket]Subscript\[UnderBracket]5[a, b, c]

which seems to be right. You could also use the same method to define other
values for f[i]. The only problem I see at the moment is that you can't get
more than a finite number of f[i]'s. However, for some purposes this maybe
enough. I can's see at this time how to overcome this restriction.

Andrzej

--

> From: "N Monomachoff" <nmonomachoff at email.msn.com>
To: mathgroup at smc.vnet.net
> Date: Sun, 21 Nov 1999 00:59:58 -0500
> To: "Andrzej Kozlowski" <andrzej at tuins.ac.jp>, <hay at haystack.demon.co.uk>,
> <mathgroup at smc.vnet.net>, <hwolf at debis.com>
> Subject: [mg20908] Re: [mg20891] Re: [mg20874] Orderless indexed functions
>
> Dear Andrzej Kozlowski,
>
> I want to thank you for the extraordinary efforts you've expended on this
> problem. Had I appreciated how nontrivial my original question was, I
> would have been much more explicit:
>
> Not only do I need pattern matching within the body of the function, I need
> to pattern match the index itself, as in the following:
>
> f[n_][x___,f[0][y___]]:=f[n][x,y]
>
> The ability to do this is precisely why I chose the indexed form.
> Unfortunately, none of the proposed solutions, not even your last, seems to
> allow for such definitions. Apparently the Notation package is unable to
> stretch this far. Even a definition as simple as:
>
> \!\(f\_n_ := h[n]\)
>
> doesn't work. On the other hand, I haven't delved into the deeper parts of
> the Notation package, so perhaps I'm wrong.
>
> N Monomachoff
> nmonomachoff at msn.com
>
>
>
>> From: Andrzej Kozlowski <andrzej at tuins.ac.jp>
To: mathgroup at smc.vnet.net
>> Date: Sat, 20 Nov 1999 17:28:49 +0900
>> To: Andrzej Kozlowski <andrzej at tuins.ac.jp>, <mathgroup at smc.vnet.net>
>> Subject: [mg20908] Re: [mg20891] Re: [mg20874] Orderless indexed functions
>>
>> I think I have worked out the right solution to your problem, which will
>> produce an indexed function with an Orderless attribute. This is what you
>> have to do. First, you need to load the Notation package:
>>
>> In[2]:=
>> << Utilities`Notation`
>>
>> (I was wrong to say you need ot move it inot the Autoload folder since the
>> ExtraPackages folder is actually included in  \$Path )
>>
>> Okay, now you symbolize "f\[UnderBracket]Subscript\[UnderBracket]i" using
>> the Notation palette:
>>
>> In[4]:=
>> \!\(\*
>> RowBox[{"Symbolize", "[",
>> TagBox[\(f\__\),
>> NotationBoxTag,
>> TagStyle->"NotationTemplateStyle"], "]"}]\)
>>
>>
>>
>> Once you have done this you need a function that will convert f[i] to
>> "f\[UnderBracket]Subscript\[UnderBracket]i". The following will work:
>>
>>
>> In[9]:=
>> f[i_] := ToExpression[
>> "f\[UnderBracket]Subscript\[UnderBracket]" <> ToString[i]]
>>
>> e.g.
>>
>> In[10]:=
>> f[3]
>> Out[10]=
>> f\[UnderBracket]Subscript\[UnderBracket]3
>>
>> Now all you need to do is
>>
>> In[13]:=
>> \!\(SetAttributes[f\_3, Orderless]\)
>>
>> and you have what you wanted:
>>
>> In[14]:=
>> f[3][a, c, b]
>> Out[14]=
>> \!\(f\_3[a, b, c]\)
>>
>> Unlike with all the other solutions that have been proposed (if I didn't
>> miss something) you get the benefit of correct behaviour with respect to
>> pattern matching:
>>
>> In[15]:=
>> F[f[3][a, b]] + F[f[3][a, c]] + F[f[3][b, d]] /.
>> F[f[3][a, x_]] + F[f[3][c, y_]] -> p[x, y]
>> Out[15]=
>> \!\(F[f\_3[b, d]] + p[b, a]\)
>>
>>
>>
>> --
>> Andrzej Kozlowski
>> Toyama International University
>> JAPAN
>> http://sigma.tuins.ac.jp
>>
>>
>>> From: Andrzej Kozlowski <andrzej at tuins.ac.jp>
To: mathgroup at smc.vnet.net
>>> Date: Sat, 20 Nov 1999 01:07:05 -0500 (EST)
>>> To: mathgroup at smc.vnet.net
>>> Subject: [mg20908] [mg20891] Re: [mg20874] Orderless indexed functions
>>>
>>> I just noticed that there is a third way to do what you want, which is
>>> possibly the simplest. Just define your function like this:
>>>
>>> f[1][x__] /; Not[OrderedQ[{x}]] := f[1][Apply[Sequence, Sort[{x}]]]
>>>
>>> However, I should also add that only the first of the three approaches I
>>> have suggested (the one based on using the Notation package) actually
> gives
>>> you the full functionality of having the Orderless attribute. All the
>>> functions defined in these ways will be "commutative", but they will not
>>> behave like Orderless functions for the purpose of Pattern matching. For
>>> example, consider the function f, which has a genuine Orderless
> attribute:
>>>
>>> In[4]:=
>>> SetAttributes[f, Orderless]
>>>
>>> Now consider the following example of pattern matching:
>>>
>>> In[5]:=
>>> F[f[a, b]] + F[f[a, c]] + F[f[b, d]] /. F[f[a, x_]] + F[f[c, y_]] -> p[x,
> y]
>>> Out[5]=
>>> F[f[b, d]] + p[b, a]
>>>
>>> If we use the definition above we won't get this behaviour:
>>>
>>> In[6]:=
>>> F[f[1][a, b]] + F[f[1][a, c]] + F[f[1][b, d]] /.
>>> F[f[1][a, x_]] + F[f[1][c, y_]] -> p[x, y]
>>> Out[6]=
>>> F[f[1][a, b]] + F[f[1][a, c]] + F[f[1][b, d]]
>>>
>>> The second method I gave in my first reply is even worse, as you can
> check
>>> yourself. So if you need your functions to be really orderless for the
>>> purpose of pattern matching I can only suggest using subscripts and the
>>> Notation package.
>>>
>>>
>>>> From: Andrzej Kozlowski <andrzej at tuins.ac.jp>
To: mathgroup at smc.vnet.net
>>> To: mathgroup at smc.vnet.net
>>>> Date: Fri, 19 Nov 1999 15:12:49 +0900
>>>> To: <nmonomachoff at email.msn.com>, <mathgroup at smc.vnet.net>
>>>> Subject: [mg20908] [mg20891] [mg20874] Orderless indexed functions
>>>>
>>>> I can think of two approaches. If you are willing to abandon the
> notation
>>>> f[k] and instead use subscripts than probably the simplest way to get
> what
>>>> you want is to use the Notation package, which you can find in the
>>>> ExtraPackages folder in the AddOns folder (you will have ot move it to
>>>> somewhere like the AutoLoad folder to make things work as in y example
>>>> below)
>>>>
>>>> In[23]:= << Utilities`Notation`
>>>>
>>>> In[27]:= Symbolize[NotationBoxTag[\(f\__\)]]
>>>>
>>>> In[28]:= SetAttributes[f\[UnderBracket]Subscript\[UnderBracket]2,
> Orderless]
>>>>
>>>> In[29]:= f\[UnderBracket]Subscript\[UnderBracket]2[b, c, a]
>>>> Out[29]= f\[UnderBracket]Subscript\[UnderBracket]2[a, b, c]
>>>>
>>>> If, on the other hand, you insist on the f[k] notation or you find the
>>>> Notation package just too much bother (as I do) you could try something
> like
>>>> this.
>>>> Suppose you want to define a function of the form: f[1][x__]:=B[x]
> (where B
>>>> is the body of your function)  and give it the attribute Orderless. The
>>>> following code will do it for you:
>>>>
>>>> f[1][x__] := Unevaluated[(Function[y, B[Sequence @@ y],
>>>> {Orderless}])[x]] /. y -> Table[Unique[z],{Length[{x}]}]
>>>>
>>>> e.g.
>>>>
>>>> In[5]:=
>>>> f[1][b, c, a, d]
>>>> Out[5]=
>>>> B[a, b, c, d]
>>>>
>>>>
>>>> --
>>>>
>>>>
>>>>> From: "N Monomachoff" <nmonomachoff at email.msn.com>
To: mathgroup at smc.vnet.net
>>> To: mathgroup at smc.vnet.net
>>>>> Date: Thu, 18 Nov 1999 20:46:23 -0500 (EST)
>>>>> To: mathgroup at smc.vnet.net
>>>>> Subject: [mg20908] [mg20891] [mg20874] Orderless indexed functions
>>>>>
>>>>> Hello,
>>>>>
>>>>> I need to use 'indexed functions' like f[0][x__] and f[1][x__].
>>>>> It's important that the functions be Orderless, but
>>>>>
>>>>> SetAttributes[f[0],Orderless]
>>>>>
>>>>> isn't accepted because f[0] isn't a symbol, and
>>>>>
>>>>> SetAttributes[f,Orderless]
>>>>>
>>>>> doesn't affect the ordering in the second set of brackets.
>>>>> How does one make a nonsymbolic head orderless?
>>>>>
>>>>> Thanks for any help.
>>>>>
>>>>> N Monomachoff
>>>>> nmonomachoff at msn.com
>>>>>
>>>>>
>>>>>
>>>>
>>>
>>>
>>
>>
>
>
>
>
>

```

• Prev by Date: Re: Re: Orderless indexed functions
• Next by Date: Re: Re: Orderless indexed functions
• Previous by thread: Re: Re: Orderless indexed functions
• Next by thread: Re: Re: Orderless indexed functions