Re: Re: Orderless indexed functions

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

```Just one more brief remark on this topic. It seems to me now that my usage
of the Notation package in this context was really a bit of a red herring.
One can get the same result more simply as follows:

In[1]:=
f[i_] := ToExpression[ToString[f] <> ToString[i]]

In[2]:=
f[3]
Out[2]=
f3

In[4]:=
Do[SetAttributes[Evaluate[f[i]], Orderless], {i, 1, 50}]

In[5]:=
f[1][c, a, b]
Out[5]=
f1[a, b, c]

As long as one needs to deal only with a finite (reasonably large) number of
functions indexed by integers this ought to be enough.

>
> 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: [mg20910] 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: [mg20910] 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: [mg20910] [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: [mg20910] [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: [mg20910] [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: FW: Re: Orderless indexed functions
• Next by Date: Admin - Group Off Line Nov 24-27
• Previous by thread: FW: Re: Orderless indexed functions
• Next by thread: What kind of math problem is this?