------ help page for diffop ------------------------------------------- Linear differential operators Description: - A differential operator L in C(x)[Dx] is an expression a_0*Dx^0+ ... +a_n*Dx^n where a_0, ... , a_n are elements of C(x). So it is a polynomial in Dx with rational functions as coefficients. In the functions for differential operators in the DEtools package, the names Dx and x (other names can be used as well) can be specified either by an entry called domain, or by setting _Envdiffopdomain to [Dx,x]. - An element L in C(x)[Dx] corresponds to a linear homogeneous differential equation L( y(x) )=0. If L = a_0*Dx^0+ ... +a_n*Dx^n then this is the equation a_0 * y(x) + a_1 * diff(y(x),x) + ... + a_n * diff(y(x),x$n) = 0 . - Multiplication (see DEtools[mult]) in the ring C(x)[Dx] corresponds to composition of differential operators. So if L = mult(f,g) then L( y(x) ) = f(g( y(x) )). In particular mult(Dx,x) = x*Dx + 1. - The following procedures allow only coefficients a_0, a_1, ... , a_n in C(x): DFactor, eigenring, endomorphism_charpoly, formal_sol, gen_exp, integrate_sols. The following procedures allow more general coefficients: GCRD, LCLM, adjoint, de2diffop, diffop2de, exterior_power, leftdivision, mult, rightdivision, symmetric_product, symmetric_power. - The main purpose of these functions is factorization of differential operators. Factorization is reducing a differential equation to another equation of lower order: If f = L*R then the solutions of R( y(x) ) = 0 are solutions of f( y(x) ) = 0 as well. In particular all exponential solutions (see DEtools[expsols]) are obtained by computing all right-hand factors of order 1. See Also: DEtools,DEtools[de2diffop] ------ help page for DEtools ------------------------------------------- Introduction to the DEtools package Calling Sequence: function(args) DEtools[function](args) Description: - The DEtools package contains functions that help you work with differential equations. The package consists of the following parts: - Functions for visualization: DEplot DEplot3d PDEplot dfieldplot phaseportrait - Functions for working with Poincare sections of dynamical systems (see also ?Poincare): generate_ic hamilton_eqs poincare zoom - Functions for manipulation with differential equations: DEnormal Dchangevar PDEchangecoords autonomous convertAlg convertsys indicialeq reduceOrder regularsp translate untranslate varparam - Functions for constructing closed form solutions: RiemannPsols abelsol bernoullisol chinisol clairautsol constcoeffsols eulersols exactsol expsols genhomosol kovacicsols liesol linearsol matrixDE parametricsol polysols ratsols riccatisol separablesol - Functions for differential operators (see also ?diffop): DFactor GCRD LCLM adjoint de2diffop diffop2de eigenring endomorphism_charpoly exterior_power formal_sol gen_exp integrate_sols leftdivision mult rightdivision symmetric_power symmetric_product - Functions for handling ODEs in the frame of the Lie symmetry method and for classifying ODEs (see also ?DEtools,Lie): buildsol buildsym canoni equinv eta_k infgen intfactor line_int odeadvisor odepde symgen symtest transinv - To use a DEtools function, either define that function alone using the command with(DEtools, function), or define all DEtools functions using the command with(DEtools). Alternatively, invoke the function using the long form DEtools[function]. This long form notation is necessary whenever there is a conflict between a package function name and another function used in the same session. - For more information on a particular function, see DEtools[function]. See Also: PDEtools ------ help page for DFactor ------------------------------------------- DEtools[DFactor] - Factor a linear differential operator Calling Sequence: DFactor(L,domain,opt) Parameters: L - a differential operator domain - a list containing two names opt - (optional) a sequence of options Description: - The input is a differential operator L with rational function coefficients. The output is a list of irreducible factors [L1, .., Lr] such that L=mult(L1, .., Lr). - The optional argument `one step` causes that the computation stops whenever a factorization is found. In this case the output is [L] if L is irreducible, and it contains 2 (not necessarily irreducible) factors if L is reducible. - For a description of the method used see M. van Hoeij, "Factorization of Differential Operators with Rational Functions Coefficients", JSC 1997. - The argument domain describes the differential algebra. If this argument is the list [Dx,x] then the differential operators will be notated with the symbols Dx and x. They are viewed as elements of the differential algebra C(x)[Dx] where C is the field of constants. If the argument domain is omitted then the differential specified by the environment variable _Envdiffopdomain will be used. If this environment variable is not set then the argument domain may not be omitted. Examples: > with(DEtools): > a:=RootOf(x^2-10); 2 a := RootOf(_Z - 10) > R:=(35/4-5/2*a)*x^2-55/2+11/2*a; 2 2 2 R := (35/4 - 5/2 RootOf(_Z - 10)) x - 55/2 + 11/2 RootOf(_Z - 10) > L:=DF^2-R; 2 2 2 2 L := DF - (35/4 - 5/2 RootOf(_Z - 10)) x + 55/2 - 11/2 RootOf(_Z - 10) > DFactor(L, [DF,x]); 2 4 4 2 [DF + 1/30 (RootOf(_Z - 10) - 5) (150 %1 - 300 x - 60 x RootOf(_Z - 10) 6 2 2 / + 45 x + 525 x - 110 - 34 RootOf(_Z - 10)) / (x / 2 4 2 (7 - 2 %1 - 10 x + 3 x + 2 RootOf(_Z - 10))), DF - 1/30 2 4 4 2 6 (RootOf(_Z - 10) - 5) (150 %1 - 300 x - 60 x RootOf(_Z - 10) + 45 x 2 2 / + 525 x - 110 - 34 RootOf(_Z - 10)) / (x / 2 4 2 (7 - 2 %1 - 10 x + 3 x + 2 RootOf(_Z - 10)))] 2 2 %1 := x RootOf(_Z - 10) > mult(op(%), [DF,x]); # this equals L 2 2 2 2 DF + 1/12 (-7 + 2 RootOf(_Z - 10)) (15 x - 110 - 22 RootOf(_Z - 10)) > L:=mult(DF^2+x^3+1/x^3, DF^2+x^2-1/x^3, [DF,x]); 5 11 6 5 4 2 2 (2 x + 3) DF x + x + x - 1 - 12 x L := DF + x (1 + x) DF + 2 ------------- + ------------------------ 4 6 x x > DFactor(L,[DF,x],`one step`); 6 5 2 x + 1 2 -1 + x [DF + ------, DF + -------] 3 3 x x See Also: diffop,DEtools[mult],DEtools[expsols] ------ help page for eigenring ------------------------------------------- DEtools[eigenring] - The endomorphisms of the solution space DEtools[endomorphism_charpoly] - Characteristic polynomial of an endomorphisms Calling Sequence: eigenring(L,domain) endomorphism_charpoly(L,r,domain) Parameters: L - a differential operator r - a differential operator in the output of eigenring domain - a list containing two names Description: - The input L is a differential operator. Denote V(L) as the solution space of L. This procedure computes a basis (as vector space) of the set of all operators r for which r(V(L)) is a subset of V(L). So r is an endomorphism of the solution space V(L). The characteristic polynomial of this map can be computed by the command endomorphism_charpoly(L,r). - For endomorphisms r, the product of L and r is divisible on the right by L. If the optional third argument is the equation verify=true then eigenring will check if the output satisfies this condition. This should not be necessary though. - The argument domain describes the differential algebra. If this argument is the list [Dt,t] then the differential operators will be notated with the symbols Dt and t. They are viewed as elements of the differential algebra C(t)[Dt] where C is the field of constants. If the argument domain is omitted then the differential specified by the environment variable _Envdiffopdomain will be used. If this environment variable is not set then the argument domain may not be omitted. Examples: > with(DEtools): # Take the differential ring C(x)[Dx] > A:=[Dx,x]; A := [Dx, x] > L:=Dx^4-2*x*Dx^2-2*Dx+x^2; 4 2 2 L := Dx - 2 x Dx - 2 Dx + x # Compute a basis v for the endomorphisms r: V(f) -> V(f). Compute an # eigenvalue e of r. Then compute the greatest common right divisor G. Then the # solution space V(G) is the kernel of r - e : V(f) -> V(f). > v:=eigenring(L,A); 2 3 2 2 v := [-x + Dx , x Dx - Dx , 1, -x - Dx + x Dx ] > for r in v do > print('r'=r); > F:=factor(endomorphism_charpoly(L,r,A)); > for e in {solve(F,x)} do > print(G=GCRD(r-e,L,A)) > od > od; 2 r = -x + Dx 4 F := x 2 G = -x + Dx 3 r = x Dx - Dx 2 2 F := (x + 2) (x + 1) 2 G = -x + Dx 2 Dx G = Dx - ---- - x x r = 1 4 F := (x - 1) 4 2 2 G = Dx - 2 x Dx - 2 Dx + x 2 2 r = -x - Dx + x Dx 4 F := x 2 Dx G = Dx - ---- - x x See Also: diffop,DEtools[GCRD] ------ help page for formal_sol ------------------------------------------- DEtools[formal_sol] - Formal solutions of a homogeneous linear differential equation Calling Sequence: formal_sol(L,domain,T,opt) formal_sol(eqn,dvar,T,opt) Parameters: L - a differential operator domain - a list containing two names T - a name opt - (optional) a sequence of options eqn - a homogeneous linear differential equation dvar - the dependent variable Description: - The input is a differential operator L or a differential equation eqn having rational function coefficients. The output is a list of lists. Each of these lists contains one type of formal solution; those solutions having the same e (see below for a description) will be grouped together in the same list. - Let x be the dependent variable. In case a differential operator was specified then x is the second element of the list domain. In case a differential equation was specified then x is implicitly given in dvar which is of the form y(x). A formal solution is a solution exp(int(e,x)) * s for some e in C[x^(-1/n)] and s in C((x^(1/n))[log(x)] for some integer n (called the ramification index). The solution space of a homogeneous linear differential equation of order N has dimension N. It has a basis of formal solutions. This procedure computes such a basis. The name T which must be specified in the input will be used to denote x^(-1/n) * a constant. This procedure computes the formal solutions and expresses them in terms of T. The relation between T and x is given in the output as well, in each list containing one type of formal solution. - If the optional argument x=p where p in P^1 (= C union {infinity}) is given, then this procedure first applies a transformation DEtools[translate] to move the point p to the point 0, then computes the formal solutions, and then substitutes x=x-p in the result (or x=1/x if p=infinity). Note that this substitution only affects the part of the output that gives the relation between T and x. If p<>infinity and the ramification index is 1, the relation between x and T given in the output is T=x-p. - Note that the formal solutions will be computed only up to conjugation over the field k((x)), where k is the minimal field of constants over which the input is defined. A larger field k can be specified by the option groundfield = a list of RootOfs. By default the number n of terms to be computed is given by the variable Order. To obtain a different number of terms, use the optional argument terms=n. - For a description of the method used see M. van Hoeij, "Formal Solutions and Factorization of Differential Operators with Power Series Coefficients", JSC 1997. - The argument domain describes the differential algebra. If this argument is the list [Dx,x] then the differential operators will be notated with the symbols Dx and x. They are viewed as elements of the differential algebra C(x)[Dx] where C is the field of constants. If the argument domain is omitted then the differential specified by the environment variable _Envdiffopdomain will be used. If this environment variable is not set then the argument domain may not be omitted. - Instead of a differential operator, the input can also be a linear homogeneous differential equation having rational function coefficients. In this case, the second argument must be the dependent variable. Examples: > with(DEtools): > L:=Dx^3+1/(x-1)^4*Dx+x; 3 Dx L := Dx + -------- + x 4 (x - 1) > formal_sol(L,[Dx,x],T,x=1); 2 5 6 3 RootOf(1 + _Z ) [[1 - 1/5 T + O(T ), T = x - 1], [T exp(- ---------------) (1 + T 2 2 2 3 4 3 RootOf(1 + _Z ) T - 12 T - 60 RootOf(1 + _Z ) T + 360 T + 2 5 6 (1/10 + 2520 RootOf(1 + _Z )) T + O(T )), T = x - 1]] # Note that the output is given only up to conjugation over the field of # definition of the input. So, to obtain a basis of the formal solutions the # conjugate (replace RootOf(1+_Z^2) by -RootOf(1+_Z^2)) solution needs to be # added as well. A larger base field can be specified with the option # groundfield: # > formal_sol(L,[Dx,x],T,x=1,'terms'=3,'groundfield'=[RootOf(x^2+1)]); 3 [[1 + O(T ), T = x - 1], 2 3 RootOf(1 + _Z ) 2 2 3 [T exp(---------------) (1 - 3 RootOf(1 + _Z ) T - 12 T + O(T )), T = x - 1] T , [ 2 3 RootOf(1 + _Z ) 2 2 3 T exp(- ---------------) (1 + 3 RootOf(1 + _Z ) T - 12 T + O(T )), T = x - 1 T ]] # Here is an example with ramification indices 2 and 3: # > eqn:=diff(y(x),x$5) + diff(y(x),x$3)/x^3 + y(x)/x^7; 3 d --- y(x) / 5 \ 3 |d | dx y(x) eqn := |--- y(x)| + -------- + ---- | 5 | 3 7 \dx / x x > formal_sol(eqn,y(x),T); [[ 5 / 965 2 28895 3 47770 4 3481550 5 6 \ T exp(- 3/T) |1 - 43/9 T + --- T - ----- T - ----- T + ------- T + O(T )| \ 81 2187 19683 177147 / 3 19/2 , -T = x], [T exp(- 2/T) / 9231 2 922729 3 202234485 4 3550440387 5 6 \ |1 + 3/16 T - ---- T + ------ T - --------- T - ---------- T + O(T )|, \ 512 8192 524288 8388608 / 2 -T = x]] See Also: diffop,DEtools[gen_exp] ------ help page for gen_exp ------------------------------------------- DEtools[gen_exp] - The generalized exponents of a linear homogeneous differential equation Calling Sequence: gen_exp(L,domain,T,opt) gen_exp(eqn,dvar,T,opt) Parameters: L - a differential operator domain - a list containing two names T - a name opt - (optional) a sequence of options eqn - a homogeneous linear differential equation dvar - the dependent variable Description: - The input is a differential operator L or a differential equation eqn having rational function coefficients. The output is a list of lists. Each of these lists contains one equivalence class of generalized exponents. - Let x be the dependent variable. In case a differential operator was specified then x is the second element of the list domain. In case a differential equation was specified then x is implicitely given in dvar which is of the form y(x). An element e in C[x^(-1/n)] is called a generalized exponent of L if there exists a formal solution y of the form y=exp(int(e,x)) * s where s is an element of C[[x^(1/n)]][log(x)] \ x^(1/n)*C[[x^(1/n)]][log(x)]. The name T which must be specified in the input will be used to denote x^(-1/n) * a constant. This procedure computes the generalized exponents and expresses them in terms of T. The relation between T and x is given in the output as well, in each equivalence class of generalized exponents. - If the optional argument x=p where p in P^1 (= C union {infinity}) is given then this procedure first applies a transformation DEtools[translate] to move the point p to the point 0, then computes the generalized exponents, and then substitutes x=x-p in the result (or x=1/x if p=infinity). Note that this substitution only affects the part of the output that gives the relation between T and x. If p<>infinity and the ramification index is 1 the relation between x and T given in the output is T=x-p. - If the option restrict_to=S where S is a subset of {minimal, integer, ramification1, rational} then only a subset of the generalized exponents is given. If the option minimal is in S then only the minimal generalized exponent in each equivalence class will be given. If the option integer or rational is given then only the generalized exponents in Z resp. in Q will be given. If the option ramification1 is given then only the generalized exponents with ramification index 1 (i.e. the generalized exponents in C[1/x]) will be given. - Note that the generalized exponents e in C[x^(-1/n)] will be computed only up to conjugation over the field k(x), where k is the minimal field of constants over which the input is defined. A larger field k can be specified by the option groundfield = a list of RootOf's. - The argument domain describes the differential algebra. If this argument is the list [Dx,x] then the differential operators will be notated with the symbols Dx and x. They are viewed as elements of the differential algebra C(x)[Dx] where C is the field of constants. If the argument domain is omitted then the differential specified by the environment variable _Envdiffopdomain will be used. If this environment variable is not set then the argument domain may not be omitted. - Instead of a differential operator, the input can also be a linear homogeneous differential equation having rational function coefficients. In this case the second argument must be the dependent variable. Examples: > with(DEtools): > L:=Dx^5+2*x^3*Dx^3+6*x^2*Dx^2+6*x*Dx+x^6*Dx+1; 5 3 3 2 2 6 L := Dx + 2 x Dx + 6 x Dx + 6 x Dx + x Dx + 1 > gen_exp(L,[Dx,x],T,x=infinity); 1 1 2 [[0, T = 1/x], [9/4 + ----, 11/4 + ----, -T = 1/x]] 5 5 T T > gen_exp(L,[Dx,x],T,x=infinity,'restrict_to'={'minimal'}); 1 2 [[0, T = 1/x], [9/4 + ----, -T = 1/x]] 5 T # Note: The quotes around the names in the options may be omitted unless a # value has been assigned to those names. > eqn:=diff(y(x),x,x)+y(x)/x^4=0; / 2 \ |d | y(x) eqn := |--- y(x)| + ---- = 0 | 2 | 4 \dx / x # generalized exponents at x=0 up to conjugation over Q: > gen_exp(eqn,y(x),T); 2 RootOf(_Z + 1) [[--------------- + 1, T = x]] T # generalized exponents at x=0 up to conjugation over Q(i): > gen_exp(eqn,y(x),T,'groundfield'=[RootOf(x^2+1)]); 2 2 RootOf(_Z + 1) RootOf(_Z + 1) [[- --------------- + 1, T = x], [--------------- + 1, T = x]] T T See Also: diffop,DEtools[formal_sol] ------ help page for integrate_sols ------------------------------------------- DEtools[integrate_sols] - integrate the solutions of a differential operator or equation Calling Sequence: integrate_sols(L,domain) integrate_sols(eqn,dvar) Parameters: L - a differential operator domain - a list containing two names eqn - a homogeneous linear differential equation dvar - the dependent variable Description: - The input L is a differential operator. This procedure computes an operator M of minimal order such that any solution of L has an antiderivative which is a solution of M. - If the order of L equals the order of M then the output will be a list [M, r] such that r(f) is an antiderivative of f and also a solution of M for every solution f of L. If the order of L is not equal to M then only M is given in the output. In this case M equals L*Dt where Dt is the derivation. - The second argument domain describes the differential algebra. If this argument is the list [Dt,t] then the differential operators will be notated with the symbols Dt and t. They are viewed as elements of the differential algebra C(t)[Dt] where C is the field of constants. If the argument domain is omitted then the differential specified by the environment variable _Envdiffopdomain will be used. If this environment variable is not set then the argument domain may not be omitted. - Instead of a differential operator, the input can also be a linear homogeneous differential equation having rational function coefficients. In this case the second argument must be the dependent variable. Examples: > with(DEtools): > L:=Dz+1/z; L := Dz + 1/z > integrate_sols(L,[Dz,z]); (Dz + 1/z) Dz > L:=Dz^2-3/2/z/(z-1)*Dz-(z-2)*(z^2-z+1)/z/(z-1)^2; 2 2 Dz (z - 2) (z - z + 1) L := Dz - 3/2 --------- - -------------------- z (z - 1) 2 z (z - 1) > integrate_sols(L,[Dz,z]); 2 z Dz Dz z Dz 1 [- ----- + 1/2 -------- + 1, ----- - 1/2 --------] z - 1 2 z - 1 2 (z - 1) (z - 1) > eqn:=2/x*diff(y(x),x)+1/x*diff(diff(y(x),x),x)+diff(diff(diff(y(x),x),x),x);\ > 2 d d --- y(x) -- y(x) 2 / 3 \ dx dx |d | eqn := 2 ------- + -------- + |--- y(x)| x x | 3 | \dx / > integrate_sols(eqn,y(x)); / 2 \ / 3 \ /d \ |d | 2 |d | [y(x) + (x + 1/2) |-- y(x)| - 1/2 x |--- y(x)| + 1/2 x |--- y(x)|, \dx / | 2 | | 3 | \dx / \dx / / 2 \ /d \ 2 |d | (-x - 1/2) y(x) + 1/2 x |-- y(x)| - 1/2 x |--- y(x)|] \dx / | 2 | \dx / See Also: diffop,DESols ------ help page for GCRD ------------------------------------------- DEtools[GCRD] - Greatest Common Right Divisor of 2 differential operators Calling Sequence: GCRD(f,g,domain) Parameters: f,g - differential operators domain - a list containing two names Description: - For operators f and g there exists an operator R such that the solution space of R is the intersection of the solution spaces of f and g. The output of this procedure is this operator R. Like the gcd for polynomials, this R is a combination R=a*f+b*g for some operators a and b. - The argument domain describes the differential algebra. If this argument is the list [Dt,t] then the differential operators will be notated with the symbols Dt and t. They are viewed as elements of the differential algebra C(t)[Dt] where C is the field of constants. If the argument domain is omitted then the differential specified by the environment variable _Envdiffopdomain will be used. If this environment variable is not set then the argument domain may not be omitted. Examples: > with(DEtools): > GCRD(Dx^4, Dx^2-18*x/(1+2*x+3*x^3),[Dx,x]); 2 2 + 9 x Dx - -------------- 3 1 + 2 x + 3 x See Also: diffop,Ore_algebra[skew_gcdex] ------ help page for LCLM ------------------------------------------- DEtools[LCLM] - Least Common Left Multiple of differential operators Calling Sequence: LCLM(L1, L2,.., Ln,domain,opt) Parameters: L1, L2,.., Ln - differential operators domain - a list containing two names opt - optional arguments Description: - The least common left multiple F=LCLM(L1 .. Ln) of operators L1 .. Ln is defined as the operator with minimal order such that all solutions L1 .. Ln are solutions of F as well. - If the optional argument 'groundfield'=ext where ext is a list of RootOf's is given then LCLM( L1 .. Ln and all their conjugates over the field Q(ext)) is computed. This LCLM is an element of Q(ext,x)[Dx]. The quotes for the name 'groundfield' are only necessary if the variable groundfield has been given a value, otherwise they may be omitted. - The argument domain describes the differential algebra. If this argument is the list [Dt,t] then the differential operators will be notated with the symbols Dt and t. They are viewed as elements of the differential algebra C(t)[Dt] where C is the field of constants. If the argument domain is omitted then the differential specified by the environment variable _Envdiffopdomain will be used. If this environment variable is not set then the argument domain may not be omitted. Examples: > with(DEtools): > a:=RootOf(x^2-2); 2 a := RootOf(_Z - 2) > b:=RootOf(x^2-3); 2 b := RootOf(_Z - 3) > A:=[Dx,x]; A := [Dx, x] > L:=LCLM(Dx+a,Dx^2+b*Dx+x,A): > degree(L,Dx); # Order = 3 3 > L:=LCLM(Dx+a,Dx^2+b*Dx+x,A,'groundfield'=[b]): > degree(L,Dx); # Order = 4 4 > L:=LCLM(Dx+a,Dx^2+b*Dx+x,A,'groundfield'=[a]): > degree(L,Dx); # Order = 5 5 > L:=LCLM(Dx+a,Dx^2+b*Dx+x,A,'groundfield'=[]); 6 5 4 3 2 7 8 x + 12 x - 21 x - 41 x - 36 x + 56 x + 81 + x L := -2 ----------------------------------------------------- %1 5 4 3 2 (3 x + x - 60 x + 12 x + 217 x + 207) Dx + 2 -------------------------------------------- %1 6 5 4 3 2 7 2 (4 x - 14 x - 21 x + 87 x - 248 x - 214 x + 65 + x ) Dx + ------------------------------------------------------------- %1 5 4 3 2 3 (3 x - 9 x - 124 x - 60 x + 297 x + 233) Dx - ------------------------------------------------ %1 6 5 4 3 2 4 (2 x + 11 x - 16 x - 88 x + 146 x + 161 x + 24) Dx + -------------------------------------------------------- %1 3 4 2 5 (32 x - 40 x + 5 x + 36 x - 13) Dx 6 - -------------------------------------- + Dx %1 3 4 5 2 %1 := -13 x + 12 x + 8 x + x - 20 x - 8 > degree(L,Dx); # Order = 6 6 See Also: diffop,Ore_algebra[annihilators] ------ help page for DEtools[adjoint] ------------------------------------------- DEtools[adjoint] - Adjoint of a differential operator Calling Sequence: adjoint(L,domain) adjoint(eqn,dvar) Parameters: L - a differential operator domain - a list containing two names eqn - a homogeneous linear differential equation dvar - the dependent variable Description: - If the input L is the differential operator a_0 * Dx^0 + ... + a_n * Dx^n then the output is (-1)^n * ( mult((-Dx)^0,a_0) + ... + mult((-Dx)^n,a_n) ). - The adjoint has the following properties: adjoint(adjoint(L)) = L and mult(adjoint(L), adjoint(M)) = adjoint(mult(M,L)). So applying the adjoint results in switching the order of multiplication; the adjoint is an anti-automorphism of C(x)[Dx], multiplied by (-1)^n. - The argument domain describes the differential algebra. If this argument is the list [Dx,x] then the differential operators will be notated with the symbols Dx and x. They are viewed as elements of the differential algebra C(x)[Dx] where C is the field of constants. If the argument domain is omitted then the differential specified by the environment variable _Envdiffopdomain will be used. If this environment variable is not set then the argument domain may not be omitted. - Instead of a differential operator, the input can also be a linear homogeneous differential equation eqn. In this case the second argument dvar must be the dependent variable. Examples: > with(DEtools): > _Envdiffopdomain:=[Dx,x]; # so the domain need not be specified anymore _Envdiffopdomain := [Dx, x] > L:=Dx^5+2*x^3*Dx^3+6*x^2*Dx^2+6*x*Dx+x^6*Dx+1; 5 3 3 2 2 6 L := Dx + 2 x Dx + 6 x Dx + 6 x Dx + x Dx + 1 > adjoint(L); 5 6 2 2 3 3 5 5 + 6 x + 18 x Dx + x Dx + 12 x Dx + 2 x Dx + Dx > adjoint(%); # this equals L 5 3 3 2 2 6 Dx + 2 x Dx + 6 x Dx + 6 x Dx + x Dx + 1 > adjoint( diff(y(x),x) + y(x) ,y(x)); /d \ -y(x) + |-- y(x)| \dx / See Also: diffop,DEtools[mult] ------ help page for de2diffop ------------------------------------------- DEtools[de2diffop] - Convert a differential equation to a differential operator DEtools[diffop2de] - Convert a differential operator to a differential equation Calling Sequence: de2diffop(eqn,dvar,domain) diffop2de(L,dvar,domain) Parameters: L - a differential operator domain - a list containing two names eqn - a homogeneous linear differential equation dvar - the dependent variable Description: - An element L in C(x)[Dx] corresponds to a linear homogeneous differential equation L( y(x) ) = 0. These two procedures convert between the operator L and the equation L( y(x) ). See also the help page diffop on linear differential operators. - The argument domain describes the differential algebra. If this argument is the list [Dx,x] then the differential operators will be notated with the symbols Dx and x. They are viewed as elements of the differential algebra C(x)[Dx] where C is the field of constants. If the argument domain is omitted then the differential specified by the environment variable _Envdiffopdomain will be used. If this environment variable is not set then the argument domain may not be omitted. Examples: > with(DEtools): > _Envdiffopdomain:=[Dx,x]: > L:=Dx^2+x; 2 L := Dx + x > diffop2de(L,y(x)); / 2 \ |d | x y(x) + |--- y(x)| | 2 | \dx / > de2diffop(%,y(x)); 2 Dx + x See Also: diffop ------ help page for exterior_power ------------------------------------------- DEtools[exterior_power] - the exterior power of a differential operator Calling Sequence: exterior_power(L,n,domain) exterior_power(eqn,n,dvar) Parameters: L - a differential operator n - a positive integer domain - a list containing two names eqn - a homogeneous linear differential equation dvar - the dependent variable Description: - The input L is a differential operator. The output of this procedure is a linear differential operator M of minimal order such that for all solutions y1 .. yn of L the determinant of the Wronskian w = det(matrix(n,n,[y1,y1',y1'', .. , y2,y2',y2'', .. , yn,yn',yn'', ..]) is a solution of M. An important property of the exterior power M is the following: If L has rational functions coefficients and L has a right-hand factor of order n then M has a right-hand factor of order 1 (in other words: M has an exponential solution exp(int(R(x),x)) where R is a rational function). - The argument domain describes the differential algebra. If this argument is the list [Dt,t] then the differential operators will be notated with the symbols Dt and t. They are viewed as elements of the differential algebra C(t)[Dt] where C is the field of constants. If the argument domain is omitted then the differential specified by the environment variable _Envdiffopdomain will be used. If this environment variable is not set then the argument domain may not be omitted. - Instead of a differential operator, the input can also be a linear homogeneous differential equation eqn. In this case the third argument must be the dependent variable dvar. Examples: > with(DEtools): > A:=[Dx,x]; A := [Dx, x] > L:=Dx^4-2*Dx-x^2; 4 2 L := Dx - 2 Dx - x > M:=exterior_power(L,2,A); 2 2 6 M := 12 x Dx + 4 x Dx + Dx > exterior_power( diff(y(x),x,x,x) - y(x), 2, y(x)); / 3 \ |d | y(x) + |--- y(x)| | 3 | \dx / See Also: diffop,DEtools[expsols] ------ help page for mult ------------------------------------------- DEtools[mult] - Multiplication of differential operators Calling Sequence: mult(L1, L2,.., Ln,domain) Parameters: L1, L2,.., Ln - differential operators domain - a list containing two names Description: - The argument domain describes the differential algebra. If this argument is the list [Dt,t] then the differential operators will be notated with the symbols Dt and t. They are viewed as elements of the differential algebra C(t)[Dt] where C is the field of constants. If the argument domain is omitted then the differential specified by the environment variable _Envdiffopdomain will be used. If this environment variable is not set then the argument domain may not be omitted. - This procedure computes products in the differential algebra C(t)[Dt]. The multiplication in this ring is defined by Dt*a=diff(a,t)+a*Dt for all a in C(t). Examples: > with(DEtools): > mult(Dt,t*Dt,[Dt,t]); 2 Dt + t Dt See Also: diffop,DEtools[DFactor], Ore_algebra[skew_product] ------ help page for rightdivision ------------------------------------------- DEtools[rightdivision] - right-hand division of differential operators DEtools[leftdivision] - left-hand division of differential operators Calling Sequence: rightdivision(a,b,domain) leftdivision(a,b,domain) Parameters: a,b - differential operators domain - a list containing two names Description: - For operators a and b there exist (like for polynomials, see quo) operators q and r such that a = q*b + r and order(r) < order(b). The output rightdivision is the list [q,r]. - The procedure leftdivision does precisely the same, only the order of multiplication q*b is reversed: b*q. - The argument domain describes the differential algebra. If this argument is the list [Dt,t] then the differential operators will be notated with the symbols Dt and t. They are viewed as elements of the differential algebra C(t)[Dt] where C is the field of constants. If the argument domain is omitted then the differential specified by the environment variable _Envdiffopdomain will be used. If this environment variable is not set then the argument domain may not be omitted. Examples: > with(DEtools): > rightdivision(Dt^4, Dt^2-18*t/(1+2*t+3*t^3),[Dt,t]); 3 2 3 5 2 t (-1 + 6 t ) Dt -2 - 9 t + 12 t + 54 t [Dt + 18 --------------, -36 ----------------- + 36 ------------------------- 3 3 2 3 3 1 + 2 t + 3 t (1 + 2 t + 3 t ) (1 + 2 t + 3 t ) ] See Also: diffop,Ore_algebra[skew_pdiv] ------ help page for symmetric_product ------------------------------------------- DEtools[symmetric_product] - Symmetric product of differential operators Calling Sequence: symmetric_product(L1, L2, .., Ln,domain) Parameters: L1, L2,.., Ln - differential operators domain - a list containing two names Description: - Let L1, L2, .., Ln be differetial operators. The output of this procedure is a linear differential operator M of minimal order such that for every solution y1 of L1, y2 of L2, .., yn of Ln, the product y1*y2*...*yn is a solution of M. Note that "symmetric product" is not a proper mathematical name for this construction on the solution space; it is a homomorphic image of the tensor product. The reason for chosing the name symmetric_product is the resemblance with the function symmetric_power. - The argument domain describes the differential algebra. If this argument is the list [Dt,t] then the differential operators will be notated with the symbols Dt and t. They are viewed as elements of the differential algebra C(t)[Dt] where C is the field of constants. If the argument domain is omitted then the differential specified by the environment variable _Envdiffopdomain will be used. If this environment variable is not set then the argument domain may not be omitted. Examples: > with(DEtools): > A:=[Dx,x]; A := [Dx, x] > L:=Dx^2+a(x)*Dx+b(x); 2 L := Dx + a(x) Dx + b(x) # A solution of Dx-c(x) is exp(int(c(x),x)) so the solutions of the following # operator M equal exp(int(c(x),x)) * (the solutions of L). > M:=symmetric_product(L,Dx-c(x),A); 2 /d \ 2 M := Dx + (-2 c(x) + a(x)) Dx + b(x) - a(x) c(x) - |-- c(x)| + c(x) \dx / See Also: diffop,DEtools[symmetric_power] ------ help page for symmetric_power ------------------------------------------- DEtools[symmetric_power] - the symmetric power of a differential equation or operator Calling Sequence: symmetric_power(L,m,domain) symmetric_power(eqn,m,dvar) Parameters: L - a differential operator m - a positive integer domain - a list containing two names eqn - a homogeneous linear differential equation dvar - the dependent variable Description: - The input L is a differential operator. The output of this procedure is a linear differential operator M of minimal order such that for every set of m solutions y1,..,ym of L the product y1*y2*...*ym is a solution of M. - The argument domain describes the differential algebra. If this argument is the list [Dt,t] then the differential operators will be notated with the symbols Dt and t. They are viewed as elements of the differential algebra C(t)[Dt] where C is the field of constants. If the argument domain is omitted then the differential specified by the environment variable _Envdiffopdomain will be used. If this environment variable is not set then the argument domain may not be omitted. - Instead of a differential operator, the input can also be a linear homogeneous differential equation having rational function coefficients. In this case the third argument must be the dependent variable. Examples: > with(DEtools): > A:=[Dx,x]; A := [Dx, x] > L:=Dx^2+a(x)*Dx+b(x); 2 L := Dx + a(x) Dx + b(x) > M:=symmetric_power(L,2,A); /d \ / 2 /d \ \ M := 4 a(x) b(x) + 2 |-- b(x)| + |2 a(x) + |-- a(x)| + 4 b(x)| Dx \dx / \ \dx / / 2 3 + 3 a(x) Dx + Dx > symmetric_power( diff(y(x),x,x), 2, y(x)); 3 d --- y(x) 3 dx See Also: diffop,DEtools[symmetric_product] ------ help page for algcurves ------------------------------------------- The algebraic curves package Calling Sequence: algcurves[ function ] ( args ) or function ( args ) Description: - To use a algcurves function, either define that function alone using the command with(algcurves, function), or define all algcurves functions using the command with(algcurves). Alternatively, invoke the function using the long form algcurves[function]. This long form notation is necessary whenever there is a conflict between a package function name and another function used in the same session. - The functions available are: Weierstrassform genus homogeneous integral_basis j_invariant parametrization plot_knot puiseux singularities - For more information on a particular function see algcurves[function]. See Also: with, geometry ------ help page for Weierstrassform ------------------------------------------- algcurves[Weierstrassform] - compute an isomorphism for function fields with genus 1 Calling Sequence: Weierstrassform(f,x,y,x0,y0,opt) Parameters: f - a polynomial in x and y representing a curve of genus 1 x,y,x0,y0 - variables opt - (optional) a sequence of options Description: - An algebraic function field Qbar(x)[y]/(f) where Qbar is the algebraic closure of Q is isomorphic to the field Qbar(x0)[y0]/(f0) where f0 is of the form y0^2 + square free polynomial in x0 of degree 3 if and only if the genus is equal to 1. This procedure computes such an isomorphism. - The output of genus is a list of 5 items containing: The curve f0 The image of x0 under this isomorphism The image of y0 under this isomorphism The image of x under the inverse isomorphism The image of y under the inverse isomorphism - A regular point [x,y,z] on the curve can be specified as a 6'th argument. Then x0 and y0 will have their poles at this point on the curve. If the option `no inverse` is used then the inverse isomorphism is not computed. The option 'Weierstrass' results in a Weierstrass normal form i.e. y0^2 - 4*x0^3 - a*x0 - b. Examples: > with(algcurves): > f:=x^4+y^4-2*x^3+x^2*y-2*y^3+x^2-x*y+y^2: > v:=Weierstrassform(f,x,y,x0,y0); 3 2 -3 y + 2 x v := [x0 + 2/3 x0 + 1/108 + y0 , 1/3 ----------, x 2 2 3 2 3 -x + 2 x y - 2 x y + x - 2 y + 2 y - 1/2 ---------------------------------------, 2 x (x - 1) 2 3 -108 x0 + 45 x0 - 52 + 54 x0 (3 x0 - 2) y0 - 3/2 ------------------------------ - 27 -------------, %1 %1 4 3 2 2 162 x0 - 432 x0 + 351 x0 - 246 x0 + 104 (3 x0 - 2) y0 1/2 ------------------------------------------ + 9 --------------] %1 %1 2 3 4 %1 := 97 - 96 x0 + 216 x0 - 216 x0 + 81 x0 > # check if the image of x and y still satisfy the relation f in > # the field Qbar(x0)[y0]/(f0) > subs({x=v[4],y=v[5]},f): > evala(subs(y0=RootOf(v[1],y0),%)); 0 > # check if the image of x0 and y0 still satisfy the relation f0 in > # the field Qbar(x)[y]/(f) > subs({x0=v[2],y0=v[3]},v[1]): > evala(subs(y=RootOf(f,y),%)); 0 See Also: algcurves[genus],algcurves[j_invariant] ------ help page for genus ------------------------------------------- algcurves[genus] - The genus of an algebraic curve Calling Sequence: genus(f,x,y,opt) Parameters: f - a squarefree polynomial specifying an algebraic curve x,y - variables opt - (optional) a sequence of options Description: - The genus of an irreducible algebraic curve is a nonnegative integer. However, if f is reducible this procedure could give a negative outcome. By default, this procedure does not check if f is irreducible. This default can be altered by giving the optional argument `irr check`. The polynomial f must be squarefree, otherwise an error message follows. Examples: > with(algcurves): > f:=x^2+x*y+y^2; 2 2 f := x + x y + y > factor(f); # It is irreducible in Q[x,y] 2 2 x + x y + y > genus(f,x,y); # The result is impossible for an irreducible curve -1 > evala(AFactor(f)); # So f must be reducible over the algebraic numbers 2 2 (x + (1 + 1/4 RootOf(_Z + 4 _Z + 16)) y) (x - 1/4 y RootOf(_Z + 4 _Z + 16)) > f:=subs(z=1 , 761328152*x^6*z^4-5431439286*x^2*y^8+2494*x^2*z^8+ > 228715574724*x^6*y^4+9127158539954*x^10-15052058268*x^6*y^2*z^2+ > 3212722859346*x^8*y^2-134266087241*x^8*z^2-202172841*y^8*z^2 > -34263110700*x^4*y^6-6697080*y^6*z^4-2042158*x^4*z^6-201803238*y^10+ > 12024807786*x^4*y^4*z^2-128361096*x^4*y^2*z^4+506101284*x^2*z^2*y^6+ > 47970216*x^2*z^4*y^4+660492*x^2*z^6*y^2-z^10-474*z^8*y^2-84366*z^6*y^4 ): # This f is a polynomial of degree 10 having a maximal number of cusps # according to the Plucker formulas. It was found by Rob Koelman. It has 26 # cusps and no other singularities, hence the genus is 10. > genus(f,x,y); 10 See Also: algcurves[singularities],algcurves[parametrization] ------ help page for algcurves[homogeneous] ------------------------------------------- algcurves[homogeneous] - Make a polynomial in two variables homogeneous in three variables. Calling Sequence: homogeneous(f,x,y,z) Parameters: f - a polynomial in x and y x,y,z - variables Description: - Algebraic curves are often represented using a polynomial in two variables, or as a homogeneous polynomial in three variables. This procedure converts to the homogeneous representation. - If f is a polynomial in x and y of degree d, and f can be written as Sum c[i,j] * x^i * y^j for some coefficients c[i,j], then the output of this procedure is Sum c[i,j] * x^i * y^j * z^(d-i-j). Examples: > with(algcurves): > f:=y^2-x^3; 2 3 f := y - x > homogeneous(f,x,y,z); 3 2 -x + y z # Now one can convert back as follows: > subs(z=1,%); 2 3 y - x See Also: algcurves ------ help page for algcurves[integral_basis] ------------------------------------------- algcurves[integral_basis] - Integral bases of algebraic function fields Calling Sequence: integral_basis(a) integral_basis(a, x) integral_basis(f, x, y, S) Parameters: a - an algebraic function or a set of algebraic functions x - a variable y - a variable f - a squarefree polynomial in x and y S - (optional) a set of irreducible polynomials in x Description: - This procedure computes an integral basis over L[x] for an algebraic function field L(x)(a), where L denotes the coefficient field. An integral basis is a basis of the L[x]-module of functions which have no poles, except maybe at x=infinity. There are several ways to specify the function field under consideration: - by a RootOf a representing an algebraic function in the variable x. The polynomial defining the RootOf need not be irreducible but must be squarefree. If it is not irreducible, then a basis for the product of fields generated by the irreducible factors is computed. - by a set a of RootOfs representing algebraic functions of x. In this case, the RootOfs must be independent. - by a squarefree polynomial f over L in x and y. If f is irreducible, then an integral basis for the field generated by one of its roots is computed. If f is reducible, then an integral basis for the product of fields generated by the irreducible factors is computed. - The coefficient field L can be the field of rational numbers, a field of rational functions over the rational numbers or any algebraic extension of those. An algebraic extension may be specified in radical or RootOf notation. If the RootOf notation is used, then the RootOfs must be independent. - The output is a list of elements of the function field which generate (as L[x]-module) the integral closure of L[x] in the function field L(x)[a]. If the input is a polynomial, then the output will expressed in terms of the variable y. If the input is a RootOf or a set of RootOfs, then these RootOfs will be used to represent the basis. - If a contains no other variable than x, then the second argument x is not necessary. Note that in this case, L is an algebraic extension of the rational numbers. - By setting infolevel[integral_basis] or infolevel[algcurves] to a positive value some information will be printed during the computation. - The method used to compute an integral basis is based on Puiseux expansions, c.f. "An algorithm for computing an integral basis in an algebraic function field", J. of Symbolic Computation, 1994, 18, p. 353-363. - If the optional argument S is given then all factors of the discriminant that do not appear in S will be ignored in the algorithm. Then the output will be an integral basis over L[x]_(p) for each polynomial p in S, (i.e. a local integral basis at p for each p in S). Examples: > with(algcurves): > alpha:=RootOf(x^3+7,x); 3 alpha := RootOf(_Z + 7) > f:=y^8+3*x*y^5*alpha+5*x^4+x^6*alpha; 8 5 3 4 6 3 f := y + 3 x y RootOf(_Z + 7) + 5 x + x RootOf(_Z + 7) > integral_basis(f,x,y); 3 4 2 3 3 2 y y y (3 x RootOf(_Z + 7) + y ) [1, y, y , ----, ----, -----------------------------, x x 2 x 3 3 3 4 3 3 y (3 x RootOf(_Z + 7) + y ) y (3 x RootOf(_Z + 7) + y ) -----------------------------, -----------------------------] 2 3 x x > g := y^4-2*x*y^2+2*2^(1/2)*y^2+x^2-2*2^(1/2)*x+2+y^6; 4 2 1/2 2 2 1/2 6 g := y - 2 x y + 2 2 y + x - 2 2 x + 2 + y > integral_basis(g,x,y); 2 2 1/2 2 1/2 2 2 4 2 3 y (1 + y ) y (-x + 2 + x y - 2 y + y + y ) [1, y, y , y , -----------, ----------------------------------------] 1/2 1/2 2 x - 2 (x - 2 ) > r := RootOf(_Z^3+_Z^2-x^4); 3 2 4 r := RootOf(_Z + _Z - x ) > integral_basis(r); [ 3 2 4 3 2 4 3 2 4 RootOf(_Z + _Z - x ) (RootOf(_Z + _Z - x ) + 1) 1, RootOf(_Z + _Z - x ), --------------------------------------------------- 2 x ] See Also: algcurves[puiseux], numtheory[integral_basis] ------ help page for j_invariant ------------------------------------------- algcurves[j_invariant] - The j invariant of an elliptic curve Calling Sequence: j_invariant(f,x,y) Parameters: f - a polynomial in x and y representing a curve of genus 1 x,y - variables Description: - For algebraic curves with genus 1 one can compute a number called the j invariant. An important property of this j invariant is the following: two elliptic (i.e. genus = 1) curves are birationally equivalent (i.e. can be transformed to each other with rational transformations over an algebraically closed field of constants) if and only if their j invariants are the same. - The curve must be irreducible and have genus 1, otherwise the j invariant is not defined and this procedure will fail. Examples: > with(algcurves): > f:=y^5+4/3-23/3*y^2+11*y^3-17/3*y^4-16/3*x^2+16/3*x^3-4/3*x^4: > # Check that the genus is 1, because only then is the j invariant defined. > genus(f,x,y); 1 > j_invariant(f,x,y); -1404928 -------- 171 See Also: algcurves[genus],algcurves[Weierstrassform] ------ help page for parametrization ------------------------------------------- algcurves[parametrization] - Compute a parametrization for a curve with genus 0 Calling Sequence: parametrization(f,x,y,t) Parameters: f - an irreducible polynomial in x and y, with genus 0 x,y,t - variables Description: - This procedure computes, if it exists, a parametrization of an algebraic curve f. A parametrization is a birational equivalence from a projective line to the given curve f. Such a parametrization exists if and only if the genus is 0 and the curve is irreducible (which can be checked by AFactor). - The output of the procedure is a list [X(t),Y(t)] of rational functions in t, such that [X(t),Y(t)] is a point on the curve f for every value of t. - For a description of the method used see M. van Hoeij, "Rational Parametrizations of Algebraic Curves using a Canonical Divisor", 23, p. 209-227, JSC 1997. Examples: > with(algcurves): > f:=y^5+2*x*y^2+2*x*y^3+x^2*y-4*x^3*y+2*x^5: > v:=parametrization(f,x,y,t); 2 3 4 t (8 + 212 t + 2070 t + 8775 t + 13500 t ) v := [-----------------------------------------------------, 5 4 3 2 107897 t + 71590 t + 18920 t + 2480 t + 160 t + 4 2 3 4 t (2 + 39 t + 276 t + 848 t + 960 t ) -2 -----------------------------------------------------] 5 4 3 2 107897 t + 71590 t + 18920 t + 2480 t + 160 t + 4 # Now subs(t=any number,v) should be a point on the curve. Test the result # (this should be 0): > normal(subs(x=v[1],y=v[2],f)); 0 > parametrization(x^4+y^4+a*x^2*y^2+b*y^3,x,y,t); 3 3 4 t b t b [- -----------------, - -----------------] 8 2 4 4 8 2 4 4 b + t b a + t b + t b a + t See Also: algcurves[genus],AFactor ------ help page for plot_knot ------------------------------------------- algcurves[plot_knot] - make a tubeplot for a singularity knot Calling Sequence: plot_knot(f,x,y,opt) Parameters: f - an algebraic curve with a singularity at the point 0 x,y - variables opt - (optional) a sequence of options Description: - Let f be a polynomial in x and y giving an algebraic curve in the plane C^2 with a singularity at the point (x,y)=(0,0). The output of this procedure is called the singularity knot of this singularity. This knot is defined as follows: By identifying C^2 with R^4 the curve can be viewed as a 2-dimensional surface over the real numbers. This procedure computes the intersection of this surface with a sphere in R^4 with radius epsilon and center 0. The intersection consists of a number of closed curves over the real numbers. After applying a projection from the sphere (which is 3 dimensional over R) to R^3 these curves can be plotted by the tubeplot command in the plots package. Such a plot gives information about the singularity of f at the point 0. See also: E. Brieskorn, H. Kn"orrer: Ebene Algebraische Kurven, Birkh"auser 1981. - The curve given by f need not be irreducible, but f must be squarefree otherwise this procedure does not work. - If printlevel > 1 the number of branches will be printed to the screen. Each branch (i.e. place above the point 0) corresponds to one component in the knot. - OPTIONS: epsilon: the radius of the sphere. The default is 1. In some cases a smaller number must be chosen for the picture to be correct. colours: Specifying a list of colors results in a plot where each branch gets its own color. The options for tubeplot can be used as well. In plot_knot these options have the following default values: numpoints=150, radius=0.05, tubepoints=5, scaling=CONSTRAINED and style=PATCHNOGRID. Examples: > with(algcurves): > printlevel:=2: > plot_knot(y^2-x^3,x,y); > f:=(y^3-x^7)*(y^2-2*x^5); > plot_knot(f,x,y,epsilon=0.8,radius=0.03,colours=[blue,red]); > plot_knot(f+y^3,x,y,epsilon=0.8); > plot_knot(f+y^3,y,x,epsilon=0.8); # Same knot, but it looks > # different because the projection point is different now > # that x and y are switched. > f:=(y^3-x^7)*(y^2-2*x^5)*(y^2+2*x^5); > plot_knot(f,y,x,epsilon=0.8,radius=0.03,colours=[blue,red,pink]); > g:=(y^3-x^7)*(y^3-x^7+100*x^13)*(y^3-x^7-100*x^13); > plot_knot(g,x,y,epsilon=0.8,radius=0.03,numpoints=250,\ > colours=[blue,red,green]); See Also: plots[tubeplot] ------ help page for puiseux ------------------------------------------- algcurves[puiseux] - determines the Puiseux expansions of an algebraic function Calling Sequence: puiseux(a,x=p,n) puiseux(f,x=p,y,n) puiseux(f,x=p,y,n,T) Parameters: a - an algebraic function in RootOf form x=p - gives the point around which the expansions are computed n - a number specifying the desired accuracy of the expansions y - a variable f - a squarefree polynomial in x and y T - (optional) a variable, used for obtaining a different output syntax Description: - A squarefree polynomial f of degree N in the variable y with coefficients in a field L(x) has N roots in the algebraic closure of the field L((x-p)). These roots are called the Puiseux expansions of f at x=p. Each Puiseux expansion is of the form Sum(a_i * (x-p)^(i/r),i=-N..infinity) for some integer r (r is called the ramification index of the Puiseux expansion), and some integer N and elements a_i in the algebraic closure of L. - The polynomial f must be squarefree, otherwise the puiseux procedure does not work. - If f is irreducible then f gives an algebraic extension L(x)[y]/(f) of L(x). Instead of giving f, this algebraic extension can also be specified with a RootOf a of f. This a can be viewed as a multivalued function in x. The Puiseux expansions give the local expansions of this multivalued function. - The procedure puiseux determines the field L from the input. The groundfield L of the computation is the smallest field such that f and p are in L(x)[y]. - The Puiseux expansions are only computed up to conjugation over L((x-p)). So if a number of expansions are algebraically conjugated over L((x-p)) then only one of these expansions is given. - The Puiseux expansions are computed modulo x^n. So if for instance n=10, then the term x^(49/5) would be computed, but not the term x^10. If n=0 then the expansions are not computed modulo x^0, but in this case the number of terms that is computed is precisely the number that is needed to distinguish the expansions from the other expansions. If n='minimal' then the same output is given. - To avoid an output containing fractional powers of x one can specify a fifth argument T. Then the Puiseux expansions in the output are represented in a different way, namely as [x = (a constant)*(a power of T) , y = a power series in T]. So then x and y are expressed in terms of a local parameter. - NOTE: The Maple "alias" function does not recognize an alias in terms of another alias. Therefore, you must not use nested aliasses for algebraic numbers because then the puiseux algorithm is not able to construct the field L over which the algebraic function is defined. Examples: > with(algcurves): > alpha:=RootOf(x^3+7); 3 alpha := RootOf(_Z + 7) > f:=y^8+x*y^5+x^4-x^6*alpha; 8 5 4 6 3 f := y + x y + x - x RootOf(_Z + 7) > puiseux(f,x=0,y,0); # is the same as puiseux(RootOf(f,y),x=0,0); 3/5 1/3 {-x , (-x) } > puiseux(f,x=0,y,5); / 25389 3 2\ 23/5 42 3 21/5 {|------ + 2/25 RootOf(_Z + 7) | x + --- RootOf(_Z + 7) x \ 15625 / 125 483 19/5 3 17/5 3 3 13/5 - --- x + 4/25 RootOf(_Z + 7) x - 2/5 x + 1/5 RootOf(_Z + 7) x 625 11/5 7/5 3/5 - 6/25 x - 1/5 x - x , 170 13/3 3 11/3 3 5/3 1/3 - --- (-x) + 1/3 RootOf(_Z + 7) (-x) + 2/3 x - 1/3 (-x) + (-x) 81 } # To get all 8 Puiseux expansions substitute all conjugates over L((x)) of # x^(1/5) and (-x)^(1/3) in this set. See Also: series ------ help page for singularities ------------------------------------------- algcurves[singularities] - The singularities of an algebraic curve Calling Sequence: singularities(f,x,y) Parameters: f - a polynomial specifying an algebraic curve x,y - variables Description: - Let f be a squarefree polynomial in x and y. Then f defines an algebraic curve in the plane C^2, and also in the projective plane P^2 by making f homogeneous. This procedure computes the singular points of the curve in the projective plane. The points are given by homogeneous co-ordinates [X,Y,Z]. For each singularity this procedure also computes the multiplicity and the delta invariant. - The output of this procedure is a set consisting of lists of the following form [ point , multiplicity , delta invariant]. - This procedure computes all singularities up to conjugation. So if a singularity [RootOf(_Z^2-2),1,1] is given in the output, and if RootOf(_Z^2-2) does not appear in the input, then [-RootOf(_Z^2-2),1,1] is a singular point as well but will not be given in the output. - The genus of a curve is the number (d-1)*(d-2)/2 - Sum(delta invariants) where d is the degree of the curve. Note that if we apply this formula to compute the genus, then for each singularity we must multiply the delta invariant by the degree of the algebraic extension over which the singularity is defined, because only 1 singularity of each conjugacy class is given in the output. Examples: > with(algcurves): > f:=-8*y^5-207*y*x^4+180*x^5-35*y^4-128*y^3*x+621*y*x^3-450*x^4+ > 82*y^3-521*y*x^2+369*x^3-19*y^2+135*y*x-100*x^2-28*y-7*x+8; 5 4 5 4 3 3 4 3 f := -8 y - 207 y x + 180 x - 35 y - 128 y x + 621 y x - 450 x + 82 y 2 3 2 2 - 521 y x + 369 x - 19 y + 135 y x - 100 x - 28 y - 7 x + 8 > degree(f,{x,y}); 5 > singularities(f,x,y); {[[0, 1, 1], 2, 1], [[1, 0, 1], 2, 1], [[1, -1, 1], 2, 1], 2 2 [[RootOf(_Z + 1), RootOf(_Z + 1), 1], 2, 1]} # Note that the conjugate (replace RootOf(_Z^2+1) by -RootOf(_Z^2+1)) is also a # singularity. So the genus is (5-1)*(5-2)/2-1-1-1-2*1=1 See Also: algcurves[puiseux],algcurves[genus],singular