<<

. 29
( 33 .)



>>


> read("o3np.mpl");

from the MAPLE command line. The file contains code for
initialization and function defitions.


The remainder of this README file contains the declarations
and comment lines for the two main functions defined in the
o3np file.



order_3_no_pole := proc( f, g, x )
#
# This procedure takes as input the polynomials f and g in x,
# and returns as output a paragraph describing the Galois group
# of the operator D^3 + fD + g over C(x), where C is the
# field of algebraic numbers.
#
# It is a wrapper function for o3np, providing a text description
# for the output of that procedure; see o3np code and comments
# for details.
#


o3np := proc( a, b, x )
#
#
#
#
# Takes as input the polynomials a and b in the
# indeterminate x, with algebraic number coefficients.
#
#
# Computes the Galois group of Dx^3 + a*Dx + b over the field
# of rational functions with algebraic number coefficients.


126
#
#
# Returns as output a list of the form
#
# [ U, P, Conj ].
#
# where U is the name of a unipotent group, P is the name of a
# reductive group, and the conjugation action of P on U is
# described by Conj.
#
#
# A nontrivial unipotent group U is one of the following:
#
# "U3", "C^2", "C", "0".
#
#
# A reductive group P is one of the following:
#
# "SL3", "PSL2", "GL2", "SL2", "C*^2" (i.e., C* x C*), "C*", "1".
#
#
#
# The conjugation action Conj for a semidirect product
# is represented in one of the following ways, depending on U and P:
#
# *** If U = 0, then Conj = "0"
#
# *** C^2 by SL2 or GL2:
# Conj = "matrix_vector" or "vector_transpose_matrix_inverse"
#
# *** C by C*:
# Conj = d, where t.u = t^d * u for t in C*, u in C
#
# *** C by C*^2:
# Conj = [d1,d2], where (t1,t2).u = t1^d1 * t2^d2 * u
# for t1, t2 in C*, u in C
#
# *** C^2 by C*:
# Conj = [d1,d2], where t.(u1,u2) = (t^d1 * u1, t^d2 * u2)
# for t in C*, u1, u2 in C
#
# *** C^2 by C*^2:
# Conj = [ [d1,d2], [e1,e2] ] where
#
# (t1,t2).(u,v) = ( t1^d1 * t2^d2 * u, t1^e1 * t2^e2 * v )
#
# for t1, t2 in C*, u, v in C
#
# *** U3 by C*:


127
# Conj. = [d1, d2], where C* embeds in SL3 via
# t |--> diag( t^d1, t^d2, t^(-d1-d2) ) and
# U3 is the group of upper triangular matrices in SL3 with
# 1s along the diagonal.
#
# *** U3 by C*^2:
# Conj. = "standard". In this case, the group is conjugate to
# T3 intersect SL3, the group of upper triangular matrices in
# SL3. Thus there is only one possible conjugation action.
#
#




A.2 Maple code
# File o3np.mpl
# by Peter Berman.
# Version 1.0. July 23, 2001. Compatible with Maple 6.


#
# CONTENTS:
#
# I. Initialization, general tools
# II. compute_torus code
# III. o3np code
# IV. order_3_no_pole code
#




#
# I. Initialization, general tools
#


with(linalg):
with(DEtools):



logDiff := proc( f, x );
#
# logDiff stands for LOGarithmic DIFFerentiation
#

128
return diff( f, x ) / f ;
end:



rfldtest := proc( f, x )
#
# rfld stands for Rational Function Logarithmic Derivative.
# This procedure returns TRUE if f = g™/g for some rational
# function g, FALSE otherwise.
#
local s;
s := ratsols(diff(y(x),x) - f*y(x), y(x));
if not ( s = [] ) then
return true ;
fi;
return false ;
end:


numES := proc( L, dom )
#
# numES stands for NUMber of Exponential Solutions.
# This procedure returns either a nonnegative integer
# or infinity, equal to the number of solutions of
# L(y) = 0 of the form exp(int(g)), g a rational function.
#
local Lde, es, esx, esld, n, i, j, y, t, x;
Lde := diffop2de( L, y(t), dom );
es := expsols( Lde = 0, y(t) );
n := nops( es );
if ( n = 0 ) then
return 0 ;
fi;
x := op( 2, dom );
esx := subs( t=x, es );
esld := map( logDiff, esx, x );
for i from 1 to n do
for j from (i+1) to n do
if ( rfldtest( op(i, esld) - op(j, esld), x ) ) then
return infinity ;
fi;
od;
od;
return n ;
end:




129
#
# II. compute_torus code
#




make_monic := proc( Llist, dom )
#
# Input: Llist, a list of three first-order
# operators over the domain dom whose
# product is monic
#
# Converts Llist to a list of monic first-order operators
# whose product is also equal to L. (Note: This
# is a precautionary measure. The elements of Llist
# are assumed to have been computed using the DEtools
# DFactor command, which might automatically return
# its factor list in this form.)
#
# Output: a list M of three monic first-order
# operators such that
# mult(Llist[1], Llist[2], Llist[3], dom) =
# mult(M[1], M[2], M[3], dom).
#
#
local M, f, s, Dx, x;
Dx := dom[1];
x := dom[2];
f := map( coeff, Llist, Dx, 1 );
s := map( coeff, Llist, Dx, 0 );
if ( f = [1,1,1] ) then return Llist ; fi;
M := [0,0,0];
M[1] := Dx + s[1]/f[1] + logDiff( f[2]*f[3], x );
M[2] := Dx + s[2]/f[2] + logDiff( f[3], x );
M[3] := Dx + s[3]/f[3];
M;
end:


Llist2rlist := proc( Llist, dom )
#
# Input: Llist, a list [L3, L2, L1] of first-order operators
# over dom, such that
#
# Dx^3 + a*Dx + b = mult(L3,L2,L1,dom)


130
#
# Output: A list [r3, r2, r1] of rational functions such that
#
# mult( L3, L2, L1, dom ) = mult( Dx - r3, Dx - r2, Dx - r1, dom )
#
local Mlist, Rlist, Dx, x;
Dx := dom[1];
x := dom[2];
Mlist := make_monic( Llist, dom );
Rlist := map( coeff, Mlist, Dx, 0 );
Rlist := map( x -> (-1)*x, Rlist );
Rlist;
end:



cf2 := proc( fn )
#
# Helper function; see coefficient_field below.
# This function recursively computes and returns a set
# containing all RootOfs appearing in fn.
#
local u, s;
if type( fn, RootOf ) then
return { fn } ;
fi;
if nops( fn ) = 1 then
return {} ;
fi;

<<

. 29
( 33 .)



>>