Name: Varun Garg

University: Indian Institute of Technology, Patna

Major: Computer Science and Engineering

email: [email protected]

github username: mamakancha

Blog: https://mamakancha.github.io

Time Zone: IST (UTC +5:30)

Hi, I am a second year undergraduate student pursuing Bachelor of Technology in Computer Science and Engineering at Indian Institute of Technology, Patna. I wrote my first Hello World program about two years ago and have been intrigued by the beauty of Computer Programs ever since. I am quite efficient in C, C++ and Python. I also did an Internship at Indian Institute of Technology, Ropar during Summer'16 which shows my interest as a developer and researcher. You can find my Internship Report here. I have also worked with the NetworkX library of Python.I learnt Python from the book : Beginning Python from Novice to Professional by Magnus Lie Hetland. I have also done various courses from Coursera in Python:

• Programming for Everybody (Python)
• An Introduction to Interactive Programming in Python (Part 1)
• An Introduction to Interactive Programming in Python (Part 2)

I came across SymPy somewhere around December'16 and have been using it consistently. Sympy was my first open source project I started contributing to. The thing I like most about SymPy is that it can give equal competition to commercial sites like Wolfram in the near future. And what's cheaper than free? See SymPy vs. Mathematica. Being an active user I also feel obliged to contribute something in return and have been submitting my patches to SymPy every now and then.I have avoided using any softwares/applications to contribute, instead I prefer using Git only and after contributions to SymPy I have also become very familiar with Git and GitHub.

OS : Ubuntu 16.04

Hardware Configuration : i5 4210U/ 4GB

Editor : SublimeText 3

It took me some time to get acquainted to GitHub. For example I started with the Issues for which Pull Requests were already submitted like this. However, due to the friendly environment created by the people here, I was never demotivated. Following is the list of contribution to Sympy in forms of Patches and Issues in chronological order.

• (Merged) Unicode issue with sympy.stats.FiniteRV#11943
• (Unmerged) [WIP] expand_mul() : fixed the crash for nilpotent terms#11996
• (Closed) Corrected the typo error in line 106 of the file mathml.py#11987
• (Unmerged) The file AUTHORS has been updated.#12331
• (Merged) Typos in the files in /examples/intermediate have been fixed.#12333
• (Closed) A few comments have been added to all.py#12344
• (Merged) Edited the link provided in coupled_cluster.py#12343
• (Merged) More test cases have been added in `test_clebsch_gordan.py`#12368
• (Merged) Use of `spherical_jn` introduced#12377
• (Unmerged) Result in doctest for `ellipse.normal_lines.py` corrected#12378
• (Closed) Travis to use the old version of theano#12403
• (Merged) More test cases have been added in `test_clebsch_gordan.py`#12368
• (Unmerged) Typos fixed and link updated in `mathml.py`#12401
• (Unmerged) IndexError fixed for sqrtdenest.#12431
• (Unmerged) Guard against recursion error in _can_print_latex#12445

• (Closed) subs() not working properly#12302
• (Closed) Problem updating AUTHORS#12318
• (Closed) IndexedBase function limited for diagonalizable matrices#12266
• (Open) The list of examples is not exhaustive.#12341

I have always been in love in Mathematics. In my free time, I also try to get hold of the books like The Joy of X by Steven Strogatz. My interest in Differential Equations developed during the course Mathematics-II in my second semester. The book I followed was S. L. Ross, Differential Equations, 3rd Edition. I am also inspired by the fact that the last GSoC project on ODE was in 2013 by Manoj Kumar and the idea for further improvement has been lingering since 2014. I would thus like to take this platform as an opportunity to contribute to SymPy on the project of Ordinary Differential Equations.

Aaron Meurer started the work on ODE Solver as his GSoC project in 2009. More work on ODE was done by Manoj Kumar during GSoC project in 2013 which also included an Implementation of Lie Group methods for first order ODEs.

My project proposal would be dealing with the implementation of the following features.

• Separation ansatz

People often fail to recognize a “hidden” separable equation such as for example the given by (cos(x + y) + cos(x - y))⋅ℯ^(x^2 + y^2) An alternative approach which is completely elementary and provides a necessary and sufficient condition for separability, as well as simple formulas for the explicit factors of f(x, y). given by "D. Scott, When is an ordinary differential equation separable?, Amer. Math. Monthly 92 (1985), pp. 422–423)" can be applied here.

• Implementation of Lie Groups for Second Order ODE

At present, first order ODE can be solved using Lie Groups ( This was implemented by Manoj Kumar) and this is not supported for second order ODE. However, using almost the same tricks as done for first order ODE, second order ODE could be solved using Lie Groups.

• Solving Differential Equations in Terms of Bessel Functions

No work has been done uptill now regarding this topic in ODE in Sympy hence making it an interesting and challenging topic to be worked upon.For differential operators of order 2, I would like to work on a new method that combines generalized exponents to find those solutions that can be represented in terms of Bessel functions.

• Separation ansatz

A first order differential equation dy/dx = f(x, y) is called separable if the right-hand side can be factorized as f(x, y) = φ(x)ψ(y). When the non linearity f(x, y) is not explicitly factorized, it becomes hard to verify if dy/dx = f(x, y) is separable or not. Contrary to the exact equations for which the criterium of exactness is standard, the following test for separability due is much less known : Let D be domain of function f f(x, y) = φ(x)ψ(y) for all (x, y) ∈ D if and only if f(x0, y0)f(x, y) = f(x, y0)f(x0, y) for all (x0, y0), (x, y) ∈ D

• Implementation of Lie Groups for Second Order ODE

The key point of Lie's method for solving ODEs is that the knowledge of a (Lie) group of transformations which leaves a given ODE invariant may help in reducing the problem of finding its solution to quadratures. We can summarize the computational task of using Symmetry Methods for solving a given 2nd order ODE, say

Eq.(1)

d^2(y)/dx^2 = φ(x,y,dy/dx)

as the finding of the infinitesimal of a one-parameter Lie group which will leave the above equation Invariant ,i.e. a pair of functions

{ξ(y, x, y1), η(y, x, y1)} satisfying :

Eq.(2)

(2*y1*(∂^2η/(∂y*∂y1)) + 2*(∂^2η/(∂x*∂y1)) - 3*y1*(∂ξ/∂y) - 2*(∂ξ/∂x) - 2*y1*(∂^2ξ/(∂x*∂y1)) + (∂η/∂y) - 2*y1^2*(∂^2ξ/(∂y*∂y1)))φ 

+ (-y1*(∂η/∂y) + y1^2*(∂ξ/∂y) + y1(∂ξ/∂x) - (∂η/∂x))*(∂φ/∂y1) + (∂^2η/∂x^2) + (∂^2η/∂y^2)*y1^2

+ ( y1(∂η/∂y1) + y1^2*(∂ξ/∂y1) - η )*(∂φ/∂y) + ( (∂^2η/∂y1^2) - y1(∂^2ξ/∂y1^2) - 2(∂ξ/∂y1) )*φ^2 

+ ( (∂η/∂y1) - y1(∂ξ/∂y1) -ξ )*(∂φ/∂x) - (∂^2ξ/∂y^2)*y1^3 - 2*(∂^2ξ/(∂y*∂x))*y1^2 + 2(∂^2η/∂y*∂x)y1 - y1(∂^2ξ/∂x^2) = 0

where y1= dy/dx

followed by the integration of the ODE by either :

• determining the differential invariants of order 0 and 1 of the symmetry group
• determining first integrals ψ(x, y, y1) = ψ0 (from the knowledge of ξ and η)
• determining the canonical coordinates, say {r, s(r)} of the associated Lie group.

Before going towards the implementation part, I would like to put forward some definitions( general and basic definitions have been skipped but could be read from the reference source mentioned ) and theorems necessary for better understanding of the topic.

Definition 1: Let K be a differential field with derivation ∂,then

   __n__
   \   `
L=  )    (ai)*∂^i , ai ∈ K
   /____,
   i = 0

Definition 2: A point p is called a "singular point" of the operator L ∈ K[∂] if p is a zero of the leading coefficient of L or if p is a pole of one of the other coefficients. The leading coefficient of L refers to the coefficient an. All other points are called regular.

Definition 3: The solutions V(LB1) of the operator LB1 := (x^2)*(∂^2) + x*∂ + (x^2 - ν^2) with the constant parameter ν ∈ C are called "Bessel functions". The two linearly independent solutions.

        __n__
        \   `      (-1)^k 
Jν(x) =  )    _______________  * (x/2)^(2k+v) and
        /____, k! * Γ (ν +k +1)
        i = 0


Yν(x) =  Jν(x) * cos(νπ) −  J−ν(x) /(sin(νπ))

generate V(LB1) and they are called "Bessel functions" of first and second kind respectively.

Definition 4: A "transformation" between two differential operators L1,L2 ∈ K[∂ ] is a map from the solution space V(L1) onto the solution space V(L2). Let L1 ∈ K[∂] be a differential operator of degree two. We define for y = y(x) ∈ V(L1) the following transformations:

1. change of variables: y(x) → y(f), f ∈ K,
2. exp-product: y → exp(Rr)y,r ∈ K, and
3. gauge transformation: y → r0*y + r1*(dy/dx),r0,r1 ∈ K.

L1 −−>((f)C L2, L1 −−>(r)E L2, and L1 −−>(r0,r1)G L2, respectively. Furthermore, we write L1 −−> L2 if there exists a sequence of those transformations which transforms L1 into L2. The relation −−> EG on two differential operators L1,L2 ∈ K[∂] is defined by L1 −−>EG L2 ⇔ ∃M ∈ K[∂] : L1 −−>E M −−>G L2.

Theorem: Let L1,L2 ∈ K[∂] such that L1 −−> L2. Then there exists an operator M ∈ K[∂] such that L1 −−>C M −−>EG L2.

Definition 5: Let L ∈ K[∂] be a differential operator, let p be any point, and let e1 and e2 be two generalized exponents of L at p. Then the difference e1 − e2 is called an "exponent difference" of L at p. If deg(L) = 2 there exist just two generalized exponents at each point and we define ∆(L, p) := ±(e1 −e2).

Definition 6: The singular points of an operator L where The solutions of L are not logarithmic and ∆(L, p) ∈ Z are called "exp-apparent singularities."

Definition 7: Let p be a singularity of the operator L ∈ K[∂] which is not exp-apparent. Then p is called

(i) exp-regular ⇔ ∆ (L, p) ∈ C,
(ii) exp-irregular ⇔ ∆ (L, p) ∈ C[1/tp]\C.

• Separation ansatz

Currently if we run the following code,

In [1]: from sympy import cos, exp, pprint, classify_ode
In [2]: from sympy.abc import x
In [3]: f= Function('f')
In [4]: exp(x**2+f(x)**2)*(cos(x+f(x))-cos(x-f(x)))
In [5]: pprint(g)
                                           2    2   
                                          x  + f (x)
Out[5]: (-cos(x - f(x)) + cos(x + f(x)))⋅ℯ          
In [6]: classify_ode(g)
Out [6]: ValueError: The function cannot be automatically detected for (-cos(x - f(x)) + cos(x + f(x)))*exp(x**2 + f(x)**2).

However, this error can be rectified if we implement the theory mentioned under Separation ansatz could be implemented. Test of separability would be done by following the mentioned steps:

• Choose any (x0, y0) ∈ D such that f(x0, y0) != 0 where D is domain of f.
• Construct the functions φ(x) = f(x,y0)/f(x0,y0) and ψ(y) = f(x0, y).
• The equation is separable if and only if f(x, y) = φ(x)ψ(y).
  
  

We want a particular solution to the Eq.(2) mentioned in the Theory. Consider for example :

ODE : d^2y/dx^2 = ((dy/dx)*x - y )^2/(x^3)

We can see that this 2nd order ODE is non linear and does not match any particular pattern for which we know how to solve this ODE. However, a polynomial asantz for the infinitesimal made by symgen routine of Maple

> symgen(ODE);      # input = ODE, output = pairs of infinitesimals
[ξ = 0 , η = x], [ξ = x , η = y], [ξ = x2, η = yx].

Passing the ODE directly to odsolve (of Maple), it will internally call symgen and use the result above to solve the ODE as follows:

> odsolve(ODE);
y = (ln(x) - ln( 1 + xC1) + C2) x.

In Maple, Given a 1st or 2nd order ODE, odsolve's main goal is to solve it in two steps: first, determine pairs of infinitesimals of 1-parameter symmetry groups which leave the ODE invariant, and then use these infinitesimals to integrate the ODE. My main challenge would be to design a counterpart of odsolve for SymPy.

For accomplishing the first step, We already have sympy.solvers.ode.infinitesimals implemented in SymPy here which serves as functionality of symgen. I will work on further refining this method and fixing it in case of any type of failures with our input set being second order ODE. We further need to develop a function sympy.solvers.ode.checkinfsol_second to check which one satisfies the Eq.(2) as mentioned in Theory.

Now we need to use the infinitesimals to integrate the ODE which is the second and final step to solve second order ODEs. I would primarily work on developing methods for the following three integration techniques for second order ODE:

1. Using Differential Invariants :

Once a pair of infinitesimals for a given 2nd order ODE is found, it is possible to integrate the ODE if one succeeds in using these infinitesimals to find the differential invariants of order 0 and 1 and in solving an intermediate 1st order ODE. However, if the symmetry is of dynamical type i.e dependent on y1, the whole scheme will break down since, to reduce the order, the scheme requires that the differential invariants of order n do not depend on derivatives of order higher than n. So we stick to the following approach which would work even in case of dynamical symmetry :

• put the symmetry in the evolutionary form ( The evolutionary form is given by [ξ = 0, η = φ(x, y, y1)]);
• use u = x as the invariant of order 0 and find the invariant of order 1, v = v(x, y, y1);
• construct the invariant of order 2: (dv/du);
• change the variables and write the ODE in terms of u, v and dv/du obtaining the expected reduction of order;
• solve this 1st order ODE, and reintroduce the original variables (x,y, y1), obtaining another 1st order ODE, which can be integrated straightforwardly since it has the same symmetry of the original 2nd order ODE.

2. Using first integrals

Taking into account the way we use "dynamical symmetries" to solve the 1st order ODE obtained in the reduction process as seen above, the extension of this scheme to work with such symmetries was straightforward. Now, it is also possible to tackle a 2nd order ODE from the knowledge of only 1 pair of infinitesimals (either of point or dynamical type), by looking for first integrals, exploiting similar ideas as those of the previous subsection; that is,

(i) Put the known symmetry in the evolutionary form.

One can then prove that there exists a first integral φ(x, y, y1) which satisfies:

A(φ) = 0
X(φ) = 0

A = f -> ∂f/∂x + y1*(∂f/∂y) + φ(x, y, y1)*(∂f/∂y1)
X = f -> ξ(x, y, y1)*(∂f/∂x) + η(x, y, y1)*(∂f/∂y) + η1(x,y,y1)*(∂/∂y1)

(ii) Solve the characteristic strip of X(φ) = 0 to obtain the invariants of order 0 and 1: c0(x, y, y1) and c1(x, y, y1).

Since the symmetry is in evolutionary form, it always happens that c0 = x, and the characteristic strip is reduced to a single 1st order ODE. Now, observing that the solution to X(φ) = 0 can always be written as φ(c0, c1).

(iii) Change the variables in A(φ) = 0, from (x, y, y1) to (c0, y, c1).

One can then prove that A(φ) = 0 becomes (∂/∂c0 + A(c1)*∂/∂c1)*φ(c0,c1) = 0 that is, a PDE in only two variables. We obtain φ(c0, c1) from here which simultaneously satisfies

A(φ) =0
X(φ) =0

3. Using canonical coordinates

It is also possible to use a pair of infinitesimals to constructively reduce the order of a 2nd order ODE by introducing the canonical variables of the related invariance group. Also, if one knows two or more symmetries at once, one can use this information to integrate the ODE in almost only one step . However, in case of dynamical symmetries, it is not much advantageous if compared to previous two techniques.

• Solving Differential Equations in Terms of Bessel Functions

The idea is to employ an algorithm which expresses the solutions of our ODE with Bessel Functions. I would primarily work on implementing the same.

The input of our algorithm is a differential operator Lin and we want to know whether the solutions can be expressed in terms of Bessel functions. We assume that LB −−> Lin for some transformations. If we find a solution to that problem, then we also find the solution space of Lin For a general algorithm, we assume k = C.Let Lin be a differential operator of degree two with coefficients in K = C(x). The Algorithm will follow the mentioned steps :

A. We can compute the singularities S of Lin by factoring the leading coefficient of Lin and the denominators of the other coefficients into linear factors.

B. For each s ∈ S we compute ds = ∆(Lin,s), isolate exp-apparent points with ds ∈ Z, and differ between exp-regular singularities Sreg with ds ∈ C and exp-irregular singularities Sirr with ds ∈ C[ts^-1]\C.

C. We can use the exponent differences ds for s ∈ Sirr to compute possibilities F for the parameter f up to a constant c ∈ k.

D. In all cases but the integer case we know at least one zero of f by picking some s0 ∈ Sreg. So we can also compute the missing constant c for each f ∈ F.

E. The set N is a set of possibilities for ν. When not being in the integer case, this set is finite. But the set might depend on the possibility f ∈ F.

F. For each pair (ν,f) ∈ N×Fwe can compute an operator M = M(ν, f) such that LB−−>(f)C M

G. For each M we can decide whether M −−>EG Lin and compute the transformations.

Equivalent Algorithm used in Maple :

Input: An operator Lin ∈ K[∂].
Output: V(Lin) when it can be represented in terms of Bessel functions and FAIL otherwise.
1. compute singularities S of Lin and Sreg,Sirr
2. F = besselSubst(Sirr)
3. P = {}
4. for each f ∈ F
5.    P = P U findBesselνf(f,Sreg)
6. for each (ν, f) ∈ P
7.    M = changeOfVar(LB, f)                                
8.    if ∃r0,r1,r2 ∈ K : M −−>(r0)E M˜ −−>(r1,r2)G Lin for some M˜ ∈ K[∂] then
9.       return V(Lin)
10.return FAIL

List of Notations for easy readability:

−−>          composition of −−> C, −−> E and −−> G 
 
−−>(f)C      change of variables with parameter f 
 
−−>(r)E      exp-product with parameter r 

−−>EG        composition of −−> E and −−> G 
 
−−>(r0,r1)G  gauge transformation with parameters r0 and r1 

∆(L,p)       exponent-difference of L at p

K[∂]         ring of differential operators with coefficients in K

Sirr         set of exp-irregular points

Sreg         set of exp-regular points

V(L)         solution space of an operator L

Here, my main challenge would be to reproduce the functionality of Maple functions besselSubst, findBesselνf, changeOfVar and a tranform_func (for step 8) and to compute the possibilities (ν, f).

SymPy has singularities.py but I don't think that would suffice to compute singularities of a differential operator so I would also have to implement singularity method for this purpose.

I would also try to introduce the checking of specific cases like Logarithmic Case, Integer Case etc. for which Algorithm could be tweaked to work faster using certain Lemmas and Theorems. If time allows, I would also work on the improvisation of the speed of the above algorithm.

I want to build robust algorithms and methods which would not only produce correct results but also take into account as many cases as possible hence giving a legit output every time. For testing, ,many resources can be found on internet from where I could produce my sample tests to check the validity of my code by verifying the outputs from Maple if possible.

My semester would end by the end of April so I would be able to completely devote myself to the project since I would be available from Day 1 (May 4) .My main aim would be to get comfortable with the source code of ode.py here and brush up my Python coding skills. The most challenging and interesting part of my project would be Solving Differential Equations in Terms of Bessel Functions and hence I would read as much theory on Bessel Functions and Singularities in Differential Equations followed by the theory required for Implementation of Lie Groups for Second Order ODE which includes study of Differential Variants and the Integration techniques I plan to implement. Since I have covered some of the above mentioned topics during my previous semesters, I will try to get started with the coding part to get a head start.

During the first two weeks, I plan to implement the Algorithm required to determine the separability of a differential equation. I plan to build a robust Algorithm which would work with every case. Towards the end of the second week I would start working on some sample tests to check the validity of the Algorithm and fix the bugs if any.

I would first finish the theory(if left) required for Implementation of Lie Groups for Second Order ODE since some topics of Bessel Functions seem to be very time consuming since they require thorough understanding of the topic. After that I plan to start working on sympy.solvers.ode.infinitesimals and go through the work done through Week 1 to Week 4 for Phase 1 Evaluation and fix the issues after discussion with the mentors.

Implement the function sympy.solvers.ode.checkinfsol_second to check which infinitesimals satisfies the Eq(2) as given in Theory. After this I plan to develop the methods for the three integration techniques Using Diffential Invariants, Using first integrals, Using canonical coordinates.

Make a function for generating Bessel Functions. Implement the functionalities of the Maple functions besselSubst, findBesselνf, changeOfVar for SymPy. Implement exponent_difference for a differential operator L at any point p. Meanwhile I would start preparing for Phase 2 Evaluation.

First I would implement singularity and transform_func and then I would start working on the final Algorithm which would employ the above mentioned methods. Since the methods used by the Algorithm would be made before working on the Algorithm, it should not take much long to implement it.

I would primarily work on giving the final touch to the Algorithm and for various sample inputs which could be found from the resources I have mentioned.

My main focus would be to remove any kind of bugs and finishing off any remaining tasks if any.

As per my Timeline goes, after the Community Bonding period, my first seven weeks go into completing the first two tasks which are Separation ansatz and Implementation of Lie Groups for Second Order ODE . The next six weeks go into making the third task possible viz. Solving Differential Equations in Terms of Bessel Functions. The third task is theoretically hardest among all the three but from the resources I went through, it is possible to find sufficient help for a practical implementation to finish it. That being said, my first priority would be to finish the first two tasks completely and then moving forward to the Bessel Functions. I am very optimistic about my Timeline and believe that all the 3 tasks would be completely by the end of term end. However even if one or two methods are left to be implemented in Bessel Functions, I would take them up as Issues immediately after August 29.

I believe that the idea of Ordinary Differential Equations has been floating since 2014 because all the previous applications on this topic I followed , somewhere or the other, some aspects or details about Implementations or Theory were missing. I believe have done proper study of the above mentioned ideas for my project and covered each and every detail required to make these ideas implemented as my project. Also due to my prior encounter with ODEs during my second semester and Singularities in third, I believe I have an extra edge due to better concepts and understanding. I have also been actively contributing to SymPy and I am quite familiar with the working environment here now thus buying me some extra time to work on proper detailing of my project if I get selected. Also, I would have no ongoing projects during my Summers this year and my semester would be over even before the community bonding period , hence, I would be able to devote myself completely to this project only.

As mentioned earlier in the Summary of my Timeline, somehow if some part of my GSoC Project is left incomplete,I would be taking it up immediately after the Term End(August 29). Being close to my heart, I will always stay a part of SymPy, either as a contributor or maybe a mentor for further GSoCs and keep contributing for years to come. I would always try to keep introducing/adding new functionalities to SymPy for a better experience. Google Summer of Code will prove as a great opportunity for me to be introduced to the open source world and be a part of the community.

• "A simple method to find out when an ordinary differential equation is separable" by José Ángel Cid
• "Computer Algebra Solving of First Order ODEs Using Symmetry Methods"(15 pages) by E.S. Cheb-Terrab, L.G.S. Duarte and L.A.C.P. da Mota.
• "Computer Algebra Solving of Second Order ODEs Using Symmetry Methods" by E.S. Cheb-Terrab, L.G.S. Duarte, L.A.C.P. da Mota
• "GSoC 2013 Application Manoj Kumar: Improved ODE Solver"
• "Solving Differential Equations in Terms of Bessel Functions" by Dr. Wolfram Koepf
• "Solving Differential Equations in Terms of Bessel Functions" by Ruben Debeerst.