Using Deep Thought functions In the following sections, functions provided for computing Deep Thought polynomials and using them for calculations are listed.
Computing Deep Thought polynomials boolean Checks the collector coll for applicability of Deep Thought functions. Note that depending on confluency some functions may be applicable, while others are not. Information on the applicability and which type of Deep Thought polynomials are suggested is printed to the terminal. Here, "+" means that the following property is fulfilled, otherwise there is a "-". The function returns false if Deep Thought is not applicable to the collector coll and true otherwise. Anyway, even if true is returned, not all functions need to be applicable (in case of inconfluencies). a DTObj Computes a DTObj for the collector coll, either with polynomials of type f_{rs} (if rs_flag = true) or with polynomials of type f_r, if rs_flag = false. If the optional argument rs_flag is not provided, polynomials of type f_{rs} are computed. The function checks whether the collector coll is confluent. If not, a warning is displayed. Note that the function assumes the collector coll to be suitable for Deep Thought, see function DTP_DTapplicability.
gap> G := UnitriangularPcpGroup(10, 0);; gap> coll := Collector(G);; gap> DTP_DTapplicability(coll); Checking collector for DT-applicability. "+" means the following property is fulfilled. + conjugacy relations + power relations + confluent Suggestion: Call DTP_DTObjFromColl with rs_flag = true. true # calling DTP_DTObjFromCollector without rs_flag implies rs_flag = true: gap> DTObj := DTP_DTObjFromCollector(coll); <DTObj>
Computations with Deep Thought polynomials an exponent vector Computes the exponent vector of expvec^{int}. If IsConfluent(DTObj) = true, then the result is in normal form. an exponent vector Computes the exponent vector of the inverse of the element corresponding to expvec. If IsConfluent(DTObj) = true, then the result is in normal form. boolean or positive integer Checks whether expvec is in normal form or not. If yes, the return value is true. Otherwise the return value is the smallest generator index for which the normal form condition is violated, i.e. for which the relative order RelativeOrder(coll)[i] is non-zero, and expvec[i] < 0 or expvec[i] \geq RelativeOrder(coll)[i]. an exponent vector Computes the exponent vector of the product expvec1 * expvec2 using the Deep Thought polynomials. If IsConfluent(DTObj) = true, then the result is returned in normal form. DTP_Multiply either calls DTP_Multiply_r or DTP_Multiply_rs depending on which type of polynomials are stored in DTObj. an exponent vector Computes the exponent vector of the product expvec1 * expvec2 using the Deep Thought polynomials of type f_r stored in DT_Obj. If IsConfluent(DTObj) = true, then the result is returned in normal form. an exponent vector Computes the exponent vector of the product expvec1 * expvec2 using the Deep Thought polynomials of type f_{rs} stored in DT_Obj. If IsConfluent(DTObj) = true, then the result is returned in normal form. an exponent vector Computes the exponent vector of the normal form of expvec. For this function to be applicable, we need IsConfluent(DTObj) = true. positive integer or infinity Computes the order of the element described by expvec. For this function to be applicable, we need IsConfluent(DTObj) = true. an exponent vector Computes the exponent vector of the element corresponding to expvec1^{-1} * expvec2, i.e. the result solves the equation expvec1 * result = expvec2. If IsConfluent(DTObj) = true, then the result describes a normal form.
gap> G := PcGroupToPcpGroup(SmallGroup(23^5, 2)); Pcp-group with orders [ 23, 23, 23, 23, 23 ] gap> coll := Collector(G); <<from the left collector with 5 generators>> gap> DTObj := DTP_DTObjFromCollector(coll); <DTObj> gap> g := [100, 134, -31, 52, 5235]; [ 100, 134, -31, 52, 5235 ] gap> DTP_IsInNormalForm(g, DTObj); 1 gap> g := DTP_NormalForm(g, DTObj); [ 8, 19, 15, 10, 19 ] gap> DTP_IsInNormalForm(g, DTObj); true gap> DTP_Inverse(g, DTObj); [ 15, 4, 22, 12, 3 ] gap> DTP_Order(g, DTObj); 529 gap> h := [142, 2, -41, 23, 1]; [ 142, 2, -41, 23, 1 ] gap> DTP_Multiply(g, h, DTObj); [ 12, 21, 4, 16, 20 ]
Computations with pcp-elements When Deep Thought polynomials are available, certain computations allow different approaches which may be faster than the methods used by default. In this section, computations for which such extra functions taking pcp-elements as input are available are listed. All of these functions expect the collector belonging to the pcp-elements to be a DTObj. pcp-element Returns the pcp-element pcp-element^{int}. If IsConfluent(DTObj) = true, then the result is in normal form. pcp-element Returns the pcp-elment pcp-element^-1. If IsConfluent(DTObj) = true, then the result is in normal form. pcp-element Returns a pcp-element which is the normal form of the input pcp-element. For this function to be applicable, we need IsConfluent(DTObj) = true. positive integer or infinity Computes the order of the pcp-element. For this function to be applicable, we need IsConfluent(DTObj) = true. pcp-element Returns the pcp-element pcp-element1^{-1} * pcp-element2, i.e. the result solves the equation pcp-element1 * pcp-element = pcp-element2. If IsConfluent(DTObj) = true, then the result describes a normal form.
gap> G := HeisenbergPcpGroup(7);; gap> coll := Collector(G);; gap> DTObj := DTP_DTObjFromCollector(coll);; gap> H := PcpGroupByCollector(DTObj);; gap> g := Random(H);; h := Random(H);; gap> DTP_PCP_SolveEquation(g, h); g1^-3*g2^-1*g3^-7*g4*g5^-6*g6*g7*g8^2*g9^3*g11^-4*g12^5*g14^-2*g15^7 g1^-3*g2^-1*g3^-7*g4*g5^-6*g6*g7*g8^2*g9^3*g11^-4*g12^5*g14^-2*g15^7 infinity gap> g^-1; g1^-2*g3^-3*g4^-1*g5^-4*g6^2*g7*g8^-3*g10^-3*g11^-1*g12^4*g14^-2*g15^-3 gap> DTP_PCP_Inverse(h); g1*g2*g3^4*g4^-2*g5^2*g6*g8^-5*g9^-3*g10^-3*g11^3*g12^-1*g15^-33
Accessing Deep Thought polynomials In this section, functions which can be used to display the content of a DTObj are documented. Furthermore, Deep Thought polynomials stored in a DTObj can be converted to &GAP; polynomials. nothing Prints information about DTObj to the terminal. In particular, the Deep Thought polynomials are printed in human-readable form. This function is also called by the method of Display for a DTObj. list Converts the Deep Thought polynomials stored in DTObj[PC_DTPPolynomials] to &GAP; polynomials and returns them in a list together with their polynomial ring.
gap> coll := FromTheLeftCollector(4);; gap> SetConjugate(coll, 2, 1, [2, 1, 3, 2]); gap> SetConjugate(coll, 3, 1, [3, 1, 4, 1]); gap> SetConjugate(coll, 3, 2, [3, 1, 4, 5]); gap> UpdatePolycyclicCollector(coll); gap> DTObj := DTP_DTObjFromCollector(coll); <DTObj> gap> Display(DTObj); Polynomials f_rs for s = 1: f_1,s = X_1 + Y_1 f_2,s = X_2 f_3,s = X_3 + 2 * X_2 Y_1 f_4,s = X_4 + X_3 Y_1 + 2 * X_2 Binomial(Y_1, 2) + 10 * Binomial(X_2, 2) Y_1 Polynomials f_rs for s = 2: f_1,s = X_1 f_2,s = X_2 + Y_2 f_3,s = X_3 f_4,s = X_4 + 5 * X_3 Y_2 Polynomials f_rs for s = 3: f_1,s = X_1 f_2,s = X_2 f_3,s = X_3 + Y_3 f_4,s = X_4 Polynomials f_rs for s = 4: f_1,s = X_1 f_2,s = X_2 f_3,s = X_3 f_4,s = X_4 + Y_4 gap> DTObj := DTP_DTObjFromCollector(coll, false); <DTObj> gap> Display(DTObj); f_1 = X_1 + Y_1 f_2 = X_2 + Y_2 f_3 = X_3 + Y_3 + 2 * X_2 Y_1 f_4 = X_4 + Y_4 + X_3 Y_1 + 2 * X_2 Binomial(Y_1, 2) + 10 * Binomial(X_2, 2) Y_1 + 5 * X_3 Y_2 + 10 * X_2 Y_1 Y_2 gap> DTP_pols2GAPpols(DTObj); [ [ x1+y1, x2+y2, 2*x2*y1+x3+y3, 5*x2^2*y1+x2*y1^2+10*x2*y1*y2-6*x2*y1+x3*y1+5*x3*y2+x4+y4 ], Rationals[x1,x2,x3,x4,y1,y2,y3,y4] ]