El algebra computacional o computo simbolico permite la manipulación y representación de expresiones y objetos matematicos de forma exacta y proceder de forma programatica en soluciones analiticas de los problemas y no limitado solo a los casos numericos como sucede en el computo tradicional. Dentro de los objetos matematicos a representar y manipular incluso se definen los numeros, permitiendo trabajar sin la presencia del redondeo de punto flotante.  

En este curso se explora el uso de _Sympy_, un paquete python se computo simbolico que ha tomado mucha fuerza en los últimos años y con un interesante sistema en línea que emula las caracteristicas de [Wolfram Alpha](http://www.wolframalpha.com/), denominado [Sympy Gamma](http://gamma.sympy.org/) (tambien existe [Sympy Live](http://live.sympy.org/) para probar sin instalar). Tambien se recomienda su exploración a nivel personal del paquete [Maxima](http://maxima.sourceforge.net/) (con interface gráfica recomendada de [WxMaxima](http://andrejv.github.io/wxmaxima/)).  

# Motivación  

Para entender su necesidad, se ilustran algunos ejemplos básicos como motivación, sin contar que esto extiende su potencial a la contribución en el desarrollo de procesos analiticos bastante extensos donde su desarrollo manual podría llevar facilmente a errores. Hoy, incluso, existen sistemas de computo simbolico que asisten demostraciones matematicas sin intervencion humana más que la inclusión formal del teorema.  

La siguiente ejemplificación es suponiendo un sistema de calculo cuya representación solo permita manipular números a 5 cifras significativas (para hacer más notable el efecto numerico).  

\begin{equation}
\begin{array}{|c|c|c|}
\hline
\text{Expresión a evaluar} & \text{Resultado Simbolico} & \text{Resultado Numerico}\\
\hline
\pi & \pi & 3.1416\\
\frac{1}{3} & \frac{1}{3} & 0.33333\\
\frac{1}{3} + \frac{1}{3} + \frac{1}{3} & 1 & 0.99999\\
\sin(\pi) & 0 & -7.3464 \cdot 10^{-6}\\
\frac{2xa+ax^2}{a} & 2x + x^2 & \text{No se reconoce 'a' ni 'x'.}\\ 
\hline
\end{array}
\end{equation}

Lo anterior muestra que sin duda, incluso a partir de operaciones simples el error numerico evita la identidad de las expresiones con sus valores exactos. Esto se debe a que los numeros en si mismos son representados de manera aproximada en una maquina, y por ende no se corresponden de manera directa a los conjuntos numericos matematicos. Como ejemplo, en la representación de maquina los numeros enteros y reales son conjuntos finitos mientras que los matematicos son conjuntos infinitos. En el caso particular de los reales, en un intervalo cerrado cualquiera en el conjunto matematico existen infinitos reales nuevamente, sin embargo en la representación de maquina el conjunto es finito.  

El último ejemplo tambien ilustra que de manera numerica toda variable siempre requiere tener un valor almacenado previo, lo cual imposibilita la manipulación algebraica de variables.  

# Representación de datos  

## Números  

## Variables  

## Expresiones  

Las expresiones matematicas son comúnmente representadas con estructuras de datos de arbolos, donde los operadores, funciones, variables y números se ubican en sus nodos, y el parentezco de los nodos es dado por la definición de los operadores y funciones. Particularmente se usan arboles binarios dado que los operadores pueden ser clasificados en binarios o unarios, siendo así innecesario tener nodos que permitan más de dos hijos.  

Los elementos númericos o variables siempre serán _hojas_ del árbol (elementos terminales, o sea, nodos sin hijos). Un operador o función siempre será un nodo padre de uno o dos nodos (acorde a si es binario o unario). La forma del árbol equivalente se obtiene al usar esta información con la información de la jerarquía de operadores (los elementos de agrupación por ejemplo no se representan en el árbol sino que nos indican como se forma este en el orden adecuado), partiendo de los valores númericos y variables como nodos terminales y uniendolos entre sí con el nodo padre del operador que les corresponde por jerarquía.  

\!\[Arboles de ejemplo]()

Sin importar la representación seleccionada, siempre aparece un problema. Una misma expresión matemática así como puede ser representada de forma escrita de múltiples formas equivalentes, tambien existen múltiples árboles equivalentes para una misma expresión matemática (incluso para una misma forma escrita). Esto dificulta el proceso de determinación de la identidad entre expresiones matematicas de manera automatica (y por ende, una dificultad para las factorizaciones y otros procedimientos).  

\!\[ejemplo de árboles equivalentes]()

# Algoritmos básicos de algebra computacional

## Aritmetica de precisión arbitraria  

## Primalidad y factorización de enteros  

## Algebra lineal sobre anillos polinomicos  

## Computo Máximo Común Divisor y factorización de polinomios  

# Sympy  

## Instalación  

Para mayor información sobre el proceso de instalación, se recomienda leer la [documentación oficial](http://docs.sympy.org/dev/install.html).  

Usando `pip`:

    pip install sympy
    
Usando `conda` (si instalo miniconda, ya que anaconda lo tiene incluido):

    conda install sympy
    
## Uso  


```python
from __future__ import division
from sympy import *
x, y, z, t = symbols('x y z t')
k, m, n = symbols('k m n', integer=True)
f, g, h = symbols('f g h', cls=Function)
init_printing(use_latex=True)
```


```python
Rational(242, 33)
```


```python
Rational(242, 33).evalf()
```




$$7.33333333333333$$




```python
sqrt(9)
```




$$3$$




```python
sqrt(8)
```




$$2 \sqrt{2}$$




```python
(x+ 2) / ((x-2)*(x+2))
```




$$\frac{1}{x - 2}$$




```python
(x+k)/((x+k)*(x-2))
```




$$\frac{1}{x - 2}$$




```python
expr = x + 2*y - 1
xexpr = x*expr
xexpr
```




$$x \left(x + 2 y - 1\right)$$




```python
xexpexpr=expand(xexpr)
xexpexpr
```




$$x^{2} + 2 x y - x$$




```python
factor(xexpexpr)
```




$$x \left(x + 2 y - 1\right)$$




```python
dse = diff(sin(x)*exp(x), x)
dse
```


```python
dfg = diff(f(x)*g(x), x)
dfg
```




$$f{\left (x \right )} \frac{d}{d x} g{\left (x \right )} + g{\left (x \right )} \frac{d}{d x} f{\left (x \right )}$$




```python
integrate(dse)
```


```python
integrate(dse, (x, -oo, 1))
```


```python
limit(sin(x)/x, x, 0)
```


```python
solve(x**2 - 2, x)
```


```python
solve(k*x**2 - 2, x)
```


```python
dsolve(Eq(y(t).diff(t, t) - y(t), exp(t)), y(t))
```


```python
Matrix([[1, 2], [2, 2]]).eigenvals()
```


```python
la = latex(Integral(cos(x)**2, (x, 0, pi)))
la
```




    '\\int_{0}^{\\pi} \\cos^{2}{\\left (x \\right )}\\, dx'




```python
from IPython.display import Latex
Latex('$'+la+'$')
```




$\int_{0}^{\pi} \cos^{2}{\left (x \right )}\, dx$



# Referencias  

1. [Symbolic Computation](https://en.wikipedia.org/wiki/Symbolic_computation). Wikipedia. Consultado el 25 de agosto.  
1. [The History of the Calculus and the Development of Computer Algebra Systems](http://www.math.wpi.edu/IQP/BVCalcHist/calctoc.html). Dan Ginsburg, Brian Groose, Josh Taylor y Prof. Bogdan Vernescu. Consultado el 25 de agosto. Capitulo 5.  
1. [COMPUTER ALGEBRA AND ITS APPLICATIONS](http://www.umiacs.umd.edu/~helalfy/pub/mscthesis01.pdf). Hazem Mohamed El-Alfy (Tesis de Maestría). 1997.  
1. [COMPUTER ALGEBRA, Algorithms, Systems and Applications](http://www-troja.fjfi.cvut.cz/~liska/ca/all.html). Richard Liska, Ladislav Drska, Jiri Limpouch, Milan Sinor, Michael Wester, Franz Winkler. 2 de junio de 1997.  
1. [SymPy: Symbolic computing in Python](https://peerj.com/preprints/2083/). PeerJ, 22 de junio de 2016.  
1. [Maxima Documentation](http://maxima.sourceforge.net/documentation.html).  
1. [Arbitrary-precision arithmetic](https://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic). Wikipedia, consultado el 27 de agosto de 2016.  
1. [Computer-assisted proof](https://en.wikipedia.org/wiki/Computer-assisted_proof). Wikipedia, consultado el 29 de agosto de 2016.  
1. [Sympy's Documentation](http://docs.sympy.org/dev/index.html). Sympy, consultado el 29 de agosto de 2016.  

6990c171d5cfa11a4d226871f107a7ed02072ac3
ipynb
Jupyter Notebook
Presentaciones/Notas/07_Algebra_computacional_sympy.ipynb
cosmoscalibur/hcomputacionales
13cbe19f1d765f22171c26afd6ab5f0ed4f08409
MIT
2017-08-18T14:46:25.000Z
2018-03-15T04:10:17.000Z
Presentaciones/Notas/07_Algebra_computacional_sympy.ipynb
cosmoscalibur/hcomputacionales
13cbe19f1d765f22171c26afd6ab5f0ed4f08409
MIT
Presentaciones/Notas/07_Algebra_computacional_sympy.ipynb
cosmoscalibur/hcomputacionales
13cbe19f1d765f22171c26afd6ab5f0ed4f08409
MIT
2017-08-25T15:11:56.000Z
2018-09-21T04:03:18.000Z
Qwen/Qwen-72B
1. YES
2. YES