Sunday, September 20, 2020

vectors in SymPy and use of dot cross and the Laplacian

Converting "\vec{\psi}(r, t)" into SymPy is feasible
Function('vecpsi')(Symbol('r'), Symbol('t'))
but I can't figure out how to apply the dot product with a vector:

>>> import sympy
>>> from sympy import *
>>> from sympy.vector import CoordSys3D, Del, curl, divergence, gradient
>>> Symbol('vecp').dot( Function('vecpsi')(Symbol('r'), Symbol('t')) )
Traceback (most recent call last):
AttributeError: 'Symbol' object has no attribute 'dot'

The issue is that a vector needs to be specified in a specific dimension (e.g., 3) and have specific coefficients with respect to the basis.

>>> N = CoordSys3D('N')
>>> v1 = Symbol('a')*N.i+Symbol('b')*N.j + Symbol('c')*N.k
>>> v2 = Symbol('f')*N.i+Symbol('g')*N.j + Symbol('k')*N.k
>>> v1.dot(v2)
a*f + b*g + c*k
>>> v1.cross(v2)
(b*k - c*g)*N.i + (-a*k + c*f)*N.j + (a*g - b*f)*N.k

see https://en.wikipedia.org/wiki/Del
>>> delop = Del()
>>> delop(Symbol('a'))
0
>>> delop(v1)
(Derivative(a*N.i + b*N.j + c*N.k, N.x))*N.i + (Derivative(a*N.i + b*N.j + c*N.k, N.y))*N.j + (Derivative(a*N.i + b*N.j + c*N.k, N.z))*N.k
>>> v1
a*N.i + b*N.j + c*N.k
>>> curl(v1)
0
>>> divergence(v1)
0
>>> Laplacian(v1)
Laplacian(a*N.i + b*N.j + c*N.k)

Also, operators can't be defined since using Laplacian requires an argument:
>>> Laplacian()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: __new__() missing 1 required positional argument: 'expr'

Sunday, September 6, 2020

expanding the list of Computer Algebra Systems used by the Physics Derivation Graph

The current implementation of the Physics Derivation Graph relies on user to 1) enter expressions as Latex and 2) assist/review the conversion from Latex to SymPy.

The choice of Latex as the input interface is based on ease of use (conciseness, low barrier to entry) and could be replaced by other options for specifying expressions. Entering characters and then parsing into an AST could be applied to a variety of input methods. A second choice is what to use the AST for -- currently the output is Sympy, but a variety of output representations is available (Sage, Mathematica, Maxima, etc).

In my experience with Sage, expressions in Sage are not as compact. There seems to be less support for features like units (feet, meters, seconds) -- https://ask.sagemath.org/question/49511/working-with-units/

I'm confident there are expressions in the PDG that Sage supports and SymPy does not. Expanding the CAS used by PDG means having three representations -- Latex and SymPy and Sage. The negative consequences of this expansion would include
  • increases the work needed to input the different representations, and
  • increases the work of verifying consistency between representations, and 
  • imposes extra knowledge requirements on the developer, and
  • additional dependencies
The potential benefit would be coverage for validating some steps not currently possible with SymPy. There might be value to other people who want to compare SymPy to Sage. 

summary of SymPy hurdles for the Physics Derivation Graph



Friday, September 4, 2020

Latex symbols that are operators - how to create SymPy placeholder

{\cal H} in Latex is used for the Hamiltonian in the "1D particle in a box"
https://en.wikipedia.org/wiki/Hamiltonian_(quantum_mechanics)
Needs to be translated to a SymPy operator 
https://docs.sympy.org/latest/modules/physics/quantum/piab.html

The Laplace operator \nabla^2 in Latex is 
delop = Del()
delop.dot(delop())

representing the Laplace operator (nabla in Latex) in SymPy using Del

https://en.wikipedia.org/wiki/Laplace_operator
https://docs.sympy.org/latest/modules/vector/fields.html

>>> import sympy
>>> from sympy import *
>>> from sympy.parsing.latex import parse_latex
>>> from sympy.vector import Del


Original expression as Latex converted to SymPy to Latex:
>>> latex(eval(sympy.srepr(parse_latex("\\frac{-\\hbar^2}{2m} \\nabla = {\\calH}"))))
'- \\frac{\\hbar^{2} nabla}{2 m} = calH'

The first two conversions yield SymPy:
>>> sympy.srepr(parse_latex("\\frac{-\\hbar^2}{2m} \\nabla = {\\calH}"))
"Equality(Mul(Symbol('nabla'), Mul(Mul(Integer(-1), Pow(Symbol('hbar'), Integer(2))), Pow(Mul(Integer(2), Symbol('m')), Integer(-1)))), Symbol('calH'))"

This can be successfully evaluated as SymPy because the 'nabla' is a Symbol
>>> eval("Equality(Mul(Symbol('nabla'), Mul(Mul(Integer(-1), Pow(Symbol('hbar'), Integer(2))), Pow(Mul(Integer(2), Symbol('m')), Integer(-1)))), Symbol('calH'))")
Eq(-hbar**2*nabla/(2*m), calH)

However, replacing 'nabla' with 'Del' causes the eval to fail:
>>> eval("Equality(Mul(Del, Mul(Mul(Integer(-1), Pow(Symbol('hbar'), Integer(2))), Pow(Mul(Integer(2), Symbol('m')), Integer(-1)))), Symbol('calH'))")
Traceback (most recent call last):
...
  File "/usr/local/lib/python3.6/dist-packages/sympy/core/mul.py", line 307, in flatten
    b, e = o.as_base_exp()
AttributeError: type object 'Del' has no attribute 'as_base_exp'



Original expression to convert to SymPy:
>>> sympy.srepr(parse_latex("\\nabla^2 \\psi \\left( \\vec{r},t) \\right) = \\frac{i}{\\hbar} \\vec{p} \\cdot \\left( \\vec{ \\nabla} \\psi( \\vec{r},t) \\right)"))
"Mul(Pow(Symbol('nabla'), Integer(2)), Mul(Symbol('psi'), Mul(Symbol('right'), Function('left')(Mul(Symbol('r'), Symbol('vec')), Symbol('t')))))"


The Latex "\nabla" is SymPy's "Del". However, squaring Del isn't available
>>> sympy.latex(sympy.Pow(Del, sympy.Integer(2)), sympy.Symbol('x'))
...
AttributeError: type object 'Del' has no attribute '_eval_power'


The Laplacian operator is the dot product of two Del operators, so
>>> delop = Del()
>>> sympy.latex(delop.dot(delop(sympy.Function('\psi')(sympy.Symbol('r'), sympy.Symbol('t')))))
'0'


Evaluating definite integrals for humans versus SymPy breaks the Latex-to-SymPy mapping of steps

 In the process of fixing expressions and steps in the PDG database, I encountered a novel challenge.

Currently every step in the PDG has a set of Latex expressions. These expressions are provided by the user, converted to SymPy, and then the step is validated using SymPy. There is a one-to-one mapping of "what the user sees" to "what the CAS checks."

In a derivation there is a sequence like

    f = \int_a^b x dx

inference rule: carry out definite integration

    f = (x^2/2)|_a^b

inference rule: simplify

    f = 1/2 (b^2 - a^2)

It seems that SymPy doesn't support the middle expression and instead goes directly from the first to the last expression. That means there is an intermediary Latex expression that cannot be converted to Sympy, breaking the assumption of "what the human reads is one-to-one with what the CAS checks."

Accounting for the mismatch between Latex steps and CAS steps would make the already-messy graph structure more complicated. Some steps that are included for human readability would not be able to be specified to the CAS, nor would those steps be checked.

ufw allow status numbered delete -- managing the firewall

$ sudo ufw status verbose
Status: active
Logging: on (low)
Default: deny (incoming), allow (outgoing), deny (routed)
New profiles: skip

To                         Action      From
--                         ------      ----
22/tcp                     LIMIT IN    Anywhere                  
443/tcp                    ALLOW IN    Anywhere                  
80/tcp                     ALLOW IN    Anywhere                  
25                         ALLOW IN    Anywhere                  
22/tcp (v6)                LIMIT IN    Anywhere (v6)             
443/tcp (v6)               ALLOW IN    Anywhere (v6)             
80/tcp (v6)                ALLOW IN    Anywhere (v6)             
25 (v6)                    ALLOW IN    Anywhere (v6)             


$ sudo ufw allow 8000/tcp
Rule added
Rule added (v6)


$ sudo  ufw status numbered
Status: active

     To                         Action      From
     --                         ------      ----
[ 1] 22/tcp                     LIMIT IN    Anywhere     
[ 2] 443/tcp                    ALLOW IN    Anywhere  
[ 3] 80/tcp                     ALLOW IN    Anywhere  
[ 4] 22/tcp (v6)                LIMIT IN    Anywhere (v6) 
[ 5] 443/tcp (v6)               ALLOW IN    Anywhere (v6) 
[ 6] 80/tcp (v6)                ALLOW IN    Anywhere (v6) 
[ 7] 25 (v6)                    ALLOW IN    Anywhere (v6) 

$ sudo ufw delete 7
Deleting:
 allow 25
Proceed with operation (y|n)? y

Rule deleted (v6)