Estructura euclídea de (ℝ^n). Curvas

Francisco Javier Pérez González
Departamento de Análisis Matemático
Universidad de Granada

Introducción

Algunos temas de este curso los voy a presentar como cuadernos de Mathematica; de esta forma dispondremos de los recursos gráficos del programa para visualizar muchos de los conceptos que vamos a estudiar. Debe quedar claro desde ahora que lo que importa es el desarrollo teórico de cada tema y que utilizo Mathematica como una herramienta para facilitar su estudio. Tu trabajo debe centrarse en el estudio y comprensión de los conceptos y definiciones y en la realización de los ejercicios que se proponen. No debes dedicar más tiempo del imprescindible a los comandos de Mathematica que se definen; lo justo para saber usarlos para construir tus propios ejemplos pero no es preciso, ni es esa mi intención, que comprendas bien los recursos de Mathematica que utilizo, los cuales, por otra parte, pueden ser de utilidad para las clases de prácticas.

Estructura euclídea de (ℝ^n)

Voy a recordarte algunas cosas que ya debes conocer. Como sabes, (ℝ^n) es un espacio vectorial en el que suele destacarse la llamada base canónica formada por los vectores {(Subscript[e, 1,]) (Subscript[e, 2]),  ... , (Subscript[e, n])} donde (Subscript[e, k]) es el vector cuyas componentes son todas nulas excepto la que ocupa el lugar k que es igual a 1. En los libros de física es frecuente poner flechas sobre las letras que representan vectores. Este proceder puede ser útil en algunos casos para evitar posibles confusiones pero, en general, no lo voy a seguir. Deberás acostumbrarte a distinguir cuándo una letra representa un vector o un número.
Dados dos vectores x = ((Subscript[x, 1]), (Subscript[x, 2]),  ... , (Subscript[x, n])),  
      y = ((Subscript[y, 1]), (Subscript[y, 2]),  ... , (Subscript[y, n])) se define su producto escalar ⟨x | 
          y⟩ por:

⟨x | 
              y⟩ = (∑_(j = 1)^n) (Subscript[x, j]) 
                (Subscript[y, j]) = (Subscript[x, 1]) (Subscript[y, 1]) + (Subscript[x, 2]) (Subscript[y, 2]) +  ...  + (Subscript[x, n]) 
                (Subscript[y, n])

Este producto escalar se llama "producto escalar euclídeo". Observa que el producto escalar de dos vectores no es un vector sino un número real. La notación x.y es frecuentemente usada en los libros de Física para representar el producto escalar de los vectores x e y. Las dos notaciones son útiles y las usaremos en lo que sigue con preferencia para la notación ⟨x | y⟩.
Las siguientes propiedades del producto escalar se deducen fácilmente de la definición:
⟨x | 
            y⟩ = ⟨y | 
            x⟩  para todos x, y, z ∈ (ℝ^n) (simetría).
⟨α x + β y | 
            z⟩ = α ⟨x | 
                z⟩  +  β ⟨y | 
                z⟩  para todos \(TraditionalForm\`α, β ∈ ℝ\) y para todos x, y, z ∈ (ℝ^n) (linealidad).
⟨x | x⟩ > 
        0 siempre que x ≠ 0
La norma euclídea de un vector se define por:

\(\(\(||\)\(x\)\(||\)\) = \(\@⟨x | x⟩ = \@\(∑\+\(j = 1\)\%n x\_j\%2\)\)\)

En libros de física es frecuente representar la norma euclídea por |x| y se le llama módulo o magnitud o longitud del vector x. También es  frecuente seguir el convenio de que una letra en negrita, por ejemplo v, representa un vector (digamos, la velocidad); y la misma letra pero en tipo normal, v, representa su norma (que sería la rapidez o celeridad). Ni que decir tiene que este convenio da lugar a muchísimas confusiones. Advertido quedas.

Desigualdad de Cauchy-Schwarz. Para todos x, y ∈ (ℝ^n)  se verifica que \(TraditionalForm
      \`|⟨x | y⟩ | 
        \( ≤ \( || x || \  || y || \)\)\). Además, supuesto que x e y no son nulos, la igualdad \(TraditionalForm
      \`\(|⟨x | y⟩ | \) = 
        \( || x || \  || y || \)\) equivale a que hay un número λ ∈ ℝ tal que y = λ x (es decir, los vectores x e y están en una misma recta que pasa por el origen).

Ejercicio 1

Desigualdad triangular. Para todos x, y ∈ (ℝ^n)  se verifica que \(TraditionalForm
      \`\( || x\  + \ y\) || 
        \( ≤ \( || x || \ \(+\ \( || y || \)\)\)\)\). Además, supuesto que x e y no son nulos, la igualdad \(TraditionalForm
      \`\(\( || x + y\) || \) = \( || x || \ \(+\ \( || y || \)\)\)\) equivale a que hay un número λ > 0 tal que y = λ x (es decir, los vectores x e y están en una misma semirecta que pasa por el origen).

Ejercicio 2

Se dice que los vectores x e y son ortogonales, y escribimos x ⊥ y cuando su producto escalar es cero. Se dice que un vector x es ortogonal a un conjunto de vectores D ⊂ (ℝ^n) cuando x es ortogonal a todo vector en D. Un conjunto de vectores no nulos que son mutuamente ortogonales se dice que es un conjunto ortogonal de vectores; si, además, los vectores tienen todos norma 1 se dice que es un conjunto ortonormal de vectores. Una base vectorial que también es un conjunto ortogonal (ortonormal) se llama una base ortogonal (ortonormal). 
Si x e y son vectores no nulos, el vector

(Subscript[Π, y]) (x) = ⟨x | 
                    y⟩/⟨y | 
                    y⟩ y

se llama la proyeccción ortogonal de x sobre y. Puedes comprobar que el vector  x - (Subscript[Π, y])(x) es ortogonal a y. En particular, si y es un vector unitario (de norma 1) entonces el vector \(TraditionalForm
      \`x\  - \ ⟨x\  | \ y⟩ y\) es ortogonal a y.

Ejercicio 3

Es muy fácil calcular las componentes de un vector en una base ortonormal. Sea B = {(Subscript[u, 1]), (Subscript[u, 2]),  ... , (Subscript[u, n])} una base ortonormal de (ℝ^n) y sea x ∈ (ℝ^n). Puedes comprobar que x=(∑_(j = 1)^n)⟨x | 
                  (Subscript[u, j])⟩ (Subscript[u, j]), es decir, x es la suma de sus proyecciones ortogonales sobre los vectores de la base. Las componentes de x en dicha base son, por tanto,  (⟨x | 
            (Subscript[u, 1])⟩, ⟨x | 
            (Subscript[u, 2])⟩, ... ⟨x | 
              (Subscript[u, n])⟩).

El producto escalar y la norma es invariante por cambios de base ortonormales. Es decir, si B = {(Subscript[u, 1]), (Subscript[u, 2]),  ... , (Subscript[u, n])} es una base ortonormal de (ℝ^n); x = ((Subscript[x, 1]), (Subscript[x, 2]),  ... , (Subscript[x, n])),  
      y = ((Subscript[y, 1]), (Subscript[y, 2]),  ... , (Subscript[y, n])) son vectores de (ℝ^n) cuyas coordenadas en la base B son, respectivamente, ((Subscript[α, 1]), (Subscript[α, 2]),  ... , (Subscript[α, n]))  y  ((Subscript[β, 1]), (Subscript[β, 2]),  ... , (Subscript[β, n])), entonces se verifica que:

⟨x | 
          y⟩ = (∑_(j = 1)^n) (Subscript[x, j]) 
            (Subscript[y, j]) = (∑_(j = 1)^n) (Subscript[α, j]) (Subscript[β, j])

En particular,

\(TraditionalForm\`\(\(||\)\(x\)\(||\)\) = \(\@\(∑\+\(j = 1\)\%n x\_j\%2\) = \@\(∑\+\(j = 1\)\%n α\_j\%2\)\)\)

Ejercicio 4

Dados dos vectores x e y, el número  || x - y ||  se llama la distancia (euclídea) entre x e y.

Supongamos ahora que H es un subespacio vectorial de (ℝ^n) y que {(Subscript[v, 1]), (Subscript[v, 2]),  ... , (Subscript[v, k])} es una base ortonormal de H. Dado un vector x ∈ (ℝ^n), el vector (Subscript[P, H])(x)=(∑_(j = 1)^k)⟨x | (Subscript[v, j])⟩ (Subscript[v, j])∈H se llama la proyección ortogonal de x sobre H. Es inmediato que el vector x-(Subscript[P, H])(x) es ortogonal a cada uno de los vectores (Subscript[v, j]),  1 ≤ j ≤ k y, por la linealidad del producto escalar, deducimos que x-(Subscript[P, H])(x) es ortogonal a H.

Distancia mínima de un punto a un subespacio. Vamos a probar que si H es un subespacio vectorial de (ℝ^n), {(Subscript[v, 1]), (Subscript[v, 2]),  ... , (Subscript[v, k])} es una base ortonormal de H  y x ∈ (ℝ^n), se verifica que la distancia mínima de x al subespacio H es igual a ||x-(∑_(j = 1)^k)⟨x | 
                      (Subscript[v, j])⟩ (Subscript[v, j])||.
Demostración. Llamemos (Subscript[P, H])(x)=(∑_(j = 1)^k)⟨x | 
                    (Subscript[v, j])⟩ (Subscript[v, j]). El vector (Subscript[P, H])(x) está en H. Queremos probar que ||x - (Subscript[P, H])(
                x)||≤||x - y|| para todo y ∈ H. En efecto, para todo y ∈ Hse tiene que el vector (Subscript[P, H])(x) - y también está en H por lo que los vectores x - (Subscript[P, H])(x) y (Subscript[P, H])(x) - y son ortogonales y, usando el teorema de Pitágoras, deducimos que

\(\(\(\(||\)\(x - 
                        y\)\)\( || \^2\)\) = \(\(||\)\((\(x\)\(-\)\)\)\)(Subscript[P, H])(x))+((Subscript[P, H])(x)-y)\( || \^2\)= ||x-(Subscript[P, H])(x)\( || \^2\)+||(Subscript[P, H])(x)-y\( || \^2\)

esta igualdad implica que \(TraditionalForm\`\(\(||\)\(x - \(P\_H\)(
              x)\)\)\( || \^2\)\(\(≤\)\(\(\(||\)\(x - 
                y\)\)\( || \^2\)\)\)\), es decir, ||x - (Subscript[P, H])(
              x) || ≤||x - 
                y||  y la igualdad se da solamente cuando y = (Subscript[P, H])(x), es decir, que la distancia mínima de x a H se alcanza solamente en el punto (Subscript[P, H])(x).

Cuando la dimensión de H es grande, puede calcularse fácilmente el vector x - (Subscript[P, H])(x)=x-(∑_(j = 1)^k)⟨x | (Subscript[v, j])⟩ (Subscript[v, j]) de la siguiente forma: se amplía la base {(Subscript[v, 1]), (Subscript[v, 2]),  ... , (Subscript[v, k])} a una base ortonormal de (ℝ^n); sea esta \(TraditionalForm
      \`B = {v\_1, v\_2,  ... , v\_k, \ u\_\(k + 1\),  ... , u\_n}\). De la igualdad  x=(∑_(j = 1)^k)⟨x | (Subscript[v, j])⟩ (Subscript[v, j])+(∑_(j = k + 1)^n)⟨x | (Subscript[u, j])⟩ 
                  (Subscript[u, j]) se sigue que  x-(∑_(j = 1)^k)⟨x | (Subscript[v, j])⟩ (Subscript[v, j])=(∑_(j = k + 1)^n)⟨x | (Subscript[u, j])⟩ (Subscript[u, j]). Este proceder es muy útil cuando k = n - 1 y permite calcular fácilmente la distancia de un punto a un hiperplano (subespacio vectorial de dimensión n - 1). Teniendo en cuenta que la distancia es invariante por traslaciones, este resultado te permite calcular (aunque no necesariamente por el camino más corto) la distancia de un punto a una recta o la distancia de un punto a un plano.

Acabamos de ver que es muy fácil calcular la proyección ortogonal de un vector sobre un subespacio si conocemos una base ortonormal del mismo. Por eso el siguiente procedimniento, conocido como procedimiento de ortogonalización de Gram-Schmidt es de gran interés. Dicho procedimiento consiste en lo siguiente. Dada una base {(Subscript[v, 1]), (Subscript[v, 2]),  ... , (Subscript[v, k])} de un subespacio vectorial H, queremos obtener a partir de ella otra base de H que sea ortonormal. Para ello definimos

(Subscript[u, 1]) = ((Subscript[v, 1])/(||(Subscript[v, 1])||)),                  \(u\_2 = \(v\_2 - ⟨v\_2 | u\_1⟩ u\_1\)\/\(\(||\)\(v\_2 - ⟨v\_2 | u\_1⟩ u\_1\)\(||\)\)\) ,\(\(\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \)\(\(u\_3 = \(v\_3 - ⟨v\_3 | u\_2⟩ u\_2 - ⟨v\_3 | u\_1⟩ u\_1\)\/\(\(||\)\(v\_3 - ⟨v\_3 | u\_2⟩ u\_2 - ⟨v\_3 | u\_1⟩ u\_1\)\(||\)\)\)\(,\)\)\)

\(u\_4 = \(v\_4 - ⟨v\_4 | u\_3⟩ u\_3 - ⟨v\_4 | u\_2⟩ u\_2 - ⟨v\_4 | u\_1⟩ u\_1\)\/\(\(||\)\(v\_4 - ⟨v\_4 | u\_3⟩ u\_3 - ⟨v\_4 | u\_2⟩ u\_2 - ⟨v\_4 | u\_1⟩ u\_1\)\(||\)\), \  ... \)

Supuestos construidos (Subscript[u, 1]), (Subscript[u, 2]),  ... ,  (Subscript[u, j]) ortonormales dos a dos, se define (Subscript[u, j + 1]) como (Subscript[v, j + 1]) menos la proyección ortogonal de (Subscript[v, j + 1]) sobre el subespacio engendrado por los vectores  (Subscript[u, 1]), (Subscript[u, 2]),  ... ,  (Subscript[u, j]) divididido por su norma,

\(TraditionalForm\`u\_\(j + 1\) = \(v\_\(j + 1\) - ∑\+\(i = 1\)\%j⟨v\_\(j + 1\) | u\_\(\(\ \)\(i\)\)⟩ u\_\(\(\ \)\(i\)\)\)\/\(\(\(\(||\)\(v\)\)\_\(j + 1\) - ∑\+\(i = 1\)\%j⟨v\_\(j + 1\) | u\_\(\(\ \)\(i\)\)⟩ u\_\(\(\ \)\(i\)\)\)\(||\)\)\)

con lo que obtenemos un vector unitario ortogonal a los vectores  (Subscript[u, 1]), (Subscript[u, 2]),  ... ,  (Subscript[u, j]) y, en consecuencia,  {(Subscript[u, 1]), (Subscript[u, 2]),  ... ,  (Subscript[u, j]),(Subscript[u, j + 1])} es un sistema ortonormal. Este proceso continúa hasta agotar todos los vectores de la base dada. Observa que como los vectores {(Subscript[u, 1]), (Subscript[u, 2]),  ... ,  (Subscript[u, k])} dependen linealmente de los vectores {(Subscript[v, 1]), (Subscript[v, 2]),  ... ,  (Subscript[v, k])} el subespacio engendrado por {(Subscript[u, 1]), (Subscript[u, 2]),  ... ,  (Subscript[u, k])} es también H.

El siguiente comando es un ejemplo de la potencia del lenguaje de programación de Mathematica. En una sola línea se define un comando que realiza el proceso que acabamos de describir. Te recuerdo lo dicho: no trates de comprender la definición del comando. Úsalo como se indica en el ejemplo para ortonormalizar conjuntos de vectores que tú mismo debes definir y comprobar que efectivamente el resultado es un conjunto ortonormal.

gramschmidt = 
            Fold[Append[#1, (#(1/(Sqrt[#1 . #1])) &)[
                      Fold[#1 - #1 . #2 #2  &, #2, #1]]] &, {}, #1] &;

Podemos aplicar este comando a vectores en cualquier dimensión (el comando Dot[x, y] o x.y calcula el producto escalar del vector x por el vector y).

tr1 = 
        gramschmidt[{{1, 0, 2}, {0, 2, 3}, {1, 4, 0}}] // Simplify  
tr2 = 
          gramschmidt[{{1, 0, 2, 1}, {0, 2, 3, -1}, {-2, 1, 4, 0}}] // 
            Simplify  
  
Outer[Dot, tr1, tr1, 1] // Simplify // Chop 
Outer[Dot, tr2, tr2, 1] // Simplify // Chop 
Clear[tr1, tr2]

Supuesto que x ≠ 0,  y ≠ 0, la desigualdad de Cauchy-Schwarz puede escribirse en la forma:

\(TraditionalForm\`\(-1\) ≤ ⟨x | y⟩\/\(\(||\)\(x\)\(||\)\(\ \)\(||\)\(y\)\(||\)\) ≤ 1\)

La medida en radianes del ángulo que forman los vectores no nulos x e y se define como el único número t ∈ [0, π] que verifica la igualdad

\(TraditionalForm\`cos\ t = ⟨x | y⟩\/\(\(||\)\(x\)\(||\)\(\ \)\(||\)\(y\)\(||\)\)\)

Naturalmente, como consecuencia de esta definición, se verifica que \(TraditionalForm
      \`⟨x | y⟩ = 
        \( || x ||  || y || cos\ t\)\).

Particularización a (ℝ^3)

En física se representan los vectores de la base canónica de (ℝ^3)con las letras i,  j,  k. Es decir:

i=(1, 0, 0), j=(0, 1, 0), k=(0, 0, 1)

Naturalmente, si (x, y, z) es un vector de (ℝ^3)se tiene que:

(x, y, z) = x i+ y j+ z k

En Matemáticas se prefiere la expresión (x, y, z) y en física se prefiere  x i+ y j+ z k. Debes tener bien claro que son dos formas de escribir lo mismo: el vector cuyas componentes en la base canónica de (ℝ^3) son x,  y,  z.
En (ℝ^3)se define el producto vectorial de dos vectores x = ((Subscript[x, 1]), (Subscript[x, 2]), (Subscript[x, 3])),  
      y = ((Subscript[y, 1]), (Subscript[y, 2]), (Subscript[y, 3])) como el vector:

x × y=(|({{(Subscript[x, 2]), (Subscript[x, 3])}, {(Subscript[y, 2]), (Subscript[y, 3])}})|,- |({{(Subscript[x, 1]), (Subscript[x, 3])}, {(Subscript[y, 1]), (Subscript[y, 3])}})|,|({{(Subscript[x, 1]), (Subscript[x, 2])}, {(Subscript[y, 1]), (Subscript[y, 2])}})| ) =((Subscript[x, 2]) (Subscript[y, 3]) - (Subscript[x, 3]) (Subscript[y, 2]))i +((Subscript[x, 3]) (Subscript[y, 1]) - (Subscript[x, 1]) (Subscript[y, 3]))j + ((Subscript[x, 1]) (Subscript[y, 2]) - (Subscript[x, 2]) (Subscript[y, 1]))k

No es imprescindible memorizar esta definición pues se verifica que:

x × y=determinante (({{i, j, k}, {(Subscript[x, 1]), (Subscript[x, 2]), (Subscript[x, 3])}, {(Subscript[y, 1]), (Subscript[y, 2]), (Subscript[y, 3])}}))=((Subscript[x, 2]) (Subscript[y, 3]) - (Subscript[x, 3]) (Subscript[y, 2]))i+((Subscript[x, 3]) (Subscript[y, 1]) - (Subscript[x, 1]) (Subscript[y, 3]))j+ ((Subscript[x, 1]) (Subscript[y, 2]) - (Subscript[x, 2]) (Subscript[y, 1]))k

Donde el determinante de la matriz se ha calculado formalmente considerando i,  j,  k como símbolos algebraicos. De aquí se deduce que el producto vectorial x×y es nulo cuando los vectores x e y son linealmente dependientes (suele decirse que son paralelos).

Las siguientes propiedades del producto vectorial son fáciles de comprobar.
x×y = -y×x (es anticonmutativo)
(α x + β y)×
          z = α(x×y) + β(y×z) (linealidad)
Usando estas propiedades y sabiendo que i×i = j×j = k×k = 0, i×j = k, j×k = i, k×i = j, es fácil calcular productos vectoriales. Una precaución que debes tener al trabajar con productos vectoriales es no usar la propiedad asociativa porque, en general, es falsa. Por ejemplo i×(i×j)=i×k = -j pero (i×i)×j = 0×j = 0.

Vamos a calcular la norma euclídea del producto vectorial. Tenemos que:

\(\(\(\(||\)\(x×y\)\)\( || \^2\)\)\(=\)\)\(\(\((\(x\_2\) y\_3 - \(x\_3\) y\_2)\)\^2 + \((\(x\_3\) y\_1 - \(x\_1\) y\_3)\)\^2 + \ \((\(x\_1\) y\_2 - \(x\_2\) y\_1)\)\^2\)\(=\)\)((Subscript[x, 1]^2) + (Subscript[x, 2]^2) + 
                (Subscript[x, 3]^2))((Subscript[y, 1]^2) + (Subscript[y, 2]^2) + (Subscript[y, 3]^2))-((((Subscript[x, 1]) (Subscript[y, 1]) + (Subscript[x, 2]) (Subscript[y, 2]) + (Subscript[x, 3]) (Subscript[y, 3])))^2)=
\(\(\(||\)\(x\)\( || \^2\)\(||\)\(y\)\( || \^2\)\(-\ ⟨x\  | \ y⟩\^2\)\) = \ \(\(\(||\)\(x\)\( || \^2\)\(||\)\(y\)\( || \^2\)\(\ \)\(-\ \ \(\(||\)\(x\)\( || \^2\)\(||\)\(y\)\( || \^2\)\(\ \)\(\(cos\^2\)(
                    t)\)\)\)\) = \(\(||\)\(x\)\( || \^2\)\(||\)\(y\)\( || \^2\)\(\(sen\^2\)(t)\)\)\)\)

siendo t la medida en radianes del ángulo que forman los vectores x e y. Como 0 ≤ t ≤ π, se tiene que sen(t) ≥ 0, y deducimos que ||x×
              y|| = ||x||||y||sen(
            t). Realmente, hemos probado la bonita identidad de Lagrange:

\(\(||\)\(x\)\( || \^2\)\(||\)\(y\)\( || \^2\)\)=(((x.y))^2)+||x×y\( || \^2\)

que relaciona la norma, el producto escalar y el producto vectorial. Podemos comprobar esta igualdad con Mathematica.

X = {(Subscript[x, 1]), (Subscript[x, 2]), (Subscript[x, 3])};
Y = {(Subscript[y, 1]), (Subscript[y, 2]), (Subscript[y, 3])};
Simplify[
      X . X*Y . Y == (X . Y)^2 + 
          Cross[X, Y] . Cross[X, Y]]

En algunos textos de física se emplea la notación x∧y para representar el producto vectorial x × y.

También usaremos de aquí en adelante las letras i, j para representar los vectores de la base canónica de (ℝ^2), es decir, los vectores (1,0) y (0,1). El contexto indicará claramente cuándo dichas letras representan vectores de (ℝ^2) o de (ℝ^3).

Con Mathematica puedes calcular el producto escalar y el producto vectorial de dos vectores x e y con los comandos x.y (o también Dot[x,y]) y Cross[x,y] respectivamente. Además, podemos comprobar que el vector x × y   es ortogonal a los vectores x e y.  Comprobamos también que el vector  x - (Subscript[Π, y])(x) es ortogonal a y.

X = {(Subscript[x, 1]), (Subscript[x, 2]), (Subscript[x, 3])};
Y = {(Subscript[y, 1]), (Subscript[y, 2]), (Subscript[y, 3])};
Cross[X, Y]
X . Cross[X, Y] // Simplify
Y . Cross[X, Y] // Simplify
(X - X . (Y/Y) . Y Y) . Y // Simplify
Clear[X, Y]

En la definición de muchas magnitudes físicas intervienen el producto escalar o el producto vectorial. Los siguientes ejemplos son significativos.
Trabajo. El trabajo, W, realizado por una fuerza constante F (recuerda que la fuerza es un vector) al mover un objeto un desplazamiento d (vector desplazamiento) viene dado por el producto escalar W=F.d.
Momento de una fuerza (par de torsión). El momento, τ, también llamado par de torsión, de una fuerza F que actúa en un punto a del espacio con vector de posición (Subscript[r, a]) respecto de un punto b con vector de posición (Subscript[r, b]) está dado por el producto vectorial τ=((Subscript[r, a])-(Subscript[r, b]))×F.
Momento cinético (o momento angular). Sea una partícula de masa m, con una velocidad v situada en un punto cuyo vector de posición es r. El momento cinético, L, (respecto al origen) de dicha partícula se define como L=r×m v.
Fuerza magnética ejercida por un campo magnético sobre una carga. Una carga q que se mueve con velocidad v en un campo magnético constante B experimenta una fuerza magnética, (Subscript[F, m]), dada por (Subscript[F, m])=q v×B. De hecho, esta igualdad se usa para definir el vector B (que se llama también densidad de flujo magnético).

Con la primitiva gráfica Arrow[base,extremo,opciones] puedes representar un vector en el plano que va del punto "base" al punto "extremo". Necesitamos cargar el correspondiente paquete.

<<Graphics`Arrow`

Para usar colores con comodidad podemos cargar el paquete "Colors".

<<Graphics`Colors`

Show[
        Graphics[{Red, Arrow[{ .5, - .5}, {- .5, 1.5}], Blue, 
            Arrow[{- .5,  .5}, {1.5, - .5}]}, 
          AspectRatio -> Automatic, Axes -> True]];

Podemos modificar ese comando como sigue.

vector2D[x_: {0, 0}, y_]:=Arrow[x, x + y]

Show[
        Graphics[{Green, vector2D[{ .2,  .4}], Blue, 
            vector2D[{ .2,  .2}, { .2,  .4}], Red, PointSize[0.02], 
            Point[{ .2,  .2}]}, Axes -> True, 
          AspectRatio -> Automatic]];

Las bases ortonormales en (ℝ^2) son de la forma B = {(a, b), (-b, a)} donde (a^2) + (b^2) = 1. En la siguiente firgura puedes ver la representación de un vector de (ℝ^2) en una base ortonormal.

u = {((-1)/(Sqrt[2])), (1/(Sqrt[2]))}; v = {((-1)/(Sqrt[2])), ((-1)/(Sqrt[2]))}; 
    x = {1, 2};
Show[
        Graphics[{Green, vector2D[u], Green, vector2D[v], Red, vector2D[x], 
            Blue, vector2D[(x . u) u], vector2D[(x . v) v]}, 
          Axes -> True, AspectRatio -> Automatic]];

En la figura siguiente puedes ver, para el caso de dos dimensiones, una representación gráfica de la proyección ortogonal de un vector sobre otro.

x = {0.6, 0.3};
y = {0.8, - .4};
\(w = \((x . y)\)*y/\((y . y)\)\ \ ; \  (*\ 
      proyección\ ortogonal\ de\ x\ sobre\ y\ *) 

    z = x - w\ \ ; \  (*\ es\ un\ vector\ ortogonal\ a\ y\ *) 

    Show[Graphics[{Red, vector2D[x], vector2D[y], Blue, vector2D[w], Green, 
          vector2D[z], vector2D[w, z], Black, Text["z", z/2 + {0,  .1}], 
          Text["Tz", z/2 + {0,  .1} + w], Text["x", x/2 + {0,  .05}], 
          Text["y", 0.7*y - {0, 0.05}], Text["w", w/2 - {0,  .05}], 
          Text["O", {\(- .03\), \(- .03\)}], 
          Text["X", x + { .03,  .03}], Text["W", w - { .03,  .03}]}, 
        TextStyle -> {FontFamily -> "Times", \ FontSize -> 12}, 
        Axes -> True, AspectRatio -> Automatic, Ticks -> None]];\)
Print["w=(x.y)y/(y.y) es la proyeccción ortogonal de x sobre \
y \nz=x-w es un vector ortogonal a y\nTz es la traslación del vector \
z alPunto W\nEl triángulo OWX es rectángulo\nOberva que \
||z||=||Tz|| es la distancia del punto X a la recta vectorial\ngenerada por \
el vector y"]
z . y // Chop   
Clear[x, y, w, z]

Vamos a definir un comando para representar vectores en el espacio. Necesitamos algunos comandos previos que tienen su propio interés.

\(\(\(norma[x_] := N[\@\(x . x\)]\  (*\ 
      norma\ euclídea\ del\ vector\ x\ *) 

    \(\(normaliza[x_]\  := If[Simplify[x . x] == 0, x, \ x/norma[x]]; \  (*\ 
      vector\ unitario\ en\ la\ dirección\ del\ vector\ x\ *) 

    normal3D[x_]\  := \ 
      normaliza[
        Which[x[\([1]\)] == 0, {1, 0, 
            0}, \((x[\([2]\)] ≠ 
                0)\) ∨ \((x[\([3]\)] ≠ 0)\), {0, 
            x[\([3]\)], \(-x[\([2]\)]\)}, \((x[\([2]\)] == 0 ∧ 
              x[\([3]\)] == 0)\), {0, 1, 0}]]\)\(
\)
    \)\)\( (*\ 
      un\ vector\ unitario\ ortogonal\ al\ vector\ x\ *) \)\)\)

\(\(\(\(arrow3D[x_, y_, color_:  RGBColor[0. , 0. , 0. ], 
          grosor_:  0.007] := 
			{{color, Thickness[grosor], 
            Line[{x, y}]}, 
\ \ \ \ \ {SurfaceColor[
              color], \ \(Polygon[
                  Append[#, 
                    y]] &\)\  /@ \ 
						Partition[\(\((y\ \  - \ 
                        0.18*\((y - x)\) + \ #)\) &\) /@ \((\((0.3*\ 0.18*
                          norma[y - x]*\ 
                          Table[{Cos[2\ k\ Pi/8. ], \ Sin[2\ k\ Pi/8. ]}, {k, 
                              0, 8}])\) . {normal3D[y - x], 
                        normaliza[Cross[normal3D[y - x], y - x]]})\), 2, 
                1]}};\)

    vector3D[x_List: {0, 0, 0}, y_List, color_:  RGBColor[0. , 0. , 0. ], 
        grosor_:  0.007] := arrow3D[x, x + y, color, grosor]\)\(\ \)\( (*\ 
      traslación\ del\ vector\ y\ al\ punto\ x\ *) \)\)\)

Show[
        Graphics3D[{vector3D[{1, 2, 3}, Blue,  .02], 
            vector3D[{ .5,  .5,  .5}, {1, 2, 3}, Green,  .02]}, Axes -> True, 
          PlotRange -> All]];

En la figura siguiente puedes ver, para el caso de tres dimensiones, una representación gráfica de la proyección ortogonal de un vector sobre otro y una interpretación gráfica del número ||x×
            y|| = ||x||||y||sen(
            t) como el área del paralelogramo construído sobre los vectores x e  y.

x = {1, 1, 1};
y = 1.5 {(Sqrt[1.5]), (Sqrt[1.5]), 0};
w = (x . y)*y/(y . y)     ;
\(z = x - w\ \ ; \  (*\ es\ un\ vector\ ortogonal\ a\ y\ *) 

    Show[Graphics3D[{vector3D[x, Red], vector3D[y, Red], vector3D[w, Blue], 
          vector3D[z, Green], vector3D[w, z, Green], Line[{x, x + y}], 
          Line[{y, x + y}], Text["z", z/2 + {0,  .15, 0}], 
          Text["x", x/2 + {0,  .05, 0.18}], 
          Text["y", 0.7*y - {0, 0.05, 0.1}], 
          Text["w", w/2 - {0,  .05, 0.1}], 
          Text["Tz", w +  .5*z + { .15, 0, 0}], 
          Text["O", {\(- .03\), \(- .03\), \(- .15\)}], 
          Text["X", x + { .03,  .03, 0.15}], 
          Text["W", w - { .03,  .03, 0.2}], 
          Text["t", { .2,  .4, 0.02}]}, 
        TextStyle -> {FontFamily -> "Times", \ FontSize -> 12}, 
        Axes -> True, AspectRatio -> Automatic, Ticks -> None, 
        Epilog -> {Circle[{0. , 
                0.3},  .2, {π/8 -  .09, π/8 +  .18}], {Blue, 
              Thickness[0.007], 
              Line[{{0.08, 0.34}, {0.35, 0.386}}]}}]];\)
Print["w=(x.y)y/(y.y) es la proyeccción ortogonal de x sobre \
y \nz=x-w es un vector ortogonal a y\nTz es la traslación del vector \
z al punto W\nEl triángulo OWX es rectángulo\n\
||Tz||=||x||sen(t) (longitud de la hipotenusa por el seno del ángulo \
opuesto)\nEl área del paralelogramo construído sobre los \
vectores x e y\nviene dada por ||x×y||=||y||||x||sen(t) (longitud de \
la base por la altura)"]
z . y // Chop   
Clear[x, y, w, z]

Ejercicio 5

Es conveniente disponer de un comando para representar los ejes de coordenadas.

\(ejes3D[u_, v_, w_:  0.006, color_:  Black]\  := \ \ {color, 
        Thickness[w], 
        Line[{{u, 0, 0}, {v, 0, 0}}], 
\ \ \ \ Line[{{0, u, 0}, {0, v, 0}}], 
        Line[{{0, 0, u}, {0, 0, v}}]}\)

u = {1,  .6,  .3};
v = {- .2, - .3, 1};
w = Cross[u, v];
graf = 
        Show[Graphics3D[{vector3D[u, Blue,  .01], 
              Text["u", u/2 + { .1,  .1,  .1}], vector3D[v, Red,  .01], 
              Text["v", v/2 + { .02,  .1,  .1}], 
              vector3D[w, Green,  .01], Text["w", w/2 + { .1,  .1,  .1}], 
              ejes3D[-0.4, 1.5]}, Boxed -> False, 
            PlotRange -> All]];
\(Print["El producto vectorial w=u×v es ortogonal a u y a v"]\ \)
Clear[u, v, w]

<<Graphics`Animation`

SpinShow[graf]
SelectionMove[EvaluationNotebook[], All, GeneratedCell];
FrontEndTokenExecute["CellGroup"]
FrontEndTokenExecute["OpenCloseGroup"]
Clear[graf]

El producto x . (y×z) se llama triple producto escalar de los vectores x, y, z. El volumen del paralelepípedo determinado por los vectores x, y, z es igual a  | x . (y×z) | . Podemos comprobarlo gráficamente.

u = 1.5 {0.6, -0.3, 1.2};
v = {1.5, 0.0, 0.0};
w = 1.5 {0.3, 1.2, 0.0};
vxw = Cross[v, w];
\(Π = \((u . \((vxw)\)/vxw . vxw)\) vxw; \  (*\ 
      proyección\ ortogonal\ de\ u\ sobre\ vxw\ *) 

    Show[Graphics3D[{vector3D[u, Red,  .01], 
          Text["u", u/2 + {\(- .12\), 0, 0}], vector3D[v, Red,  .01], 
          Text["v", v/2 + {0,  .15, 0}], vector3D[w, Red,  .01], 
          Text["w", w/2 + {0, 0,  .15}], vector3D[vxw, Green,  .01], 
          Text["v×w",  .9  vxw + {\(- .3\), 0, 0}], 
          vector3D[Π, Blue,  .01], Line[{u, u + w, w}], 
          Text["Π", Π/2 + {\(- .2\), 0, 0}], 
          Line[{u, u + v, v}], Line[{w, v + w, v}], 
          Line[{v + w, u + v + w, u + v}], Line[{u + v + w, u + w}], 
          Line[{u, Π}]}, Boxed -> False, PlotRange -> All, 
        TextStyle -> {FontFamily -> "Times", \ 
            FontSize -> 11}]];\)
Print["El volumen del paralelogramo determinado por los vectores u, v \
y w\nes igual al producto del área de la base por la altura.\nEl \
área de la base es igual a ||v×w||\nLa altura es igual a la \
norma del vector Π que es\nla proyección ortogonal del \
vector u sobre el vector v×w\n||Π||=|u.(v×w)|/||v\
×w||\nPor tanto el volumen del paralelepípedo es igual a |u.(v\
×w)|"] 
Clear[u, v, w, vxw, Π]

La siguiente gráfica ilustra la forma de calcular la distancia de un punto p = (1, 2, 3) al plano Π engendrado por los vectores x = (1, 0, 1) e y = (1, 2, 0) .

x = {1, 0, 1};
\(y = {1, 2, 0};  (*\ 
      los\ vectores\ x\ e\ y\ son\ una\ base\ del\ plano\ Π\ *) 

    y = y - \((y . x/x . x)\)*x\ ;  (*\ vector\ ortogonal\ a\ x\ *) 

    v1 = x/norma[x]; 
    v2 = y/norma[y];  (*\ {v1, 
          v2}\ es\ una\ base\ ortonormal\ del\ plano\ Π\ *) 

    p = {1, 2, 3};\)
w1 = (p . v1)*v1     ;
w2 = (p . v2)*v2     ;
\(z = p - w1 - w2\ \ ;  (*\ 
      es\ un\ vector\ ortogonal\ a\ v1\ y\ a\ v2\ y, \ 
      por\ tanto\ es\ ortogonal\ al\ plano\ Π\ *) 

    Show[Graphics3D[{vector3D[2  v1, Red], vector3D[2  v2, Red], 
          vector3D[p, Blue], 
          vector3D[z, Green], {Magenta, \ 
            Line[{v1, 3  v1, 3 \((v1 + v2)\), 3  v2, v2}]}, 
          vector3D[w1 + w2, z, Green], vector3D[w1 + w2, Cyan], 
          Text["v1", v1 - {0, 0, 1}], 
          Text["v2", v2 + {0,  .8, \(- .1\)}], 
          Text["p", p + {0,  .12,  .12}], 
          Text["z", z - {0, \(- .25\), 3}], 
          Text["w1+w2", w1 + w2 - {0,  .3,  .1}], 
          Text["Π", w1 + w2 + {0,  .3, 1}], 
          Text["Tz", p - {0, \(-0.1\), 3}]}, AspectRatio -> Automatic, 
        Ticks -> None, Boxed -> False, PlotRange -> All, 
        ViewPoint -> {0.767, \ \(-0.731\), \ 3.214}, 
        TextStyle -> {FontFamily -> "Times", \ 
            FontSize -> 12}]];\)
Print["{v1,v2} es una base ortonormal de Π\nw1+w2 es la \
proyección ortogonal de p sobre el plano Π\nz=p-w1-w2 es \
un vector ortogonal a π\nTz se obtiene por traslación de z\nLa \
distancia del punto p al plano π es igual a ||Tz||=||z||= ", 
      norma[z]] 
\(	Clear[x, y, v1, v2, w1, w2, z, p]\)

Ejercicio 6

Ejercicio 7

\(TraditionalForm\`\(\(|\)\(A\ a\  + \ B\ b\  + C\ c\  + \ D\)\(|\)\)\/\(\(||\)\((A, B, C)\)\(||\)\(\ \)\)\)

Curvas en el plano

En todo lo que sigue consideraremos funciones de una o varias variables con derivada continua o con derivadas parciales de primer orden continuas respectivamente.
Una curva Γ en el plano puede venir dada de tres formas:
a) Como la gráfica de una función f : I -> ℝ donde I es un intervalo de ℝ: Γ = {(x, f(x)) : 
            x ∈ I}.
b) De forma implícita como el conjunto de puntos donde se anula una función de dos variables: Γ = {(x, 
                        y) ∈ (ℝ^2):g(x, y)=0}.
c) Por medio de ecuaciones paramétricas γ(t) = (x(t), y(t)) donde t ∈ I siendo I un intervalo de ℝ: Γ = γ(
            I) = {(x(t), y(t)) : t ∈ I}.
Observa que a) es un caso particular de b)  pues la gráfica de una función f es el conjunto de puntos donde se anula la función de dos variables g(x, y) = f(x) - y, y también es un caso particular de c)  pues la gráfica de una función  f  tiene como ecuaciones paramétricas  γ(x) = (x, f(x)).

Para cada uno de estos casos Mathematica tiene un comando que permite representar la curva dada:
Plot[f[x],{x,a,b},opciones]  representa la gráfica de la función f en el intervalo [a,b].
ImplicitPlot[g(x,y)==0,{x,a,b},opciones] representa la gráfica de la curva {(x, y) ∈ (ℝ^2):g(x, y)=0, a ≤ x ≤ b}.
ParametricPlot[{x[t],y[t]},{t,a,b},opciones]  representa la gráfica de la curva de ecuaciones paramétricas γ(t) = (x(t), y(t)) para  t ∈ [a, b].

f[x_] := (1/5) Cos[(x^2)] (E^Sin)[2 x]
\(\(graf1 = 
        Plot[f[x], {x, \(-2\), 3}, 

          PlotRange -> {{\(-2.1\), 3.5}, {\(- .5\),  .5}}, 

          AspectRatio -> Automatic, 
PlotStyle -> Thickness[ .004], 
	
          Ticks -> None, ImageSize -> {407, \ 73}];\)\)

<<  Graphics`ImplicitPlot`  (* 
      Hay que cargar este paquete para poder usar el comando *)

\(\(\(g[x_, y_] := x\^2\/9 + y\^2\/3 - 1

    \(\(graf2 = ImplicitPlot[g[x, y] == 0, {x, \(-3\), 3}];\)\(
\)
    \)\)\( (*\ 
      Una\ curva\ definida\ implícitamente\ *) \)\)\)

graf3=ParametricPlot[{Cos[3  t/5], Sin[2  t/5]},{t, 0, 10  Pi},
		AspectRatio -> Automatic] ;
 (* 
        Una curva definida por sus ecuaciones paramétricas *)

Las curvas planas más sencillas son las cónicas que se definen como el conjunto de puntos donde se anula una función polinómica de grado dos con dos variables.

ImplicitPlot[
        2 x *y  -  (x^2) + (y^2) - 4 == 0, {x, -5, 5}];

Recta tangente en un punto de una curva plana

El cálculo de la recta tangente depende de cómo venga dada la curva. Consideremos los tres casos posibles.

a) La tangente en un punto (a, 
          b) = (a, f(a)) ∈ Γ es la recta de ecuación cartesiana y - b = f ' (a) (x - a). El vector (1, f ' (a)) es tangente a Γ en el punto (a, b) y el vector (f ' (a), -1) es ortogonal a Γ en el punto (a, b).
b) La tangente en un punto (a, b) ∈ Γ es la recta de ecuación implícita ⟨∇g(a, 
                b) | (x - a, 
              y - b)⟩ = 0. Se supone que ∇g(a, b) ≠  (0, 0) pues en otro caso, la tangente en (a, b) no está definida. El vector gradiente ∇g(a, b) es ortogonal a Γ en el punto (a, b).
c) Supuesto que γ' ((Subscript[t, 0]))≠(0, 0), la tangente a γ en (Subscript[t, 0]) (suele decirse, aunque no es del todo correcto, vector tangente a Γ en el punto γ((Subscript[t, 0]))) es la recta de ecuaciones paramétricas (x, y) = γ((Subscript[t, 0])) + t γ' ((Subscript[t, 0])) . El vector γ' ((Subscript[t, 0]))=(x' ((Subscript[t, 0])),y' ((Subscript[t, 0]))) es tangente a γ en (Subscript[t, 0]) (suele decirse, aunque no es del todo correcto, vector tangente a Γ en γ((Subscript[t, 0]))). En los puntos en los que el vector derivada es el vector cero no está definida la tangente.

Las siguientes gráficas ilustran estos conceptos.

\(\(vectgnte1 = 
        Graphics[
		Table[{{Hue[ .65], 
                vector2D[{x, f[x]}, {1, \(f'\)[x]}]}, {Hue[0], 
                PointSize[ .012], Point[{x, f[x]}]}}, {x, \(-1.8\), 
              2.3,  .5}]
					];\)\)
Show[{graf1, vectgnte1}, ImageSize -> {407,  73}];
Clear[f, graf1, vectgnte1]

gradg[x_, y_] = {D[g[x, y], x], D[g[x, y], y]};
\(puntos = 
      Union[graf2[\([1, 1, 1, 1, 1, 1]\)], 
        graf2[\([1, 1, 1, 2, 1, 1]\)]];  (*\ 
      así\ obtengo\ una\ lista\ con\ los\ puntos\ de\ la\ gráfica\ *) 

    vectores = puntos /. {x_, y_} -> vector2D[{x, y}, gradg[x, y]];
 (*\ 
      vectores\ gradiente\ con\ base\ en\ los\ puntos\ *) \)
\(\(vectortgnal2 = 
        Graphics[
Table[{{Hue[ .65], 
                vectores[\([k]\)]}, {Hue[0], PointSize[ .015], 
                Point[puntos[\([k]\)]]}}, {k, 1, 
              Length[puntos]}]
					];\)\)
Show[{graf2, vectortgnal2}];
Clear[graf2, puntos, vectores, vectortgnal2, g, gradg]

γ[t_]={Cos[3  t/5], Sin[2  t/5]};
\(vectgnte3 = 
          Graphics[
		Table[{{Hue[ .65], 
                  vector2D[γ[t], \(γ'\)[t]]}, {Hue[0], 
                  PointSize[ .015], Point[γ[t]]}}, {t, 0, 10  π, 
                2. }]
					]\);											
Show[{graf3, 
          vectgnte3}];

Podemos interpretar una curva γ(t) = (x(t), y(t)) como la trayectoria que recorre un móvil cuyo vector de posición en el instante t viene dado por γ(t) = (x(t), y(t)). En tal caso, el vector derivada, \(TraditionalForm
      \`γ' \((t)\) = \((x' \((t)\), y' \((t)\))\)\)  es la velocidad del móvil en el instante t y la norma euclídea de dicho vector, \(TraditionalForm
      \`\(\( || γ'\) \((t)\) || \) = 
        \@\(x' \((t)\)\^2 + y' \((t)\)\^2\)\) es la rapidez o celeridad del móvil en el instante t. La distancia recorrida por el móvil desde el instante t = a hasta el instante t = b se obtiene, como es natural, integrando la rapidez y viene dada por \(TraditionalForm
      \`∫\_a\%b\(\( || γ'\) \((t)\) || 
          dt\)\). Dicho de otra forma: la longitud de la curva γ(t) = (x(t), y(t)), donde a ≤ t ≤ b, viene dada por \(TraditionalForm
      \`∫\_a\%b\(\( || γ'\) \((t)\) || 
          dt\)\).

Una curva γ(t) = (x(t), y(t)) se dice que es suave si tiene derivada \(TraditionalForm
      \`γ' \((t)\) = \((x' \((t)\), y' \((t)\))\)\) continua y que no se anula nunca. En tal caso se define el vector tangente unitario como

T(t)=((γ' (t))/( || γ' (t) ||  ))

Como \(TraditionalForm
      \`⟨T(t)\  | \ T(t)⟩ = 1\), se deduce que \(TraditionalForm
      \`⟨T' \((t)\)\  | \ T(t)⟩ = 0\), es decir, supuesto que T' (t) ≠ (0, 0), el vector T' (t) es ortogonal al vector tangente. Se define por ello el vector normal unitario a la curva como

N(t)=((T'(t))/(||T'(t)|| ))

Es fácil definir comandos que calculen dichos vectores.

tgtunit[func_, 
          t_] = func'[t]/(Sqrt[func'[t] . func'[t]]);
normalunit[func_, t_] := 
      Module[{s}, normaliza[D[tgtunit[func, s], s]] /. s -> t]

\(\(vectgnteunit = 
        Graphics[
		Table[{{Hue[ .65], 
                vector2D[γ[t], tgtunit[γ, t]]}, {Hue[0], 
                PointSize[ .015], Point[γ[t]]}}, {t, 0, 10  π, 
              5. }]];\)\)
\(\(vectnormalunit = 
        Graphics[
		Table[{Hue[ .25], 
              vector2D[γ[t], normalunit[γ, t]]}, {t, 0, 
              10  π, 5. }]];\)\)
Show[{graf3, vectgnteunit, vectnormalunit}];
Clear[graf3, vectgnteunit, vectnormalunit, vectgnte3]

Ejercicio 8

((x^2)/((a^2) ))+((y^2)/((b^2) ))=1

Ejercicio 9

El siguiente ejercicio pone de manifiesto que la forma geométrica de una curva no proporciona información sobre la derivabilidad de la misma ni sobre su longitud. Lo importante de una curva es cómo se recorre dicha curva, es decir, la función que la define.

Ejercicio 10

Si f(x, y) es un campo escalar de dos variables, las curvas de ecuación implícita f(x, y) = c o, lo que es igual f(x, y) - c = 0, donde c es una constante, se llaman curvas de nivel. De lo dicho antes, se sigue que el vector gradiente ∇f(x, y) es ortogonal en todo punto (x, y) (en el que ∇f(x, y) ≠ (0, 0)) a la curva de nivel que pasa por dicho punto. Podemos representar varias curvas de nivel de una función usando el comando

"ContourPlot[f[x,y],{x,xmin,xmax},{y,ymin,ymax},opciones]"

que representa curvas de nivel, f(x, y) = c, para una sucesión de valores de c igualmente espaciados. Con la opción "Contours->{valores}" puedes especificar para qué valores de c quieres que se representen las curvas de nivel .

ContourPlot[x^2/4 + y^2/9, {x, -2, 2}, {y, -3, 3}, 
        Contours -> Table[c, {c,  .1, 1,  .2}], AspectRatio -> Automatic, 
        ContourShading -> False, PlotPoints -> 25, Axes -> True, 
        AxesOrigin -> {0, 0}, Frame -> False];

Curvas paramétricas en el espacio. Velocidad, aceleración, curvatura.

Las definiciones que hemos dado antes para curvas paramétrica en el plano pueden generalizarse sin esfuerzo a curvas paramétricas en (ℝ^n). Como en las aplicaciones físicas el caso n = 3 tiene especial importancia, consideraremos en lo que sigue curvas en (ℝ^3) aunque la mayoría de los conceptos que vamos a estudiar se generalizan fácilmente a (ℝ^n). 
Por definición, una curva en (ℝ^3) es una aplicación continua γ : [a, b]->(ℝ^3). La función γ debe ser de la forma

γ(t)=(x(t), y(t), z(t))=x(t)i+y(t)j+z(t)k

En lo que sigue supondremos que las funciones x(t),  y(t),  z(t) son derivables con derivada continua en el intervalo [a, b]. El punto γ(a) se llama punto inicial de la curva u origen y el punto γ(b) se llama punto final o extremo. Cuando γ(a) = γ(b) se dice que la curva es cerrada. Una curva se dice que es simple si pasa una sola vez por cada uno de sus puntos, es decir si no se corta a sí misma o, lo que es igual, la función γ es inyectiva en [a, b], o sea, γ(u) ≠ γ(v) siempre que u, v ∈ [a, b] y u ≠ v. Una curva cerrada se dice que es simple si γ es inyectiva en [a, b[. Una curva cerrada y simple se llama una curva de Jordan.

El comando ParametricPlot3D[{X[t],Y[t],Z[t]},{t,tmin,tmax},opciones] sirve para representar curvas en (ℝ^3) dadas por sus ecuaciones paramétricas. Si añades al final una función de color, como en el siguiente ejemplo donde se usa la función de color "Hue[ ]", los puntos de la curva se colorean variando los colores de forma continua. También puedes controlar el grosor de la línea con "Thickness[ ]".

helice = 
      ParametricPlot3D[{3  Cos[t], 3  Sin[t], 
          t, {Hue[t/3  π], Thickness[ .01]}}, {t, 0, 3  π}, 
        Ticks -> None];

Podemos interpretar una curva γ(t) = (x(t), y(t),  z(t)) como la trayectoria en (ℝ^3)que recorre un móvil cuyo vector de posición en el instante t viene dado por γ(t) = (x(t), y(t),  z(t)). Se dice entonces que γ es la función de trayectoria del móvil. En tal caso, el vector derivada, \(TraditionalForm
      \`γ' \((t)\) = \((x' \((t)\), y' \((t)\), \ z' \((t)\))\)\)  es la velocidad del móvil en el instante t y la norma euclídea de dicho vector, \(TraditionalForm
      \`\(\( || γ'\) \((t)\) || \) = 
        \@\(x' \((t)\)\^2 + y' \((t)\)\^2 + z' \((t)\)\^2\)\) es la rapidez o celeridad del móvil en el instante t. Debes tener clara la diferencia entre estos conceptos.

Una curva γ(t) = (x(t), y(t),  z(t)) se dice que es suave si tiene derivada \(TraditionalForm
      \`γ' \((t)\) = \((x' \((t)\), y' \((t)\), \ z' \((t)\))\)\) continua y que no se anula nunca. En tal caso se define el vector tangente unitario como

T(t)=((γ' (t))/( || γ' (t) ||  ))

Como ⟨T(t) | T(t)⟩=1, se deduce que ⟨T '(t) | T(t)⟩=0, es decir, supuesto que T '(t)≠(0, 0, 0), el vector T '(t) es ortogonal al vector tangente.

Ejercicio 11

Se define por ello el vector normal principal unitario a la curva como

N(t)=((T'(t))/(||T'(t)|| ))

Observa que los comandos que antes hemos definido "tgtunit[ ]" y "normalunit[ ]" podemos usarlos también para curvas en (ℝ^3).

Se define el vector binormal como el producto vectorial del vector tangente unitario por el vector normal principal unitario

B(t)=T(t)×N(t)

Es claro, por las definiciones dadas, que, cualquiera sea t, el sistema {T(t),N(t),B(t)} es una base ortonormal de (ℝ^3) que se llama el triedro intrínseco de la curva γ. Podemos visualizarlo (multiplicamos por 2 los vectores de la base para verlos mejor).

γ[t_] := {3  Cos[t], 3  Sin[t], t};
\(\(vectgnteunit = 
        Graphics3D[
		Table[{{vector3D[γ[t], 
                  2  tgtunit[γ, t]]}, {Red, PointSize[ .02], 
                Point[γ[t]]}}, {t, 0, 3  π, 
              N[π/2]}]];\)\)
\(\(vectnormalunit = 
        Graphics3D[
		Table[{vector3D[γ[t], 
                2  normalunit[γ, t]]}, {t, 0, 3  π, 
              N[π/2]}]];\)\)
\(\(binormalunit = 
        Graphics3D[
		Table[{vector3D[γ[t], 
                2  Cross[tgtunit[γ, t], 
                    normalunit[γ, t]]]}, {t, 0, 3  π, 
              N[π/2]}]];\)\)
Show[{helice, vectgnteunit, vectnormalunit, 
          binormalunit}];
Print["En la gráfica se ha representado la base \
{T(t),N(t),B(t)} para distintos \nvalores de t trasladándola al punto \
correspondiente de la curva."]
Clear[γ, helice, vectgnteunit, vectnormalunit, 
      binormalunit]

La distancia recorrida por el móvil desde el instante t = a hasta el instante t = b se obtiene, como es natural, integrando la rapidez y viene dada por \(TraditionalForm
      \`∫\_a\%b\(\( || γ'\) \((t)\) || 
          dt\)\). Dicho de otra forma: la longitud de la curva γ(t) = (x(t), y(t), z(t)), donde a ≤ t ≤ b, viene dada por

(∫_a^b) || γ' (t)||dt=(∫_a^b)
              (Sqrt[ x' (((t))^2) + y' (((t))^2) + z' (((t))^2)]) 
              dt

La función s : [a, b] -> ℝ definida para todo t ∈ [a, b] por

s(t)=(∫_a^t)\(\(||\)\(γ' \((u)\)\)\(||\)\(du\)\)=(∫_a^t)(Sqrt[ x' (((u))^2) + y' (((u))^2) + 
                      z' (((u))^2)]) du

se llama función longitud de arco y nos da la distancia recorrida por el móvil hasta el instante t. Por su definición, es claro que s(t) es una primitiva de ||γ' (t)||, es decir, \(TraditionalForm\`s' \((t)\) = \(\(\(\(||\)\(γ'\)\) \((t)\)\)\(||\)\)\). Observa que la igualdad s' (t)=(Sqrt[x' (((t))^2) + y' (((t))^2) + z' (((t))^2)]) tiene una intrepretación física clara: la derivada del espacio recorrido respecto al tiempo es la rapidez. Esta igualdad suele expresarse en la forma

ds=(Sqrt[d(x^2) + d(y^2) + 
                d(z^2)])

y a ds se le llama elemento diferencial de longitud de arco.

Se define la aceleración como la derivada de la velocidad, es decir, la derivada segunda, \(TraditionalForm
      \`\(γ'\)' \((t)\) = 
        \((\(x'\)' \((t)\), \(y'\)' \((t)\), \(z'\)' \((t)\))\)\), de la función de trayectoria. En física son frecuentes las siguientes notaciones:
r(t) para representar la función de trayectoria que hemos representado por γ(t); r(t)=(x(t), y(t), z(t))=x(t)i+y(t)j+z(t)k (es un vector).
v(t) para representar la velocidad; v(t)=r '(t)=(x' (t), y' (t),  z' (t))=x'(t)i+y'(t)j+z'(t)k (es un vector).
v(t) para representar la rapidez;  v(t)=||v(t)||=(Sqrt[x' (((t))^2) + y' (((t))^2) + z' (((t))^2)])(es un número).
a(t) para representar la aceleración; a(t)=v'(t)=r ''(t)=(x'' (t), y'' (t), z'' (t))=x''(t)i+y''(t)j+z''(t)k (es un vector).
Seguiremos estas notaciones de aquí en adelante.

Como en todo instante t el triedro intrínseco {T(t), N(t), B(t)} forma una base ortonormal de (ℝ^3), podemos referir a dicha base cualquier vector u∈(ℝ^3) y sabemos que dicho vector es igual a la suma de sus proyecciones ortogonales sobre los elementos de dicha base, esto es:

u=⟨u | T(t)⟩T(t)+⟨u | N(t)⟩N(t)+⟨u | B(t)⟩B(t)

Como el vector velocidad tiene la dirección del vector T(t) se sigue que ⟨v(t)| N(t)⟩=⟨v(t)| B(t)⟩=0, por lo que

v(t)=⟨v(t) | T(t)⟩T(t)=⟨v(t)  |((v(t) )/(||v (t) || ))⟩T(t)=||v(t)||T(t)=v(t)T(t)

Es decir, las componentes del vector velocidad en el triedro intrínseco son (v(t), 0, 0).
Derivando la igualdad anterior obtenemos:

a(t)=v'(t)=v'(t)T(t)+v(t)T '(t)=v'(t)T(t)+v(t)||T '(t)|| N(t)

que es la expresión del vector aceleración en el triedro intrínseco. Esta igualdad nos dice que el vector aceleración está siempre situado en el plano engendrado por los vectores T(t) y N(t) por lo que ⟨a(t)| B(t)⟩=0, ⟨a(t)| T(t)⟩=v' (t) y ⟨a(t)| N(t)⟩=v(t)||T '(t)||. El vector (Subscript[a, T])(t)=v'(t)T(t), que es la proyección ortogonal de la aceleración sobre el vector tangente unitario, se llama aceleración tangencial. El vector (Subscript[a, N])(t)=v(t)||T '(t)|| N(t), que es la proyección ortogonal de la aceleración sobre el vector normal principal, se llama aceleración normal. Es decir, las componentes del vector aceleración en el triedro intrínseco son (v' (t),v(t)||T '(t)||,0).

Advertencia. En muchos textos de física se llama aceleración tangencial a la norma del vector (Subscript[a, T])(t)=v'(t)T(t) y la representan por (Subscript[a, T])(t) = v ' (t), es decir, la aceleración tangencial es la derivada de la rapidez. Esta aceleración representa la variación de la velocidad en la dirección del movimiento y cuando un vehículo acelera es la que hace que tu espalda se pegue al asiento. Así mismo, es frecuente llamar aceleración normal y también aceleración centrípeta a la norma del vector (Subscript[a, N])(t)=v(t)||T '(t)|| N(t) y representarla por (Subscript[a, N])(t)=v(t)||T '(t)|| . Esta aceleración representa la variación de la dirección del vector tangente unitario, tiene la dirección de la normal a la curva y es la responsable de que cuando un vehículo toma una curva te sientas empujado contra una puerta.

Expresiones útiles para las aceleraciones tangencial y normal se deducen de las igualdades

⟨r '(t)|r''(t)⟩=⟨v(t) | a(t)⟩=⟨v(t)T(t) | v'(t)T(t)+v(t)||T '(t)|| N(t)⟩=v(t) v' (t)

r '(t)×r''(t)=v(t) × a(t)=v(t)T(t) ×( v'(t)T(t)+v(t)||T '(t)|| N(t))=((v(t))^2)||T '(t)||B(t)

de donde

(Subscript[a, T])(t)=v'(t)=((⟨v(t)|a(t)⟩)/(v(t)))=((⟨r '(t)|r''(t)⟩)/(||r '(t)|| ))

(Subscript[a, N])(t)=v(t)||T '(t)||=((||v(t)×a(t)||)/(v(t)))=((||r '(t)×r''(t)||)/(||r '(t)|| ))

La curvatura de una curva suave r(t) es, por definición, el número

κ (t)=((||r '(t)×r''(t)||)/(||r '(t)\( || \^3\)))

en consecuencia, obtenemos la siguiente expresión para la aceleración normal

(Subscript[a, N])(t)=κ(t)v(((t))^2)

Obtenemos así la expresión

a(t)=v'(t)T(t)+κ(t)((v(t))^2) N(t)

El radio de curvatura se define como

ρ (t) = (1/(κ (t)))

por tanto, también podemos escribir

(Subscript[a, N])(t)=((v(((t))^2))/(ρ (t)))

Observación. En algunas de las fórmulas anteriores interviene el producto vectorial. Te recuerdo que este producto solamente está definido para vectores de (ℝ^3) por lo que dichas fórmulas solamente tienen sentido para curvas en el espacio. Pueden particularizarse dichas fórmulas para curvas en (ℝ^2) de la forma que sigue. Dada una curva en (ℝ^2), γ(t) = (x(t), y(t)), podemos asociarle una curva en (ℝ^3) por la igualdad λ(t) = (x(t), y(t), 0) es decir, se trata de la "misma curva plana γ vista dentro del espacio tridimensional". Podemos ahora particularizar las expresiones anteriores para λ y así obtenemos las siguientes igualdades:
La curvatura de una curva plana suave r(t)=(x(t), y(t)) viene dada por

κ(t)=((||r '(t)×r''(t)||)/(||r '(t)\( || \^3\)))=((||(x' (t), y' (t), 0)×(x''(t),y'' (t),0)||)/(||(x' (t), y' (t), 0)\( || \^3\)))=((|x' (t) y'' (t) - x''(t)y'(t)|)/((((((x' (t)))^2)+(((y' (t)))^2)))^(3/
                    2)))

Si en la última expresión suprimimos el valor absoluto se obtiene lo que se llama "curvatura con signo". Podemos particularizar la expresión obtenida para el caso de que la curva venga dada como la gráfica de una función f, es decir, por medio de una función del tipo γ(x) = (x, f(x)). En este caso es fácil obtener que la curvatura (con signo) viene dada por

κ(x)=((f ''(x))/(((1+(((f'(x)))^2)))^(3/2)))

En este caso la curvatura es positiva donde la curva es convexa (f'' (x) > 0) y es negativa donde la curva es cóncava (f'' (x) < 0).

La (norma de la) componente normal de la aceleración de una curva plana suave r(t)=(x(t), y(t)) viene dada por

(Subscript[a, N])(t)=v(t)||T '(t)||=((||v(t)×a(t)||)/(v(t)))=((||r '(t)×r''(t)||)/(||r '(t)|| ))=((|x' (t) y'' (t) - x''(t)y'(t)|)/((((((x' (t)))^2)+(((y' (t)))^2)))^(1/
                      2)))

Finalmente, te recuerdo la segunda ley del movimiento de Newton, F(t)= m a(t), donde F(t) es la resultante de todas las fuerzas que actúan sobre un objeto de masa m y a(t) es la aceleración que experimenta dicho objeto en el instante t. Conociendo la aceleración es fácil calcular, por integración componente a componente, la velocidad y la función de trayectoria.

Ejercicio 12

Ejercicio 13

Ejercicio 14 (movimiento circular)

Ejercicio 15

Ejercicio 16

Ejercicio 17