HOMOGENIZE AND SOLVE METHOD The homgenize-and-solve method is a simplified version of Hirota's method to find solitary wave and soliton solutions to certain classes of nonlinear PDEs. In contrast to Hirota's method, the bilinear operator form of the PDE is not needed. At his point, only one type of transformation is used to homogenize a PDE, namely, a logarithmic-derivative transformation. The code is currently restricted to evolution equations. The homogenization method is based on 1. Ph.D. Dissertation of Ameina Nuseir: Symbolic Computation of Exact Solutions of Nonlinear Partial Differential Equations using Direct Methods, Department of Mathematical and Computer Sciences, Colorado School of Mines, May 1995. 2. W. Hereman and A. Nuseir, Symbolic methods to construct exact solutions of nonlinear partial differential equations, Mathematics and Computers in Simulation, vol. 43, no. 1, pp. 13-27 (1997). SPONSOR: National Science Foundation of the USA. PROJECT: REU Project of Andrew Cook -- Summer 2012. SUPERVISION: Willy Hereman, Department of Applied Mathematics and Statistics. Colorado School of Mines, Golden, Colorado 80401, USA. ----------------------------------------------------------------------------- PURPOSE: The purpose of this document is to explain the basic structure of the code contained in this file. CODE: HOMOGENIZE-AND-SOLVE-Oct14-2012-v1-wh.m TEXT: Andrew Cook, September 9, 2012 LAST EDITED: October 14, 2012 by Willy Hereman The idea for this code came from work Hereman and Nuseir performed with a class of PDEs for which solitary wave and soliton solutions exist. We hope that by writing this code the user can investigate other PDEs and perhaps compute solitary wave and soliton solutions. The code can be broken down into 2 main sections, the homogenization process and the searching for solitary wave and soliton solutions. Step 1: Homogenizing the PDE. First, the user will either pick a PDE from a menu or enter one of his or her own (by producing a data file). Our intent is to then homogenize the PDE to the lowest order possible, in order to make the computation of possible exact solutions easier. The original PDE is composed of various terms in u[x,t] and its x and t derivatives. To homogenize the given PDE, we attempt a logarithmic-derivative transformation of the form: u[x,t] = K*D[Log[F[x,t], {x, n}], where n is an integer. Since we hope to minimize the degree of the transformed PDE, we try to minimize the number of x derivatives needed. We start with n = 1 and attempt to find possible K values that homogenize the PDE. If none are found, we move to n = 2, and so on, until 1 or more K values are found. The users will then choose which resulting PDE, with the K values substituted, they wish to consider. If the PDE can not be homogenized, solitary wave or soliton solutions cannot be found by this method. Step 2: Searching for Soliton Solutions. All solitary wave and soliton solutions consider by the code are of the form F[x,t] = 1 + Epsilon^2 f[1][x,t] + Epsilon^2 f[2][x,t] + ... where the f[i][x,t] are terms involving Phi's and constants, where Phi[i][x,t] = E^(Theta[i][x,t]) = E^(k[i]*x - Omega[i]*t + delta[i]). The idea is to compute the f[1][x,t], f[2][x,t] one after another, in the hope that f[i][x,t] = f[i+1][x,t] = .... = 0 at some order i. We use the Phi notation to make the calculations appear neater. Also, the number of Phis in f[1][x,t] can be chosen by the user, depending on which soliton solution (1, 2, or 3 soliton) he or she wants to compute. This code provides two methods for finding soliton solutions. Method 1: 'solitonsoln'. This method should be considered the most reliable method. The soliton solution is found using an order-by-order scheme grouping each f[i][x,t] term with a power of Epsilon, where Epsilon serves purely as a bookkeeping parameter (it is not a small parameter!). First, we look at all of the terms that have Epsilon^1 in them. If this is zero, we move on to Epsilon^2 and keep moving up until we reach an Epsilon that has terms associated with it. Since we want the F[x,t] to solve the homogenized PDE, we hope that upon substitution into the PDE, all of the terms at each order of Epsilon will cancel to produce zero. The only terms that should appear at the first nonzero order of Epsilon should be terms involving f[1][x,t], which was already chosen by the user. To make the terms vanish, we define an Omega[1] to k[1] relationship (dispersion law). The same relationship will be used for Omega[2] to k[2], Omega[3] to k[3] and so on (see Note 1. below). For the remainder of the Epsilon powers, we will use the terms to find a f[i][x,t] term. For example, at the 2nd nonzero Epsilon, we expect f[1][x,t] and f[2][x,t] terms to appear. Since we know f[1][x,t] and the Omega to k relationship, we can pick an f[2][x,t] that will reduce the Epsilon terms to zero. At the next order in Epsilon, f[1][x,t], f[2][x,t] and f[3][x,t] terms will appear. Since we know f[1][x,t] and now f[2][x,t], we can compute f[3][x,t]. And so on. We also split up the terms into left hand side (LHS) and right hand side (RHS) terms, where the LHS contains the f[i][x,t] terms we wish to solve for and the RHS contains the terms we should already know. We set the LHS = RHS to solve. When finding f[i][x,t], we need to introduce coefficients on the Phi's in order for the LHS = RHS. These take the form of a[i][j], where 'i' is the level of Epsilon, and 'j' increases by one for every coefficient needed at that level. To find these coefficients, we look at the LHS terms with the appropriate Phis and the RHS terms with the appropriate Phis, set them equal, and solve. If the PDE does have a soliton solution, as 'i' increases we should see that some f[i][x,t] terms can be set to zero (see Note 2.). We take note of the first zero f[i][x,t] term that appears. From here, we depend on the operator knowledge to tell us when to stop searching for f[i][x,t] terms. This is the only operator logic used in this method. Once we have satisfied the condition determined by the operator, we set all subsequent f[i][x,t] = 0. At this point, we can create the solution. Recall that: F[x,t] = 1 + f[1][x,t] + f[2][x,t] + .... We can substitute in the nonzero f[i][x,t] terms to create a solitary wave or soliton solution, setting Epsilon = 1 to remove the bookkeeping parameter. Method 2: 'solitonsolnOper'. This method is not nearly as reliable as the one listed above, however it has the potential to be substantially faster. Once again, we will implement an order-by-order scheme with each f[i][x,t] term to find the desired soliton solution, however Epsilons will not be used. As the title suggests, this approach uses operators to find a solitary wave or soliton solutions. Hereman and I were able to find general formulas involving operators for the terms produced at each level of Epsilon, depending upon the homogenized order (see Note 3.). To deal with these operators, a series of replacement rules are introduced. From here, the work performed by this method is similar to the approach that does not use operators. We use the general formulas to first look at the operators produced at 'level 1' (or Epsilon 1, if you prefer). We expand this out, set the terms equal to zero, and find an Omega to k relationship. As before, the remaining f[i][x,t] terms are found by looking at the operators produced by the general formulas at level 2, 3, 4, etc. The operators are split up into LHS and RHS pieces, where the LHS will always contain the linear operator of the f[i][x,t] term we wish to find, and the RHS contains the rest. From here, replacement rules are applied and calculations are performed to find f[i][x,t]. Coefficients of the Phi terms are found exactly as in the approach without operators. If the PDE has a solitary wave or soliton solution, we will reach a point where all of the operators at a given level have a zero present in them, after substitution of prior f[i][x,t] terms. We can now create the soliton solution, substituting into the nonzero f[i][x,t] terms to create the F[x,t] solution. Rest of the code: The heart of the code lies in the 3 'main' modules listed above. The pieces outside of these modules are typically either sub-modules used in the one of the 3 main modules, or checks to verify that the main modules produced accurate results. Notes and suggestions for further development: 1. Defining an explicit Omega[i] to k[i] relationship is dangerous. It is possible that Omega[1] = k[1]^2 yet Omega[2] != k[2]^2. This is something that still needs to be investigated. 2. If a nonzero f[i][x,t] is not found after a certain value of 'i' is reached, we terminate the calculations and conclude that we cannot find a soliton solution using this method. 3. See 'CauchySums' notebooks for more detailed work related to the project. The formulas were only derived for a homogenized PDE of order between 1 and 4. Andrew Cook Golden, September 9, 2012 Willy Hereman Boulder, October 14, 2012 -----------------------------------------------------------------------------