# Exercise 1.14: Coordinate-independence of Lagrange equations

```clojurescript id=a782c7d4-4b1a-450f-8571-e66d69be4b52
(require '[sicmutils.env :refer :all])
```

Look carefully at what this exercise is asking us to do:

> Check that the Lagrange equations for central force motion in polar coordinates and in rectangular coordinates are equivalent. Determine the relationship among the second derivatives by substituting paths into the transformation equations and computing derivatives, then substitute these relations into the equations of motion.

The punchline that we'll encounter soon is that a coordinate transformation of applied to some path function $q$ can commute with $\Gamma$. You can always write some function $C$ of the local tuple that handles the coordinate transformation *after* $\Gamma[q]$ instead of transforming the path directly. In other words, you can always find some $C$ such that

$$
\begin{equation}
C \circ \Gamma[q] = \Gamma[q']
\end{equation}
$$
Because function composition is associative, instead of ever transforming the path, you can push the coordinate transformation into the Lagrangian to generate a new Lagrangian: $L = L' \circ C$.

The section of textbook just before the exercise has given us two Lagrangians in different coordinates – `L-central-polar` and `L-rectangular` – and generated Lagrange equations from each.

Our task is to directly transform the Lagrange equations by substituting the first and second derivatives of the coordinate transformation expression into one of the sets of equations, and looking to see that it's equivalent to the other.

Fair warning: this is much more painful than transforming the Lagrangian *before* generating the Lagrange equations. This exercise continues the theme of devastating you with algebra as a way to show you the horror that the later techniques were developed to avoid. Let us proceed.

Here are the two Lagrangians from the book:

```clojurescript id=4f34f2ab-7373-47fb-8e80-444b4eb026be
(defn L-central-rectangular [m U]
  (fn [[_ q v]]
    (- (* (/ 1 2) m (square v))
       (U (sqrt (square q))))))

(defn L-central-polar [m U]
  (fn [[_ [r phi] [rdot phidot]]]
    (- (* (/ 1 2) m
          (+ (square rdot)
             (square (* r phidot))) )
       (U r))))
```

Here are the rectangular equations of motion:

```clojurescript id=31190898-d004-4a35-a562-be705094ed04
(((Lagrange-equations
   (L-central-rectangular 'm (literal-function 'U)))
  (up (literal-function 'x)
      (literal-function 'y)))
 't)
```

And the polar Lagrange equations:

```clojurescript id=70b61ae7-2fdf-4328-aac2-a536eb9b4b7a
(((Lagrange-equations
   (L-central-polar 'm (literal-function 'U)))
  (up (literal-function 'r)
      (literal-function 'phi)))
 't)
```

Once again, our goal is to show that, if you can write down coordinate transformations for the coordinates, velocities and accelerations and substitute them in to one set of Lagrange equations, the other will appear.

To do this by hand, take the coordinate transformation described in 1.64 in the book:

$$
\begin{equation}
\begin{aligned}
  x &= r \cos \phi \cr
  y &= r \sin \phi
\end{aligned}
\end{equation}
$$
Note that $x$, $y$, $r$ and $\phi$ are functions of $t$. Take the derivative of each equation (Use the product and chain rules) to obtain expressions for the rectangular velocities in terms of the polar coordinates, just like equation 1.66 in the book:

$$
\begin{equation}
  \begin{aligned}
    Dx(t) &= Dr(t) \cos \phi(t) - r(t) D\phi(t) \sin \phi(t) \cr
    Dy(t) &= Dr(t) \sin \phi(t) + r(t) D\phi(t) \cos \phi(t)
  \end{aligned}
\end{equation}
$$
The rectangular equations of motion have second derivatives, so we need to keep going. This is too devastating to imagine doing by hand. Let's move to Scheme.

Write the coordinate transformation for polar coordinates to rectangular in Scheme:

```clojurescript id=c4a95fb4-f7d1-4c55-9434-c2c93b33b76d
(ns-unmap *ns* 'p->r)

(defn p->r [[_ [r phi]]]
  (let [x (* r (cos phi))
        y (* r (sin phi))]
    (up x y)))
```

Now use `F->C`, first described on page 46. This is a function that takes a coordinate transformation like `p->r` and returns a *new* function that can convert an entire local tuple from one coordinate system to another; the $C$ discussed above.

The version that the book presents on page 46 can only generate a velocity transformation given a coordinate transformation, but `scmutils` contains a more general version that will convert as many path elements as you pass to it.

Here are the rectangular positions, velocities and accelerations, written in polar coordinates:

```clojurescript id=3476ba99-8335-4467-83c8-8ac0fda6c7fa
(let [convert-path (F->C p->r)
      polar-path (up 't
                     (up 'r 'phi)
                     (up 'rdot 'phidot)
                     (up 'rdotdot 'phidotdot))]
  (convert-path polar-path))
```

Ordinarily, it would be too heartbreaking to substitute these in to the rectangular equations of motion. The fact that we have Scheme on our side gives me the strength to proceed.

Write the rectangular Lagrange equations as a function of the local tuple, so we can call it directly:

```clojurescript id=d247b89f-e4e1-46c6-b0a7-aa1489824773
(defn rect-equations [[_ [x y] [xdot ydot] [xdotdot ydotdot]]]
  (let [U (literal-function 'U)]
    (up (/ (+ (* 'm xdotdot (sqrt (+ (square x) (square y))))
              (* x ((D U) (sqrt (+ (square x) (square y))))))
           (sqrt (+ (square x) (square y))))
        (/ (+ (* 'm ydotdot (sqrt (+ (square x) (square y))))
              (* y ((D U) (sqrt (+ (square x) (square y))))))
           (sqrt (+ (square x) (square y)))))))
```

Verify that these are, in fact, the rectangular equations of motion by passing in a symbolic rectangular local tuple:

```clojurescript id=648ba3d8-f481-4195-8ddc-143736fa4bf7
(let [rect-path (up 't
                    (up 'x 'y)
                    (up 'xdot 'ydot)
                    (up 'xdotdot 'ydotdot))]
  (rect-equations rect-path))
```

Now use the `p->r` conversion to substitute each of the rectangular values above with their associated polar values:

```clojurescript id=0b831f30-b06a-4dee-8564-264480ef6e99
(let [convert-path (F->C p->r)
      polar-path (up 't
                     (up 'r 'phi)
                     (up 'rdot 'phidot)
                     (up 'rdotdot 'phidotdot))
      local (convert-path polar-path)]
  (rect-equations local))
```

Oh no. This looks quite different from the polar Lagrange equations above. What is the problem?

I had to stare at this for a long time before I saw what to do. Notice that the terms we want from the polar Lagrange equations all seem to appear in the first equation with a $\cos \phi$, and in the second equation with a $\sin \phi$. Using the trigonometric identity:

$$
\begin{equation}
(\cos \phi)^2 + (\sin \phi)^2 = 1
\end{equation}
$$
I realized that I could recover the first equation through a linear combination of both terms. Multiply the first by $\cos \phi$ and the second by $\sin \phi$, add them together and the unwanted terms all drop away.

A similar trick recovers the second equation,given an extra factor of $r$:

```clojurescript id=45f50c46-8989-4464-9dca-18d15c74fe5d
(let [convert-path (F->C p->r)
      polar-path (up 't
                     (up 'r 'phi)
                     (up 'rdot 'phidot)
                     (up 'rdotdot 'phidotdot))
      local (convert-path polar-path)
      eq (rect-equations local)]
  (up (+ (* (cos 'phi) (ref eq 0))
         (* (sin 'phi) (ref eq 1)))
      (- (* 'r (cos 'phi) (ref eq 1))
         (* 'r (sin 'phi) (ref eq 0)))))
```

This was a powerful lesson. We're allowed to take a linear combination here because each equation is a residual, equal to zero. $a0 + b0 = 0$ for any $a$ and $b$, so any combination we generate is still a valid residual.

There is something important going on here, with the way we were able to remove $\phi$ completely from the Lagrange equations. It seemed like $\phi$ was quite important, until we managed to kill it. Is this related to the discussions of symmetries that we'll encounter later in the book? Let me know if you know the answer here.

<details id="com.nextjournal.article">
<summary>This notebook was exported from <a href="https://nextjournal.com/a/NbVGebPBfLBo2vZyDbwxX?change-id=DKwH2XzCG5hXJP2Ru4K7F2">https://nextjournal.com/a/NbVGebPBfLBo2vZyDbwxX?change-id=DKwH2XzCG5hXJP2Ru4K7F2</a></summary>

```edn nextjournal-metadata
{:article
 {:nodes
  {"0b831f30-b06a-4dee-8564-264480ef6e99"
   {:id "0b831f30-b06a-4dee-8564-264480ef6e99",
    :kind "code",
    :runtime [:runtime "b8a33406-535c-4801-a685-7886bc3999ac"]},
   "31190898-d004-4a35-a562-be705094ed04"
   {:id "31190898-d004-4a35-a562-be705094ed04",
    :kind "code",
    :runtime [:runtime "b8a33406-535c-4801-a685-7886bc3999ac"]},
   "3476ba99-8335-4467-83c8-8ac0fda6c7fa"
   {:id "3476ba99-8335-4467-83c8-8ac0fda6c7fa",
    :kind "code",
    :runtime [:runtime "b8a33406-535c-4801-a685-7886bc3999ac"]},
   "3ed5d17d-bde7-4aef-b219-7652fb52c6d3"
   {:compute-ref :static-compute-ref,
    :id "3ed5d17d-bde7-4aef-b219-7652fb52c6d3",
    :kind "code",
    :runtime [:runtime "34a7a869-c43e-40dd-adc4-45ef799538f3"]},
   "45f50c46-8989-4464-9dca-18d15c74fe5d"
   {:id "45f50c46-8989-4464-9dca-18d15c74fe5d",
    :kind "code",
    :runtime [:runtime "b8a33406-535c-4801-a685-7886bc3999ac"]},
   "4f34f2ab-7373-47fb-8e80-444b4eb026be"
   {:id "4f34f2ab-7373-47fb-8e80-444b4eb026be",
    :kind "code",
    :runtime [:runtime "b8a33406-535c-4801-a685-7886bc3999ac"]},
   "648ba3d8-f481-4195-8ddc-143736fa4bf7"
   {:id "648ba3d8-f481-4195-8ddc-143736fa4bf7",
    :kind "code",
    :runtime [:runtime "b8a33406-535c-4801-a685-7886bc3999ac"]},
   "70b61ae7-2fdf-4328-aac2-a536eb9b4b7a"
   {:id "70b61ae7-2fdf-4328-aac2-a536eb9b4b7a",
    :kind "code",
    :runtime [:runtime "b8a33406-535c-4801-a685-7886bc3999ac"]},
   "a782c7d4-4b1a-450f-8571-e66d69be4b52"
   {:id "a782c7d4-4b1a-450f-8571-e66d69be4b52",
    :kind "code",
    :runtime [:runtime "b8a33406-535c-4801-a685-7886bc3999ac"]},
   "b8a33406-535c-4801-a685-7886bc3999ac"
   {:id "b8a33406-535c-4801-a685-7886bc3999ac",
    :kind "runtime",
    :language "clojurescript",
    :type :nextjournal},
   "c4a95fb4-f7d1-4c55-9434-c2c93b33b76d"
   {:id "c4a95fb4-f7d1-4c55-9434-c2c93b33b76d",
    :kind "code",
    :runtime [:runtime "b8a33406-535c-4801-a685-7886bc3999ac"]},
   "d247b89f-e4e1-46c6-b0a7-aa1489824773"
   {:id "d247b89f-e4e1-46c6-b0a7-aa1489824773",
    :kind "code",
    :runtime [:runtime "b8a33406-535c-4801-a685-7886bc3999ac"]}},
  :nextjournal/id #uuid "0303df6f-4764-4f14-a62b-9985499304bc",
  :article/change
  {:nextjournal/id #uuid "63d28031-1ca8-422b-ac75-97db77c05d05"}}}

```
</details>