Oleg wrote:
>  Incorrect form: the first "." is composition, the second
>  should be multiplication. The composition on the right
>  side should be between f' and first g.

Tracy responded:
>  Between what John Randall wrote and the elaboration by the 
>  author in the original, I think your attempt at correction 
>  is unsuccessful.

I think he got it right.  Here's another page on the "chain rule" (composition 
rule for derivatives):

  
http://www.math.uncc.edu/~bjwichno/fall2004-math1242-006/Review_Calc_I/lec_composition_rule.htm

In particular, check out the graphic at the very top:

  http://www.math.uncc.edu/~bjwichno/fall2004-math1242-006/Images/image12.gif

Transcribing that into ASCII, we get:

   (f o g)'(x) = f'(g(x)) * g'(x)

Here, I've substituted ' for the mathematical "prime" symbol [1],  o  for the 
mathematical "composition" symbol [2] and  *  for the mathematical "dot 
product" symbol [3].

Incidentally, I think poor ASCII transliteration was what caused this confusion 
in the first place.  Conal wanted to use the symbol "." for both function 
composition and dot product.  Not coincidentally, problems like these are why J 
symbols are all ASCII-based.  

Nor is the original math notation itself without flaw.  I notice that the 
left-hand side of the equation is written using function composition:

   (f o g)'

but the right-hand side is written with nested function calls:

   f'(g(x))

which is inconsistent.  I might've written the equation thus:

   (f o g)'(x) = (f' o g)(x) * g'(x)

Having done so, it is easy to get a reasonable approximation of the equation in 
J, with the additional benefit that it's executable:

           o      =:  @:       NB.  Composition 
           D      =:  D.1      NB.  Derivative (i.e. prime-symbol)
           x      =:  +/ . *   NB.  Dot product (even though it looks like a 
cross product, or the variable "x").

           NB.             (f o g)'(x) = (f'  o g)(x) *  g'   (x)
           chain  =:  2 : '(f o g) D   = (f D o g)    x (g D)'

In J4, we could've gotten even closer:

           f      =:  [.
           g      =:  ].
           NB.        (f o g)'(x) =  (f'   o g)(x) *   g'   (x)
           chain  =:  (f o g D)   = ((f D) o g     x  (g D))

-Dan

[1]  ? aka U+2032 (i.e.  u: 16b2032 ) aka "prime" aka "feet" aka "minutes"
     http://www.fileformat.info/info/unicode/char/2032/index.htm

[2]  ? aka U+2218 (i.e.  u: 16b2218 ) aka "composite function" aka "APL jot"
     http://www.fileformat.info/info/unicode/char/2218/index.htm

[3]  ? aka U+22C5 (i.e.  u: 16b22C5 ) aka "dot operator" 
     http://www.fileformat.info/info/unicode/char/22C5/index.htm
     
So if my system can compose Unicode properly, and yours can render it, then the 
formula could be written:

  (f ? g)?(x) = f?(g(x)) ? g?(x)

and, if a future version of J supports Unicode (rather than just ASCII) names, 
we could assign these characters appropriately:

   ?      =:  @:
   ?      =:  D.1
   ?      =:  +/ . *

and come that much closer to having "executable math".  But that's a long way 
off.  As this post proves (probably), Unicode has a way to go before we can 
transmit it reliably.  But it would make the APL guys happy.

----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm

Reply via email to