			afmsp1minpol( p, F, a )

	"algebraic function over modular single primes, transcendence
	degree 1, minimal polynomial"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol afmsp1minpol(p,F,a)  single p; pol F, a;
	M = afmsp1minpol(p,F,a);
	Sei x eine Unbestimmte ueber (Z/pZ), wobei p eine single
	Primzahl ist.
	F ist das definierende Polynom einer separablen Algebra ueber
	(Z/pZ) (x) - dem rationalen Funktionenkoerper ueber (Z/pZ) -
	d.h. F ist ein normiertes, separables Polynom in einer
	Unbestimmten ueber dem Polynomring (Z/pZ) [x].
	a ist ein Element dieser Algebra und wird durch ein CD-Polynom
	repraesentiert ( siehe cdprfmsp1fcl ).
	M ist das Minimalpolynom von a ueber (Z/pZ) [x]; M ist also
	ein Polynom in einer Unbestimmten ueber (Z/pZ) [x].



			bpmisubcubeq( p, P, R )

	"bivariate polynomial over modular integers substitution with
	respect to a cubic equation"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol bpmisubcubeq(p,P,R)  int p; pol P; pol R;
	P3 = bpmisubcubeq(p,P,R);
	p ist eine Primzahl.
	P ist aus Z/pZ [x,y], wobei x und y Variablen ueber Z/pZ sind.
	y ist die Hauptvariable von P.
	R ist ein Polynom aus Z/pZ [x] der Form x^3 + a x + b.
	P3 ist das Polynom aus Z/pZ [x,y] mit Grad(P3) < 2, das	entsteht,
	indem man in P jeweils y^2 durch x^3 + a x + b ersetzt, d.h. y^2
	wird gemaess der kubischen Gleichung y^2 = x^3 + a x + b ersetzt.
	Genauer ersetzt man fuer jede natuerliche Zahl i den Ausdruck
	y^(2*i+d) mit d aus { 0, 1 } durch y^d * ( x^3 + a x + b )^i.



			cdprfcl( L )

	"common denominator polynomial over the rationals from
	coefficient list"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol cdprfcl(L) list L;
	P = cdprfcl(L);
	Sei a_n * x^n + ... + a_0 * x^0 ein Polynom ( ungleich dem
	Nullpolynom ) ueber den rationalen Zahlen.
	d sei das kgV der Nenner der Koeffizienten ungleich der Null und
	fuer 0 <= i <= n sei b_i = d * a_i.
	Dann ist (d, b_n, .. b_0) eine "coefficient list" von obigem
	Polynom.
	Sei m die Maechtigkeit der Menge {0 <= j <= n | b_j != 0}
	und 0 <= e_1 < ... < e_m <= n seien alle Zahlen, fuer die
	b_(e_k) != 0 ist (1 <= k <= m).
	Dann ist (d, e_m, b_(e_m), ... e_1, b_(e_1) ) die Liste, die obiges
	Polynom als CD - Polynom repraesentiert.
	Das Nullpolynom wird auch als CD - Polynom durch das Nullatom
	dargestellt.
	Eine "coefficient list" des Nullpolynoms hat die Form
	(d, 0, ... , 0), wobei d eine ganze Zahl ungleich Null ist
	und die Listenlaenge groesser gleich 2 ist.
	Sei nun L eine "coefficient list" eines Polynoms, dann ist P die
	Liste, die das gleiche Polynom als CD - Polynom repraesentiert.



			cdprfmsp1fcl( L, p )

	"common denominator polynomial over rational functions over
	modular single prime, transcendence degree 1, from coefficient
	list"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol cdprfmsp1fcl(L,p) list L; single p;
	P = cdprfmsp1fcl(L,p);
	Sei a_n * y^n + ... + a_0 * y^0 ein Polynom ( ungleich dem 
	Nullpolynom ) ueber dem rationalen Funktionenkoerper ueber
	(Z/pZ),	wobei p eine single Primzahl ist.
	d sei das kgV der Nenner der Koeffizienten ungleich Null und
	fuer 0 <= i <= n sei b_i := d * a_i.
	Dann ist (d, b_n, .. b_0) eine "coefficient list" von obigem
	Polynom.
	Sei m die Maechtigkeit der Menge {0 <= j <= n | b_j != 0}
	und 0 <= e_1 < ... < e_m <= n seien alle Zahlen, fuer die
	b_(e_k) != 0 ist (1 <= k <= m).
	Dann ist (d, e_m, b_(e_m), ... e_1, b_(e_1) ) die Liste, die
	obiges Polynom als CD - Polynom repraesentiert.
	Das Nullpolynom wird auch als CD - Polynom durch das Nullatom
	dargestellt.
	Eine "coefficient list" des Nullpolynoms hat die Form
	(d, 0, ... , 0), wobei d ein Polynom in einer Veraenderlichen
	ueber (Z/pZ) ungleich dem Nullpolynom ist und die Listenlaenge
	groesser gleich 2 ist.
	Sei nun L eine "coefficient list" eines Polynoms, dann ist P
	die Liste, die das Polynom als CD - Polynom repraesentiert.



			cdprfmsp1fup( p, P )

	"common denominator polynomial over rational functions over
	modular single prime, transcendence degree 1, from univariate
	polynomial over rational functions over modular single prime,
	transcendence degree 1"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol cdprfmsp1fup(p,P) single p; pol P;
	PC = cdprfmsp1fup(p,P);
	P ist eine Polynom in einer Veraenderlichen ueber dem rationalen
	Funktionenkoerper ueber Z/pZ, wobei p eine single Primzahl ist.
	P ist in sparse - Darstellung.
	PC = P als CD - Polynom ( siehe cdprfmsp1fcl ).



			cdprfmsp1inv( p, F, A )

	"common denominator polynomial over rational functions over 
	modular single prime, transcendence degree 1, inverse"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol cdprfmsp1inv(p,F,A) single p; pol F,A;
	B = cdprfmsp1inv(p,F,A);
	Sei x eine Unbestimmte ueber Z/pZ, wobei p eine single Primzahl
	ist.
	F ist ein normiertes Polynom positiven Grades in einer
	Unbestimmten ueber (Z/pZ) (x) - dem rationalen Funktionenkoerper
	in x ueber Z/pZ.
	A ist ein CD - Polynom in einer Unbestimmten ungleich dem
	Nullpolynom ueber dem rationalen Funktionenkoerper (Z/pZ) (x)
	( siehe cdprfmsp1fcl ).
	F und A haben ueber (Z/pZ) (x) keinen Polynomteiler positiven
	Grades gemeinsam.
	B ist ein CD - Polynom ueber (Z/pZ) (x), so dass ein Polynom L
	ueber (Z/pZ) (x) existiert, mit dem gilt A*B = 1 + F*L,
	d.h. B = (A)^(-1) mod F.
	Der Grad von B ist kleiner als der Grad von F.



			cdprfmsp1lfm( M, p )

	"common denominator polynomial over rational functions over
	modular single prime, transcendence degree 1, list from
	common denominator matrix of rational functions over 
	modular single prime, transcendence degree 1"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	list cdprfmsp1lfm(M,p) matrix M; single p;
	L = cdprfmsp1lfm(M,p);
	M ist eine CD - Matrix ueber dem rationalen Funktionenkoerper
	ueber (Z/pZ), wobei p eine single Primzahl ist.
	Die Zeilen von M repraesentieren als "coefficient list" 
	CD - Polynome ( siehe cdmarfmsp1id und cdprfmsp1fcl ).
	L ist die Liste dieser CD - Polynome, beginnend mit dem CD -
	Polynom, das durch die erste Zeile von M repraesentiert wird.



			cdprfmsp1mh( p, P, M )

	"common denominator polynomial over rational functions over
	modular single primes, transcendence degree 1, module homomorphism"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol cdprfmsp1mh(p,P,M)  single p; pol P, M;
	P1 = cdprfmsp1mh(p,P,M);
	Sei x eine Unbestimmte ueber Z/pZ, wobei p eine single Primzahl
	ist, y sei eine Unbestimmte ueber (Z/pZ) (x) - dem rationalen
	Funktionenkoerper in x ueber Z/pZ.
	P ist ein CD - Polynom ueber (Z/pZ) (x) ( siehe cdprfmsp1fcl )
	in der Unbestimmten y.
	M ist ein Polynom aus (Z/pZ) [x] - dem Polynomring in x ueber Z/pZ.
	M ist ungleich dem Nullpolynom.
	P1(y) = P(y) mod ( M * (Z/pZ)[x] ) [y] als CD - Polynom in der
	Unbestimmten y ueber (Z/pZ)(x), d.h. P wird reduziert modulo dem
	durch M ueber (Z/pZ) [x] [y] erzeugten Modul.



			cdprfmsp1sum( p, P1, P2 )

	"common denominator polynomial over rational functions over
	modular	single prime, transcendence degree 1, sum"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol cdprfmsp1sum(p,P1,P2)  single p; pol P1,P2;
	P = cdprfmsp1sum(p,P1,P2);
	P1 und P2 sind CD - Polynome in einer Veraenderlichen ueber
	dem rationalen Funktionenkoerper ueber (Z/pZ), wobei p eine
	single Primzahl ist (siehe cdprfmsp1fcl).
	P = P1 + P2 als CD - Polynom.



			cdprfmsp1upq( p, F, P )

	"common denominator polynomial over rational functions over modular
	single prime, transcendence degree 1, univariate polynomial over
	modular single prime quotient"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol cdprfmsp1upq(p,F,P) single p; pol F, P;
	F1 = cdprfmsp1upq(p,F,P);
	F ist ein CD - Polynom in einer Veraenderlichen ueber (Z/pZ) (x) -
	dem rationalen Funktionenkoerper in der Veraenderlichen x ueber
	Z/pZ, wobei p eine single Primzahl ist ( siehe cdprfmsp1fcl ).
	P ist aus dem Polynomring (Z/pZ) [x] und ungleich dem Nullpolynom.
	F1 = F / P ( F1 wird durch ein CD - Polynom repraesentiert ).



			cdprfupr( P )

	"common denominator polynomial over the rationals from
	univariate polynomial over the rationals"
	Quellbibliothek : srclib.pol2
	Include - Datei : _pol2.h
	pol cdprfupr(P) pol P;
	PC = cdprfupr(P);
	PC = P als CD - Polynom ( siehe cdprfcl ).



			cdprinv( F, A )

	"common denominator polynomial over the rationals inverse"
	Quellbibliothek : srclib.pol2
	Include - Datei : _pol2.h
	pol cdprinv(F,A) pol F,A;
	B = cdprinv(F,A);
	F ist ein normiertes Polynom in einer Veraenderlichen ueber
	den ganzen Zahlen.
	A ist ein CD - Polynom ueber den rationalen Zahlen ( siehe
	cdprfcl ).
	F und A haben ueber den rationalen Zahlen keinen Polynomteiler
	positiven Grades gemeinsam.
	B ist ein CD - Polynom ueber Q, so dass ein Polynom L ueber Q
	existiert, mit dem gilt A*B = 1 + F*L, d.h. B = (A)^(-1) mod F.
	Der Grad von B ist kleiner als der Grad von F.



			cdpriquot( P, I )

	"common denominator polynomial over the rationals integer quotient"
	Quellbibliothek : srclib.pol2
	Include - Datei : _pol2.h
	pol cdpriquot(P,I) pol P; int I;
	P1 = cdpriquot(P,I);
	P ist ein CD - Polynom in einer Veraenderlichen ueber den
	rationalen Zahlen ( siehe cdprfcl ).
	I ist eine ganze Zahl ungleich Null.
	P1 = P / I ( P1 als CD - Polynom ).



			cdprlfcdmar( M )

	"common denominator polynomial over the rationals list from
	common denominator matrix of rationals"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list cdprlfcdmar(M)  matrix M;
	L = cdprlfcdmar(M);
	M ist eine CD - Matrix, deren Zeilen als "coefficient list"
	CD - Polynome repraesentieren ( siehe cdmarid und cdprfcl ).
	L ist die Liste dieser CD - Polynome, beginnend mit dem CD -
	Polynom, das durch die erste Zeile von M repraesentiert wird.



			cdprsum( P1, P2 )

	"common denominator polynomial over the rationals sum"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol cdprsum(P1,P2)  pol P1,P2;
	P = cdprsum(P1,P2);
	P1 und P2 sind als CD - Polynome Polynome in einer Variablen
	ueber den rationalen Zahlen (siehe cdprfcl).
	P = P1 + P2 als CD - Polynom.



			cdprzmodhom( P, M )

	"common denominator polynomial over the rationals Z-module
	homomorphism"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol cdprzmodhom(P,M)  pol P; int M;
	P1 = cdprzmodhom(P,M);
	P ist ein CD - Polynom in einer Veraenderlichen ueber den
	rationalen Zahlen ( siehe cdprfcl ).
	M ist eine positive ganze Zahl.
	P1(x) = P(x) mod ( M * Z[x] ) als CD - Polynom in einer
	Veraenderlichen ueber den rationalen Zahlen.



			clfcdpr( P, n )

	"coefficient list from common denominator polynomial over the
	rationals"
	Quellbibliothek : srclib.pol2
	Include - Datei : _pol2.h
	list clfcdpr(P,n) pol P; single n;
	L = clfcdpr(P,n);
	Zur Erklaerung der Begriffe CD - Polynom und "coefficient list"
	siehe cdprfcl.
	clfcdpr wandelt ein CD - Polynom in eine "coefficient list" der
	Laenge (n+1) um. Dabei muss n groesser als der Grad von P sein.



			clfcdprfmsp1( P, n )

	"coefficient list from common denominator polynomial over rational
	functions over modular single prime, transcendence degree 1"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	list clfcdprfmsp1(P,n) pol P; single n;
	L = clfcdprfmsp1(P,n);
	Zur Erklaerung der Begriffe CD - Polynom und "coefficient list"
	siehe cdprfmsp1fcl.
	clfcdprfmsp1 wandelt ein CD - Polynom in eine "coefficient list"
	der Laenge (n+1) um. Dabei muss n groesser als der Grad von P sein.



			dipbsort( r, P )

        "distributive polynomial bubble sort"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single dipbsort( r, P )  single r, pol P;
        n = dipbsort( r, P );
        P ist distributives Polynom in r Variablen (0<=r<BASIS), das 
        UNGEORDNET sein darf.
        P wird in lexikographisch absteigender Reihenfolge sortiert.
        P wird veraendert.
        n hat den Wert 0.



			dipdimpolid( r, G, pS, pM )

	"distributive polynomial dimension of a polynomial ideal"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single dipdimpolid(r,G,pS,pM)  single r; list G; list *pS,*pM;
        dim = dipdimpolid(r,G,pS,pM);
        G  ist   eine  Groebnerbasis  von  Polynomen  in  r  (0<=r<BASIS)
        Variablen ueber einem beliebigen Ring.
        Berechnet wird
          - dim = die Dimension des von G erzeugten Ideals,
          - *pS = die maximal unabhaengige Menge von Variablen  und
          - *pM = die Menge aller maximal unabhaengigen Mengen  von  Vari-
                  ablen
        durch die Berechnung der  unabhaengigen  Mengen  der Variablen der
        fuehrenden Monome der Polynome in der Groebnerbasis.  Die  berech-
        neten Groessen sind NUR im Fall der  lexikographischen Termordnung 
        (d.h.: die globale Variable EVORD = 1) eindeutig bestimmt.
        Werden andere Termordnungen benutzt, so sind die berechneten Werte
        lediglich untere Schranken fuer die Dimension  und  die unabhaeng-
        igen Mengen. Wenn G keine Groebnerbasis ist, dann sind die berech-
        neten Werte ebenfalls nur untere Schranken.



			dipevcomp( r, EV1, EV2 )

        "distributive polynomial exponent vector compare"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single dipevcomp(r,EV1,EV2)  single r; list EV1,EV2;
        t = dipevcomp(r,EV1,EV2);
        EV1 und EV2 sind Exponentenvektoren von Polynomen in r Variablen 
	(0 <= r < BASIS) in distributiver Darstellung ueber einem belie-
	bigen Grundring.
	EV1 und EV2 haben also Laenge r.
        t=-1, wenn EV1 < EV2,
        t= 0, wenn EV1 = EV2,
        t= 1, wenn EV1 > EV2,
        wobei " <, =, > " bzgl. der Ordnung des Exponentenvektors zu
        verstehen sind. Die Ordnung des Exponentenvektors wird durch
        die globale Variable "EVORD" angegeben.
        Folgende Ordnungen sind moeglich:
              - lexikographische (SIMATH-Konvention, siehe SIMATH-
                Handbuch)
                                                       ( EVORD = 1 ),
              - graduierte lexikographische:
                EV1=(e1,...,en), EV2=(f1,...,fn);
                EV1 > EV2: ei == fi, fuer i=1,..,j-1,
                           ej > fj   und
                           (ej+1 +...+ en) >= (fj+1 +...+ fn),
                           oder
                           ej < fj   und
                           (ej+1 +...+ en) > (fj+1 +...+ fn);
                EV1 = EV2: ei == fi, fuer i=1,...,n;
                EV1 < EV2: ei == fi, fuer i=1,..,j-1,
                           ej > fj   und
                           (ej+1 +...+ en) < (fj+1 +...+ fn),
                           oder
                           ej < fj   und
                           (ej+1 +...+ en) <= (fj+1 +...+ fn);
                                                       ( EVORD = 2 ),
              - bzgl. dem Totalgrad (Buchbergers Totalgrad Ordnung)
                EV1=(e1,...,en), EV2=(f1,...,fn);
                EV1 > EV2: ei == fi, fuer i=n,..,j+1,
                           ej > fj   und
                           (ej-1 +...+ e1) >= (fj-1 +...+ f1),
                           oder
                           ej < fj   und
                           (ej-1 +...+ e1) > (fj-1 +...+ f1);
                EV1 = EV2: ei == fi, fuer i=n,...,1;
                EV1 < EV2: ei == fi, fuer i=n,..,j+1,
                           ej > fj   und
                           (ej-1 +...+ e1) < (fj-1 +...+ f1),
                           oder
                           ej < fj   und
                           (ej-1 +...+ e1) <= (fj-1 +...+ f1);
                                                       ( EVORD = 3 ),
              - lexikographische mit umgekehrtem Exponentenvektor:
                EV1=(e1,...,en), EV2=(f1,...,fn);
                (en,...,e1) und (fn,...,f1) werden lexikographisch
                geordnet;
                                                       ( EVORD = 4 ).
        Wird EVORD nicht vorbesetzt, so wird die lexikographische
        Ordnung benutzt.



			dipevdif( r, EV1, EV2 )

        "distributive polynomial exponent vector difference"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list dipevdif(r,EV1,EV2)  single r; list EV1,EV2;
        EV = dipevdif(r,EV1,EV2);
        EV1 und EV2 sind Exponentenvektoren von Polynomen in r Variablen 
	(0 <= r < BASIS) in distributiver Darstellung ueber einem belie-
	bigen Grundring.
	EV1 und EV2 haben also Laenge r.
        EV = EV1-EV2, d.h. EV entsteht durch komponentenweise Subtraktion
        von EV1 und EV2.



			dipevl( r, P )

        "distributive polynomial exponent vector of the leading monomial"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list dipevl(r,P)  single r; pol P;
        EV = dipevl(r,P);
        P ist ein Polynom in r Variablen (0 <= r < BASIS) in distribu-
	tiver Darstellung ueber einem beliebigen Grundring.
        EV ist der Exponentenvektor des fuehrenden Monoms, hat also 
	Laenge r.



			dipevlcm( r, EV1, EV2 )

        "distributive polynomial exponent vector least common multiple"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list dipevlcm(r,EV1,EV2)  single r; list EV1,EV2;
        EV = dipevlcm(r,EV1,EV2);
        EV1 und EV2 sind Exponentenvektoren von Polynomen in r Variablen 
	(0 <= r < BASIS) in distributiver Darstellung ueber einem belie-
	bigen Grundring.
	EV1 und EV2 haben also Laenge r.
        EV ist das kgV von EV1 und EV2, d.h. das komponentenweise Maximum.



			dipevmt( r, EV1, EV2 )

        "distributive polynomial exponent vector multiple test"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single dipevmt(r,EV1,EV2)  single r; list EV1,EV2;
        t = dipevmt(r,EV1,EV2);
        EV1 und EV2 sind Exponentenvektoren von Polynomen in r Variablen 
	(0 <= r < BASIS) in distributiver Darstellung ueber einem belie-
	bigen Grundring.
	EV1 und EV2 haben also Laenge r.
        t = 1, wenn EV1 ein Vielfaches von EV2 ist, d.h. wenn EV1 kompo-
	       nentenweise >= EV2 ist;
        t = 0, sonst.



			dipevsign( r, EV )

        "distributive polynomial exponent vector signum"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single dipevsign(r,EV)  single r; list EV;
        s = dipevsign(r,EV);
        EV ist ein Exponentenvektor eines Polynoms in r Variablen 
	(0 <= r < BASIS) in distributiver Darstellung ueber einem
	beliebigen Grundring.
	EV hat also Laenge r.
        s =  1, wenn mindestens ein Eintrag von EV groesser 0 ist,
                aber alle groesser gleich 0 sind;
        s =  0, wenn alle Eintraege von EV gleich 0 sind;
        s = -1, wenn mindestens ein Eintrag kleiner 0 ist.



			dipevsum( r, EV1, EV2 )

        "distributive polynomial exponent vector sum"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list dipevsum(r,EV1,EV2)  single r; list EV1,EV2;
        EV = dipevsum(r,EV1,EV2);
        EV1 und EV2 sind Exponentenvektoren von Polynomen in r Variablen 
	(0 <= r < BASIS) in distributiver Darstellung ueber einem belie-
	bigen Grundring.
	EV1 und EV2 haben also Laenge r.
        EV = EV1+EV2, d.h. EV entsteht durch komponentenweise Addition
        von EV1 und EV2.



			dipfmo( r, BC, EV )             (MACRO)

        "distributive polynomial from monomial"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipfmo(r,BC,EV)  single r; obj BC; list EV;
        P = dipfmo(r,BC,EV);
        Dabei muss gelten:
              - 0 <= r < BASIS.
              - BC ist ein Element eines beliebigen Grundrings.
              - EV ist ein Exponentenvektor der Laenge r.
	P ist ein Monom in distributiver Darstellung mit BC als
	Koeffizient und EV als Exponentenvektor.
	P ist also ein Polynom in r Variablen.



			dipgfsdif( r, p, AL, P1, P2 )

        "distributive polynomial over Galois-field with single
         characteristic difference"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipgfsdif(r,p,AL,P1,P2)  single r,p; list AL; pol P1,P2;
        P3 = dipgfsdif(r,p,AL,P1,P2);
        Dabei muss gelten:
              - p ist Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n)
                interpretiert werden (siehe gfsalgen), wobei 
		n = llength(AL1)+1.
              - P1 und P2 sind distributive Polynome in r (0 <= r < BASIS)
		Variablen ueber GF(p^n).
        P3 = P1 - P2.



			dipgfsgb( r, p, AL, PL )

        "distributive polynomial over Galois-field with single
         characteristic Groebner basis"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        list dipgfsgb(r,p,AL,PL)  single r,p; list AL,PL;
        PP = dipgfsgb(r,p,AL,PL);
        Dabei muss gelten:
              - p ist Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n)
                interpretiert werden (siehe gfsalgen), wobei
                n = llength(AL1)+1.
              - PL ist eine Liste von distributiven Polynomen in r 
		(0 <= r < BASIS) Variablen ueber GF(p^n).
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (Verfahren cf. B. Buchberger)



			dipgfsgba( r, p, AL, PL, P )

        "distributive polynomial over Galois-field with single
         characteristic Groebner basis augmentation"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        list dipgfsgba(r,p,AL,PL,P)  single r,p; list AL,PL; pol P;
        PP = dipgfsgba(r,p,AL,PL,P);
        Dabei muss gelten:
	      - 0 <= r < BASIS.
              - p ist Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n)
                interpretiert werden (siehe gfsalgen), wobei
                n = llength(AL1)+1.
              - PL ist eine Groebner Basis von distributiven Polynomen 
		in r Variablen ueber GF(p^n).
              - P ist ein distributives Polynom in r Variablen ueber 
		GF(p^n).
        PP ist die minimale normierte und geordnete Groebner Basis von 
	(PL,P).
        (Verfahren cf. B. Buchberger)



			dipgfsgbr( r, p, AL, PL )

        "distributive polynomial over Galois-field with single
         characteristic Groebner basis recursion"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        list dipgfsgbr(r,p,AL,PL)  single r,p; list AL,PL;
        PP = dipgfsgbr(r,p,AL,PL);
        Dabei muss gelten:
              - p ist Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n)
                interpretiert werden (siehe gfsalgen), wobei
                n = llength(AL1)+1.
              - PL ist eine Liste von distributiven Polynomen in r 
		(0 <= r < BASIS) Variablen ueber GF(p^n).
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (zur Erlaeuterung:
	 Sei PL = {P1,...,Pn} die Liste von Polynomen. 
	 Zunaechst wird fuer P1 die reduzierte (= minimale normierte und
	 geordnete) Groebner Basis berechnet. 
	 Zu dieser Basis wird P2 hinzugenommen und wieder die reduzierte 
	 Groebner Basis berechnet. usw.
	 Diese Vorgehensweise wird fuer alle n Polynome durchgefuehrt.)



			dipgfsgfprod( r, p, AL, P, a )

        "distributive polynomial over Galois-field with single 
	 characteristic, Galois-field with single characteristic element 
	 product"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipgfsgfprod(r,p,AL,P,a)  single r,p; list AL; pol P; gfel a;
        P1 = dipgfsgfprod(r,p,AL,P,a);
        Dabei muss gelten:
              - p ist Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n)
                interpretiert werden (siehe gfsalgen), wobei
                n = llength(AL1)+1.
              - P ist ein distributives Polynom in r (0 <= r < BASIS) 
		Variablen ueber GF(p^n).
              - a ist ein Element aus GF(p^n).
        P1 = a*P.



			dipgfslotglo( r, p, AL, P )

        "distributive polynomial over Galois-field with single
         characteristic in lexicographical order to distributive
         polynomial over Galois-field with single characteristic
         in graduated lexicographical order"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipgfslotglo(r,p,AL,P)  single r,p; list AL; pol P;
        P1 = dipgfslotglo(r,p,AL,P);
        Dabei muss gelten:
              - p ist Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n)
                interpretiert werden (siehe gfsalgen), wobei
                n = llength(AL1)+1.
              - P ist ein distributives Polynom in r (0 <= r < BASIS)
		Variablen ueber GF(p^n).
        Das Polynom P hat lexikographische Termordnung und wird in das
        Polynom P1 in graduiert lexikographischer Termordnung umgewandelt.



			dipgfslotlio( r, p, AL, P )

        "distributive polynomial over Galois-field with single
         characteristic in lexicographical order to distributive
         polynomial over Galois-field with single characteristic
         in lexicographical order with inverse exponent vector"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipgfslotlio(r,p,AL,P)  single r,p; list AL; pol P;
        P1 = dipgfslotlio(r,p,AL,P);
        Dabei muss gelten:
              - p ist Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n)
                interpretiert werden (siehe gfsalgen), wobei
                n = llength(AL1)+1.
              - P ist ein distributives Polynom in r (0 <= r < BASIS)
		Variablen ueber GF(p^n).
        Das Polynom P hat lexikographische Termordnung und wird in das
        Polynom P1 in lexikographischer Termordnung bzgl. umgekehrter
        Exponentenvektoren umgewandelt.



			dipgfslottdo( r, p, AL, P )

        "distributive polynomial over Galois-field with single
         characteristic in lexicographical order to distributive
         polynomial over Galois-field with single characteristic
         with total degree ordering"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipgfslottdo(r,p,AL,P)  single r,p; list AL; pol P;
        P1 = dipgfslottdo(r,p,AL,P);
        Dabei muss gelten:
              - p ist Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n)
                interpretiert werden (siehe gfsalgen), wobei
                n = llength(AL1)+1.
              - P ist ein distributives Polynom in r (0 <= r < BASIS)
		Variablen ueber GF(p^n).
        Das Polynom P hat lexikographische Termordnung und wird in das
        Polynom P1 mit Termordnung nach dem Totalgrad umgewandelt.



			dipgfsmonic( r, p, AL, P )

        "distributive polynomial over Galois-field with single
         characteristic monic"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipgfsmonic(r,p,AL,P)  single r,p; pol P;
        P1 = dipgfsmonic(r,p,AL,P);
        Dabei muss gelten:
              - p ist Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n)
                interpretiert werden (siehe gfsalgen), wobei
                n = llength(AL1)+1.
              - P ist ein distributives Polynom in r (0 <= r < BASIS) 
		Variablen ueber GF(p^n).
        P1 ist das normierte Polynom P.



			dipgfsneg( r, p, AL, P )

        "distributive polynomial over Galois-field with single
         characteristic negation"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipgfsneg(r,p,AL,P)  single r,p; list AL; pol P;
        P1 = dipgfsneg(r,p,AL,P);
        Dabei muss gelten:
              - p ist Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n)
                interpretiert werden (siehe gfsalgen), wobei
                n = llength(AL1)+1.
              - P ist ein distributives Polynom in r (0 <= r < BASIS)
		Variablen ueber GF(p^n).
        P1 = -P.



			dipgfsprod( r, p, AL, P1, P2 )

        "distributive polynomial over Galois-field with single
         characteristic product"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipgfsprod(r,p,AL,P1,P2)  single r,p; list AL; pol P1,P2;
        P3 = dipgfsprod(r,p,AL,P1,P2);
        Dabei muss gelten:
              - p ist Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n)
                interpretiert werden (siehe gfsalgen), wobei
                n = llength(AL1)+1.
              - P1 und P2 sind distributive Polynome in r (0 <= r < BASIS)
		Variablen ueber GF(p^n).
        P3 = P1 * P2.



			dipgfssp( r, p, AL, P1, P2 )

        "distributive polynomial over Galois-field with single
         characteristic S-polynomial"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipgfssp(r,p,AL,P1,P2)  single r,p; list AL; pol P1,P2;
        P3 = dipgfssp(r,p,AL,P1,P2);
        Dabei muss gelten:
              - p ist Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n)
                interpretiert werden (siehe gfsalgen), wobei
                n = llength(AL1)+1.
              - P1 und P2 sind distributive Polynome in r (0 <= r < BASIS)
		Variablen ueber GF(p^n).
        P3 ist das S-Polynom von P1 und P2.
        (zur Erlaeuterung:
         Sei f das fuehrende Monom von P1 und g das fuehrende Monom 
	 von P2. Dann ergibt sich das S-Polynom zu:
              P3 = kgV(f,g)/f*P1 - kgV(f,g)/g*P2 .
         siehe auch:
         "Ein algorithmisches Kriterium fuer die Loesbarkeit eines
         algebraischen Gleichungssystems" von B. Buchberger;
         Aequationes mathematicae, Vol.4, 1970)



			dipgfssum( r, p, AL, P1, P2 )

        "distributive polynomial over Galois-field with single
         characteristic sum"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipgfssum(r,p,AL,P1,P2)  single r,p; list AL; pol P1,P2;
        P3 = dipgfssum(r,p,AL,P1,P2);
        Dabei muss gelten:
              - p ist Primzahl.
	      - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n)
                interpretiert werden (siehe gfsalgen), wobei
                n = llength(AL1)+1.
              - P1 und P2 sind distributive Polynome in r (0 <= r < BASIS)
		Variablen ueber GF(p^n).
        P3 = P1 + P2.



			diphomog( r, P )

        "distributive polynomial homogenize"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol diphomog(r,P) single r, pol P;
        Q = diphomog(r,P);
        P = distributives Polynom in r Variablen (0<=r<BASIS)
        Q = nach (r+1)-ter Variablen homogenisiertes Polynom in
               distributiver Darstellung, falls r+1<BASIS 
               und homogener Gesamtgrad < BASIS
          = ERROR, sonst.                              
        ACHTUNG: Q ist Polynom mit Variablenliste (Xr+1, X1, ..., Xr) !



			diphomogsv( r, P, n )

        "distributive polynomial homogenize specified variable"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol diphomogsv(r,P,n) single r, pol P, single n;
        Q = diphomogsv(r,P,n);
        P = distributives Polynom in r Variablen (0<=r<BASIS-1)
        Fall a: 0<=r<BASIS-1 und 1<=n<=r+1 und homogener Gesamtgrad < BASIS
        Fall b: sonst
        Q   = ERROR im Fall b)
            = nach einer zusaetzlichen Variablen homogenisiertes Polynom P
                 in distributiver Darstellung, wobei die zusaetzliche
                 Variable an n-ter Stelle steht (1<=n<=r+1) im Fall a).
!!!     ACHTUNG: P mit Variablenliste (X1, ...................., Xr)
!!!              Q mit Variablenliste (X1, ..., Xn-1, Xr+1, Xn, ..., Xr)
        Vergleiche diphomog.



			dipicp( r, P, pPP )

        "distributive polynomial over integers content and primitive part"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        int dipicp(r,P,pPP)  single r; pol P,*pPP;
        C = dipicp(r,P,pPP);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z.
        C ist der Inhalt des Polynoms P. 
	*pPP ist der primitive Anteil von P; der fuehrende Basiskoeffizient 
	von *pPP ist positiv.



			dipidif( r, P1, P2 )

        "distributive polynomial over integers difference"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipidif(r,P1,P2)  single r; pol P1,P2;
        P3 = dipidif(r,P1,P2);
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS)
	Variablen ueber Z.
        P3 = P1 - P2.



			dipigb( r, PL )

        "distributive polynomial over integers Groebner basis"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list dipigb(r,PL)  single r; list PL;
        PP = dipigb(r,PL);
        PL ist eine Liste von distributiven Polynomen in r 
	(0 <= r < BASIS) Variablen ueber Z.
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (Verfahren cf. B. Buchberger)



			dipigba( r, PL, P )

        "distributive polynomial over integers Groebner basis
         augmentation"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list dipigba(r,PL,P)  single r; list PL; pol P;
        PP = dipigba(r,PL,P);
        Dabei muss gelten:
              - 0 <= r < BASIS.
              - PL ist eine Groebner Basis von Polynomen in r Variablen
                ueber Z in distributiver Darstellung.
              - P ist ein Polynom in r Variablen ueber Z in distributiver
                Darstellung.
        PP ist die minimale normierte und geordnete Groebner Basis von 
	(PL,P).
        (Verfahren cf. B. Buchberger)



			dipigbr( r, PL )

        "distributive polynomial over integers Groebner basis recursion"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list dipigbr(r,PL)  single r; list PL;
        PP = dipigbr(r,PL);
        PL ist eine Liste von distributiven Polynomen in r (0 <= r < BASIS) 
	Variablen ueber Z.
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (zur Erlaeuterung:
	 Sei PL = {P1,...,Pn} die Liste von Polynomen. 
	 Zunaechst wird fuer P1 die reduzierte (= minimale normierte und
	 geordnete) Groebner Basis berechnet. 
	 Zu dieser Basis wird P2 hinzugenommen und wieder die reduzierte 
	 Groebner Basis berechnet. usw.
	 Diese Vorgehensweise wird fuer alle n Polynome durchgefuehrt.)



			dipiiprod( r, P, A )

        "distributive polynomial over integers, integer product"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipiiprod(r,P,A)  single r; pol P; int A;
        P1C = dipiiprod(r,P,A);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z.
        P1 = A*P.



			dipilotoglo( r, P )

        "distributive polynomial over integers in lexicographical order
         to distributive polynomial over integers in graduated
         lexicographical order"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipilotoglo(r,P)  single r; pol P;
        P1 = dipilotoglo(r,P);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 in graduiert lexikographischer Termordnung umgewandelt.



			dipilotolio( r, P )

        "distributive polynomial over integers in lexicographical order
         to distributive polynomial over integers in lexicographical order
         with inverse exponent vector"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipilotolio(r,P)  single r; pol P;
        P1 = dipilotolio(r,P);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 in lexikographischer Termordnung bzgl. umgekehrter 
	Exponentenvektoren umgewandelt.



			dipilototdo( r, P )

        "distributive polynomial over integers in lexicographical order
         to distributive polynomial over integers with total degree
         ordering"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipilototdo(r,P)  single r; pol P;
        P1 = dipilototdo(r,P);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 mit Termordnung nach dem Totalgrad umgewandelt.



			dipineg( r, P )

        "distributive polynomial over integers negation"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipineg(r,P)  single r; pol P;
        P1 = dipineg(r,P);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z.
        P1 = -P.



			dipiprod( r, P1, P2 )

        "distributive polynomial over integers product"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipiprod(r,P1,P2)  single r; pol P1,P2;
        P3 = dipiprod(r,P1,P2);
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS) 
	Variablen ueber Z.
        P3 = P1 * P2.



			dipisp( r, P1, P2 )

        "distributive polynomial over integers S-polynomial"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipisp(r,P1,P2)  single r; pol P1,P2;
        P3 = dipisp(r,P1,P2);
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS) 
	Variablen ueber Z.
        P3 ist das S-Polynom von P1 und P2.
        (zur Erlaeuterung:
         Sei f das fuehrende Monom von P1 und g das fuehrende Monom 
	 von P2. Dann ergibt sich das S-Polynom zu:
              P3 = kgV(f,g)/f*P1 - kgV(f,g)/g*P2 .
         siehe auch:
         "Ein algorithmisches Kriterium fuer die Loesbarkeit eines
         algebraischen Gleichungssystems" von B. Buchberger;
         Aequationes mathematicae, Vol.4, 1970)



			dipisum( r, P1, P2 )

        "distributive polynomial over integers sum"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipisum(r,P1,P2)  single r; pol P1,P2;
        P3 = dipisum(r,P1,P2);
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS) 
	Variablen ueber Z.
        P3 = P1 + P2.



			diplbc( r, P )                  (MACRO)

        "distributive polynomial leading base coefficient"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        obj diplbc(r,P)  single r; pol P;
        LBC = diplbc(r,P);
        P ist ein distributives Polynom in r (0 <= r < BASIS) 
	Variablen ueber einem beliebigen Grundring.
        LBC ist der Basiskoeffizient des fuehrenden Monoms von P.



			dipmipdif( r, p, P1, P2 )

        "distributive polynomial over modular integer primes difference"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmipdif(r,p,P1,P2)  single r; int p; pol P1,P2;
        P3 = dipmipdif(r,p,P1,P2);
	p ist Primzahl.
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS) 
	Variablen ueber Z/pZ.
        P3 = P1 - P2.



			dipmipgb( r, p, PL )

        "distributive polynomial over modular integer primes Groebner
         basis"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list dipmipgb(r,p,PL)  single r; int p; list PL;
        PP = dipmipgb(r,p,PL);
	p ist Primzahl.
        PL ist eine Liste von distributiven Polynomen in r 
	(0 <= r < BASIS) Variablen ueber Z/pZ.
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (Verfahren cf. B. Buchberger)



			dipmipgba( r, p, PL, P )

        "distributive polynomial over modular integer primes Groebner
         basis augmentation"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list dipmipgba(r,p,PL,P)  single r; int p; list PL; pol P;
        PP = dipmipgba(r,p,PL,P);
        Dabei muss gelten:
              - 0 <= r < BASIS.
              - p ist Primzahl.
              - PL ist eine Groebner Basis von Polynomen in r Variablen
                ueber Z/pZ in distributiver Darstellung.
              - P ist ein Polynom in r Variablen ueber Z/pZ in
                distributiver Darstellung.
        PP ist die minimale normierte und geordnete Groebner Basis von 
	(PL,P).
        (Verfahren cf. B. Buchberger)



			dipmipgbr( r, p, PL )

        "distributive polynomial over modular integer primes Groebner
         basis recursion"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list dipmipgbr(r,p,PL)  single r; int p; list PL;
        PP = dipmipgbr(r,p,PL);
        Dabei muss gelten:
              - 0 <= r < BASIS.
              - p ist Primzahl.
              - PL ist eine Liste von Polynomen in r Variablen ueber
                Z/pZ in distributiver Darstellung.
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (zur Erlaeuterung:
	 Sei PL = {P1,...,Pn} die Liste von Polynomen. 
	 Zunaechst wird fuer P1 die reduzierte (= minimale normierte und
	 geordnete) Groebner Basis berechnet. 
	 Zu dieser Basis wird P2 hinzugenommen und wieder die reduzierte 
	 Groebner Basis berechnet. usw.
	 Diese Vorgehensweise wird fuer alle n Polynome durchgefuehrt.)



			dipmiplotglo( r, p, P )

        "distributive polynomial over modular integer primes in
         lexicographical order to distributive polynomial over modular
         integer primes in graduated lexicographical order"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmiplotglo(r,p,P)  single r; int p; pol P;
        P1 = dipmiplotglo(r,p,P);
	p ist Primzahl.
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z/pZ.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 in graduiert lexikographischer Termordnung umgewandelt.



			dipmiplotlio( r, p, P )

        "distributive polynomial over modular integer primes in
         lexicographical order to distributive polynomial over modular
         integer primes in lexicographical order with inverse exponent
         vector"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmiplotlio(r,p,P)  single r; int p; pol P;
        P1 = dipmiplotlio(r,p,P);
	p ist Primzahl.
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z/pZ.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 in lexikographischer Termordnung bzgl. umgekehrter 
	Exponentenvektoren umgewandelt.



			dipmiplottdo( r, p, P )

        "distributive polynomial over modular integer primes in
         lexicographical order to distributive polynomial over modular
         integer primes with total degree ordering"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmiplottdo(r,p,P)  single r; int p; pol P;
        P1 = dipmiplottdo(r,p,P);
	p ist Primzahl.
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z/pZ.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 mit Termordnung nach dem Totalgrad umgewandelt.



			dipmipmiprod( r, p, P, A )

        "distributive polynomial over modular integer primes, modular
         integer primes product"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmipmiprod(r,p,P,A)  single r; int p; pol P; int A;
        P1 = dipmipmiprod(r,p,P,A);
        Dabei muss gelten:
              - 0 <= r < BASIS.
              - p ist Primzahl.
              - P ist ein Polynom in r Variablen ueber Z/pZ in
                distributiver Darstellung.
              - A ist ein Element aus Z/pZ.
        P1 = A*P.



			dipmipmonic( r, p, P )

        "distributive polynomial over modular integer primes monic"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmipmonic(r,p,P)  single r; int p; pol P;
        P1 = dipmipmonic(r,p,P);
	p ist Primzahl.
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z/pZ.
        P1 ist das normierte Polynom P.



			dipmipneg( r, p, P )

        "distributive polynomial over modular integer primes negation"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmipneg(r,p,P)  single r; int p; pol P;
        P1 = dipmipneg(r,p,P);
	p ist Primzahl.
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z/pZ.
        P1 = -P.



			dipmipprod( r, p, P1, P2 )

        "distributive polynomial over modular integer primes product"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmipprod(r,p,P1,P2)  single r; int p; pol P1,P2;
        P3 = dipmipprod(r,p,P1,P2);
	p ist Primzahl.
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS) 
	Variablen ueber Z/pZ.
        P3 = P1 * P2.



			dipmipsp( r, p, P1, P2 )

        "distributive polynomial over modular integer primes S-polynomial"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmipsp(r,p,P1,P2)  single r; int p; pol P1,P2;
        P3 = dipmipsp(r,p,P1,P2);
	p ist Primzahl.
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS) 
	Variablen ueber Z/pZ.
        P3 ist das S-Polynom von P1 und P2.
        (zur Erlaeuterung:
         Sei f das fuehrende Monom von P1 und g das fuehrende Monom 
	 von P2. Dann ergibt sich das S-Polynom zu:
              P3 = kgV(f,g)/f*P1 - kgV(f,g)/g*P2 .
         siehe auch:
         "Ein algorithmisches Kriterium fuer die Loesbarkeit eines
         algebraischen Gleichungssystems" von B. Buchberger;
         Aequationes mathematicae, Vol.4, 1970)



			dipmipsum( r, p, P1, P2 )

        "distributive polynomial over modular integer primes sum"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmipsum(r,p,P1,P2)  single r; int p; pol P1,P2;
        P3 = dipmipsum(r,p,P1,P2);
	p ist Primzahl.
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS) 
	Variablen ueber Z/pZ.
        P3 = P1 + P2.



			dipmoad( r, P, pLBC, pLEV )

        "distributive polynomial monomial advance"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmoad(r,P,pLBC,pLEV)  single r; pol P; obj *pLBC; list *pLEV;
        P1 = dipmoad(r,P,pLBC,pLEV);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber einem beliebigen Grundring.
        *pLBC ist der Koeffizient des fuehrenden Monoms von P. 
	*pLEV ist der Exponentenvektor des fuehrenden Monoms von P.
        P1 ist das Polynom P ohne das fuehrende Monom.
	!! Achtung !!
	!! Falls P Monom ist, ist P1 die leere Liste. !!



			dipmspdif( r, p, P1, P2 )

        "distributive polynomial over modular single primes difference"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmspdif(r,p,P1,P2)  single r,p; pol P1,P2;
        P3 = dipmspdif(r,p,P1,P2);
	p ist Primzahl.
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS) 
	Variablen ueber Z/pZ.
        P3 = P1 - P2.



			dipmspgb( r, p, PL )

        "distributive polynomial over modular single primes Groebner
         basis"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list dipmspgb(r,p,PL)  single r,p; list PL;
        PP = dipmspgb(r,p,PL);
	p ist Primzahl.
        PL ist eine Liste von distributiven Polynomen in r 
	(0 <= r < BASIS) Variablen ueber Z/pZ.
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (Verfahren cf. B. Buchberger)



			dipmspgba( r, p, PL, P )

        "distributive polynomial over modular single primes Groebner
         basis augmentation"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list dipmspgba(r,p,PL,P)  single r,p; list PL; pol P;
        PP = dipmspgba(r,p,PL,P);
        Dabei muss gelten:
              - 0 <= r < BASIS.
              - p ist Primzahl.
              - PL ist eine Groebner Basis von Polynomen in r Variablen
                ueber Z/pZ in distributiver Darstellung.
              - P ist ein Polynom in r Variablen ueber Z/pZ in
                distributiver Darstellung.
        PP ist die minimale normierte und geordnete Groebner Basis von 
	(PL,P).
        (Verfahren cf. B. Buchberger)



			dipmspgbr( r, p, PL )

        "distributive polynomial over modular single primes Groebner
         basis recursion"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list dipmspgbr(r,p,PL)  single r,p; list PL;
        PP = dipmspgbr(r,p,PL);
        Dabei muss gelten:
              - 0 <= r < BASIS.
              - p ist Primzahl.
              - PL ist eine Liste von Polynomen in r Variablen ueber
                Z/pZ in distributiver Darstellung.
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (zur Erlaeuterung:
	 Sei PL = {P1,...,Pn} die Liste von Polynomen. 
	 Zunaechst wird fuer P1 die reduzierte (= minimale normierte und
	 geordnete) Groebner Basis berechnet. 
	 Zu dieser Basis wird P2 hinzugenommen und wieder die reduzierte 
	 Groebner Basis berechnet. usw.
	 Diese Vorgehensweise wird fuer alle n Polynome durchgefuehrt.)



			dipmsplotglo( r, p, P )

        "distributive polynomial over modular single primes in
         lexicographical order to distributive polynomial over modular
         single primes in graduated lexicographical order"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmsplotglo(r,p,P)  single r,p; pol P;
        P1 = dipmsplotglo(r,p,P);
	p ist Primzahl.
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z/pZ.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 in graduiert lexikographischer Termordnung umgewandelt.



			dipmsplotlio( r, p, P )

        "distributive polynomial over modular single primes in
         lexicographical order to distributive polynomial over modular
         single primes in lexicographical order with inverse exponent
         vector"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmsplotlio(r,p,P)  single r,p; pol P;
        P1 = dipmsplotlio(r,p,P);
	p ist Primzahl.
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z/pZ.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 in lexikographischer Termordnung bzgl. umgekehrter 
	Exponentenvektoren umgewandelt.



			dipmsplottdo( r, p, P )

        "distributive polynomial over modular single primes in
         lexicographical order to distributive polynomial over modular
         single primes with total degree ordering"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmsplottdo(r,p,P)  single r,p; pol P;
        P1 = dipmsplottdo(r,p,P);
	p ist Primzahl.
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z/pZ.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 mit Termordnung nach dem Totalgrad umgewandelt.



			dipmspmonic( r, p, P )

        "distributive polynomial over modular single primes monic"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmspmonic(r,p,P)  single r,p; pol P;
        P1 = dipmspmonic(r,p,P);
	p ist Primzahl.
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z/pZ.
        P1 ist das normierte Polynom P.



			dipmspmsprod( r, p, P, a )

        "distributive polynomial over modular single primes, modular
         single primes product"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmspmsprod(r,p,P,a)  single r,p; pol P; single a;
        P1 = dipmspmsprod(r,p,P,a);
        Dabei muss gelten:
              - 0 <= r < BASIS.
              - p ist Primzahl.
              - P ist ein Polynom in r Variablen ueber Z/pZ in
                distributiver Darstellung.
              - a ist ein Element aus Z/pZ.
        P1 = a*P.



			dipmspneg( r, p, P )

        "distributive polynomial over modular single primes negation"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmspneg(r,p,P)  single r,p; pol P;
        P1 = dipmspneg(r,p,P);
	p ist Primzahl.
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z/pZ.
        P1 = -P.



			dipmspprod( r, p, P1, P2 )

        "distributive polynomial over modular single primes product"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmspprod(r,p,P1,P2)  single r,p; pol P1,P2;
        P3 = dipmspprod(r,p,P1,P2);
	p ist Primzahl.
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS) 
	Variablen ueber Z/pZ.
        P3 = P1 * P2.



			dipmspsp( r, p, P1, P2 )

        "distributive polynomial over modular single primes S-polynomial"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmspsp(r,p,P1,P2)  single r,p; pol P1,P2;
        P3 = dipmspsp(r,p,P1,P2);
	p ist Primzahl.
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS) 
	Variablen ueber Z/pZ.
        P3 ist das S-Polynom von P1 und P2.
        (zur Erlaeuterung:
         Sei f das fuehrende Monom von P1 und g das fuehrende Monom 
	 von P2. Dann ergibt sich das S-Polynom zu:
              P3 = kgV(f,g)/f*P1 - kgV(f,g)/g*P2 .
         siehe auch:
         "Ein algorithmisches Kriterium fuer die Loesbarkeit eines
         algebraischen Gleichungssystems" von B. Buchberger;
         Aequationes mathematicae, Vol.4, 1970)



			dipmspsum( r, p, P1, P2 )

        "distributive polynomial over modular single primes sum"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipmspsum(r,p,P1,P2)  single r,p; pol P1,P2;
        P3 = dipmspsum(r,p,P1,P2);
	p ist Primzahl.
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS) 
	Variablen ueber Z/pZ.
        P3 = P1 + P2.



			dipnfdif( r, F, P1, P2 )

        "distributive polynomial over number field difference"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipnfdif(r,F,P1,P2)  single r; pol F,P1,P2;
        P3 = dipnfdif(r,F,P1,P2);
        Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z
		vom Grad >= 1 in dense-Darstellung, das den Zahlkoerper k 
		erzeugt.
              - P1 und P2 sind distributive Polynome in r (0 <= r < BASIS)
		Variablen ueber k.
        P3 = P1 - P2.



			dipnfgb( r, F, PL )

        "distributive polynomial over number field Groebner basis"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        list dipnfgb(r,F,PL)  single r; pol F; list PL;
        PP = dipnfgb(r,F,PL);
        Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z
		vom Grad >= 1 in dense-Darstellung, das den Zahlkoerper k 
		erzeugt.
              - PL ist eine Liste von distributiven Polynomen in r 
		(0 <= r < BASIS) Variablen ueber k
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (Verfahren cf. B. Buchberger)



			dipnfgba( r, F, PL, P )

        "distributive polynomial over number field Groebner basis
         augmentation"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        list dipnfgba(r,F,PL,P)  single r; pol F; list PL; pol P;
        PP = dipnfgba(r,F,PL,P);
        Dabei muss gelten:
              - 0 <= r < BASIS.
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z
		vom Grad >= 1 in dense-Darstellung, das den Zahlkoerper k 
		erzeugt.
              - PL ist eine Liste von distributiven Polynomen in r 
		Variablen ueber k.
              - P ist ein distributives Polynom in r Variablen ueber k.
        PP ist die minimale normierte und geordnete Groebner Basis von 
	(PL,P).
        (Verfahren cf. B. Buchberger)



			dipnfgbr( r, F, PL )

        "distributive polynomial over number field Groebner basis
         recursion"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        list dipnfgbr(r,F,PL)  single r; pol F; list PL;
        PP = dipnfgbr(r,F,PL);
        Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z 
		vom Grad >= 1 in dense-Darstellung, das den Zahlkoerper k 
		erzeugt.
              - PL ist eine Liste von distributiven Polynomen in r 
		(0 <= r < BASIS) Variablen ueber k.
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (zur Erlaeuterung:
	 Sei PL = {P1,...,Pn} die Liste von Polynomen. 
	 Zunaechst wird fuer P1 die reduzierte (= minimale normierte und
	 geordnete) Groebner Basis berechnet. 
	 Zu dieser Basis wird P2 hinzugenommen und wieder die reduzierte 
	 Groebner Basis berechnet. usw.
	 Diese Vorgehensweise wird fuer alle n Polynome durchgefuehrt.)



			dipnflotoglo( r, F, P )

        "distributive polynomial over number field in lexicographical 
	 order to distributive polynomial over number field in graduated
         lexicographical order"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipnflotoglo(r,F,P)  single r; pol F,P;
        P1 = dipnflotoglo(r,F,P);
        Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z
		vom Grad >= 1 in dense-Darstellung, das den Zahlkoerper k 
		erzeugt.
              - P ist ein distributives Polynom in r (0 <= r < BASIS)
		Variablen ueber k.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 in graduiert lexikographischer Termordnung umgewandelt.



			dipnflotolio( r, F, P )

        "distributive polynomial over number field in lexicographical 
	 order to distributive polynomial over number field in 
	 lexicographical order with inverse exponent vector"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipnflotolio(r,F,P)  single r; pol F,P;
        P1 = dipnflotolio(r,F,P);
        Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z
		vom Grad >= 1 in dense-Darstellung, das den Zahlkoerper k 
		erzeugt.
              - P ist ein distributives Polynom in r (0 <= r < BASIS)
		Variablen ueber k.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 in lexikographischer Termordnung bzgl. umgekehrter 
	Exponentenvektoren umgewandelt.



			dipnflototdo( r, F, P )

        "distributive polynomial over number field in lexicographical 
	 order to distributive polynomial over number field with total 
	 degree ordering"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipnflototdo(r,F,P)  single r; pol F,P;
        P1 = dipnflototdo(r,F,P);
        Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z
		vom Grad >= 1 in dense-Darstellung, das den Zahlkoerper k 
		erzeugt.
              - P ist ein distributives Polynom in r (0 <= r < BASIS)
		Variablen ueber k.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 in graduiert lexikographischer Termordnung umgewandelt.



			dipnfmonic( r, F, P )

        "distributive polynomial over number field monic"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipnfmonic(r,F,P)  single r; pol F,P;
        P1 = dipnfmonic(r,F,P);
        Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z
		vom Grad >= 1 in dense-Darstellung, das den Zahlkoerper k 
		erzeugt.
              - P ist ein distributives Polynom in r (0 <= r < BASIS)
		Variablen ueber k.
        P1 ist das normierte Polynom P.



			dipnfneg( r, F, P )

        "distributive polynomial over number field negation"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipnfneg(r,F,P)  single r; pol F,P;
        P1 = dipnfneg(r,F,P);
        Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z
		vom Grad >= 1 in dense-Darstellung, das den Zahlkoerper k 
		erzeugt.
              - P ist ein distributives Polynom in r (0 <= r < BASIS)
		Variablen ueber k.
        P1 = -P.



			dipnfnfprod( r, F, P, A )

        "distributive polynomial over number field, number field
         element product"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipnfnfprod(r,F,P,A)  single r; pol F,P; nfel A;
        P1 = dipnfnfprod(r,F,P,A);
        Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z
		vom Grad >= 1 in dense-Darstellung, das den Zahlkoerper k 
		erzeugt.
              - P ist ein distributives Polynom in r (0 <= r < BASIS)
		Variablen ueber k.
              - A ist ein Element aus k.
        P1 = A*P.



			dipnfprod( r, F, P1, P2 )

        "distributive polynomial over number field product"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipnfprod(r,F,P1,P2)  single r; pol F,P1,P2;
        P3 = dipnfprod(r,F,P1,P2);
        Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z
		vom Grad >= 1 in dense-Darstellung, das den Zahlkoerper k 
		erzeugt.
              - P1 und P2 sind distributive Polynome in r (0 <= r < BASIS)
		Variablen ueber k.
        P3 = P1 * P2.



			dipnfsp( r, F, P1, P2 )

        "distributive polynomial over number field S-polynomial"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipnfsp(r,F,P1,P2)  single r; pol F,P1,P2;
        P3 = dipnfsp(r,F,P1,P2);
        Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z
		vom Grad >= 1 in dense-Darstellung, das den Zahlkoerper k 
		erzeugt.
              - P1 und P2 sind distributive Polynome in r (0 <= r < BASIS)
		Variablen ueber k.
        P3 ist das S-Polynom von P1 und P2.
        (zur Erlaeuterung:
         Sei f das fuehrende Monom von P1 und g das fuehrende Monom 
	 von P2. Dann ergibt sich das S-Polynom zu:
              P3 = kgV(f,g)/f*P1 - kgV(f,g)/g*P2 .
         siehe auch:
         "Ein algorithmisches Kriterium fuer die Loesbarkeit eines
         algebraischen Gleichungssystems" von B. Buchberger;
         Aequationes mathematicae, Vol.4, 1970)



			dipnfsum( r, F, P1, P2 )

        "distributive polynomial over number field sum"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol dipnfsum(r,F,P1,P2)  single r; pol F,P1,P2;
        P3 = dipnfsum(r,F,P1,P2);
        Dabei muss gelten:
	      - F ist ein irreduzibles Polynom in einer Variablen ueber Z
		vom Grad >= 1 in dense-Darstellung, das den Zahlkoerper k 
		erzeugt.
              - P1 und P2 sind distributive Polynome in r (0 <= r < BASIS)
		Variablen ueber k.
        P3 = P1 + P2.



			dipnmv( r, P, n )

        "distributive polynomial new main variable"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol dipnmv(r,P,n) single r, pol P, single n;
        Q = dipnmv(r,P,n);
        P = distributives Polynom in r Variablen (0<=r<BASIS)
        Q = nach der neuen Hauptvariablen Xn (1 <= n <=r) umgeordnetes
                   Polynom P in distributiver Darstellung; d.h.
                   Variablenliste zu P = (X1, ..., Xr)
                   Variablenliste zu Q = (X1, ..., Xn-1, Xn+1, ..., Xr, Xn)
          = ERROR  sonst (n > r oder n < 1)



			dippicgb( r1, r2, VL1, VL2, PL, CONDS, OPL, pGS, pi, pf )

	"distributive polynomial over polynomials over integers
        comprehensive Groebner basis"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        list dippicgb(r1, r2, VL1, VL2, PL, CONDS, OPL, pGS, pi, pf)
             	single r1, r2; list VL1, VL2, PL, CONDS, OPL; list *pGS;
             	single *pi; FILE *pf;
        CGBL = dippicgb(r1,r2,VL1,VL2,PL,CONDS,OPL,pGS,pi,pf);
        PL ist eine Liste von distributiven Polynomen in r1  (0<=r1<BASIS)
        Variablen  ueber  einem  Polynomring  ueber Z in r2  (0<=r2<BASIS)
        Variablen,  wobei die Liste VL1 die r1 Variablennamen der Polynome
        repraesentiert  und die Liste VL2 die r2 Variablennamen  des Poly-
        nomrings ueber Z repraesentiert  (VL2 ist also die Liste der Vari-
        ablennamen des Grundrings).
        CONDS ist  eine  Fallunterscheidung, d.h. entweder die leere Liste
        ("{}")  oder  eine  Liste,  die aus einer geraden Anzahl von Teil-
        listen besteht,  wobei die Teillisten mit ungerader Laufnummer die
        Koeffizientenpolynome enthalten, die  gleich  Null  sind, und  die
        mit  gerader  Laufnummer  die  Koeffizientenpolynome, die ungleich
        Null sind.
        Sei z.B. VL2 = a,b,c,d.
        Dann kann die Fallunterscheidung wie folgt aussehen:
             {{a^2-d# c+d#}{a#}{}{a^4-b*a^3+c*d}},
                            d.h. a^2-d==0, c+d==0, a!=0, a^4-b*a^3+c*d!=0;
             oder
             {{a^2-d# c+d#}{a#}}, d.h. a^2-d==0, c+d==0, a!=0;
             oder
             {{}{b^2-d^3+c# a# c#}}, d.h. b^2-d^3+c!=0, a!=0, c!=0;
             oder
             {{b# c# a^5-d^4+d^3+d#}{}},
                                        d.h. b==0, c==0, a^5-d^4+d^3+d==0.
        OPL ist eine Liste von Schaltern der Laenge 3,  wobei die Schalter
        nur die Werte 0 und 1 annehmen.
        Mit dem ersten Schalter wird die Faktorisierung der Koeffizienten-
        polynome ein (1) bzw. aus (0) geschaltet.
        Der zweite Schalter stellt den  Reduktionsalgorithmus  ein,  bzgl.
        dem die Polynome auf  Normalform  gebracht werden.  Es stehen zwei
        Reduktionsalgorithmen  zur  Verfuegung, einmal  die  Topreduktion,
        d.h. es werden nur die fuehrenden Monome  (bzgl. der Termordnung),
        deren Koeffizienten ungleich Null sind,  eliminiert.  Topreduktion
        wird mit (0) eingestellt. Der  andere  Reduktionsalgorithmus  ent-
        spricht der Reduktion bei der ueblichen Groebnerbasen-  bzw. Stan-
        dardbasenberechnung. Die allgemein uebliche Reduktion wird mit (1)
        eingestellt.
        (cf. V. Weispfenning, Comprehensive Groebner Bases, MIP 9003
             oder
             E. Schoenfeld, Diplomarbeit: Parametrische Groebnerbasen im
             Computer Algebra System ALDES/SAC2 1991 (Passau)            )
        Der  dritte  Schalter erlaubt die Ausgabe von  Zwischenergebnissen
        waehrend des Programmlaufs.  Wird die  Ausgabe  von Zwischenergeb-
        nissen  gewuenscht  (Schalter = 1),  muss  zuvor  eine  Datei  zum
        Schreiben geoeffnet werden, entweder durch
                CGBL = dippicgb(r1,r2,VL1,VL2,PL,CONDS,OPL,pGS,pi,stdout);
        was bewirkt, dass die Ausgabe auf dem Bildschirm erfolgt,
        oder durch
                pf   = fopen("ZWISCHENWERTE","w");
                CGBL = dippicgb(r1,r2,VL1,VL2,PL,CONDS,OPL,pGS,pi,pf);
             oder
                pf   = fopen("ZWISCHENWERTE","a");
                CGBL = dippicgb(r1,r2,VL1,VL2,PL,CONDS,OPL,pGS,pi,pf);
        was bewirkt, dass die  Zwischenergebnisse  in  die  Datei  mit dem
        Namen "ZWISCHENWERTE" geschrieben  werden.  Wird keine Ausgabe der
        Zwischenwerte gewuenscht, so hat der Schalter den Wert 0.
        Berechnet wird ein Groebnersystem *pGS, d.h. anhand der Fallunter-
        scheidung,  die waehrend des Programmlaufs weiter verfeinert wird,
        wird fuer jedes Koeffizientenlistenpaar ( siehe oben: CONDS ) eine
        Groebnerbasis berechnet,  wodurch  eine  Art Baum entsteht, der in
        jedem  Zweig  ein  Koeffizientenlistenpaar  und eine dazugehoerige
        Groebnerbasis  enthaelt.  War  die  Fallunterscheidung  die  leere
        Liste,  so  wird  waehrend  der  Rechnung  eine Fallunterscheidung
        erstellt und verfeinert.
        *pi liefert die Anzahl der "Zweige" des Groebnersystems.
        *pf: siehe oben Erlaeuterung zu OPL, Schalter 3.
        CGBL  ist  die  Vereinigung  der  Groebnerbasen im Groebnersystem,
        jedoch ohne die dazugehoerigen Koeffizientenlistenpaare.



			dippicp( r1, r2, P, pPP )

        "distributive polynomial over polynomials over integers content
         and primitive part"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        int dippicp(r1,r2,P,pPP)  single r1,r2; pol P,*pPP;
        C = dippicp(r1,r2,P,pPP);
        P ist ein distributives Polynom in r1 (0 <= r1 < BASIS) Variablen 
	ueber einem Polynomring ueber Z in r2 (0 <= r2 < BASIS) Variablen.
        C ist der Inhalt des Polynoms P. 
	*pPP ist der primitive Anteil von P; der fuehrende Basiskoeffizient 
	des fuehrenden Basiskoeffizienten von *pPP ist positiv.



			dippidif( r1, r2, P1, P2 )

        "distributive polynomial over polynomials over integers difference"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        pol dippidif(r1,r2,P1,P2)  single r1,r2; pol P1,P2;
        P3 = dippidif(r1,r2,P1,P2);
        P1 und P2 sind distributive Polynome in r1 (0 <= r1 < BASIS) 
	Variablen ueber einem Polynomring ueber Z in r2 (0 <= r2 < BASIS)
	Variablen.
        P3 = P1 - P2.



			dippidim( r1, r2, s, PL, CONDS, fac, VL1, VL2, pf )

	"distributive polynomial over polynomials over integers
         dimension"
	Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        list dippidim(r1,r2,s,PL,CONDS,fac,VL1,VL2,pf)  single r1,r2,s;
             list PL,CONDS; single fac; list VL1,VL2; FILE *pf;
        DIML = dippidim(r1,r2,s,PL,CONDS,fac,VL1,VL2,pf);
        s kann nur die Werte 0 und 1 annehmen.
        Ist s = 0, so ist
            PL eine Liste von distributiven Polynomen in r1  (0<=r1<BASIS)
        Variablen  ueber  einem  Polynomring  ueber Z in r2  (0<=r2<BASIS)
        Variablen,  wobei die Liste VL1 die r1 Variablennamen der Polynome
        repraesentiert  und die Liste VL2 die r2 Variablennamen  des Poly-
        nomrings ueber Z repraesentiert  (VL2 ist also die Liste der Vari-
        ablennamen des Grundrings).
        Ist s = 1, so ist
            PL ein Groebner-System.
        (siehe: dippicgb  oder  dippircgb)
        CONDS ist  eine  Fallunterscheidung, d.h. entweder die leere Liste
        ("{}")  oder  eine  Liste,  die aus einer geraden Anzahl von Teil-
        listen besteht,  wobei die Teillisten mit ungerader Laufnummer die
        Koeffizientenpolynome enthalten, die  gleich  Null  sind, und  die
        mit  gerader  Laufnummer  die  Koeffizientenpolynome, die ungleich
        Null sind.
        Sei z.B. VL2 = a,b,c,d.
        Dann kann die Fallunterscheidung wie folgt aussehen:
             {{a^2-d# c+d#}{a#}{}{a^4-b*a^3+c*d}},
                            d.h. a^2-d==0, c+d==0, a!=0, a^4-b*a^3+c*d!=0;
             oder
             {{a^2-d# c+d#}{a#}}, d.h. a^2-d==0, c+d==0, a!=0;
             oder
             {{}{b^2-d^3+c# a# c#}}, d.h. b^2-d^3+c!=0, a!=0, c!=0;
             oder
             {{b# c# a^5-d^4+d^3+d#}{}},
                                        d.h. b==0, c==0, a^5-d^4+d^3+d==0.
        Mit dem Schalter  fac  wird die Faktorisierung der  Koeffizienten-
        polynome ein (1) bzw. aus (0) geschaltet.
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        Fuer jedes Element des Groebner-Systems wird die Dimension berech-
        net. DIML ist eine Liste von Bedingungen und Dimensionen.



			dippigb( r1, r2, PL )

        "distributive polynomial over polynomials over integers Groebner
         basis"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        list dippigb(r1,r2,PL)  single r1,r2; list PL;
        PP = dippigb(r1,r2,PL);
        PL ist eine Liste von distributiven Polynomen in r1 
	(0 <= r1 < BASIS) Variablen ueber einem Polynomring ueber Z 
	in r2 (0 <= r2 < BASIS) Variablen.
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (Verfahren cf. B. Buchberger)



			dippigba( r1, r2, PL, P )

        "distributive polynomial over polynomials over integers Groebner
         basis augmentation"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        list dippigba(r1,r2,PL,P)  single r1,r2; list PL; pol P;
        PP = dippigba(r1,r2,PL,P);
        Dabei muss gelten:
	      - 0 <= r1 < BASIS.
	      - 0 <= r2 < BASIS.
              - PL ist eine Groebner Basis von distributiven Polynomen 
		in r1 Variablen ueber einem Polynomring ueber Z in r2 
		Variablen.
              - P ist ein distributives Polynom in r1 Variablen ueber 
		einem Polynomring ueber Z in r2 Variablen.
        PP ist die minimale normierte und geordnete Groebner Basis von 
	(PL,P).
        (Verfahren cf. B. Buchberger)



			dippigbr( r1, r2, PL )

        "distributive polynomial over polynomials over integers Groebner
         basis recursion"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        list dippigbr(r1,r2,PL)  single r1,r2; list PL;
        PP = dippigbr(r1,r2,PL);
        PL ist eine Liste von distributiven Polynomen in r1 
	(0 <= r1 < BASIS) Variablen ueber einem Polynomring ueber Z 
	in r2 (0 <= r2 < BASIS) Variablen.
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (zur Erlaeuterung:
	 Sei PL = {P1,...,Pn} die Liste von Polynomen. 
	 Zunaechst wird fuer P1 die reduzierte (= minimale normierte und
	 geordnete) Groebner Basis berechnet. 
	 Zu dieser Basis wird P2 hinzugenommen und wieder die reduzierte 
	 Groebner Basis berechnet. usw.
	 Diese Vorgehensweise wird fuer alle n Polynome durchgefuehrt.)



			dippigt( r1, r2, s, PL, CONDS, OPL, pCGB1 )

	"distributive polynomial over polynomials over integers
         Groebner test"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        list dippigt(r1,r2,s,PL,CONDS,OPL,pCGB1)  single r1,r2,s;
             list PL,CONDS,OPL; list *pCGB1;
        CGB0 = dippigt(r1,r2,s,PL,CONDS,OPL,pCGB1);
        s kann nur die Werte 0 und 1 annehmen.
        Ist s = 0, so ist
            PL eine Liste von distributiven Polynomen in r1  (0<=r1<BASIS)
        Variablen  ueber  einem  Polynomring  ueber Z in r2  (0<=r2<BASIS)
        Variablen,  wobei die Liste VL1 die r1 Variablennamen der Polynome
        repraesentiert, und die Liste VL2 die r2 Variablennamen  des Poly-
        nomrings ueber Z repraesentiert  (VL2 ist also die Liste der Vari-
        ablennamen des Grundrings).
        Ist s = 1, so ist
            PL eine parametrische Groebnerbasis.
        (siehe: dippicgb  oder  dippircgb)
        CONDS ist  eine  Fallunterscheidung, d.h. entweder die leere Liste
        ("{}")  oder  eine  Liste,  die aus einer geraden Anzahl von Teil-
        listen besteht,  wobei die Teillisten mit ungerader Laufnummer die
        Koeffizientenpolynome enthalten, die  gleich  Null  sind, und  die
        mit  gerader  Laufnummer  die  Koeffizientenpolynome, die ungleich
        Null sind.
        Sei z.B. VL2 = a,b,c,d.
        Dann kann die Fallunterscheidung wie folgt aussehen:
             {{a^2-d# c+d#}{a#}{}{a^4-b*a^3+c*d}},
                            d.h. a^2-d==0, c+d==0, a!=0, a^4-b*a^3+c*d!=0;
             oder
             {{a^2-d# c+d#}{a#}}, d.h. a^2-d==0, c+d==0, a!=0;
             oder
             {{}{b^2-d^3+c# a# c#}}, d.h. b^2-d^3+c!=0, a!=0, c!=0;
             oder
             {{b# c# a^5-d^4+d^3+d#}{}},
                                        d.h. b==0, c==0, a^5-d^4+d^3+d==0.
        OPL ist eine Liste von Schaltern der Laenge 3,  wobei die Schalter
        nur die Werte 0 und 1 annehmen.
        Mit dem ersten Schalter wird die Faktorisierung der Koeffizienten-
        polynome ein (1) bzw. aus (0) geschaltet.
        Der zweite Schalter stellt den  Reduktionsalgorithmus  ein,  bzgl.
        dem die Polynome auf  Normalform  gebracht werden.  Es stehen zwei
        Reduktionsalgorithmen  zur  Verfuegung, einmal  die  Topreduktion,
        d.h. es werden nur die fuehrenden Monome  (bzgl. der Termordnung),
        deren Koeffizienten ungleich Null sind,  eliminiert.  Topreduktion
        wird mit (0) eingestellt. Der  andere  Reduktionsalgorithmus  ent-
        spricht der Reduktion bei der ueblichen Groebnerbasen-  bzw. Stan-
        dardbasenberechnung. Die allgemein uebliche Reduktion wird mit (1)
        eingestellt.
        Der  dritte  Schalter ist optional.
        dippigt verifiziert, ob P eine parametrische Groebnerbasis bzgl. C
        ist.
        CGB0 ist eine Liste, die die Bedingungen enthaelt,  so dass P eine
        Groebnerbasis ist,  und *pCGB1 ist eine  Liste,  die  die  Beding-
        ungen enthaelt, so dass P keine Groebnerbasis ist.
        (cf. V. Weispfenning, Comprehensive Groebner Bases, MIP 9003
             oder
             E. Schoenfeld, Diplomarbeit: Parametrische Groebnerbasen im
             Computer Algebra System ALDES/SAC2 1991 (Passau)            )



			dippilotoglo( r1, r2, P )

        "distributive polynomial over polynomials over integers in
         lexicographical order to distributive polynomial over polynomials
         over integers in graduated lexicographical order"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        pol dippilotoglo(r1,r2,P)  single r1,r2; pol P;
        P1 = dippilotoglo(r1,r2,P);
        P ist ein distributives Polynom in r1 (0 <= r1 < BASIS) Variablen 
	ueber einem Polynomring ueber Z in r2 (0 <= r2 < BASIS) Variablen.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 in graduiert lexikographischer Termordnung umgewandelt.



			dippilotolio( r1, r2, P )

        "distributive polynomial over polynomials over integers in
         lexicographical order to distributive polynomial over polynomials
         over integers in lexicographical order with inverse exponent
         vector"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        pol dippilotolio(r1,r2,P)  single r1,r2; pol P;
        P1 = dippilotolio(r1,r2,P);
        P ist ein distributives Polynom in r1 (0 <= r1 < BASIS) Variablen 
	ueber einem Polynomring ueber Z in r2 (0 <= r2 < BASIS) Variablen.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 in lexikographischer Termordnung bzgl. umgekehrter 
	Exponentenvektoren umgewandelt.



			dippilototdo( r1, r2, P )

        "distributive polynomial over polynomials over integers in
         lexicographical order to distributive polynomial over polynomials
         over integers with total degree ordering"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        pol dippilototdo(r1,r2,P)  single r1,r2; pol P;
        P1 = dippilototdo(r1,r2,P);
        P ist ein distributives Polynom in r1 (0 <= r1 < BASIS) Variablen 
	ueber einem Polynomring ueber Z in r2 (0 <= r2 < BASIS) Variablen.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 mit Termordnung nach dem Totalgrad umgewandelt.



			dippineg( r1, r2, P )

        "distributive polynomial over polynomials over integers negation"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        pol dippineg(r1,r2,P)  single r1,r2; pol P;
        P1 = dippineg(r1,r2,P);
        P ist ein distributives Polynom in r1 (0 <= r1 < BASIS) Variablen 
	ueber einem Polynomring ueber Z in r2 (0 <= r2 < BASIS) Variablen.
        P1 = -P.



			dippipim( r1, r2, s, PL, PTL, CONDS, OPL )

	"distributive polynomial over polynomials over integers
         parametric ideal membership test"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        list dippipim(r1,r2,s,PL,PTL,CONDS,OPL)  single r1,r2,s;
        	list PL,PTL,CONDS,OPL;
        NOUT = dippipim(r1,r2,s,PL,PTL,CONDS,OPL);
        s kann nur die Werte 0 und 1 annehmen.
        Ist s = 0, so ist
            PL eine Liste von distributiven Polynomen in r1  (0<=r1<BASIS)
        Variablen  ueber  einem  Polynomring  ueber Z in r2  (0<=r2<BASIS)
        Variablen,  wobei die Liste VL1 die r1 Variablennamen der Polynome
        repraesentiert  und die Liste VL2 die r2 Variablennamen  des Poly-
        nomrings ueber Z repraesentiert  (VL2 ist also die Liste der Vari-
        ablennamen des Grundrings).
        Ist s = 1, so ist
            PL eine parametrische Groebnerbasis.
        (siehe: dippicgb  oder  dippircgb)
        PTL  eine  Liste  von distributiven Polynomen in r1  (0<=r1<BASIS)
        Variablen  ueber  einem  Polynomring  ueber Z in r2  (0<=r2<BASIS)
        Variablen.
        CONDS ist  eine  Fallunterscheidung, d.h. entweder die leere Liste
        ("{}")  oder  eine  Liste,  die aus einer geraden Anzahl von Teil-
        listen besteht,  wobei die Teillisten mit ungerader Laufnummer die
        Koeffizientenpolynome enthalten, die  gleich  Null  sind, und  die
        mit  gerader  Laufnummer  die  Koeffizientenpolynome, die ungleich
        Null sind.
        Sei z.B. VL2 = a,b,c,d.
        Dann kann die Fallunterscheidung wie folgt aussehen:
             {{a^2-d# c+d#}{a#}{}{a^4-b*a^3+c*d}},
                            d.h. a^2-d==0, c+d==0, a!=0, a^4-b*a^3+c*d!=0;
             oder
             {{a^2-d# c+d#}{a#}}, d.h. a^2-d==0, c+d==0, a!=0;
             oder
             {{}{b^2-d^3+c# a# c#}}, d.h. b^2-d^3+c!=0, a!=0, c!=0;
             oder
             {{b# c# a^5-d^4+d^3+d#}{}},
                                        d.h. b==0, c==0, a^5-d^4+d^3+d==0.
        OPL ist eine Liste von Schaltern der Laenge 3,  wobei die Schalter
        nur die Werte 0 und 1 annehmen.
        Mit dem ersten Schalter wird die Faktorisierung der Koeffizienten-
        polynome ein (1) bzw. aus (0) geschaltet.
        Der zweite Schalter stellt den  Reduktionsalgorithmus  ein,  bzgl.
        dem die Polynome auf  Normalform  gebracht werden.  Es stehen zwei
        Reduktionsalgorithmen  zur  Verfuegung, einmal  die  Topreduktion,
        d.h. es werden nur die fuehrenden Monome  (bzgl. der Termordnung),
        deren Koeffizienten ungleich Null sind,  eliminiert.  Topreduktion
        wird mit (0) eingestellt. Der  andere  Reduktionsalgorithmus  ent-
        spricht der Reduktion bei der ueblichen Groebnerbasen-  bzw. Stan-
        dardbasenberechnung. Die allgemein uebliche Reduktion wird mit (1)
        eingestellt.
        (cf. V. Weispfenning, Comprehensive Groebner Bases, MIP 9003
             oder
             E. Schoenfeld, Diplomarbeit: Parametrische Groebnerbasen im
             Computer Algebra System ALDES/SAC2 1991 (Passau)            )
        Der  dritte  Schalter ist optional.
        NOUT ist  eine  Liste,  die jedes Polynom aus PTL enthaelt und die
        Bedingungen und Normalformen,  so dass das Polynom ein Element des
        Ideals ist,  und solche Bedingungen und Normalformen,  so dass das
        Polynom kein Element des Ideals ist.



			dippipiprod( r1, r2, P, A )

        "distributive polynomial over polynomials over integers, polynomial
         over integers product"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        pol dippipiprod(r1,r2,P,A)  single r1,r2; pol P,A;
        P1 = dippipiprod(r1,r2,P,A);
        Dabei muss gelten:
              - 0 <= r1 < BASIS.
              - 0 <= r2 < BASIS.
              - P ist ein distributives Polynom in r1 Variablen ueber 
		einem Polynomring ueber Z in r2 Variablen.
              - A ist ein Polynom ueber Z in r2 Variablen (in sparse
                Darstellung).
        P1 = A*P.



			dippiprod( r1, r2, P1, P2 )

        "distributive polynomial over polynomials over integers product"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        pol dippiprod(r1,r2,P1,P2)  single r1,r2; pol P1,P2;
        P3 = dippiprod(r1,r2,P1,P2);
        P1 und P2 sind distributive Polynome in r1 (0 <= r1 < BASIS) 
	Variablen ueber einem Polynomring ueber Z in r2 (0 <= r2 < BASIS)
	Variablen.
        P3 = P1 * P2.



			dippiqff( r1, r2, s, PL, CONDS, fac )

	"distributive polynomial over polynomials over integers
         quantifier free formula"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        list dippiqff(r1,r2,s,PL,CONDS,fac)  single r1,r2,s;
             list PL,CONDS; single fac;
        QFFL = dippiqff(r1,r2,s,PL,CONDS,fac);
        s kann nur die Werte 0 und 1 annehmen.
        Ist s = 0, so ist
            PL eine Liste von distributiven Polynomen in r1  (0<=r1<BASIS)
        Variablen  ueber  einem  Polynomring  ueber Z in r2  (0<=r2<BASIS)
        Variablen,  wobei die Liste VL1 die r1 Variablennamen der Polynome
        repraesentiert, und die Liste VL2 die r2 Variablennamen  des Poly-
        nomrings ueber Z repraesentiert  (VL2 ist also die Liste der Vari-
        ablennamen des Grundrings).
        Ist s = 1, so ist
            PL eine parametrische Groebnerbasis.
        (siehe: dippicgb  oder  dippircgb)
        CONDS ist  eine  Fallunterscheidung, d.h. entweder die leere Liste
        ("{}")  oder  eine  Liste,  die aus einer geraden Anzahl von Teil-
        listen besteht,  wobei die Teillisten mit ungerader Laufnummer die
        Koeffizientenpolynome enthalten, die  gleich  Null  sind, und  die
        mit  gerader  Laufnummer  die  Koeffizientenpolynome, die ungleich
        Null sind.
        Sei z.B. VL2 = a,b,c,d.
        Dann kann die Fallunterscheidung wie folgt aussehen:
             {{a^2-d# c+d#}{a#}{}{a^4-b*a^3+c*d}},
                            d.h. a^2-d==0, c+d==0, a!=0, a^4-b*a^3+c*d!=0;
             oder
             {{a^2-d# c+d#}{a#}}, d.h. a^2-d==0, c+d==0, a!=0;
             oder
             {{}{b^2-d^3+c# a# c#}}, d.h. b^2-d^3+c!=0, a!=0, c!=0;
             oder
             {{b# c# a^5-d^4+d^3+d#}{}},
                                        d.h. b==0, c==0, a^5-d^4+d^3+d==0.
        Mit dem Schalter  fac  wird die Faktorisierung der  Koeffizienten-
        polynome ein (1) bzw. aus (0) geschaltet.
        QFFL ist die quantorenfreie Formel einer Basis.
        (cf. V. Weispfenning, Comprehensive Groebner Bases, MIP 9003
             oder
             E. Schoenfeld, Diplomarbeit: Parametrische Groebnerbasen im
             Computer Algebra System ALDES/SAC2 1991 (Passau)            )



			dippircgb( r1, r2, VL1, VL2, PL, CONDS, OPL, pGS, pi, pf )

	"distributive polynomial over polynomials over integers
        reduced comprehensive Groebner basis"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        list dippircgb(r1, r2, VL1, VL2, PL, CONDS, OPL, pGS, pi, pf)
             single r1, r2; list VL1, VL2, PL, CONDS, OPL; list *pGS;
             single *pi; FILE *pf;
        CGBL = dippircgb(r1, r2, VL1, VL2, PL, CONDS, OPL, pGS, pi, pf);
        PL ist eine Liste von distributiven Polynomen in r1  (0<=r1<BASIS)
        Variablen  ueber  einem  Polynomring  ueber Z in r2  (0<=r2<BASIS)
        Variablen,  wobei die Liste VL1 die r1 Variablennamen der Polynome
        repraesentiert  und die Liste VL2 die r2 Variablennamen  des Poly-
        nomrings ueber Z repraesentiert  (VL2 ist also die Liste der Vari-
        ablennamen des Grundrings).
        CONDS ist  eine  Fallunterscheidung, d.h. entweder die leere Liste
        ("{}")  oder  eine  Liste,  die aus einer geraden Anzahl von Teil-
        listen besteht,  wobei die Teillisten mit ungerader Laufnummer die
        Koeffizientenpolynome enthalten, die  gleich  Null  sind, und  die
        mit  gerader  Laufnummer  die  Koeffizientenpolynome, die ungleich
        Null sind.
        Sei z.B. VL2 = a,b,c,d.
        Dann kann die Fallunterscheidung wie folgt aussehen:
             {{a^2-d# c+d#}{a#}{}{a^4-b*a^3+c*d}},
                            d.h. a^2-d==0, c+d==0, a!=0, a^4-b*a^3+c*d!=0;
             oder
             {{a^2-d# c+d#}{a#}}, d.h. a^2-d==0, c+d==0, a!=0;
             oder
             {{}{b^2-d^3+c# a# c#}}, d.h. b^2-d^3+c!=0, a!=0, c!=0;
             oder
             {{b# c# a^5-d^4+d^3+d#}{}},
                                        d.h. b==0, c==0, a^5-d^4+d^3+d==0.
        OPL ist eine Liste von Schaltern der Laenge 3,  wobei die Schalter
        nur die Werte 0 und 1 annehmen.
        Mit dem ersten Schalter wird die Faktorisierung der Koeffizienten-
        polynome ein (1) bzw. aus (0) geschaltet.
        Der zweite Schalter stellt den  Reduktionsalgorithmus  ein,  bzgl.
        dem die Polynome auf  Normalform  gebracht werden.  Es stehen zwei
        Reduktionsalgorithmen  zur  Verfuegung, einmal  die  Topreduktion,
        d.h. es werden nur die fuehrenden Monome  (bzgl. der Termordnung),
        deren Koeffizienten ungleich Null sind,  eliminiert.  Topreduktion
        wird mit (0) eingestellt. Der  andere  Reduktionsalgorithmus  ent-
        spricht der Reduktion bei der ueblichen Groebnerbasen-  bzw. Stan-
        dardbasenberechnung. Die allgemein uebliche Reduktion wird mit (1)
        eingestellt.
        (cf. V. Weispfenning, Comprehensive Groebner Bases, MIP 9003
             oder
             E. Schoenfeld, Diplomarbeit: Parametrische Groebnerbasen im
             Computer Algebra System ALDES/SAC2 1991 (Passau)            )
        Der  dritte  Schalter erlaubt die Ausgabe von  Zwischenergebnissen
        waehrend des Programmlaufs.  Wird die  Ausgabe  von Zwischenergeb-
        nissen  gewuenscht  (Schalter = 1),  muss  zuvor  eine  Datei  zum
        Schreiben geoeffnet werden, entweder durch
                CGBL = dippicgb(r1,r2,VL1,VL2,PL,CONDS,OPL,pGS,pi,stdout);
        was bewirkt, dass die Ausgabe auf dem Bildschirm erfolgt,
        oder durch
                pf   = fopen("ZWISCHENWERTE","w");
                CGBL = dippircgb(r1,r2,VL1,VL2,PL,CONDS,OPL,pGS,pi,pf);
             oder
                pf   = fopen("ZWISCHENWERTE","a");
                CGBL = dippircgb(r1,r2,VL1,VL2,PL,CONDS,OPL,pGS,pi,pf);
        was bewirkt, dass die  Zwischenergebnisse  in  die  Datei  mit dem
        Namen "ZWISCHENWERTE" geschrieben  werden.  Wird keine Ausgabe der
        Zwischenwerte gewuenscht, so hat der Schalter den Wert 0.
        Berechnet wird ein  reduziertes  Groebnersystem *pGS,  d.h. anhand
        der Fallunterscheidung, die waehrend des Programmlaufs weiter ver-
        feinert wird, wird fuer jedes Koeffizientenlistenpaar (siehe oben:
        CONDS) eine Groebnerbasis berechnet,  wodurch  eine  Art Baum ent-
        steht, der in jedem  Zweig  ein  Koeffizientenlistenpaar  und eine
        dazugehoerige Groebnerbasis  enthaelt.  War die Fallunterscheidung
        die leere Liste,  so wird waehrend  der  Rechnung  eine Fallunter-
        scheidung erstellt und verfeinert.
        *pi liefert die Anzahl der "Zweige" des Groebnersystems.
        *pf: siehe oben, Erlaeuterung zu OPL, Schalter 3.
        CGBL ist die Vereinigung der Groebnerbasen im  reduzierten  Groeb-
        nersystem, jedoch ohne die dazugehoerigen Koeffizientenlistenpaare.



			dippisp( r1, r2, P1, P2 )

        "distributive polynomial over polynomials over integers 
	 S-polynomial"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        pol dippisp(r1,r2,P1,P2)  single r1,r2; pol P1,P2;
        P3 = dippisp(r1,r2,P1,P2);
        P1 und P2 sind distributive Polynome in r1 (0 <= r1 < BASIS) 
	Variablen ueber einem Polynomring ueber Z in r2 (0 <= r2 < BASIS)
	Variablen.
        P3 ist das S-Polynom von P1 und P2.
        (zur Erlaeuterung:
         Sei f das fuehrende Monom von P1 und g das fuehrende Monom 
	 von P2. Dann ergibt sich das S-Polynom zu:
              P3 = kgV(f,g)/f*P1 - kgV(f,g)/g*P2 .
         siehe auch:
         "Ein algorithmisches Kriterium fuer die Loesbarkeit eines
         algebraischen Gleichungssystems" von B. Buchberger;
         Aequationes mathematicae, Vol.4, 1970)



			dippisum( r1, r2, P1, P2 )

        "distributive polynomial over polynomials over integers sum"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        pol dippisum(r1,r2,P1,P2)  single r1,r2; pol P1,P2;
        P3 = dippisum(r1,r2,P1,P2);
        P1 und P2 sind distributive Polynome in r1 (0 <= r1 < BASIS) 
	Variablen ueber einem Polynomring ueber Z in r2 (0 <= r2 < BASIS)
	Variablen.
        P3 = P1 + P2.



			diprdif( r, P1, P2 )

        "distributive polynomial over rationals difference"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol diprdif(r,P1,P2)  single r; pol P1,P2;
        P3 = diprdif(r,P1,P2);
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS)
	Variablen ueber Q.
        P3 = P1 - P2.



			diprfrdif( r1, r2, P1, P2 )

        "distributive polynomial over rational functions over the rationals
         difference"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        pol diprfrdif(r1,r2,P1,P2)  single r1,r2; pol P1,P2;
        P3 = diprfrdif(r1,r2,P1,P2);
        P1 und P2 sind distributive Polynome in r1 (0 <= r1 < BASIS) 
	Variablen ueber rationalen Funktionen in r2 (0 <= r2 < BASIS)
	Variablen ueber Q.
        P3 = P1 - P2.



			diprfrgb( r1, r2, PL )

        "distributive polynomial over rational functions over the rationals
         Groebner basis"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        list diprfrgb(r1,r2,PL)  single r1,r2; list PL;
        PP = diprfrgb(r1,r2,PL);
        PL ist eine Liste von distributiven Polynomen in r1 
	(0 <= r1 < BASIS) Variablen ueber rationalen Funktionen 
	in r2 (0 <= r2 < BASIS) Variablen ueber Q.
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (Verfahren cf. B. Buchberger)



			diprfrgba( r1, r2, PL, P )

        "distributive polynomial over rational functions over the rationals
         Groebner basis augmentation"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        list diprfrgba(r1,r2,PL,P)  single r1,r2; list PL; pol P;
        PP = diprfrgba(r1,r2,PL,P);
        Dabei muss gelten:
              - 0 <= r1 < BASIS.
              - 0 <= r2 < BASIS.
              - PL ist eine Liste von distributiven Polynomen in r1 
		Variablen ueber rationalen Funktionen in r2 Variablen 
		ueber Q.
              - P ist ein distributives Polynom in r1 Variablen ueber 
		rationalen Funktionen in r2 Variablen ueber Q.
        PP ist die minimale normierte und geordnete Groebner Basis von 
	(PL,P).
        (Verfahren cf. B. Buchberger)



			diprfrgbr( r1, r2, PL )

        "distributive polynomial over rational functions over the rationals
         Groebner basis recursion"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        list diprfrgbr(r1,r2,PL)  single r1,r2; list PL;
        PP = diprfrgbr(r1,r2,PL);
        PL ist eine Liste von distributiven Polynomen in r1 
	(0 <= r1 < BASIS) Variablen ueber rationalen Funktionen in r2
	(0 <= r2 < BASIS) Variablen ueber Q.
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (zur Erlaeuterung:
	 Sei PL = {P1,...,Pn} die Liste von Polynomen. 
	 Zunaechst wird fuer P1 die reduzierte (= minimale normierte und
	 geordnete) Groebner Basis berechnet. 
	 Zu dieser Basis wird P2 hinzugenommen und wieder die reduzierte 
	 Groebner Basis berechnet. usw.
	 Diese Vorgehensweise wird fuer alle n Polynome durchgefuehrt.)



			diprfrlotglo( r1, r2, P )

        "distributive polynomial over rational functions over the rationals
         in lexicographical order to distributive polynomial over rational 
	 functions over the rationals in graduated lexicographical order"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        pol diprfrlotglo(r1,r2,P)  single r1,r2; pol P;
        P1 = diprfrlotglo(r1,r2,P);
        P ist ein distributives Polynom in r1 (0 <= r1 < BASIS) Variablen 
	ueber rationalen Funktionen in r2 (0 <= r2 < BASIS) Variablen ueber
        Q.
        Das Polynom P hat lexikographische Termordnung und wird in das 
        Polynom P1 in graduiert lexikographischer Termordnung umgewandelt.



			diprfrlotlio( r1, r2, P )

        "distributive polynomial over rational functions over the rationals
         in lexicographical order to distributive polynomial over rational 
	 functions over the rationals in lexicographical order with inverse 
	 exponent vector"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        pol diprfrlotlio(r1,r2,P)  single r1,r2; pol P;
        P1 = diprfrlotlio(r1,r2,P);
        P ist ein distributives Polynom in r1 (0 <= r1 < BASIS) Variablen 
	ueber rationalen Funktionen in r2 (0 <= r2 < BASIS) Variablen ueber
        Q.
        Das Polynom P hat lexikographische Termordnung und wird in das
        Polynom P1 in lexikographischer Termordnung bzgl. umgekehrter
        Exponentenvektoren umgewandelt.



			diprfrlottdo( r1, r2, P )

        "distributive polynomial over rational functions over the rationals
         in lexicographical order to distributive polynomial over rational 
	 functions over the rationals with total degree ordering"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        pol diprfrlottdo(r1,r2,P)  single r1,r2; pol P;
        P1 = diprfrlottdo(r1,r2,P);
        P ist ein distributives Polynom in r1 (0 <= r1 < BASIS) Variablen 
	ueber rationalen Funktionen in r2 (0 <= r2 < BASIS) Variablen ueber 
	Q.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 mit Termordnung nach dem Totalgrad umgewandelt.



			diprfrmonic( r1, r2, P )

        "distributive polynomial over rational functions over the rationals
         monic"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        pol diprfrmonic(r1,r2,P)  single r1,r2; pol P;
        P1 = diprfrmonic(r1,r2,P);
        P ist ein distributives Polynom in r1 (0 <= r1 < BASIS) Variablen 
	ueber rationalen Funktionen in r2 (0 <= r2 < BASIS) Variablen ueber 
	Q.
        P1 ist das normierte Polynom P.



			diprfrneg( r1, r2, P )

        "distributive polynomial over rational functions over the rationals
         negation"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        pol diprfrneg(r1,r2,P)  single r1,r2; pol P;
        P1 = diprfrneg(r1,r2,P);
        P ist ein distributives Polynom in r1 (0 <= r1 < BASIS) Variablen 
	ueber rationalen Funktionen in r2 (0 <= r2 < BASIS) Variablen ueber 
	Q.
        P1 = -P.



			diprfrprod( r1, r2, P1, P2 )

        "distributive polynomial over rational functions over the rationals
         product"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        pol diprfrprod(r1,r2,P1,P2)  single r1,r2; pol P1,P2;
        P3 = diprfrprod(r1,r2,P1,P2);
        P1 und P2 sind distributive Polynome in r1 (0 <= r1 < BASIS) 
	Variablen ueber rationalen Funktionen in r2 (0 <= r2 < BASIS)
	Variablen ueber Q.
        P3 = P1 * P2.



			diprfrrfprod( r1, r2, P, A )

        "distributive polynomial over rational functions over the rationals
         rational function over the rationals product"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        pol diprfrrfprod(r1,r2,P,A)  single r1,r2; pol P; rfunc A;
        P1C = diprfrrfprod(r1,r2,P,A);
        Dabei muss gelten:
              - 0 <= r1 < BASIS.
              - 0 <= r2 < BASIS.
              - P ist ein distributives Polynom in r1 Variablen ueber 
                rationalen Funktionen in r2 Variablen ueber Q.
              - A ist eine rationale Funktion in r2 Variablen ueber Q.
        P1 = A*P.



			diprfrsp( r1, r2, P1, P2 )

        "distributive polynomial over rational functions over the rationals
         S-polynomial"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        pol diprfrsp(r1,r2,P1,P2)  single r1,r2; pol P1,P2;
        P3 = diprfrsp(r1,r2,P1,P2);
        P1 und P2 sind distributive Polynome in r1 (0 <= r1 < BASIS)
	Variablen ueber rationalen Funktionen in r2 (0 <= r2 < BASIS)
	Variablen ueber Q.
        P3 ist das S-Polynom von P1 und P2.
        (zur Erlaeuterung:
         Sei f das fuehrende Monom von P1 und g das fuehrende Monom 
	 von P2. Dann ergibt sich das S-Polynom zu:
              P3 = kgV(f,g)/f*P1 - kgV(f,g)/g*P2 .
         siehe auch:
         "Ein algorithmisches Kriterium fuer die Loesbarkeit eines
         algebraischen Gleichungssystems" von B. Buchberger;
         Aequationes mathematicae, Vol.4, 1970)



			diprfrsum( r1, r2, P1, P2 )

        "distributive polynomial over rational functions over the rationals
         sum"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        pol diprfrsum(r1,r2,P1,P2)  single r1,r2; pol P1,P2;
        P3 = diprfrsum(r1,r2,P1,P2);
        P1 und P2 sind distributive Polynome in r1 (0 <= r1 < BASIS) 
	Variablen ueber rationalen Funktionen in r2 (0 <= r2 < BASIS)
	Variablen ueber Q.
        P3 = P1 + P2.



			diprfrtorfr( r1, r2, P )

        "distributive polynomial over rational functions over the rationals
         to rational function over the rationals"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        rfunc diprfrtorfr(r1,r2,P)  single r1,r2; pol P;
        F = diprfrtorfr(r1,r2,P);
        Dabei muss gelten:
              - 0 <= r1 < BASIS.
              - 0 <= r2 < BASIS.
              - P ist ein distributives Polynom in r1 Variablen ueber
		rationalen Funktionen in r2 Variablen ueber Q.
        F ist die P entsprechende rationale Funktion in r = r1 + r2 
	Variablen ueber Q, wobei das Nennerpolynom von F nur die r2 
	Variablen des rationalen Funktionenkoerpers ueber Q enthaelt.



			diprgb( r, PL )

        "distributive polynomial over rationals Groebner basis"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list diprgb(r,PL)  single r; list PL;
        PP = diprgb(r,PL);
        PL ist eine Liste von distributiven Polynomen in r 
	(0 <= r < BASIS) Variablen ueber Q.
        PP ist die minimale normierte und geordnete Groebner Basis von PL.
        (Verfahren cf. B. Buchberger)



			diprgba( r, PL, P )

        "distributive polynomial over rationals Groebner basis
         augmentation"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list diprgba(r,PL,P)  single r; list PL; pol P;
        PP = diprgba(r,PL,P);
        Dabei muss gelten:
              - 0 <= r < BASIS.
              - PL ist eine Groebner Basis von Polynomen in r Variablen
                ueber Q in distributiver Darstellung.
              - P ist ein Polynom in r Variablen ueber Q in distributiver
                Darstellung.
        PP ist die minimale normierte und geordnete Groebner Basis von 
	(PL,P).
        (Verfahren cf. B. Buchberger)



			diprgbr( r, PL )

        "distributive polynomial over rationals Groebner basis recursion"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list diprgbr(r,PL)  single r; list PL;
        PP = diprgbr(r,PL);
        PL ist eine Liste von distributiven Polynomen in r (0 <= r < BASIS) 
	Variablen ueber Q.
        PP ist die minimale normierte und geordnete Groebner Basis von PL. 
        (zur Erlaeuterung:
	 Sei PL = {P1,...,Pn} die Liste von Polynomen. 
	 Zunaechst wird fuer P1 die reduzierte (= minimale normierte und
	 geordnete) Groebner Basis berechnet. 
	 Zu dieser Basis wird P2 hinzugenommen und wieder die reduzierte 
	 Groebner Basis berechnet. usw.
	 Diese Vorgehensweise wird fuer alle n Polynome durchgefuehrt.)



			diprlotoglo( r, P )

        "distributive polynomial over rationals in lexicographical order
         to distributive polynomial over rationals in graduated
         lexicographical order"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol diprlotoglo(r,P)  single r; pol P;
        P1 = diprlotoglo(r,P);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Q.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 in graduiert lexikographischer Termordnung umgewandelt.



			diprlotolio( r, P )

        "distributive polynomial over rationals in lexicographical order
         to distributive polynomial over rationals in lexicographical
         order with inverse exponent vector"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol diprlotolio(r,P)  single r; pol P;
        P1 = diprlotolio(r,P);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Q.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 in lexikographischer Termordnung bzgl. umgekehrter 
	Exponentenvektoren umgewandelt.



			diprlototdo( r, P )

        "distributive polynomial over rationals in lexicographical order
         to distributive polynomial over rationals with total degree
         ordering"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol diprlototdo(r,P)  single r; pol P;
        P1 = diprlototdo(r,P);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Q.
        Das Polynom P hat lexikographische Termordnung und wird in das
	Polynom P1 mit Termordnung nach dem Totalgrad umgewandelt.



			diprmonic( r, P )

        "distributive polynomial over rationals monic"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol diprmonic(r,P)  single r; pol P;
        P1 = diprmonic(r,P);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Q.
        P1 ist das normierte Polynom P.



			diprneg( r, P )

        "distributive polynomial over rationals negation"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol diprneg(r,P)  single r; pol P;
        P1 = diprneg(r,P);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Q.
        P1 = -P.



			diprprod( r, P1, P2 )

        "distributive polynomial over rationals product"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol diprprod(r,P1,P2)  single r; pol P1,P2;
        P3 = diprprod(r,P1,P2);
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS) 
	Variablen ueber Q.
        P3 = P1 * P2.



			diprrprod( r, P, A )

        "distributive polynomial over rationals, rational number
	 product"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol diprrprod(r,P,A)  single r; pol P; rat A;
        P1 = diprrprod(r,P,A);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Q.
        P1 = A*P.



			diprsp( r, P1, P2 )

        "distributive polynomial over rationals S-polynomial"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol diprsp(r,P1,P2)  single r; pol P1,P2;
        P3 = diprsp(r,P1,P2);
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS) 
	Variablen ueber Q.
        P3 ist das S-Polynom von P1 und P2.
        (zur Erlaeuterung:
         Sei f das fuehrende Monom von P1 und g das fuehrende Monom 
	 von P2. Dann ergibt sich das S-Polynom zu:
              P3 = kgV(f,g)/f*P1 - kgV(f,g)/g*P2 .
         siehe auch:
         "Ein algorithmisches Kriterium fuer die Loesbarkeit eines
         algebraischen Gleichungssystems" von B. Buchberger;
         Aequationes mathematicae, Vol.4, 1970)



			diprsum( r, P1, P2 )

        "distributive polynomial over rationals sum"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        pol diprsum(r,P1,P2)  single r; pol P1,P2;
        P3 = diprsum(r,P1,P2);
        P1 und P2 sind distributive Polynome in r (0 <= r < BASIS) 
	Variablen ueber Q.
        P3 = P1 + P2.



			diptdg( r, P )

        "distributive polynomial total degree"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single diptdg(r,P)  single r; pol P;
        max = diptdg(r,P);
	P ist ein distributives Polynom in r (0<=r<BASIS) Variablen 
	ueber einem beliebigen Ring.
        max ist der groesste Totalgrad von P.



			diptop( r, P )

	"distributive polynomial to polynomial" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol diptop(r,P)  single r; pol P;
	P1 = diptop(r,P);
	P ist ein Polynom in distributiver Darstellung in r
	(0<=r<BASIS) Variablen.
	P1 = P (rekursive Darstellung).



			dpdegvec( r, P )

	"dense polynomial degree vector" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list dpdegvec(r,P)  single r; pol P;
	L = dpdegvec(r,P);
	P ist ein Polynom in dense-Darstellung in r (1<=r<BASIS)
	Variablen X1,...,Xr, wobei Xr die Hauptvariable bezeichnet.
	L ist eine Liste (gr,...,g1), mit gn ist der Grad von P in Xn,
	falls P ungleich 0 ist, 0 sonst.



			dpmidif( r, m, P1, P2 )

	"dense polynomial over modular integers difference" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol dpmidif(r,m,P1,P2)  single r; int m; pol P1,P2;
	P3 = dpmidif(r,m,P1,P2);
	m ist eine positive ganze Zahl.
	P1 und P2 sind Polynome in dense-Darstellung in r (0<=r<BASIS)
	Variablen ueber Z/mZ.
	P3 = P1 - P2.



			dpmineg( r, m, P )

	"dense polynomial over modular integers negation" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol dpmineg(r,m,P)  single r; int m; pol P;
	P1 = dpmineg(r,m,P);
	m ist eine positive ganze Zahl.
	P ist ein Polynom in dense-Darstellung in r (0<=r<BASIS)
	Variablen ueber Z/mZ.
	P1 = -P.



			dpmiprod( r, M, P1, P2 )

	"dense polynomial over modular integers product" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol dpmiprod(r,M,P1,P2)  single r; int M; pol P1,P2;
	P3 = dpmiprod(r,M,P1,P2);
	M ist eine positive ganze Zahl.
	P1 und P2 sind Polynome in dense-Darstellung in r (0<=r<BASIS)
	Variablen ueber Z / M*Z.
	P3 = P1 * P2.



			dpmisum( r, M, P1, P2 )

	"dense polynomial over modular integers sum" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol dpmisum(r,M,P1,P2)  single r; int M; pol P1,P2;
	P3 = dpmisum(r,M,P1,P2);
	M ist ein positive ganze Zahl.
	P1 und P2 sind Polynome in dense-Darstellung in r (0<=r<BASIS)
	Variablen ueber Z / M*Z.
	P3 = P1 + P2.



			dpmsdif( r, m, P1, P2 )

	"dense polynomial over modular singles difference" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol dpmsdif(r,m,P1,P2) single r,m; pol P1,P2;
	P3 = dpmsdif(r,m,P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in r (0<=r<BASIS)
	Variablen ueber Z/mZ mit m aus [1,BASIS-1].
	P3 = P1 - P2;



			dpmsneg( r, m, P )

	"dense polynomial over modular singles negation" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol dpmsneg(r,m,P) single r,m; pol P;
	P1 = dpmsneg(r,m,P);
	P ist ein Polynom in dense-Darstellung in r (0<=r<BASIS)
	Variablen ueber Z/mZ mit m aus [1,BASIS-1].
	P1 = -P.



			dpmsprod( r, m, P1, P2 )

	"dense polynomial over modular singles product" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol dpmsprod(r,m,P1,P2) single r,m; pol P1,P2;
	P3 = dpmsprod(r,m,P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in r (0<=r<BASIS)
	Variablen ueber Z/mZ mit m aus [1,BASIS-1].
	P3 = P1 * P2.



			dpmssum( r, m, P1, P2 )

	"dense polynomial over modular singles sum" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol dpmssum(r,m,P1,P2) single r,m; pol P1,P2;
	P3 = dpmssum(r,m,P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in r (0<=r<BASIS)
	Variablen ueber Z/mZ mit m aus [1,BASIS-1].
	P3 = P1 + P2;



			dpred( r, P )

	"dense polynomial reductum"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol dpred(r,P)  single r; pol P;
	P1 = dpred(r,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen in dense-Darstellung.
	P1 ist das Polynomreduktum von P, d. h.
	P1 = P ohne die Terme hoechsten Grades in der Hauptvariablen,
	       falls P nicht das Nullpolynom ist,
	P1 = 0, falls P das Nullpolynom ist.



			dptop( r, P )

	"dense polynomial to polynomial" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol dptop(r,P) single r; pol P;
	P1 = dptop(r,P);
	P ist ein Polynom in dense-Darstellung in r (0<=r<BASIS)
	Variablen.
	P1 = P (rekursive Darstellung).



			fgetdipgfsl( r, p, AL, VL, Vgfs, pf )

	"file get distributive polynomial over Galois-field with single
         characteristic list"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list fgetdipgfsl(r,p,AL,VL,Vgfs,pf)  single r,p; list AL,VL,Vgfs;
             FILE *pf;
        PL = fgetdipgfsl(r,p,AL,VL,Vgfs,pf);
	r>=0, p Primzahl.
        AL  ist die zu einem endlichen Koerper GF(q) der Charakteristik p
        gehoerende Arithmetikliste.
        Ist r gleich 0, so muss VL die  leere  Liste  sein; sonst  ist  VL
        eine  Liste  der  Form  VL = (V1, ... , Vn), wobei die Elemente Vi
        von  VL  Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Analog ist  Vgfs  eine einelementige Variablenliste, die den Namen
	eines  primitiven  Elementes  der  Koerpererweiterung GF(q)/(Z/pZ)
	repraesentiert.
        pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
        fgetdipgfsl  liest  eine  Liste von Polynomen in r Variablen ueber
        GF(q) von der Datei *pf.
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm },
	d.h. die Liste muss mit '{' beginnen, mit '}' enden, und die  ein-
	zelnen Polynome muessen durch Kommata voneinander getrennt sein.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Das Polynomende muss mit '#' markiert sein.
	      2)  Es sind nur positive Exponenten zugelassen; diese werden
                  durch vorangestelltes '^' oder '**' gekennzeichnet.  Die
                  Angabe des Exponenten 1  kann  unterbleiben,  ebenso die
                  Angabe des Exponenten 0;  in  letzterem  Fall muss  dann
                  allerdings auch die Angabe der entsprechenden  Variablen
                  unterbleiben.
	      3)  Es sind  beliebig  grosse  Koeffizienten  zulaessig. Das
                  Vorzeichen des Koeffizienten kann durch Blanks vom Koef-
                  fizienten getrennt werden. Die  Angabe des Koeffizienten
                  1 kann unterbleiben. Koeffizient und zugehoerige Variab-
                  lenliste  koennen durch beliebig viele Blanks oder durch
		  '*' und beliebig viele Blanks getrennt werden.
		  Diese Trennung ist nicht notwendig.
	      4)  Variablennamen muessen in VL aufgefuehrt sein und duerfen
                  nicht durch Sonderzeichen (wie z.B. CR) getrennt werden.
                  Einzelne  Variablen  mit ihren Exponenten koennen  durch
                  beliebig viele Blanks  oder durch '*' und beliebig viele
                  Blanks getrennt werden. Diese Trennung ist nur dann not-
                  wendig, wenn kein Exponent angegeben wurde.
	      5)  Tritt in  einem  Monom  eine  Variable  mehrfach auf, so
                  werden die verschiedenen  Vorkommen geeignet zusammenge-
                  fasst.
		  Tritt ein Monom mehrfach auf, so  werden  die  verschie-
                  denen Vorkommen geeignet zusammengefasst.
              6)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp)
        fgetdipgfsl  ist  insbesondere  in  der  Lage, von fputdipgfsl ge-
        schriebene Polynomlisten zu lesen.
	fgetdipgfsl liefert als Ergebniswert
		eine Liste von distributiven Polynomen ueber GF(q),
			falls der Programmablauf fehlerfrei war;
		ERROR,  falls Fehler auftraten.



			fgetdipil( r, VL, pf )

	"file get distributive polynomial over integers list"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list fgetdipil(r,VL,pf)  single r; list VL; FILE *pf;
        PL = fgetdipil(r,VL,pf);
        r ist eine ganze Zahl mit  0<=r<BASIS.  Ist r gleich 0, so muss VL
        die  leere  Liste  sein;  sonst  ist   VL   eine  Liste  der  Form
        VL = (V1, ... , Vn), wobei die Elemente Vi von  VL  Variablennamen
        repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
        fgetdipil liest eine  Liste von Polynomen in r Variablen ueber den
        ganzen Zahlen von der Datei *pf.
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm },
	d.h. die Liste muss mit '{' beginnen, mit '}' enden, und die  ein-
	zelnen Polynome muessen durch Kommata voneinander getrennt sein.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Das Polynomende muss mit '#' markiert sein.
	      2)  Es sind nur positive Exponenten zugelassen; diese werden
                  durch vorangestelltes '^' oder '**' gekennzeichnet.  Die
                  Angabe des Exponenten 1  kann  unterbleiben,  ebenso die
                  Angabe des Exponenten 0;  in  letzterem  Fall muss  dann
                  allerdings auch die Angabe der entsprechenden  Variablen
                  unterbleiben.
	      3)  Es sind  beliebig  grosse  Koeffizienten  zulaessig. Das
                  Vorzeichen des Koeffizienten kann durch Blanks vom Koef-
                  fizienten getrennt werden. Die  Angabe des Koeffizienten
                  1 kann unterbleiben. Koeffizient und zugehoerige Variab-
                  lenliste  koennen durch beliebig viele Blanks oder durch
		  '*' und beliebig viele Blanks getrennt werden.
		  Diese Trennung ist nicht notwendig.
	      4)  Variablennamen muessen in VL aufgefuehrt sein und duerfen
                  nicht durch Sonderzeichen (wie z.B. CR) getrennt werden.
                  Einzelne  Variablen  mit ihren Exponenten koennen  durch
                  beliebig viele Blanks  oder durch '*' und beliebig viele
                  Blanks getrennt werden. Diese Trennung ist nur dann not-
                  wendig, wenn kein Exponent angegeben wurde.
	      5)  Tritt in  einem  Monom  eine  Variable  mehrfach auf, so
                  werden die verschiedenen  Vorkommen geeignet zusammenge-
                  fasst.
		  Tritt ein Monom mehrfach auf, so  werden  die  verschie-
                  denen Vorkommen geeignet zusammengefasst.
              6)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp)
	fgetdipil ist insbesondere in der Lage, von fputdipil geschriebene 
	Polynomlisten zu lesen.
	fgetdipil liefert als Ergebniswert
		eine Liste von distributiven Polynomen ueber Z,
			falls der Programmablauf fehlerfrei war;
		ERROR,  falls Fehler auftraten.



			fgetdipmipl( r, p, VL, pf )

	"file get distributive polynomial over modular integer primes 
	 list"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list fgetdipmipl(r,p,VL,pf)  single r; int p; list VL; FILE *pf;
        PL = fgetdipmipl(r,p,VL,pf);
        r ist eine ganze Zahl mit  0<=r<BASIS.  Ist r gleich 0, so muss VL
        die  leere  Liste  sein;  sonst  ist   VL   eine  Liste  der  Form
        VL = (V1, ... , Vn), wobei die Elemente Vi von  VL  Variablennamen
        repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
        fgetdipmipl  liest  eine  Liste von Polynomen in r Variablen ueber
        Z/pZ (p Primzahl) von der Datei *pf.
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm },
	d.h. die Liste muss mit '{' beginnen, mit '}' enden, und die  ein-
	zelnen Polynome muessen durch Kommata voneinander getrennt sein.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Das Polynomende muss mit '#' markiert sein.
	      2)  Es sind nur positive Exponenten zugelassen; diese werden
                  durch vorangestelltes '^' oder '**' gekennzeichnet.  Die
                  Angabe des Exponenten 1  kann  unterbleiben,  ebenso die
                  Angabe des Exponenten 0;  in  letzterem  Fall muss  dann
                  allerdings auch die Angabe der entsprechenden  Variablen
                  unterbleiben.
	      3)  Es sind  beliebig  grosse  Koeffizienten  zulaessig. Das
                  Vorzeichen des Koeffizienten kann durch Blanks vom Koef-
                  fizienten getrennt werden. Die  Angabe des Koeffizienten
                  1 kann unterbleiben. Koeffizient und zugehoerige Variab-
                  lenliste  koennen durch beliebig viele Blanks oder durch
		  '*' und beliebig viele Blanks getrennt werden.
		  Diese Trennung ist nicht notwendig.
	      4)  Variablennamen muessen in VL aufgefuehrt sein und duerfen
                  nicht durch Sonderzeichen (wie z.B. CR) getrennt werden.
                  Einzelne  Variablen  mit ihren Exponenten koennen  durch
                  beliebig viele Blanks  oder durch '*' und beliebig viele
                  Blanks getrennt werden. Diese Trennung ist nur dann not-
                  wendig, wenn kein Exponent angegeben wurde.
	      5)  Tritt in  einem  Monom  eine  Variable  mehrfach auf, so
                  werden die verschiedenen  Vorkommen geeignet zusammenge-
                  fasst.
		  Tritt ein Monom mehrfach auf, so  werden  die  verschie-
                  denen Vorkommen geeignet zusammengefasst.
              6)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp)
        fgetdipmipl  ist  insbesondere  in  der  Lage, von fputdipmipl ge-
        schriebene Polynomlisten zu lesen.
	fgetdipmipil liefert als Ergebniswert
		eine Liste von distributiven Polynomen ueber Z/pZ,
			falls der Programmablauf fehlerfrei war;
		ERROR,  falls Fehler auftraten.



			fgetdipmspl( r, p, VL, pf )

	"file get distributive polynomial over modular single primes list"     
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list fgetdipmspl(r,p,VL,pf)  single r,p; list VL; FILE *pf;
        PL = fgetdipmspl(r,p,VL,pf);
        r ist eine ganze Zahl mit  0<=r<BASIS.  Ist r gleich 0, so muss VL
        die  leere  Liste  sein;  sonst  ist   VL   eine  Liste  der  Form
        VL = (V1, ... , Vn), wobei die Elemente Vi von  VL  Variablennamen
        repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
        fgetdipmspl  liest  eine  Liste von Polynomen in r Variablen ueber
        Z/pZ (p Primzahl) von der Datei *pf.
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm },
	d.h. die Liste muss mit '{' beginnen, mit '}' enden, und die  ein-
	zelnen Polynome muessen durch Kommata voneinander getrennt sein.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Das Polynomende muss mit '#' markiert sein.
	      2)  Es sind nur positive Exponenten zugelassen; diese werden
                  durch vorangestelltes '^' oder '**' gekennzeichnet.  Die
                  Angabe des Exponenten 1  kann  unterbleiben,  ebenso die
                  Angabe des Exponenten 0;  in  letzterem  Fall muss  dann
                  allerdings auch die Angabe der entsprechenden  Variablen
                  unterbleiben.
	      3)  Es sind  beliebig  grosse  Koeffizienten  zulaessig. Das
                  Vorzeichen des Koeffizienten kann durch Blanks vom Koef-
                  fizienten getrennt werden. Die  Angabe des Koeffizienten
                  1 kann unterbleiben. Koeffizient und zugehoerige Variab-
                  lenliste  koennen durch beliebig viele Blanks oder durch
		  '*' und beliebig viele Blanks getrennt werden.
		  Diese Trennung ist nicht notwendig.
	      4)  Variablennamen muessen in VL aufgefuehrt sein und duerfen
                  nicht durch Sonderzeichen (wie z.B. CR) getrennt werden.
                  Einzelne  Variablen  mit ihren Exponenten koennen  durch
                  beliebig viele Blanks  oder durch '*' und beliebig viele
                  Blanks getrennt werden. Diese Trennung ist nur dann not-
                  wendig, wenn kein Exponent angegeben wurde.
	      5)  Tritt in  einem  Monom  eine  Variable  mehrfach auf, so
                  werden die verschiedenen  Vorkommen geeignet zusammenge-
                  fasst.
		  Tritt ein Monom mehrfach auf, so  werden  die  verschie-
                  denen Vorkommen geeignet zusammengefasst.
              6)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp)
        fgetdipmspl  ist  insbesondere  in  der  Lage, von fputdipmspl ge-
        schriebene Polynomlisten zu lesen.
	fgetdipmspil liefert als Ergebniswert
		eine Liste von distributiven Polynomen ueber Z/pZ,
			falls der Programmablauf fehlerfrei war;
		ERROR,  falls Fehler auftraten.



			fgetdipnfl( r, F, VL, Vnf, pf )

	"file get distributive polynomial over number field list"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list fgetdipnfl(r,F,VL,Vnf,pf)  single r; pol F; list VL,Vnf;
             FILE *pf;
        PL = fgetdipnfl(r,F,VL,Vnf,pf);
	r ist eine ganze Zahl mit 0<=r<BASIS.  F ist das  zu  einem  Zahl-
        koerper k gehoerende irreduzible Polynom vom Grad n in einer Vari-
        ablen in dense-Darstellung, das k erzeugt, d.h.  k  entsteht durch
        Adjunktion einer Nullstelle von F.
        Ist r gleich 0, so muss VL die  leere  Liste  sein; sonst  ist  VL
        eine  Liste  der  Form  VL = (V1, ... , Vn), wobei die Elemente Vi
        von  VL  Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Analog ist Vnf eine  einelementige  Variablenliste,  die den Namen
        einer Nullstelle von F repraesentiert.
        pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
        fgetdipnfl  liest  eine  Liste  von Polynomen in r Variablen ueber
        dem Zahlkoerper k von der Datei *pf.
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm },
	d.h. die Liste muss mit '{' beginnen, mit '}' enden, und die  ein-
	zelnen Polynome muessen durch Kommata voneinander getrennt sein.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Das Polynomende muss mit '#' markiert sein.
	      2)  Es sind nur positive Exponenten zugelassen; diese werden
                  durch vorangestelltes '^' oder '**' gekennzeichnet.  Die
                  Angabe des Exponenten 1  kann  unterbleiben,  ebenso die
                  Angabe des Exponenten 0;  in  letzterem  Fall muss  dann
                  allerdings auch die Angabe der entsprechenden  Variablen
                  unterbleiben.
	      3)  Es sind  beliebig  grosse  Koeffizienten  zulaessig. Das
                  Vorzeichen des Koeffizienten kann durch Blanks vom Koef-
                  fizienten getrennt werden. Die  Angabe des Koeffizienten
                  1 kann unterbleiben. Koeffizient und zugehoerige Variab-
                  lenliste  koennen durch beliebig viele Blanks oder durch
		  '*' und beliebig viele Blanks getrennt werden.
		  Diese Trennung ist nicht notwendig.
	      4)  Variablennamen muessen in VL aufgefuehrt sein und duerfen
                  nicht durch Sonderzeichen (wie z.B. CR) getrennt werden.
                  Einzelne  Variablen  mit ihren Exponenten koennen  durch
                  beliebig viele Blanks  oder durch '*' und beliebig viele
                  Blanks getrennt werden. Diese Trennung ist nur dann not-
                  wendig, wenn kein Exponent angegeben wurde.
	      5)  Tritt in  einem  Monom  eine  Variable  mehrfach auf, so
                  werden die verschiedenen  Vorkommen geeignet zusammenge-
                  fasst.
		  Tritt ein Monom mehrfach auf, so  werden  die  verschie-
                  denen Vorkommen geeignet zusammengefasst.
              6)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp)
        fgetdipnfl  ist  insbesondere  in  der  Lage,  von  fputdipnfl ge-
        schriebene Polynomlisten zu lesen.
	fgetdipnfl liefert als Ergebniswert
		eine Liste von distributiven Polynomen ueber dem Zahlkoer-
		per k,  falls der Programmablauf fehlerfrei war;
		ERROR,  falls Fehler auftraten.



			fgetdippicd( r1, r2, VL1, VL2, fac, pf )

	"file get distributive polynomial over polynomials over integers
         case distinction"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list fgetdippicd(r1, r2, VL1, VL2, fac, pf)  single r1, r2;
        	list VL1, VL2; single fac; FILE *pf;
	CONS = fgetdippicd(r1, r2, VL1, VL2, fac, pf);
        r1 und r2 sind ganze Zahlen mit 0<= r1,r2 <BASIS.  Ist  r1 bzw. r2
        gleich 0, so muss VL1 bzw. VL2 die  leere  Liste sein;  sonst sind
        VL1 und VL2 Listen der Form VLi = (V1i, ... , Vri), wobei die Ele-
        mente Vji von VLi Variablennamen repraesentieren,  und zwar in der
        Form:
          Vji = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
        fgetdippicd liest eine Fallunterscheidung, d.h. entweder die leere
        Liste ("{}")  oder  eine  Liste,  die aus einer geraden Anzahl von
        Teillisten besteht,  wobei die Teillisten mit ungerader Laufnummer
        die Koeffizientenpolynome  enthalten, die  gleich  Null  sind, und
        die  mit  gerader  Laufnummer  die  Koeffizientenpolynome, die un-
        gleich Null sind, von der Datei *pf.
        Die Koeffizientenpolynome sind Polynome in r2 Variablen ueber den
        ganzen Zahlen, deren korrekter Aufbau in "fgetpi" beschrieben ist.
        Mit  dem Schalter  fac  wird die Faktorisierung der Koeffizienten-
        polynome ein (fac = 1) bzw. aus (fac = 0) geschaltet.
        Eingabebeispiel:
        Sei  VL2 = a,b,c,d .
        Dann kann die Fallunterscheidung wie folgt aussehen:
             {{a^2-d# c+d#}{a#}{}{a^4-b*a^3+c*d}},
                            d.h. a^2-d==0, c+d==0, a!=0, a^4-b*a^3+c*d!=0;
             oder
             {{a^2-d# c+d#}{a#}}, d.h. a^2-d==0, c+d==0, a!=0;
             oder
             {{}{b^2-d^3+c# a# c#}}, d.h. b^2-d^3+c!=0, a!=0, c!=0;
             oder
             {{b# c# a^5-d^4+d^3+d#}{}},
                                        d.h. b==0, c==0, a^5-d^4+d^3+d==0.
	Im Fehlerfall ist CONS = ERROR.



			fgetdippil( r1, r2, VL1, VL2, pf )

	"file get distributive polynomial over polynomials over 
	integers list"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list fgetdippil(r1, r2, VL1, VL2, pf)  single r1, r2; 
		list VL1, VL2; FILE *pf;
        PL = fgetdippil(r1, r2, VL1, VL2, pf);
        r1 und r2 sind ganze Zahlen mit 0<= r1, r2 <=BASIS. Ist r1 bzw. r2
        gleich 0, so muss VL1 bzw. VL2 die  leere  Liste sein;  sonst sind
        VL1 und VL2 Listen der Form VLi = (V1i, ... , Vri), wobei die Ele-
        mente Vji von VLi Variablennamen repraesentieren,  und zwar in der
        Form:
          Vji = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
        fgetdippil liest eine  Liste  von  Polynomen in r1 Variablen ueber
        dem Polynomring,  der entsteht,  wenn man die Variablen aus VL2 zu
        den ganzen Zahlen adjungiert, von der Datei *pf.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Das Polynomende muss mit '#' markiert sein.
	      2)  Es sind nur positive Exponenten zugelassen; diese werden
                  durch vorangestelltes '^' oder '**' gekennzeichnet.  Die
                  Angabe des Exponenten 1  kann  unterbleiben,  ebenso die
                  Angabe des Exponenten 0;  in  letzterem  Fall muss  dann
                  allerdings auch die Angabe der entsprechenden  Variablen
                  unterbleiben.
	      3)  Es sind  beliebig  grosse  Koeffizienten  zulaessig. Das
                  Vorzeichen des Koeffizienten kann durch Blanks vom Koef-
                  fizienten getrennt werden. Die  Angabe des Koeffizienten
                  1 kann unterbleiben. Koeffizient und zugehoerige Variab-
                  lenliste  koennen durch beliebig viele Blanks oder durch
		  '*' und beliebig viele Blanks getrennt werden.
		  Diese Trennung ist nicht notwendig.
	      4)  Variablennamen muessen in V aufgefuehrt sein und duerfen
                  nicht durch Sonderzeichen (wie z.B. CR) getrennt werden.
                  Einzelne  Variablen  mit ihren Exponenten koennen  durch
                  beliebig viele Blanks  oder durch '*' und beliebig viele
                  Blanks getrennt werden. Diese Trennung ist nur dann not-
                  wendig, wenn kein Exponent angegeben wurde.
	      5)  Tritt in  einem  Monom  eine  Variable  mehrfach auf, so
                  werden die verschiedenen  Vorkommen geeignet zusammenge-
                  fasst.
		  Tritt ein Monom mehrfach auf, so  werden  die  verschie-
                  denen Vorkommen geeignet zusammengefasst.
              6)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp.S)
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm }, Liste von m Polynomen in distributiver Dar-
        stellung.  fgetdippil ist insbesondere in der Lage, von fputdippil
        geschriebene Polynomlisten zu lesen.
	fgetdippil liefert den Ergebniswert
		PL     falls der Programmablauf fehlerfrei war;
		ERROR  falls Fehler auftraten.



			fgetdiprfrl( r1, r2, VL1, VL2, pf )

	"file get distributive polynomial over rational functions over 
	 the rationals list"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	list fgetdiprfrl(r1,r2,VL1,VL2,pf)  single r1,r2; list VL1,VL2;
             FILE *pf;
        PL = fgetdiprfrl(r1,r2,VL1,VL2,pf);
        r1 und r2 sind ganze Zahlen mit 0<= r1, r2 <BASIS.  Ist r1 bzw. r2
        gleich 0, so muss VL1 bzw. VL2 die  leere  Liste sein;  sonst sind
        VL1 und VL2 Listen der Form VLi = (V1i, ... , Vri), wobei die Ele-
        mente Vji von VLi Variablennamen repraesentieren,  und zwar in der
        Form:
          Vji = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
        fgetdiprfrl liest eine Liste  von  Polynomen in r1 Variablen ueber
        dem Funktionenkoerper,  der entsteht,  wenn  man die Variablen aus
        VL2 zu den rationalen Zahlen adjungiert, von der Datei *pf.
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm },
	d.h. die Liste muss mit '{' beginnen, mit '}' enden, und die  ein-
	zelnen Polynome muessen durch Kommata voneinander getrennt sein.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Die Polynome werden wie rationale Funktionen eingelesen,
                  wobei zu beachten ist, dass das Nennerpolynom der Haupt-
                  nenner der Nenner der Koeffizientenfunktionen ist.
              2)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp)
        fgetdiprfrl  ist  insbesondere  in  der  Lage, von fputdiprfrl ge-
        schriebene Polynomlisten zu lesen.
	fgetdiprfrl liefert als Ergebniswert
		eine Liste von distributiven Polynomen  ueber  rationalen
		Funktionen,       falls der Programmablauf fehlerfrei war;
		ERROR,            falls Fehler auftraten.



			fgetdiprl( r, VL, pf )

	"file get distributive polynomial over rationals list"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list fgetdiprl(r,VL,pf)  single r; list VL; FILE *pf;
        PL = fgetdiprl(r,VL,pf);
        r ist eine ganze Zahl  mit  0<=r<ASIS.  Ist r gleich 0, so muss VL
        die  leere  Liste  sein;  sonst  ist   VL   eine  Liste  der  Form
        VL = (V1, ... , Vn), wobei die Elemente Vi von  VL  Variablennamen
        repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
        fgetdiprl liest eine  Liste von Polynomen in r Variablen ueber den
        rationalen Zahlen von der Datei *pf.
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm },
	d.h. die Liste muss mit '{' beginnen, mit '}' enden, und die  ein-
	zelnen Polynome muessen durch Kommata voneinander getrennt sein.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Das Polynomende muss mit '#' markiert sein.
	      2)  Es sind nur positive Exponenten zugelassen; diese werden
                  durch vorangestelltes '^' oder '**' gekennzeichnet.  Die
                  Angabe des Exponenten 1  kann  unterbleiben,  ebenso die
                  Angabe des Exponenten 0;  in  letzterem  Fall muss  dann
                  allerdings auch die Angabe der entsprechenden  Variablen
                  unterbleiben.
	      3)  Es sind  beliebig  grosse  Koeffizienten  zulaessig. Das
                  Vorzeichen des Koeffizienten kann durch Blanks vom Koef-
                  fizienten getrennt werden. Die  Angabe des Koeffizienten
                  1 kann unterbleiben. Koeffizient und zugehoerige Variab-
                  lenliste  koennen durch beliebig viele Blanks oder durch
		  '*' und beliebig viele Blanks getrennt werden.
		  Diese Trennung ist nicht notwendig.
	      4)  Variablennamen muessen in VL aufgefuehrt sein und duerfen
                  nicht durch Sonderzeichen (wie z.B. CR) getrennt werden.
                  Einzelne  Variablen  mit ihren Exponenten koennen  durch
                  beliebig viele Blanks  oder durch '*' und beliebig viele
                  Blanks getrennt werden. Diese Trennung ist nur dann not-
                  wendig, wenn kein Exponent angegeben wurde.
	      5)  Tritt in  einem  Monom  eine  Variable  mehrfach auf, so
                  werden die verschiedenen  Vorkommen geeignet zusammenge-
                  fasst.
		  Tritt ein Monom mehrfach auf, so  werden  die  verschie-
                  denen Vorkommen geeignet zusammengefasst.
              6)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp)
        fgetdiprl ist insbesondere in der Lage, von fputdiprl geschriebene 
	Polynomlisten zu lesen.
	fgetdiprl liefert als Ergebniswert
		eine Liste von distributiven Polynomen ueber Q,
			falls der Programmablauf fehlerfrei war;
		ERROR,  falls Fehler auftraten.



			fgetpgf2( r, G, V, Vgf2, pf )

	"file get polynomial over Galois-field with characteristic 2"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol fgetpgf2(r, G, V, Vgf2, pf)  single r; obj G; list V, Vgf2;
					 FILE *pf;
	P = fgetpgf2(r, G, V, Vgf2, pf);
	r ist eine ganze Zahl mit 0 <= r < BASIS.
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	Vgf2 ist eine einelementige Variablenliste, die den Namen
	eines primitiven Elementes der Koerpererweiterung 
	GF(2^n)/(Z/2Z) repraesentiert.
	pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
	fgetpgf2 liest ein Polynom in r Variablen V1,...,Vr ueber
	GF(2^n) von der Datei *pf. Die Koeffizienten des Polynoms sind
	in spezieller Bit-Darstellung dargestellt.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
		1)  Das Polynomende muss mit '#' markiert sein.
		2)  Es sind nur positive Exponenten zugelassen; diese
		    werden durch vorangestelltes '^' oder '**'
		    gekennzeichnet. Die Angabe des Exponenten 1
		    kann unterbleiben, ebenso die Angabe des
		    Exponenten 0; in letzterem Fall muss dann allerdings
		    auch die Angabe der entsprechenden Variablen unter-
		    bleiben.
		3)  Es sind beliebig grosse Koeffizienten zulaessig.
		    Das Vorzeichen des Koeffizienten kann durch Blanks
		    vom Koeffizienten getrennt werden. Die Angabe
		    des Koeffizienten 1 kann unterbleiben.
		    Koeffizient und zugehoerige Variablenliste
		    koennen durch beliebig viele Blanks oder durch
		    '*' und beliebig viele Blanks getrennt werden.
		    Diese Trennung ist nicht notwendig.
		4)  Variablennamen muessen in V aufgefuehrt sein
		    und duerfen nicht durch Sonderzeichen (wie z.B. CR)
		    getrennt werden. Einzelne Variablen mit ihren
		    Exponenten koennen durch beliebig viele Blanks
		    oder durch '*' und beliebig viele Blanks getrennt
		    werden. Diese Trennung ist nur dann notwendig,
		    wenn kein Exponent angegeben wurde.
		5)  Tritt in einem Monom eine Variable mehrfach auf, so
		    werden die verschiedenen Vorkommen geeignet
		    zusammengefasst.
		    Tritt ein Monom mehrfach auf, so werden die
		    verschiedenen Vorkommen geeignet zusammengefasst.
	fgetpgf2 ist insbesondere in der Lage, von fputpgf2 geschriebene
	Polynome zu lesen.
	fgetpgf2 liefert den Ergebniswert
		P          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			fgetpgfs( r, p, AL, V, Vgfs, pf )

	"file get polynomial over Galois-field with single characteristic"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol fgetpgfs(r,p,AL,V,Vgfs,pf)  single r,p; list AL;
				        list V,Vgfs; FILE *pf;
	P = fgetpgfs(r,p,AL,V,Vgfs,pf);
	r und p sind ganze Zahlen mit 0<=r<BASIS, 0<p<BASIS und p
	Primzahl. AL ist die zu einem endlichen Koerper GF(q) der
	Charakteristik p gehoerende Arithmetikliste.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	Analog ist Vgfs eine einelementige Variablenliste, die den Namen
	eines primitiven Elementes der Koerpererweiterung GF(q)/(Z/pZ)
	repraesentiert.
	pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
	fgetpgfs liest ein Polynom in r Variablen V1,...,Vr ueber GF(q)
	von der Datei *pf.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
		1)  Das Polynomende muss mit '#' markiert sein.
		2)  Es sind nur positive Exponenten zugelassen; diese
		    werden durch vorangestelltes '^' oder '**'
		    gekennzeichnet. Die Angabe des Exponenten 1
		    kann unterbleiben, ebenso die Angabe des
		    Exponenten 0; in letzterem Fall muss dann allerdings
		    auch die Angabe der entsprechenden Variablen unter-
		    bleiben.
		3)  Es sind beliebig grosse Koeffizienten zulaessig.
		    Das Vorzeichen des Koeffizienten kann durch Blanks
		    vom Koeffizienten getrennt werden. Die Angabe
		    des Koeffizienten 1 kann unterbleiben.
		    Koeffizient und zugehoerige Variablenliste
		    koennen durch beliebig viele Blanks oder durch
		    '*' und beliebig viele Blanks getrennt werden.
		    Diese Trennung ist nicht notwendig.
		4)  Variablennamen muessen in V aufgefuehrt sein
		    und duerfen nicht durch Sonderzeichen (wie z.B. CR)
		    getrennt werden. Einzelne Variablen mit ihren
		    Exponenten koennen durch beliebig viele Blanks
		    oder durch '*' und beliebig viele Blanks getrennt
		    werden. Diese Trennung ist nur dann notwendig,
		    wenn kein Exponent angegeben wurde.
		5)  Tritt in einem Monom eine Variable mehrfach auf, so
		    werden die verschiedenen Vorkommen geeignet
		    zusammengefasst.
		    Tritt ein Monom mehrfach auf, so werden die
		    verschiedenen Vorkommen geeignet zusammengefasst.
	fgetpgfs ist insbesondere in der Lage, von fputpgfs geschriebene
	Polynome zu lesen.
	fgetpgfs liefert den Ergebniswert
		P          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			fgetpi( r, V, pf )

	"file get polynomial over integers"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol fgetpi(r,V,pf)  single r; list V; FILE *pf;
	P = fgetpi(r,V,pf);
	r ist eine ganze Zahl mit 0<=r<BASIS.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	Variablennamen repraesentieren, und zwar in der Form
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
	fgetpi liest ein Polynom in r Variablen V1,...,Vr ueber
	den ganzen Zahlen von der Datei *pf.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
		1)  Das Polynomende muss mit '#' markiert sein.
		2)  Es sind nur positive Exponenten zugelassen; diese
		    werden durch vorangestelltes '^' oder '**'
		    gekennzeichnet. Die Angabe des Exponenten 1
		    kann unterbleiben, ebenso die Angabe des
		    Exponenten 0; in letzterem Fall muss dann allerdings
		    auch die Angabe der entsprechenden Variablen unter-
		    bleiben.
		3)  Es sind beliebig grosse Koeffizienten zulaessig.
		    Das Vorzeichen des Koeffizienten kann durch Blanks
		    vom Koeffizienten getrennt werden. Die Angabe
		    des Koeffizienten 1 kann unterbleiben.
		    Koeffizient und zugehoerige Variablenliste
		    koennen durch beliebig viele Blanks oder durch
		    '*' und beliebig viele Blanks getrennt werden.
		    Diese Trennung ist nicht notwendig.
		4)  Variablennamen muessen in V aufgefuehrt sein
		    und duerfen nicht durch Sonderzeichen (wie z.B. CR)
		    getrennt werden. Einzelne Variablen mit ihren
		    Exponenten koennen durch beliebig viele Blanks
		    oder durch '*' und beliebig viele Blanks getrennt
		    werden. Diese Trennung ist nur dann notwendig,
		    wenn kein Exponent angegeben wurde.
		5)  Tritt in einem Monom eine Variable mehrfach auf, so
		    werden die verschiedenen Vorkommen geeignet
		    zusammengefasst.
		    Tritt ein Monom mehrfach auf, so werden die
		    verschiedenen Vorkommen geeignet zusammengefasst.
	fgetpi ist insbesondere in der Lage, von fputpi geschriebene
	Polynome zu lesen.
	fgetpi liefert den Ergebniswert
		P          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			fgetpmi( r, M, V, pf )

	"file get polynomial over modular integers"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol fgetpmi(r,M,V,pf)  single r; int M; list V; FILE *pf;
	P = fgetpmi(r,M,V,pf);
	r ist eine ganze Zahl mit 0<=r<BASIS.
	M ist eine positive ganze Zahl.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	Variablennamen repraesentieren, und zwar in der Form
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
	fgetpmi liest ein Polynom in r Variablen V1,...,Vr ueber
	Z / M*Z von der Datei *pf.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
		1)  Das Polynomende muss mit '#' markiert sein.
		2)  Es sind nur positive Exponenten zugelassen; diese
		    werden durch vorangestelltes '^' oder '**'
		    gekennzeichnet. Die Angabe des Exponenten 1
		    kann unterbleiben. Ebenso kann die Angabe des
		    Exponenten 0 unterbleiben, falls die Angabe
		    der zugehoerigen Variablen ebenfalls unterbleibt.
		3)  Es sind beliebig grosse Koeffizienten zulaessig.
		    Das Vorzeichen des Koeffizienten kann durch Blanks
		    vom Koeffizienten getrennt werden. Die Angabe
		    des Koeffizienten 1 kann unterbleiben.
		    Koeffizient und zugehoerige Variablenliste
		    koennen durch beliebig viele Blanks oder durch
		    '*' und beliebig viele Blanks getrennt werden.
		    Diese Trennung ist nicht notwendig.
		4)  Variablennamen muessen in V aufgefuehrt sein
		    und duerfen nicht durch Sonderzeichen (wie z.B. CR)
		    getrennt werden. Einzelne Variablen mit ihren
		    Exponenten koennen durch beliebig viele Blanks
		    oder durch '*' und beliebig viele Blanks getrennt
		    werden. Diese Trennung ist nur dann notwendig,
		    wenn kein Exponent angegeben wurde.
		5)  Tritt in einem Monom eine Variable mehrfach auf, so
		    werden die verschiedenen Vorkommen geeignet
		    zusammengefasst.
		    Tritt ein Monom mehrfach auf, so werden die
		    verschiedenen Vorkommen geeignet zusammengefasst.
	fgetpmi ist insbesondere in der Lage, von fputpmi geschriebene
	Polynome zu lesen.
	fgetpmi liefert den Ergebniswert
		P          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			fgetpms( r, m, V, pf )

	"file get polynomial over modular singles"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol fgetpms(r,m,V,pf)  single r,m; list V; FILE *pf;
	P = fgetpms(r,m,V,pf);
	r und m sind ganze Zahlen mit 0<=r<BASIS und 0<m<BASIS.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	Variablennamen repraesentieren, und zwar in der Form
		Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
	fgetpms liest ein Polynom in r Variablen V1,...,Vr ueber
	Z/mZ von der Datei *pf.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
		1)  Das Polynomende muss mit '#' markiert sein.
		2)  Es sind nur positive Exponenten zugelassen; diese
		    werden durch vorangestelltes '^' oder '**'
		    gekennzeichnet. Die Angabe des Exponenten 1
		    kann unterbleiben, ebenso die Angabe des
		    Exponenten 0; in letzterem Fall muss dann allerdings
		    auch die Angabe der entsprechenden Variablen unter-
		    bleiben.
		3)  Es sind beliebig grosse Koeffizienten zulaessig.
		    Das Vorzeichen des Koeffizienten kann durch Blanks
		    vom Koeffizienten getrennt werden. Die Angabe
		    des Koeffizienten 1 kann unterbleiben.
		    Koeffizient und zugehoerige Variablenliste
		    koennen durch beliebig viele Blanks oder durch
		    '*' und beliebig viele Blanks getrennt werden.
		    Diese Trennung ist nicht notwendig.
		4)  Variablennamen muessen in V aufgefuehrt sein
		    und duerfen nicht durch Sonderzeichen (wie z.B. CR)
		    getrennt werden. Einzelne Variablen mit ihren
		    Exponenten koennen durch beliebig viele Blanks
		    oder durch '*' und beliebig viele Blanks getrennt
		    werden. Diese Trennung ist nur dann notwendig,
		    wenn kein Exponent angegeben wurde.
		5)  Tritt in einem Monom eine Variable mehrfach auf, so
		    werden die verschiedenen Vorkommen geeignet
		    zusammengefasst.
		    Tritt ein Monom mehrfach auf, so werden die
		    verschiedenen Vorkommen geeignet zusammengefasst.
	fgetpms ist insbesondere in der Lage, von fputpms geschriebene
	Polynome zu lesen.
	fgetpms liefert den Ergebniswert
		P          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			fgetpnf( r, F, V, Vnf, pf )

	"file get polynomial over number field"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol fgetpnf(r,F,V,Vnf,pf)  single r; pol F; list V,Vnf; FILE *pf;
	P = fgetpnf(r,F,V,Vnf,pf);
	r ist eine ganze Zahl mit 0<=r<BASIS. F ist das zu einem
	Zahlkoerper K gehoerende irreduzible Polynom vom Grad n
	in einer Variablen in dense-Darstellung, das K erzeugt,
	d.h. K entsteht durch Adjunktion einer Nullstelle von F.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	Analog ist Vnf eine einelementige Variablenliste, die den
	Namen einer Nullstelle von F repraesentiert.
	pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
	fgetpnf liest ein Polynom in r Variablen V1,...,Vr ueber
	einem Zahlkoerper K von der Datei *pf. Dabei sind die Elemente
	des Zahlkoerpers dargestellt als Polynome in der durch Vnf 
	gegebenen Variable ueber den rationalen Zahlen. Diese Poly-  
	nome werden modulo F reduziert und anschliessend in die Form 
	eines Elements des von F erzeugten Zahlkoerpers gebracht.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
		1)  Das Polynomende muss mit '#' markiert sein.
		2)  Es sind nur positive Exponenten zugelassen; diese
		    werden durch vorangestelltes '^' oder '**'
		    gekennzeichnet. Die Angabe des Exponenten 1
		    kann unterbleiben, ebenso die Angabe des
		    Exponenten 0; in letzterem Fall muss dann allerdings
		    auch die Angabe der entsprechenden Variablen unter-
		    bleiben.
		3)  Es sind beliebig grosse Koeffizienten zulaessig.
		    Das Vorzeichen des Koeffizienten kann durch Blanks
		    vom Koeffizienten getrennt werden. Die Angabe
		    des Koeffizienten 1 kann unterbleiben.
		    Koeffizient und zugehoerige Variablenliste
		    koennen durch beliebig viele Blanks oder durch
		    '*' und beliebig viele Blanks getrennt werden.
		    Diese Trennung ist nicht notwendig.
		4)  Variablennamen muessen in V aufgefuehrt sein
		    und duerfen nicht durch Sonderzeichen (wie z.B. CR)
		    getrennt werden. Einzelne Variablen mit ihren
		    Exponenten koennen durch beliebig viele Blanks
		    oder durch '*' und beliebig viele Blanks getrennt
		    werden. Diese Trennung ist nur dann notwendig,
		    wenn kein Exponent angegeben wurde.
		5)  Tritt in einem Monom eine Variable mehrfach auf, so
		    werden die verschiedenen Vorkommen geeignet
		    zusammengefasst.
		    Tritt ein Monom mehrfach auf, so werden die
		    verschiedenen Vorkommen geeignet zusammengefasst.
	fgetpnf ist insbesondere in der Lage, von fputpnf geschriebene
	Polynome zu lesen.
	fgetpnf liefert den Ergebniswert
		P          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			fgetppf( r, p, V, pf )

	"file get polynomial over p-adic field"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol fgetppf( r, p, V, pf )  single r,p; list V; FILE *pf;
	P = fgetppf( r, p, V, pf );
	Dabei muss gelten:
	      - r ist eine ganze Zahl mit 0 <= r < BASIS.
	      - p ist prim.
	      - pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
	Ist r gleich 0, muss V die leere Liste sein; ansonsten ist V
	eine Liste der Form
		V = ( V1, ..., Vr ),
	deren Elemente Vi Variablennamen repraesentieren; also hat Vi
	die Form
		Vi = ( ascii( Bu ), ascii( BZ2 ), ..., ascii( BZn ) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen
	Zeichen Bu,BZ2,...,BZn besteht. Ein Variablenname muss stets mit
	einem Buchstaben beginnen. Die Liste Vr repraesentiert den Namen
	der Hauptvariablen.
	fgetppf liest ein Polynom in r Variablen V1, ..., Vr ueber den
	p-adischen Zahlen von der Datei *pf ein. Fuer die Eingabe sind
	folgende Richtlinien zu beachten:
	     1) Das Polynomende und das Ende der Koeffizienten muessen
		mit '#' markiert sein.
	     2) Die Koeffizienten muessen in Klammern '(' und ')' einge-
		schlossen werden.
	     3) Es sind nur positive Exponenten (bei den Variablen)
		zugelassen; diese werden durch vorangestelltes '^' oder
		'**' gekennzeichnet. Die Angabe des Exponenten 1 bzw. 0
		kann unterbleiben; allerdings muss im Falle 0 auch die
		Angabe der entsprechenden Variablen unterbleiben.
	     4) Es sind beliebig grosse p-adische Koeffizienten zulaes-
		sig, deren Eingabe den Konventionen von fgetpfel
		genuegen muss. Ihr Vorzeichen kann durch Blanks vom Ko-
		effizienten getrennt werden. Auf die Angabe des Koeffi-
		zienten 1 kann verzichtet werden.
		Koeffizient und zugehoerige Variablenliste koennen durch
		beliebig viele Blanks oder durch '*' und beliebig viele
		Blanks getrennt werden. Dabei ist diese Trennung nicht
		notwendig.
	     5) Variablennamen muessen in V aufgefuehrt sein und duerfen
		nicht durch Sonderzeichen (wie z.B CR) getrennt werden.
		Einzelne Variablen mit ihren Exponenten koennen durch
		beliebig viele Blanks oder durch '*' und beliebig viele
		Blanks getrennt werden. Diese Trennung ist nur dann not-
		wendig, wenn die Angabe des Exponenten unterbleibt.
	     6) Tritt in einem Monom eine Variable mehrfach auf, werden
		die verschiedenen Vorkommen gegeignet zusammengefasst.
		Tritt ein Monom mehrfach auf, werden die verschiedenen
		Vorkommen gegeignet zusammengefasst.
	fgetppf ist insbesondere in der Lage, von fputppf geschriebene
	Polynome einzulesen.
	fgetppf liefert den Ergebniswert
		P       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			fgetpr( r, V, pf )

	"file get polynomial over rationals"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol fgetpr(r,V,pf)  single r; list V; FILE *pf;
	P = fgetpr(r,V,pf);
	r ist eine ganze Zahl mit 0<=r<BASIS.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	Variablennamen repraesentieren, und zwar in der Form
		Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
	fgetpr liest ein Polynom in r Variablen V1,...,Vr ueber
	den rationalen Zahlen von der Datei *pf.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
		1)  Das Polynomende muss mit '#' markiert sein.
		2)  Es sind nur positive Exponenten zugelassen; diese
		    werden durch vorangestelltes '^' oder '**'
		    gekennzeichnet. Die Angabe des Exponenten 1
		    kann unterbleiben, ebenso die Angabe des
		    Exponenten 0; in letzterem Fall muss dann allerdings
		    auch die Angabe der entsprechenden Variablen unter-
		    bleiben.
		3)  Es sind beliebig grosse Koeffizienten zulaessig.
		    Das Vorzeichen des Koeffizienten kann durch Blanks
		    vom Koeffizienten getrennt werden. Die Angabe
		    des Koeffizienten 1 kann unterbleiben.
		    Koeffizient und zugehoerige Variablenliste
		    koennen durch beliebig viele Blanks oder durch
		    '*' und beliebig viele Blanks getrennt werden.
		    Diese Trennung ist nicht notwendig.
		4)  Variablennamen muessen in V aufgefuehrt sein
		    und duerfen nicht durch Sonderzeichen (wie z.B. CR)
		    getrennt werden. Einzelne Variablen mit ihren
		    Exponenten koennen durch beliebig viele Blanks
		    oder durch '*' und beliebig viele Blanks getrennt
		    werden. Diese Trennung ist nur dann notwendig,
		    wenn kein Exponent angegeben wurde.
		5)  Tritt in einem Monom eine Variable mehrfach auf, so
		    werden die verschiedenen Vorkommen geeignet
		    zusammengefasst.
		    Tritt ein Monom mehrfach auf, so werden die
		    verschiedenen Vorkommen geeignet zusammengefasst.
	fgetpr ist insbesondere in der Lage, von fputpr geschriebene
	Polynome zu lesen.
	fgetpr liefert den Ergebniswert
		P          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			fgetvl( pf )

	"file get variable list"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list fgetvl(pf)  FILE *pf;
	V = fgetvl(pf);
	pf ist ein Zeiger auf eine zum Lesen geoeffnete Datei.
	fgetvl liest von der Datei *pf eine Liste von Variablennamen,
	deren Ende mit '#' markiert sein muss.
	Die Variablennamen muessen durch Blank, ',' oder ';' getrennt
	sein. Die einzelnen Variablennamen duerfen nur aus alpha-
	numerischen Zeichen bestehen und duerfen keine Sonderzeichen
	wie z.B. LF oder CR enthalten. Das erste Zeichen eines
	Variablennamens muss immer ein Buchstabe sein.
	fgetvl liefert als Ergebnis
		V         (= Liste der Variablennamen), falls fgetvl
			  fehlerfrei ablief;
		ERROR     falls Fehler auftraten.



			fputdipdim( r, dim, S, M, VL, pf )

	"file put distributive polynomial dimension"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single fputdipdim(r,dim,S,M,VL,pf)  single r,dim; list S,M,VL;
               FILE *pf;
        a = fputdipdim(r,dim,S,M,VL,pf);
        dim, S und M sind die in dipdimpolid berechneten  Groessen, d.h.
          - dim = die Dimension des von G erzeugten Ideals,
          - S   = die maximal unabhaengige Menge von Variablen  und
          - M   = die Menge aller maximal unabhaengigen Mengen  von  Vari-
                  ablen  aus  VL.
        VL  ist  die  Variablenliste  des Polynomideals der Laenge r (0<=r
        <BASIS).  Ist r gleich 0, so muss VL  die leere Liste sein;  sonst
        ist VL eine Liste VL = (V1, ..., Vr), wobei die Elemente Vi von VL
        die Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
	fputdipdim schreibt die Groessen  dim, S und M  auf die Datei *pf.
        fputdipdim liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			fputdipgfsl( r, p, AL, PL, VL, Vgfs, pf )

	"file put distributive polynomial over Galois-field with single
         characteristic list"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        single fputdipgfsl(r,p,AL,PL,VL,Vgfs,pf)  single r,p;
               list AL,PL,VL,Vgfs; FILE *pf;
        a = fputdipgfsl(r,p,AL,PL,VL,Vgfs,pf);
        PL  ist eine Liste von Polynomen in distributiver Darstellung in r
        (0<=r<BASIS)  Variablen  ueber  einem  endlichen Koerper GF(q) der
        Charakteristik p, wobei AL die Arithmetikliste zu GF(q) ist.
        Ist r gleich 0, so  muss  VL  die  leere  Liste  sein;  sonst  ist
        VL  eine Liste VL = (V1, ..., Vr),  wobei die  Elemente  Vi von VL
        die Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen.
	Analog ist Vgfs eine  einelementige  Variablenliste, die den Namen
	eines  primitiven  Elementes  der  Koerpererweiterung GF(q)/(Z/pZ)
	repraesentiert.
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        fputdipgfsl schreibt die Liste PL von Polynomen auf  die Datei *pf
        in der Form { p1, ..., pm }.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        fputdipgfsl liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			fputdipil( r, PL, VL, pf )

	"file put distributive polynomial over integers list"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single fputdipil(r,PL,VL,pf)  single r; list PL,VL; FILE *pf;
        a = fputdipil(r,PL,VL,pf);
        PL  ist eine Liste von Polynomen in distributiver Darstellung in r
        (0<=r<BASIS)  Variablen ueber den ganzen Zahlen.  Ist  r gleich 0,
        so  muss  VL  die  leere  Liste  sein;  sonst  ist  VL  eine Liste
        VL = (V1, ..., Vr),  wobei die  Elemente  Vi von VL die Variablen-
        namen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen.
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        fputdipil  schreibt die Liste PL von Polynomen  auf  die Datei *pf
        in der Form { p1, ..., pm }.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        fputdipil liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			fputdipmipl( r, p, PL, VL, pf )

	"file put distributive polynomial over modular integer primes 
	 list"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single fputdipmipl(r,p,PL,VL,pf)  single r; int p; list PL,VL;
               FILE *pf;
        a = fputdipmipl(r,p,PL,VL,pf);
        PL  ist eine Liste von Polynomen in distributiver Darstellung in r
        (0<=r<BASIS)  Variablen  ueber  Z/pZ (p Primzahl). Ist r gleich 0,
        so  muss  VL  die  leere  Liste  sein;  sonst  ist  VL  eine Liste
        VL = (V1, ..., Vr),  wobei die  Elemente  Vi von VL die Variablen-
        namen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen.
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        fputdipmipl schreibt die Liste PL von Polynomen auf  die Datei *pf
        in der Form { p1, ..., pm }.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        fputdipmipl liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			fputdipmspl( r, p, PL, VL, pf )

	"file put distributive polynomial over modular single primes list"    
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single fputdipmspl(r,p,PL,VL,pf)  single r,p; list PL,VL; 
		FILE *pf;
        a = fputdipmspl(r,p,PL,VL,pf);
        PL  ist eine Liste von Polynomen in distributiver Darstellung in r
        (0<=r<BASIS)  Variablen  ueber  Z/pZ (p Primzahl). Ist r gleich 0,
        so  muss  VL  die  leere  Liste  sein;  sonst  ist  VL  eine Liste
        VL = (V1, ..., Vr),  wobei die  Elemente  Vi von VL die Variablen-
        namen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen.
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        fputdipmspl schreibt die Liste PL von Polynomen auf  die Datei *pf
        in der Form { p1, ..., pm }.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        fputdipmspl liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			fputdipnfl( r, F, PL, VL, Vnf, pf )

	"file put distributive polynomial over number field list"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        single fputdipnfl(r,F,PL,VL,Vnf,pf)  single r; pol F;
               list PL,VL,Vgfs; FILE *pf;
        a = fputdipnfl(r,F,PL,VL,Vnf,pf);
        PL  ist eine Liste von Polynomen in distributiver Darstellung in r
        (0<=r<BASIS)  Variablen  ueber einem  Zahlkoerper k. F ist das zu-
        gehoerige irreduzible Polynom in einer Variablen ueber Z,  das den
        Zahlkoerper erzeugt, d.h. k entsteht durch  Adjunktion einer Null-
        stelle von F.
        Ist r gleich 0, so  muss  VL  die  leere  Liste  sein;  sonst  ist
        VL  eine Liste VL = (V1, ..., Vr),  wobei die  Elemente  Vi von VL
        die Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen.
	Analog ist Vnf eine einelementige Variablenliste,  die  den  Namen
        einer Nullstelle von F repraesentiert.
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        fputdipnfl  schreibt die Liste PL von Polynomen auf  die Datei *pf
        in der Form { p1, ..., pm }.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        fputdipnfl liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			fputdippicgb( r1, r2, CGBL, i, VL1, VL2, pf )

	"file put distributive polynomial over polynomials over	integers
         comprehensive Groebner basis"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single fputdippicgb(r1,r2,CGBL,i,VL1,VL2,pf)  single r1,r2;
               list CGBL; single i; list VL1,VL2; FILE *pf;
        a = fputdippicgb(r1,r2,CGBL,i,VL1,VL2,pf);
        CGBL ist eine von "dippicgb" bzw. "dippircgb" erstellte Liste, die
        eine  parametrische  bzw. eine reduzierte parametrische  Groebner-
        basis repraesentiert.
        i ist die Anzahl der "Zweige" des dazugehoerigen Groebnersystems.
        Die Polynome der Basis liegen in  distributiver  Darstellung in r1
        (0<=r1<BASIS)  Variablen ueber dem Polynomring vor,  der entsteht,
        wenn man zu den ganzen  Zahlen die  Variablen  aus VL2 adjungiert.
        Ist r2 gleich 0, so muss VL2  die leere Liste  sein; sonst ist VL2
        eine Liste VL2 = (V1, ..., Vr),  wobei die Elemente Vi von VL2 die
        Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen. Der
        Aufbau der Variablenliste VL1 ist identisch mit dem der Liste VL2.
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        fputdippicgb schreibt die Liste CGBL und die Zahl i  auf die Datei  
	*pf  in der Form
        {
         p1
         ...
         pm
        }
        i condition(s)
        wobei die pi, i=1,...,m, die Polynome der Basis sind.
        fputdippicgb liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			fputdippidim( r1, r2, DIML, VL1, VL2, pf )

	"file put distributive polynomial over polynomials over integers
         dimension"
	Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single fputdippidim(r1,r2,DIML,VL1,VL2,pf)  single r1,r2;
               list DIML,VL1,VL2; FILE *pf;
        a = fputdippidim(r1,r2,DIML,VL1,VL2,pf);
        DIML ist eine Liste von Bedingungen und Dimensionen.
        (cf. V. Weispfenning, Comprehensive Groebner Bases, MIP 9003
             oder
             E. Schoenfeld, Diplomarbeit: Parametrische Groebnerbasen im
             Computer Algebra System ALDES/SAC2 1991 (Passau)            )
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        fputdippidim schreibt die Liste DIML auf die Datei *pf.
        Dabei liegen die in den  Bedingungen  vorkommenden  Koeffizienten-
	polynome in  r2  (0<=r2<BASIS)  Variablen vor.  Ist  r2  gleich 0,
        so  muss  VL2  die  leere  Liste  sein;  sonst  ist VL2 eine Liste
        VL2 = (V1, ..., Vr), wobei die Elemente Vi von VL2 die  Variablen-
        namen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen. Der
        Aufbau der Variablenliste VL1 ist identisch mit dem der Liste VL2.
        Die jeweiligen Polynomenden werden mit '#' markiert.  fputdippidim
        ist insbesondere in der Lage,  die von  dippidim  berechnete Liste
        auf die Datei *pf zu schreiben.
        fputdippidim liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			fputdippigbs( r1, r2, GS, VL1, VL2, cs, pf )

	"file put distributive polynomial over polynomials over integers
        Groebner system"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single fputdippigbs(r1, r2, GS, VL1, VL2, pf)  single r1, r2;
               list GS, VL1, VL2; single cs; FILE *pf;
        a = fputdippigbs(r1, r2, GS, VL1, VL2, cs, pf);
        GS ist ein Groebnersystem, d.h. eine Art Baum,  der in jedem Zweig
        ein Koeffizientenlistenpaar  und  eine dazugehoerige Groebnerbasis
        enthaelt (siehe auch: dippicgb).
        Die  Koeffizientenlistenpaare  sind  Listen  von  Polynomen  in r2
        (0<=r2<BASIS) Variablen ueber den ganzen Zahlen.  Ist r2 gleich 0,
        so  muss  VL2  die  leere  Liste  sein;  sonst  ist VL2 eine Liste
        VL2 = (V1, ..., Vr),  wobei die Elemente Vi von VL2 die Variablen-
        namen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        Die Groebnerbasen sind Listen von Polynomen in distributiver  Dar-
        stellung in r1 (0<=r1<BASIS) Variablen ueber dem Polynomring,  der
        entsteht, wenn  man zu den  ganzen  Zahlen die  Variablen  aus VL2
        adjungiert. Der Aufbau  der  Variablenliste VL1  ist identisch mit
        dem der Liste VL2.
        cs ist ein Schalter,  mit  dessen  Hilfe man die Groebnerbasen zu-
        saetzlich ohne die Monome ausgeben kann,  deren Koeffizient gleich
        0 sind.
        cs gleich 1   bewirkt die  zusaetzliche  Ausgabe  der  Basen  ohne
        Monome mit  Koeffizienten gleich 0.
        cs gleich 0   bewirkt die Ausgabe der Basen mit allen Monomen.
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        fputdippigbs schreibt ein Groebnersystem auf die Datei *pf.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        fputdippigbs liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			fputdippigt( r1, r2, C, PP, CGB0, CGB1, VL1, VL2, pf )

        "file put distributive polynomial over polynomials over integers
         Groebner test"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single fputdippigt(r1,r2,C,PP,CGB0,CGB1,VL1,VL2,pf)  single r1,r2;
               list C,PP,CGB0,CGB1,VL1,VL2; FILE *pf;
        a = fputdippigt(r1,r2,C,PP,CGB0,CGB1,VL1,VL2,pf);
        C  ist  eine  Fallunterscheidung,  d.h.  entweder  die leere Liste
        ("{}")  oder  eine  Liste,  die aus einer geraden Anzahl von Teil-
        listen besteht,  wobei die Teillisten mit ungerader Laufnummer die
        Koeffizientenpolynome enthalten, die  gleich  Null  sind, und  die
        mit  gerader  Laufnummer  die  Koeffizientenpolynome, die ungleich
        Null sind.
        Sei z.B. VL2 = a,b,c,d.
        Dann kann die Fallunterscheidung wie folgt aussehen:
             {{a^2-d# c+d#}{a#}{}{a^4-b*a^3+c*d}},
                            d.h. a^2-d==0, c+d==0, a!=0, a^4-b*a^3+c*d!=0;
             oder
             {{a^2-d# c+d#}{a#}}, d.h. a^2-d==0, c+d==0, a!=0;
             oder
             {{}{b^2-d^3+c# a# c#}}, d.h. b^2-d^3+c!=0, a!=0, c!=0;
             oder
             {{b# c# a^5-d^4+d^3+d#}{}},
                                        d.h. b==0, c==0, a^5-d^4+d^3+d==0.
        PP ist eine Liste von Polynomen in distributiver Darstellung in r1
        (0<=r1<BASIS)  Variablen ueber dem Polynomring, der entsteht, wenn
        man zu den  ganzen  Zahlen die  Variablen  aus VL2 adjungiert. Ist
        r2 gleich 0, so muss VL2  die  leere  Liste  sein;  sonst  ist VL2
        eine Liste VL2 = (V1, ..., Vr),  wobei die Elemente Vi von VL2 die
        Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen. Der
        Aufbau der Variablenliste VL1 ist identisch mit dem der Liste VL2.
        CGB0 enthaelt die Nachfolger von C, so dass P  eine  Groebnerbasis
        ist;
        CGB1 enthaelt die Nachfolger von C, so dass P  keine Groebnerbasis
        ist.
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
	fputdippigt schreibt die Listen  C,  PP,  CGB0  und  CGB1  auf die
        Datei *pf.
        fputdippigt liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			fputdippil( r1, r2, PL, VL1, VL2, pf )

	"file put distributive polynomial over polynomials over integers 
	 list"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single fputdippil(r1, r2, PL, VL1, VL2, pf)  single r1, r2;
               list PL, VL1, VL2; FILE *pf;
        a = fputdippil(r1, r2, PL, VL1, VL2, pf);
        PL ist eine Liste von Polynomen in distributiver Darstellung in r1
        (0<=r1<BASIS)  Variablen ueber dem Polynomring, der entsteht, wenn
        man zu den  ganzen  Zahlen die  Variablen  aus VL2 adjungiert. Ist
        r2 gleich 0, so muss VL2  die  leere  Liste  sein;  sonst  ist VL2
        eine Liste VL2 = (V1, ..., Vr),  wobei die Elemente Vi von VL2 die
        Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen. Der
        Aufbau der Variablenliste VL1 ist identisch mit dem der Liste VL2.
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        fputdippil schreibt die Liste PL von Polynomen  auf  die Datei *pf
        in der Form { p1, ..., pm }.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        fputdippil liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			fputdippipim( r1, r2, NOUT, VL1, VL2, pf )

        "file put distributive polynomial over polynomials over integers
         parametric ideal membership test"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single fputdippipim(r1,r2,NOUT,VL1,VL2,pf)  single r1,r2;
               list NOUT,VL1,VL2; FILE *pf;
        a = fputdippipim(r1,r2,NOUT,VL1,VL2,pf);
        NOUT ist eine Liste,  die  die  Polynome  enthaelt,  die auf para-
        metrische Idealmitgliedschaft getestet wurden, und die Bedingungen
        und Normalformen,  so dass das Polynom ein Element des Ideals ist,
        und solche Bedingungen und Normalformen,  so dass das Polynom kein
        Element des Ideals ist.  Die Polynome  liegen  in ihrer Normalform
        vor.
        Die  Polynome  sind  Polynome  in  distributiver Darstellung in r1
        (0<=r1<BASIS)  Variablen ueber dem Polynomring, der entsteht, wenn
        man zu den  ganzen  Zahlen die  Variablen  aus VL2 adjungiert. Ist
        r2 gleich 0, so muss VL2  die  leere  Liste  sein;  sonst  ist VL2
        eine Liste VL2 = (V1, ..., Vr),  wobei die Elemente Vi von VL2 die
        Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen. Der
        Aufbau der Variablenliste VL1 ist identisch mit dem der Liste VL2.
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        fputdippipim schreibt die Liste NOUT auf die Datei *pf in der Form
          tested polynomial
          TP1 #
          polynomial completely reduced for
          the following condition(s)
          condition:
          {
          { cfp11 # ... cfp1m # } == 0
          { cfp21 # ... cfp2n # } != 0
          }
          factor
          cff1 #
          .
          .
          .
          polynomial not completely reduced for
          the following condition(s)
          condition:
          {
          { cfp31 # ... cfp3l # } == 0
          { cfp41 # ... cfp4k # } != 0
          }
          reduced to
          RTP1 #
          factor
          cff2 #
          .
          .
          .
          quantifier free formula for
          parametric ideal membership
          ( ( a == 0 )  and ... and  ( b == 0 )  and ( c != 0 )  and
          ... and  ( d != 0 ) )
          or
          .
          .
          .
          or
          ( ( e == 0 )  and ... and  ( f == 0 )  and ( g != 0 )  and
          ... and  ( h != 0 ) )
          tested polynomial
          TP2 #
          .
          .
          .                                                      ,
        wobei TP1, TP2 die zu testenden Polynome sind, die  cfpij  Koeffi-
        zientenpolynome sind, die die  Fallunterscheidung  erzeugen,  und 
	RTP1 das zu TP1 gehoerige reduzierte Polynom ist.  a, b, c, d usw. 
	sind wieder Koeffizientenpolynome.
	fputdippipim liefert den Ergebniswert
	    0	   falls der Programmlauf fehlerfrei war;
	    ERROR  falls Fehler auftraten.



			fputdippiqff( r1, r2, QFFL, VL1, VL2, pf )

	"file put distributive polynomial over polynomials over integers
         quantifier free formula"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single fputdippiqff(r1,r2,QFFL,VL1,VL2,pf)  single r1,r2;
               list QFFL,VL1,VL2; FILE *pf;
        a = fputdippiqff(r1,r2,QFFL,VL1,VL2,pf);
        QFFL ist die quantorenfreie Formel einer Basis.
        (cf. V. Weispfenning, Comprehensive Groebner Bases, MIP 9003
             oder
             E. Schoenfeld, Diplomarbeit: Parametrische Groebnerbasen im
             Computer Algebra System ALDES/SAC2 1991 (Passau)            )
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        fputdippiqff schreibt die Liste  QFFL  von  Koeffizientenpolynomen
        auf die Datei *pf in der Form
             ( ( a == 0 )  or
             ( b != 0 )  or ... or  ( c != 0 ) )
             and
             ( ( d == 0 )  or
             ( e != 0 )  or ... or  ( f != 0 ) )
             and
             .                      
             .
             .
             and
             ( ( g == 0 )  or
             ( h != 0 )  or ... or  ( k != 0 ) )      ;
        dabei sind a, b, c, d, e, f, g, h, k Koeffizientenpolynome  in  r2
        (0<=r2<BASIS) Variablen. Ist r2 gleich 0,  so muss VL2  die  leere
        Liste  sein;  sonst  ist VL2 eine Liste VL2 = (V1, ..., Vr), wobei
        die Elemente Vi von VL2 die  Variablennamen  repraesentieren,  und
        zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen. Der
        Aufbau der Variablenliste VL1 ist identisch mit dem der Liste VL2.
        Die jeweiligen Polynomenden werden mit '#' markiert.  fputdippiqff
        ist insbesondere in der Lage,  die von  dippiqff  berechnete Liste
        auf die Datei *pf zu schreiben.
        fputdippiqff liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			fputdiprfrl( r1, r2, PL, VL1, VL2, pf )

	"file put distributive polynomial over rational functions over
	 the rationals list"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        single fputdiprfrl(r1,r2,PL,VL1,VL2,pf)  single r1,r2;
               list PL,VL1,VL2; FILE *pf;
        a = fputdiprfrl(r1,r2,PL,VL1,VL2,pf);
        PL ist eine Liste von Polynomen in distributiver Darstellung in r1
        (0<=r1<BASIS)  Variablen  ueber  dem  Funktionenkoerper, der  ent-
        steht, wenn man zu den  rationalen  Zahlen die  Variablen  aus VL2
        adjungiert. Ist r2 gleich 0, so muss VL2  die  leere  Liste  sein;
        sonst  ist VL2 eine Liste VL2 = (V1, ..., Vr),  wobei die Elemente
        Vi  von  VL2  die  Variablennamen repraesentieren, und zwar in der
        Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen. Der
        Aufbau der Variablenliste VL1 ist identisch mit dem der Liste VL2.
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        fputdiprfrl schreibt die Liste PL von Polynomen auf  die Datei *pf
        in der Form { p1, ..., pm },  wobei  die pi, i=1,...,m, als ratio-
        nale Funktionen dargestellt sind.
        fputdiprfrl liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			fputdiprl( r, PL, VL, pf )

	"file put distributive polynomial over rationals list"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single fputdiprl(r,PL,VL,pf)  single r; list PL,VL; FILE *pf;
        a = fputdiprl(r,PL,VL,pf);
        PL  ist eine Liste von Polynomen in distributiver Darstellung in r
        (0<=r<BASIS)  Variablen  ueber  den  rationalen  Zahlen.   Ist   r
        gleich 0, so muss VL die leere Liste sein; sonst ist VL eine Liste
        VL = (V1, ..., Vr),  wobei die  Elemente  Vi von VL die Variablen-
        namen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen.
        pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
        fputdiprl  schreibt die Liste PL von Polynomen  auf  die Datei *pf
        in der Form { p1, ..., pm }.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        fputdiprl liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			fputlpi( r, L, V, pf )

	"file put list of polynomials over integers"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single fputlpi(r,L,V,pf) single r; list L; list V; FILE *pf;
	t = fputlpi( r,L,V,pf );
	L ist eine Liste von Polynomen in r (0<=r<BASIS) Variablen
	ueber den ganzen Zahlen.
	V ist eine Variablenliste.
	L wird als Liste von Polynomen gemaess den in "fputpi" beschriebenen
	Vorschriften auf die Datei *pf ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			fputlpr( r, L, V, pf )

	"file put list of polynomials over rationals"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single fputlpr(r,L,V,pf) single r; list L; list V; FILE *pf;
	t = fputlpr( r,L,V,pf );
	L ist eine Liste von Polynomen in r (0<=r<BASIS) Variablen
	ueber den rationalen Zahlen.
	V ist eine Variablenliste.
	L wird als Liste von Polynomen gemaess den in "fputpr" beschriebenen
	Vorschriften auf die Datei *pf ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			fputpgf2( r, G, P, V, Vgf2, pf )

	"file put polynomial over Galois-field with characteristic 2"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	single fputpgf2(r, G, P, V, Vgf2, pf)  single r; obj G; pol P;
					       list V, Vgf2; FILE *pf;
	a = fputpgf2(r, G, P, V, Vgf2, pf);
	r ist eine ganze Zahl mit 0 <= r < BASIS.
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
	P ist ein Polynom in r Variablen ueber GF(2^n) mit
	Koeffizienten in spezieller Bit-Darstellung.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	Vgf2 ist eine einelementige Variablenliste, die den Namen
	eines primitiven Elementes der Koerpererweiterung GF(2^n)/(Z/2Z)
	repraesentiert.
	pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
	fputpgf2 schreibt ein Polynom in r Variablen ueber GF(2^n) auf
	die Datei *pf. Das Polynomende wird mit '#' markiert.
	fputpgf2 liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			fputpgfs( r, p, AL, P, V, Vgfs, pf )

	"file put polynomial over Galois-field"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	single fputpgfs(r,p,AL,P,V,Vgfs,pf)  single r,p; list AL; 
				    pol P; list V,Vgfs; FILE *pf;
	a = fputpgfs(r,p,AL,P,V,Vgfs,pf);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber einem
	endlichen Koerper GF(q) der Charakteristik p < BASIS, wobei
	AL = (G,AL1) die Arithmetikliste zu GF(q) ist.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	Analog ist Vgfs eine einelementige Variablenliste, die den Namen
	eines primitiven Elementes der Koerpererweiterung GF(q)/(Z/pZ)
	repraesentiert.
	pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
	fputpgfs schreibt ein Polynom in r Variablen ueber GF(q) auf
	die Datei *pf. Das Polynomende wird mit '#' markiert.
	fputpgfs liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			fputpi( r, P, V, pf )

	"file put polynomial over integers"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single fputpi(r,P,V,pf)  single r; pol P; list V; FILE *pf;
	a = fputpi(r,P,V,pf);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
	fputpi schreibt ein Polynom in r Variablen ueber den ganzen
	Zahlen auf die Datei *pf. Das Polynomende wird mit '#' markiert.
	fputpi liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			fputpmi( r, M, P, V, pf )

	"file put polynomial over modular integers"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single fputpmi(r,M,P,V,pf)  single r; int M; pol P;
				    list V; FILE *pf;
	a = fputpmi(r,M,P,V,pf);
	M ist eine positive ganze Zahl.
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber Z / M*Z.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
	fputpmi schreibt ein Polynom in r Variablen ueber Z / M*Z auf
	die Datei *pf. Das Polynomende wird mit '#' markiert.
	fputpmi liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			fputpms( r, m, P, V, pf )

	"file put polynomial over modular singles"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single fputpms(r,m,P,V,pf)  single r,m; pol P; list V; FILE *pf;
	a = fputpms(r,m,P,V,pf);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber Z/mZ.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
	fputpms schreibt ein Polynom in r Variablen ueber Z/mZ auf
	die Datei *pf. Das Polynomende wird mit '#' markiert.
	fputpms liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			fputpnf( r, F, P, V, Vnf, pf )

	"file put polynomial over number field"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	single fputpnf(r,F,P,V,Vnf,pf)  single r; pol F,P;
				       list V,Vnf; FILE *pf;
	a = fputpnf(r,F,P,V,Vnf,pf);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber einem
	Zahlkoerper K. F ist das zugehoerige irreduzible Polynom in
	einer Variablen ueber Z, das den Zahlkoerper erzeugt, d.h. K
	entsteht durch Adjunktion einer Nullstelle von F.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	Analog ist Vnf eine einelementige Variablenliste, die den
	Namen einer Nullstelle von F repraesentiert.
	pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
	fputpnf schreibt ein Polynom in r Variablen ueber einem Zahl-
	koerper K auf die Datei *pf. Die Koeffizienten werden dann als
	Polynome in der Variablen von Vnf ueber Q aufgefasst.
	Das Polynomende wird mit '#' markiert.
	fputpnf liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			fputppf( r, p, P, V, pf )

	"file put polynomial over p-adic field"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	single fputppf( r, p, P, V, pf )  single p,r; pol P; 
					  list V; FILE *pf;
	s = fputppf( r, p, P, V, pf );
	Dabei muss gelten:
	      - r ist eine ganze Zahl mit 0 <= r < BASIS.
	      - p ist prim.
	      - pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
	P ist ein Polynom in r Variablen ueber den p-adischen Zahlen. Ist
	r gleich 0, muss V die leere Liste sein; sonst ist V eine Liste
		V = ( V1, ..., Vr ),
	deren Elemente Vi Variablennamen repraesentieren, also hat Vi
	die folgende Form
		Vi = ( ascii( Bu ), ascii( BZ2 ), ..., ascii( BZn ) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen
	Zeichen Bu, BZ2,...,BZn besteht. Ein Variablenname muss immer
	mit einem Buchstaben beginnen. Die Liste Vr repraesentiert den
	Namen der Hauptvariablen.
	fputppf schreibt ein Polynom in r Variablen ueber den p-adischen
	Zahlen auf die Datei *pf. Das Polynomende wird mit '#' markiert.
	fputppf liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			fputpr( r, P, V, pf )

	"file put polynomial over rationals"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single fputpr(r,P,V,pf)  single r; pol P; list V; FILE *pf;
	a = fputpr(r,P,V,pf);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
	fputpr schreibt ein Polynom in r Variablen ueber den rationalen
	Zahlen auf die Datei *pf. Das Polynomende wird mit '#' markiert.
	fputpr liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			getdipgfsl( r, p, AL, VL, Vgfs )(MACRO)

	"get distributive polynomial over Galois-field with single
         characteristic list"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list getdipgfsl(r,p,AL,VL,Vgfs)  single r,p; list AL,VL,Vgfs;
        PL = getdipgfsl(r,p,AL,VL,Vgfs);
	r>=0, p Primzahl.
        AL  ist die zu einem endlichen Koerper GF(q) der Charakteristik p
        gehoerende Arithmetikliste.
        Ist r gleich 0, so muss VL die  leere  Liste  sein; sonst  ist  VL
        eine  Liste  der  Form  VL = (V1, ... , Vn), wobei die Elemente Vi
        von  VL  Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Analog ist  Vgfs  eine einelementige Variablenliste, die den Namen
	eines  primitiven  Elementes  der  Koerpererweiterung GF(q)/(Z/pZ)
	repraesentiert.
        getdipgfsl  liest  eine  Liste  von Polynomen in r Variablen ueber
        GF(q) von stdin.
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm },
	d.h. die Liste muss mit '{' beginnen, mit '}' enden, und die  ein-
	zelnen Polynome muessen durch Kommata voneinander getrennt sein.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Das Polynomende muss mit '#' markiert sein.
	      2)  Es sind nur positive Exponenten zugelassen; diese werden
                  durch vorangestelltes '^' oder '**' gekennzeichnet.  Die
                  Angabe des Exponenten 1  kann  unterbleiben,  ebenso die
                  Angabe des Exponenten 0;  in  letzterem  Fall muss  dann
                  allerdings auch die Angabe der entsprechenden  Variablen
                  unterbleiben.
	      3)  Es sind  beliebig  grosse  Koeffizienten  zulaessig. Das
                  Vorzeichen des Koeffizienten kann durch Blanks vom Koef-
                  fizienten getrennt werden. Die  Angabe des Koeffizienten
                  1 kann unterbleiben. Koeffizient und zugehoerige Variab-
                  lenliste  koennen durch beliebig viele Blanks oder durch
		  '*' und beliebig viele Blanks getrennt werden.
		  Diese Trennung ist nicht notwendig.
	      4)  Variablennamen muessen in VL aufgefuehrt sein und duerfen
                  nicht durch Sonderzeichen (wie z.B. CR) getrennt werden.
                  Einzelne  Variablen  mit ihren Exponenten koennen  durch
                  beliebig viele Blanks  oder durch '*' und beliebig viele
                  Blanks getrennt werden. Diese Trennung ist nur dann not-
                  wendig, wenn kein Exponent angegeben wurde.
	      5)  Tritt in  einem  Monom  eine  Variable  mehrfach auf, so
                  werden die verschiedenen  Vorkommen geeignet zusammenge-
                  fasst.
		  Tritt ein Monom mehrfach auf, so  werden  die  verschie-
                  denen Vorkommen geeignet zusammengefasst.
              6)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp)
        getdipgfsl  ist  insbesondere  in  der  Lage,  von  putdipgfsl ge-
        schriebene Polynomlisten zu lesen.
	getdipgfsl liefert als Ergebniswert
		eine Liste von distributiven Polynomen ueber GF(q),
			falls der Programmablauf fehlerfrei war;
		ERROR,  falls Fehler auftraten.



			getdipil( r, VL )               (MACRO)

	"get distributive polynomial over integers list"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list getdipil(r,VL)  single r; list VL;
        PL = getdipil(r,VL);
        r ist eine ganze Zahl mit  0<=r<BASIS.  Ist r gleich 0, so muss VL
        die  leere  Liste  sein;  sonst  ist   VL   eine  Liste  der  Form
        VL = (V1, ... , Vn), wobei die Elemente Vi von  VL  Variablennamen
        repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        getdipil  liest eine  Liste von Polynomen in r Variablen ueber den
        ganzen Zahlen von stdin.
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm },
	d.h. die Liste muss mit '{' beginnen, mit '}' enden, und die  ein-
	zelnen Polynome muessen durch Kommata voneinander getrennt sein.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Das Polynomende muss mit '#' markiert sein.
	      2)  Es sind nur positive Exponenten zugelassen; diese werden
                  durch vorangestelltes '^' oder '**' gekennzeichnet.  Die
                  Angabe des Exponenten 1  kann  unterbleiben,  ebenso die
                  Angabe des Exponenten 0;  in  letzterem  Fall muss  dann
                  allerdings auch die Angabe der entsprechenden  Variablen
                  unterbleiben.
	      3)  Es sind  beliebig  grosse  Koeffizienten  zulaessig. Das
                  Vorzeichen des Koeffizienten kann durch Blanks vom Koef-
                  fizienten getrennt werden. Die  Angabe des Koeffizienten
                  1 kann unterbleiben. Koeffizient und zugehoerige Variab-
                  lenliste  koennen durch beliebig viele Blanks oder durch
		  '*' und beliebig viele Blanks getrennt werden.
		  Diese Trennung ist nicht notwendig.
	      4)  Variablennamen muessen in VL aufgefuehrt sein und duerfen
                  nicht durch Sonderzeichen (wie z.B. CR) getrennt werden.
                  Einzelne  Variablen  mit ihren Exponenten koennen  durch
                  beliebig viele Blanks  oder durch '*' und beliebig viele
                  Blanks getrennt werden. Diese Trennung ist nur dann not-
                  wendig, wenn kein Exponent angegeben wurde.
	      5)  Tritt in  einem  Monom  eine  Variable  mehrfach auf, so
                  werden die verschiedenen  Vorkommen geeignet zusammenge-
                  fasst.
		  Tritt ein Monom mehrfach auf, so  werden  die  verschie-
                  denen Vorkommen geeignet zusammengefasst.
              6)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp)
        getdipil ist insbesondere in der Lage, von  putdipil geschriebene 
	Polynomlisten zu lesen.
	getdipil liefert als Ergebniswert
		eine Liste von distributiven Polynomen ueber Z,
			falls der Programmablauf fehlerfrei war;
		ERROR,  falls Fehler auftraten.



			getdipmipl( r, p, VL )          (MACRO)

	"get distributive polynomial over modular integer primes list"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list getdipmipl(r,p,VL)  single r; int p; list VL;
        PL = getdipmipl(r,p,VL);
        r ist eine ganze Zahl mit  0<=r<BASIS.  Ist r gleich 0, so muss VL
        die  leere  Liste  sein;  sonst  ist   VL   eine  Liste  der  Form
        VL = (V1, ... , Vn), wobei die Elemente Vi von  VL  Variablennamen
        repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        getdipmipl  liest  eine  Liste  von Polynomen in r Variablen ueber
        Z/pZ (p Primzahl) von stdin.
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm },
	d.h. die Liste muss mit '{' beginnen, mit '}' enden, und die  ein-
	zelnen Polynome muessen durch Kommata voneinander getrennt sein.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Das Polynomende muss mit '#' markiert sein.
	      2)  Es sind nur positive Exponenten zugelassen; diese werden
                  durch vorangestelltes '^' oder '**' gekennzeichnet.  Die
                  Angabe des Exponenten 1  kann  unterbleiben,  ebenso die
                  Angabe des Exponenten 0;  in  letzterem  Fall muss  dann
                  allerdings auch die Angabe der entsprechenden  Variablen
                  unterbleiben.
	      3)  Es sind  beliebig  grosse  Koeffizienten  zulaessig. Das
                  Vorzeichen des Koeffizienten kann durch Blanks vom Koef-
                  fizienten getrennt werden. Die  Angabe des Koeffizienten
                  1 kann unterbleiben. Koeffizient und zugehoerige Variab-
                  lenliste  koennen durch beliebig viele Blanks oder durch
		  '*' und beliebig viele Blanks getrennt werden.
		  Diese Trennung ist nicht notwendig.
	      4)  Variablennamen muessen in VL aufgefuehrt sein und duerfen
                  nicht durch Sonderzeichen (wie z.B. CR) getrennt werden.
                  Einzelne  Variablen  mit ihren Exponenten koennen  durch
                  beliebig viele Blanks  oder durch '*' und beliebig viele
                  Blanks getrennt werden. Diese Trennung ist nur dann not-
                  wendig, wenn kein Exponent angegeben wurde.
	      5)  Tritt in  einem  Monom  eine  Variable  mehrfach auf, so
                  werden die verschiedenen  Vorkommen geeignet zusammenge-
                  fasst.
		  Tritt ein Monom mehrfach auf, so  werden  die  verschie-
                  denen Vorkommen geeignet zusammengefasst.
              6)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp)
        getdipmipl  ist  insbesondere  in  der  Lage,  von  putdipmipl ge-
        schriebene Polynomlisten zu lesen.
	getdipmipil liefert als Ergebniswert
		eine Liste von distributiven Polynomen ueber Z/pZ,
			falls der Programmablauf fehlerfrei war;
		ERROR,  falls Fehler auftraten.



			getdipmspl( r, p, VL )          (MACRO)

	"get distributive polynomial over modular single primes list"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list getdipmspl(r,p,VL)  single r,p; list VL;
        PL = getdipmspl(r,p,VL);
        r ist eine ganze Zahl mit  0<=r<=BASIS.  Ist r gleich 0, so muss VL
        die  leere  Liste  sein;  sonst  ist   VL   eine  Liste  der  Form
        VL = (V1, ... , Vn), wobei die Elemente Vi von  VL  Variablennamen
        repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        getdipmspl  liest  eine  Liste  von Polynomen in r Variablen ueber
        Z/pZ (p Primzahl) von stdin.
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm },
	d.h. die Liste muss mit '{' beginnen, mit '}' enden, und die  ein-
	zelnen Polynome muessen durch Kommata voneinander getrennt sein.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Das Polynomende muss mit '#' markiert sein.
	      2)  Es sind nur positive Exponenten zugelassen; diese werden
                  durch vorangestelltes '^' oder '**' gekennzeichnet.  Die
                  Angabe des Exponenten 1  kann  unterbleiben,  ebenso die
                  Angabe des Exponenten 0;  in  letzterem  Fall muss  dann
                  allerdings auch die Angabe der entsprechenden  Variablen
                  unterbleiben.
	      3)  Es sind  beliebig  grosse  Koeffizienten  zulaessig. Das
                  Vorzeichen des Koeffizienten kann durch Blanks vom Koef-
                  fizienten getrennt werden. Die  Angabe des Koeffizienten
                  1 kann unterbleiben. Koeffizient und zugehoerige Variab-
                  lenliste  koennen durch beliebig viele Blanks oder durch
		  '*' und beliebig viele Blanks getrennt werden.
		  Diese Trennung ist nicht notwendig.
	      4)  Variablennamen muessen in VL aufgefuehrt sein und duerfen
                  nicht durch Sonderzeichen (wie z.B. CR) getrennt werden.
                  Einzelne  Variablen  mit ihren Exponenten koennen  durch
                  beliebig viele Blanks  oder durch '*' und beliebig viele
                  Blanks getrennt werden. Diese Trennung ist nur dann not-
                  wendig, wenn kein Exponent angegeben wurde.
	      5)  Tritt in  einem  Monom  eine  Variable  mehrfach auf, so
                  werden die verschiedenen  Vorkommen geeignet zusammenge-
                  fasst.
		  Tritt ein Monom mehrfach auf, so  werden  die  verschie-
                  denen Vorkommen geeignet zusammengefasst.
              6)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp)
        getdipmspl  ist  insbesondere  in  der  Lage,  von  putdipmspl ge-
        schriebene Polynomlisten zu lesen.
	getdipmspil liefert als Ergebniswert
		eine Liste von distributiven Polynomen ueber Z/pZ,
			falls der Programmablauf fehlerfrei war;
		ERROR,  falls Fehler auftraten.



			getdipnfl( r, F, VL, Vnf )      (MACRO)

	"get distributive polynomial over number field list"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list getdipnfl(r,F,VL,Vnf)  single r; pol F; list VL,Vnf;
        PL = getdipnfl(r,F,VL,Vnf);
	r ist eine ganze Zahl mit 0<=r<BASIS.  F ist das  zu  einem  Zahl-
        koerper k gehoerende irreduzible Polynom vom Grad n in einer Vari-
        ablen in dense-Darstellung, das k erzeugt, d.h.  k  entsteht durch
        Adjunktion einer Nullstelle von F.
        Ist r gleich 0, so muss VL die  leere  Liste  sein; sonst  ist  VL
        eine  Liste  der  Form  VL = (V1, ... , Vn), wobei die Elemente Vi
        von  VL  Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Analog ist Vnf eine  einelementige  Variablenliste,  die den Namen
        einer Nullstelle von F repraesentiert.
        getdipnfl  liest  eine  Liste  von  Polynomen in r Variablen ueber
        ueber dem Zahlkoerper k von stdin.
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm },
	d.h. die Liste muss mit '{' beginnen, mit '}' enden, und die  ein-
	zelnen Polynome muessen durch Kommata voneinander getrennt sein.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Das Polynomende muss mit '#' markiert sein.
	      2)  Es sind nur positive Exponenten zugelassen; diese werden
                  durch vorangestelltes '^' oder '**' gekennzeichnet.  Die
                  Angabe des Exponenten 1  kann  unterbleiben,  ebenso die
                  Angabe des Exponenten 0;  in  letzterem  Fall muss  dann
                  allerdings auch die Angabe der entsprechenden  Variablen
                  unterbleiben.
	      3)  Es sind  beliebig  grosse  Koeffizienten  zulaessig. Das
                  Vorzeichen des Koeffizienten kann durch Blanks vom Koef-
                  fizienten getrennt werden. Die  Angabe des Koeffizienten
                  1 kann unterbleiben. Koeffizient und zugehoerige Variab-
                  lenliste  koennen durch beliebig viele Blanks oder durch
		  '*' und beliebig viele Blanks getrennt werden.
		  Diese Trennung ist nicht notwendig.
	      4)  Variablennamen muessen in VL aufgefuehrt sein und duerfen
                  nicht durch Sonderzeichen (wie z.B. CR) getrennt werden.
                  Einzelne  Variablen  mit ihren Exponenten koennen  durch
                  beliebig viele Blanks  oder durch '*' und beliebig viele
                  Blanks getrennt werden. Diese Trennung ist nur dann not-
                  wendig, wenn kein Exponent angegeben wurde.
	      5)  Tritt in  einem  Monom  eine  Variable  mehrfach auf, so
                  werden die verschiedenen  Vorkommen geeignet zusammenge-
                  fasst.
		  Tritt ein Monom mehrfach auf, so  werden  die  verschie-
                  denen Vorkommen geeignet zusammengefasst.
              6)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp)
        getdipnfl ist insbesondere in der Lage, von putdipnfl geschriebene
        Polynomlisten zu lesen.
	getdipnfl liefert als Ergebniswert
		eine Liste von distributiven Polynomen ueber dem Zahlkoer-
		per k,  falls der Programmablauf fehlerfrei war;
		ERROR,  falls Fehler auftraten.



			getdippicd( r1, r2, VL1, VL2, fac )(MACRO)

	"get distributive polynomial over polynomials over integers
         case distinction"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list getdippicd(r1, r2, VL1, VL2, fac)  single r1, r2;
		list VL1, VL2; single fac;
	CONS = getdippicd(r1, r2, VL1, VL2, fac);
        r1 und r2 sind ganze Zahlen mit 0<= r1,r2 <BASIS.  Ist  r1 bzw. r2
        gleich 0, so muss VL1 bzw. VL2 die  leere  Liste sein;  sonst sind
        VL1 und VL2 Listen der Form VLi = (V1i, ... , Vri), wobei die Ele-
        mente Vji von VLi Variablennamen repraesentieren,  und zwar in der
        Form:
          Vji = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        getdippicd  liest eine Fallunterscheidung, d.h. entweder die leere
        Liste ("{}")  oder  eine  Liste,  die aus einer geraden Anzahl von
        Teillisten besteht,  wobei die Teillisten mit ungerader Laufnummer
        die Koeffizientenpolynome  enthalten, die  gleich  Null  sind, und
        die  mit  gerader  Laufnummer  die  Koeffizientenpolynome, die un-
        gleich Null sind, von stdin.
        Die Koeffizientenpolynome sind Polynome in r2 Variablen ueber den
        ganzen Zahlen, deren korrekter Aufbau in "fgetpi" beschrieben ist.
        Mit  dem Schalter  fac  wird die Faktorisierung der Koeffizienten-
        polynome ein (fac = 1) bzw. aus (fac = 0) geschaltet.
        Eingabebeispiel:
        Sei  VL2 = a,b,c,d .
        Dann kann die Fallunterscheidung wie folgt aussehen:
             {{a^2-d# c+d#}{a#}{}{a^4-b*a^3+c*d}},
                            d.h. a^2-d==0, c+d==0, a!=0, a^4-b*a^3+c*d!=0;
             oder
             {{a^2-d# c+d#}{a#}}, d.h. a^2-d==0, c+d==0, a!=0;
             oder
             {{}{b^2-d^3+c# a# c#}}, d.h. b^2-d^3+c!=0, a!=0, c!=0;
             oder
             {{b# c# a^5-d^4+d^3+d#}{}},
                                        d.h. b==0, c==0, a^5-d^4+d^3+d==0.
	Im Fehlerfall ist CONS = ERROR.



			getdippil( r1, r2, VL1, VL2 )   (MACRO)

	"get distributive polynomial over polynomials over integers
        list"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list getdippil(r1, r2, VL1, VL2)  single r1, r2; list VL1, VL2;
        PL = getdippil(r1, r2, VL1, VL2);
        r1 und r2 sind ganze Zahlen mit 0<= r1,r2 <=BASIS.  Ist r1 bzw. r2
        gleich 0, so muss VL1 bzw. VL2 die  leere  Liste sein;  sonst sind
        VL1 und VL2 Listen der Form VLi = (V1i, ... , Vri), wobei die Ele-
        mente Vji von VLi Variablennamen repraesentieren,  und zwar in der
        Form:
          Vji = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        getdippil  liest eine  Liste  von  Polynomen in r1 Variablen ueber
        dem Polynomring,  der entsteht,  wenn man die Variablen aus VL2 zu
        den ganzen Zahlen adjungiert, von stdin.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Das Polynomende muss mit '#' markiert sein.
	      2)  Es sind nur positive Exponenten zugelassen; diese werden
                  durch vorangestelltes '^' oder '**' gekennzeichnet.  Die
                  Angabe des Exponenten 1  kann  unterbleiben,  ebenso die
                  Angabe des Exponenten 0;  in  letzterem  Fall muss  dann
                  allerdings auch die Angabe der entsprechenden  Variablen
                  unterbleiben.
	      3)  Es sind  beliebig  grosse  Koeffizienten  zulaessig. Das
                  Vorzeichen des Koeffizienten kann durch Blanks vom Koef-
                  fizienten getrennt werden. Die  Angabe des Koeffizienten
                  1 kann unterbleiben. Koeffizient und zugehoerige Variab-
                  lenliste  koennen durch beliebig viele Blanks oder durch
		  '*' und beliebig viele Blanks getrennt werden.
		  Diese Trennung ist nicht notwendig.
	      4)  Variablennamen muessen in V aufgefuehrt sein und duerfen
                  nicht durch Sonderzeichen (wie z.B. CR) getrennt werden.
                  Einzelne  Variablen  mit ihren Exponenten koennen  durch
                  beliebig viele Blanks  oder durch '*' und beliebig viele
                  Blanks getrennt werden. Diese Trennung ist nur dann not-
                  wendig, wenn kein Exponent angegeben wurde.
	      5)  Tritt in  einem  Monom  eine  Variable  mehrfach auf, so
                  werden die verschiedenen  Vorkommen geeignet zusammenge-
                  fasst.
		  Tritt ein Monom mehrfach auf, so  werden  die  verschie-
                  denen Vorkommen geeignet zusammengefasst.
              6)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp.S)
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm }, Liste von m Polynomen in distributiver Dar-
        stellung.  getdippil  ist insbesondere in der Lage, von  putdippil
        geschriebene Polynomlisten zu lesen.
	getdippil liefert den Ergebniswert
		PL     falls der Programmablauf fehlerfrei war;
		ERROR  falls Fehler auftraten.



			getdiprfrl( r1, r2, VL1, VL2 )  (MACRO)

	"get distributive polynomial over rational functions over the
	 rationals list"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	list getdiprfrl(r1,r2,VL1,VL2)  single r1,r2; list VL1,VL2;
        PL = getdiprfrl(r1,r2,VL1,VL2);
        r1 und r2 sind ganze Zahlen mit 0<= r1, r2 <=BASIS. Ist r1 bzw. r2
        gleich 0, so muss VL1 bzw. VL2 die  leere  Liste sein;  sonst sind
        VL1 und VL2 Listen der Form VLi = (V1i, ... , Vri), wobei die Ele-
        mente Vji von VLi Variablennamen repraesentieren,  und zwar in der
        Form:
          Vji = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        getdiprfrl  liest eine Liste  von  Polynomen in r1 Variablen ueber
        dem Funktionenkoerper,  der entsteht,  wenn  man die Variablen aus
        VL2 zu den rationalen Zahlen adjungiert, von stdin.
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm },
	d.h. die Liste muss mit '{' beginnen, mit '}' enden, und die  ein-
	zelnen Polynome muessen durch Kommata voneinander getrennt sein.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Die Polynome werden wie rationale Funktionen eingelesen,
                  wobei zu beachten ist, dass das Nennerpolynom der Haupt-
                  nenner der Nenner der Koeffizientenfunktionen ist.
              2)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp)
        getdiprfrl  ist  insbesondere  in  der  Lage,  von  putdiprfrl ge-
        schriebene Polynomlisten zu lesen.
	getdiprfrl liefert als Ergebniswert
		eine Liste von distributiven Polynomen  ueber  rationalen
		Funktionen,       falls der Programmablauf fehlerfrei war;
		ERROR,            falls Fehler auftraten.



			getdiprl( r, VL )               (MACRO)

	"get distributive polynomial over rationals list"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list getdiprl(r,VL)  single r; list VL;
        PL = getdiprl(r,VL);
        r ist eine ganze Zahl mit  0<=r<=BASIS.  Ist r gleich 0, so muss VL
        die  leere  Liste  sein;  sonst  ist   VL   eine  Liste  der  Form
        VL = (V1, ... , Vn), wobei die Elemente Vi von  VL  Variablennamen
        repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        getdiprl liest eine  Liste  von Polynomen in r Variablen ueber den
        rationalen Zahlen von stdin.
        Eine korrekte Liste von Polynomen hat die Form:
              { P1, ..., Pm },
	d.h. die Liste muss mit '{' beginnen, mit '}' enden, und die  ein-
	zelnen Polynome muessen durch Kommata voneinander getrennt sein.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
	      1)  Das Polynomende muss mit '#' markiert sein.
	      2)  Es sind nur positive Exponenten zugelassen; diese werden
                  durch vorangestelltes '^' oder '**' gekennzeichnet.  Die
                  Angabe des Exponenten 1  kann  unterbleiben,  ebenso die
                  Angabe des Exponenten 0;  in  letzterem  Fall muss  dann
                  allerdings auch die Angabe der entsprechenden  Variablen
                  unterbleiben.
	      3)  Es sind  beliebig  grosse  Koeffizienten  zulaessig. Das
                  Vorzeichen des Koeffizienten kann durch Blanks vom Koef-
                  fizienten getrennt werden. Die  Angabe des Koeffizienten
                  1 kann unterbleiben. Koeffizient und zugehoerige Variab-
                  lenliste  koennen durch beliebig viele Blanks oder durch
		  '*' und beliebig viele Blanks getrennt werden.
		  Diese Trennung ist nicht notwendig.
	      4)  Variablennamen muessen in VL aufgefuehrt sein und duerfen
                  nicht durch Sonderzeichen (wie z.B. CR) getrennt werden.
                  Einzelne  Variablen  mit ihren Exponenten koennen  durch
                  beliebig viele Blanks  oder durch '*' und beliebig viele
                  Blanks getrennt werden. Diese Trennung ist nur dann not-
                  wendig, wenn kein Exponent angegeben wurde.
	      5)  Tritt in  einem  Monom  eine  Variable  mehrfach auf, so
                  werden die verschiedenen  Vorkommen geeignet zusammenge-
                  fasst.
		  Tritt ein Monom mehrfach auf, so  werden  die  verschie-
                  denen Vorkommen geeignet zusammengefasst.
              6)  Die Monome werden gemaess der durch die globale Variable
                  'EVORD'  eingestellte  Termordnung  sortiert. EVORD kann 
                  folgende Werte annehmen:
                     EVORD = 1 -> lexikographische Termordnung;
                           = 2 -> graduiert lexikographische Termordnung;
                           = 3 -> Buchbergers Totalgrad Ordnung;
                           = 4 -> lexikographische  Termordnung  mit umge-
                                  kehrtem Exponentenvektor;
                       default -> lexikographische Termordnung.
                  (siehe auch: dipevcomp)
        getdiprl ist insbesondere in  der Lage, von putdiprl geschriebene 
	Polynomlisten zu lesen.
	getdiprl liefert als Ergebniswert
		eine Liste von distributiven Polynomen ueber Q,
			falls der Programmablauf fehlerfrei war;
		ERROR,  falls Fehler auftraten.



			getpgf2( r, G, V, Vgf2 )        (MACRO)

	"get polynomial over Galois-field with characteristic 2"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol getpgf2(r, G, V, Vgf2)  single r; obj G; list V,Vgf2;
	P = getpgf2(r, G, V, Vgf2);
	r ist eine ganze Zahlen mit 0<=r<BASIS.
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	Vgf2 ist eine einelementige Variablenliste, die den Namen
	eines primitiven Elementes der Koerpererweiterung 
	GF(2^n)/(Z/2Z) repraesentiert.
	getpgf2 liest ein Polynom in r Variablen V1,...,Vr ueber
	GF(2^n) von stdin. Die Koeffizienten von des Polynoms 
	sind in spezieller Bit-Darstellung dargestellt.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
		1)  Das Polynomende muss mit '#' markiert sein.
		2)  Es sind nur positive Exponenten zugelassen; diese
		    werden durch vorangestelltes '^' oder '**'
		    gekennzeichnet. Die Angabe des Exponenten 1
		    kann unterbleiben, ebenso die Angabe des
		    Exponenten 0; in letzterem Fall muss dann allerdings
		    auch die Angabe der entsprechenden Variablen unter-
		    bleiben.
		3)  Es sind beliebig grosse Koeffizienten zulaessig.
		    Das Vorzeichen des Koeffizienten kann durch Blanks
		    vom Koeffizienten getrennt werden. Die Angabe
		    des Koeffizienten 1 kann unterbleiben.
		    Koeffizient und zugehoerige Variablenliste
		    koennen durch beliebig viele Blanks oder durch
		    '*' und beliebig viele Blanks getrennt werden.
		    Diese Trennung ist nicht notwendig.
		4)  Variablennamen muessen in V aufgefuehrt sein
		    und duerfen nicht durch Sonderzeichen (wie z.B. CR)
		    getrennt werden. Einzelne Variablen mit ihren
		    Exponenten koennen durch beliebig viele Blanks
		    oder durch '*' und beliebig viele Blanks getrennt
		    werden. Diese Trennung ist nur dann notwendig,
		    wenn kein Exponent angegeben wurde.
		5)  Tritt in einem Monom eine Variable mehrfach auf, so
		    werden die verschiedenen Vorkommen geeignet
		    zusammengefasst.
		    Tritt ein Monom mehrfach auf, so werden die
		    verschiedenen Vorkommen geeignet zusammengefasst.
	getpgf2 liefert den Ergebniswert
		P          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			getpgfs( r, p, AL, V, Vgfs )    (MACRO)

	"get polynomial over Galois-field with single characteristic"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol getpgfs(r,p,AL,V,Vgfs)  single r,p; list AL; list V,Vgfs;
	P = getpgfs(r,p,AL,V,Vgfs);
	r und p sind ganze Zahlen mit 0<=r<BASIS, 0<p<BASIS und p
	Primzahl. AL ist die zu einem endlichen Koerper GF(q) der
	Charakteristik p gehoerende Arithmetikliste.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	Analog ist Vgfs eine einelementige Variablenliste, die den Namen
	eines primitiven Elementes der Koerpererweiterung GF(q)/(Z/pZ)
	repraesentiert.
	getpgfs liest ein Polynom in r Variablen V1,...,Vr ueber GF(q)
	von stdin.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
		1)  Das Polynomende muss mit '#' markiert sein.
		2)  Es sind nur positive Exponenten zugelassen; diese
		    werden durch vorangestelltes '^' oder '**'
		    gekennzeichnet. Die Angabe des Exponenten 1
		    kann unterbleiben, ebenso die Angabe des
		    Exponenten 0; in letzterem Fall muss dann allerdings
		    auch die Angabe der entsprechenden Variablen unter-
		    bleiben.
		3)  Es sind beliebig grosse Koeffizienten zulaessig.
		    Das Vorzeichen des Koeffizienten kann durch Blanks
		    vom Koeffizienten getrennt werden. Die Angabe
		    des Koeffizienten 1 kann unterbleiben.
		    Koeffizient und zugehoerige Variablenliste
		    koennen durch beliebig viele Blanks oder durch
		    '*' und beliebig viele Blanks getrennt werden.
		    Diese Trennung ist nicht notwendig.
		4)  Variablennamen muessen in V aufgefuehrt sein
		    und duerfen nicht durch Sonderzeichen (wie z.B. CR)
		    getrennt werden. Einzelne Variablen mit ihren
		    Exponenten koennen durch beliebig viele Blanks
		    oder durch '*' und beliebig viele Blanks getrennt
		    werden. Diese Trennung ist nur dann notwendig,
		    wenn kein Exponent angegeben wurde.
		5)  Tritt in einem Monom eine Variable mehrfach auf, so
		    werden die verschiedenen Vorkommen geeignet
		    zusammengefasst.
		    Tritt ein Monom mehrfach auf, so werden die
		    verschiedenen Vorkommen geeignet zusammengefasst.
	getpgfs liefert den Ergebniswert
		P          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			getpi( r, V )                   (MACRO)

	"get polynomial over integers"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol getpi(r,V) single r; list V;
	P = getpi(r,V);
	r ist eine ganze Zahl mit 0<=r<BASIS.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	Variablennamen repraesentieren, und zwar in der Form
	  	Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	getpi liest ein Polynom in r Variablen V1,...,Vr ueber
	den ganzen Zahlen von stdin.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
		1)  Das Polynomende muss mit '#' markiert sein.
		2)  Es sind nur positive Exponenten zugelassen; diese
		    werden durch vorangestelltes '^' oder '**'
		    gekennzeichnet. Die Angabe des Exponenten 1
		    kann unterbleiben, ebenso die Angabe des
		    Exponenten 0; in letzterem Fall muss dann allerdings
		    auch die Angabe der entsprechenden Variablen unter-
		    bleiben.
		3)  Es sind beliebig grosse Koeffizienten zulaessig.
		    Das Vorzeichen des Koeffizienten kann durch Blanks
		    vom Koeffizienten getrennt werden. Die Angabe
		    des Koeffizienten 1 kann unterbleiben.
		    Koeffizient und zugehoerige Variablenliste
		    koennen durch beliebig viele Blanks oder durch
		    '*' und beliebig viele Blanks getrennt werden.
		    Diese Trennung ist nicht notwendig.
		4)  Variablennamen muessen in V aufgefuehrt sein
		    und duerfen nicht durch Sonderzeichen (wie z.B. CR)
		    getrennt werden. Einzelne Variablen mit ihren
		    Exponenten koennen durch beliebig viele Blanks
		    oder durch '*' und beliebig viele Blanks getrennt
		    werden. Diese Trennung ist nur dann notwendig,
		    wenn kein Exponent angegeben wurde.
		5)  Tritt in einem Monom eine Variable mehrfach auf, so
		    werden die verschiedenen Vorkommen geeignet
		    zusammengefasst.
		    Tritt ein Monom mehrfach auf, so werden die
		    verschiedenen Vorkommen geeignet zusammengefasst.
	getpi liefert den Ergebniswert
		P          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			getpmi( r, M, V )               (MACRO)

	"get polynomial over modular integers"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol getpmi(r,M,V)  single r; int M; list V;
	P = getpmi(r,M,V);
	M ist eine positive ganze Zahl.
	r ist groesser oder gleich 0.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	Variablennamen repraesentieren, und zwar in der Form
	  	Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	getpmi liest ein Polynom in r Variablen V1,...,Vr ueber
	Z / M*Z von stdin.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
		1)  Das Polynomende muss mit '#' markiert sein.
		2)  Es sind nur positive Exponenten zugelassen; diese
		    werden durch vorangestelltes '^' oder '**'
		    gekennzeichnet. Die Angabe des Exponenten 1
		    kann unterbleiben, ebenso die Angabe des
		    Exponenten 0; in letzterem Fall muss dann allerdings
		    auch die Angabe der entsprechenden Variablen unter-
		    bleiben.
		3)  Es sind beliebig grosse Koeffizienten zulaessig.
		    Das Vorzeichen des Koeffizienten kann durch Blanks
		    vom Koeffizienten getrennt werden. Die Angabe
		    des Koeffizienten 1 kann unterbleiben.
		    Koeffizient und zugehoerige Variablenliste
		    koennen durch beliebig viele Blanks oder durch
		    '*' und beliebig viele Blanks getrennt werden.
		    Diese Trennung ist nicht notwendig.
		4)  Variablennamen muessen in V aufgefuehrt sein
		    und duerfen nicht durch Sonderzeichen (wie z.B. CR)
		    getrennt werden. Einzelne Variablen mit ihren
		    Exponenten koennen durch beliebig viele Blanks
		    oder durch '*' und beliebig viele Blanks getrennt
		    werden. Diese Trennung ist nur dann notwendig,
		    wenn kein Exponent angegeben wurde.
		5)  Tritt in einem Monom eine Variable mehrfach auf, so
		    werden die verschiedenen Vorkommen geeignet
		    zusammengefasst.
		    Tritt ein Monom mehrfach auf, so werden die
		    verschiedenen Vorkommen geeignet zusammengefasst.
	getpmi liefert den Ergebniswert
		P          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			getpms( r, m, V )               (MACRO)

	"get polynomial over modular singles"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol getpms(r,m,V)  single r,m; list V;
	P = getpms(r,m,V);
	r und m sind ganze Zahlen mit 0<=r<BASIS und 0<m<BASIS.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	Variablennamen repraesentieren, und zwar in der Form
	  	Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	getpms liest ein Polynom in r Variablen V1,...,Vr ueber
	Z/mZ von stdin.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
		1)  Das Polynomende muss mit '#' markiert sein.
		2)  Es sind nur positive Exponenten zugelassen; diese
		    werden durch vorangestelltes '^' oder '**'
		    gekennzeichnet. Die Angabe des Exponenten 1
		    kann unterbleiben, ebenso die Angabe des
		    Exponenten 0; in letzterem Fall muss dann allerdings
		    auch die Angabe der entsprechenden Variablen unter-
		    bleiben.
		3)  Es sind beliebig grosse Koeffizienten zulaessig.
		    Das Vorzeichen des Koeffizienten kann durch Blanks
		    vom Koeffizienten getrennt werden. Die Angabe
		    des Koeffizienten 1 kann unterbleiben.
		    Koeffizient und zugehoerige Variablenliste
		    koennen durch beliebig viele Blanks oder durch
		    '*' und beliebig viele Blanks getrennt werden.
		    Diese Trennung ist nicht notwendig.
		4)  Variablennamen muessen in V aufgefuehrt sein
		    und duerfen nicht durch Sonderzeichen (wie z.B. CR)
		    getrennt werden. Einzelne Variablen mit ihren
		    Exponenten koennen durch beliebig viele Blanks
		    oder durch '*' und beliebig viele Blanks getrennt
		    werden. Diese Trennung ist nur dann notwendig,
		    wenn kein Exponent angegeben wurde.
		5)  Tritt in einem Monom eine Variable mehrfach auf, so
		    werden die verschiedenen Vorkommen geeignet
		    zusammengefasst.
		    Tritt ein Monom mehrfach auf, so werden die
		    verschiedenen Vorkommen geeignet zusammengefasst.
	getpms liefert den Ergebniswert
		P          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			getpnf( r, F, V, Vnf )          (MACRO)

	"get polynomial over number field"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol getpnf(r,F,V,Vnf)  single r; pol F; list V,Vnf;
	P = getpnf(r,F,V,Vnf);
	r ist eine ganze Zahl mit 0<=r<BASIS. F ist das zu einem
	Zahlkoerper K gehoerende irreduzible Polynom vom Grad n
	in einer Varablen in dense-Darstellung, das K erzeugt,
	d.h. K entsteht durch Adjunktion einer Nullstelle von F.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	Analog ist Vnf eine einelementige Variablenliste, die den
	Namen einer Nullstelle von F repraesentiert.
	getpnf liest ein Polynom in r Variablen V1,...,Vr ueber
	einem Zahlkoerper K von stdin. Dabei sind die Elemente
	des Zahlkoerpers dargestellt als Polynome in der durch Vnf 
	gegebenen Variable ueber den rationalen Zahlen. Diese Poly-  
	nome werden modulo F reduziert und anschliessend in die Form 
	eines Elements des von F erzeugten Zahlkoerpers gebracht.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
		1)  Das Polynomende muss mit '#' markiert sein.
		2)  Es sind nur positive Exponenten zugelassen; diese
		    werden durch vorangestelltes '^' oder '**'
		    gekennzeichnet. Die Angabe des Exponenten 1
		    kann unterbleiben, ebenso die Angabe des
		    Exponenten 0; in letzterem Fall muss dann allerdings
		    auch die Angabe der entsprechenden Variablen unter-
		    bleiben.
		3)  Es sind beliebig grosse Koeffizienten zulaessig.
		    Das Vorzeichen des Koeffizienten kann durch Blanks
		    vom Koeffizienten getrennt werden. Die Angabe
		    des Koeffizienten 1 kann unterbleiben.
		    Koeffizient und zugehoerige Variablenliste
		    koennen durch beliebig viele Blanks oder durch
		    '*' und beliebig viele Blanks getrennt werden.
		    Diese Trennung ist nicht notwendig.
		4)  Variablennamen muessen in V aufgefuehrt sein
		    und duerfen nicht durch Sonderzeichen (wie z.B. CR)
		    getrennt werden. Einzelne Variablen mit ihren
		    Exponenten koennen durch beliebig viele Blanks
		    oder durch '*' und beliebig viele Blanks getrennt
		    werden. Diese Trennung ist nur dann notwendig,
		    wenn kein Exponent angegeben wurde.
		5)  Tritt in einem Monom eine Variable mehrfach auf, so
		    werden die verschiedenen Vorkommen geeignet
		    zusammengefasst.
		    Tritt ein Monom mehrfach auf, so werden die
		    verschiedenen Vorkommen geeignet zusammengefasst.
	getpnf liefert den Ergebniswert
		P          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			getppf( r, p, V )

	"get polynomial over p-adic field"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol getppf( r, p, V )  single p,r; list V;
	P = getppf( r, p, V );
	Dabei muss gelten:
	      - r ist eine ganze Zahl mit 0 <= r < BASIS.
	      - p ist prim.
	Ist r gleich 0, muss V die leere Liste sein; ansonsten ist V
	eine Liste der Form
		V = ( V1, ..., Vr ),
	deren Elemente Vi Variablennamen repraesentieren; also hat Vi
	die Form
		Vi = ( ascii( Bu ), ascii( BZ2 ), ..., ascii( BZn ) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen
	Zeichen Bu,BZ2,...,BZn besteht. Ein Variablenname muss stets mit
	einem Buchstaben beginnen. Die Liste Vr repraesentiert den Namen
	der Hauptvariablen.
	getppf liest ein Polynom in r Variablen V1, ..., Vr ueber den
	p-adischen Zahlen von stdin ein. Fuer die Eingabe sind folgende 
	Richtlinien zu beachten:
	     1) Das Polynomende und das Ende der Koeffizienten muessen
		mit '#' markiert sein.
	     2) Die Koeffizienten muessen in Klammern '(' und ')' einge-
		schlossen werden.
	     3) Es sind nur positive Exponenten (bei den Variablen)
		zugelassen; diese werden durch vorangestelltes '^' oder
		'**' gekennzeichnet. Die Angabe des Exponenten 1 bzw. 0
		kann unterbleiben; allerdings muss im Falle 0 auch die
		Angabe der entsprechenden Variablen unterbleiben.
	     4) Es sind beliebig grosse p-adische Koeffizienten zulaes-
		sig, deren Eingabe den Konventionen von getpfel
		genuegen muss. Ihr Vorzeichen kann durch Blanks vom Ko-
		effizienten getrennt werden. Auf die Angabe des Koeffi-
		zienten 1 kann verzichtet werden.
		Koeffizient und zugehoerige Variablenliste koennen durch
		beliebig viele Blanks oder durch '*' und beliebig viele
		Blanks getrennt werden. Dabei ist diese Trennung nicht
		notwendig.
	     5) Variablennamen muessen in V aufgefuehrt sein und duerfen
		nicht durch Sonderzeichen (wie z.B CR) getrennt werden.
		Einzelne Variablen mit ihren Exponenten koennen durch
		beliebig viele Blanks oder durch '*' und beliebig viele
		Blanks getrennt werden. Diese Trennung ist nur dann not-
		wendig, wenn die Angabe des Exponenten unterbleibt.
	     6) Tritt in einem Monom eine Variable mehrfach auf, werden
		die verschiedenen Vorkommen gegeignet zusammengefasst.
		Tritt ein Monom mehrfach auf, werden die verschiedenen
		Vorkommen gegeignet zusammengefasst.
	getppf ist insbesondere in der Lage, von putppf geschriebene Po-
	lynome einzulesen.
	getppf liefert den Ergebniswert
		P       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			getpr( r, V )                   (MACRO)

	"get polynomial over rationals"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol getpr(r,V)  single r; list V;
	P = getpr(r,V);
	r ist eine ganze Zahl mit 0<=r<BASIS.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	Variablennamen repraesentieren, und zwar in der Form
	  	Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen 
	Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	getpr liest ein Polynom in r Variablen V1,...,Vr ueber
	den rationalen Zahlen von stdin.
	Fuer die Eingabe von Polynomen gelten folgende Richtlinien:
		1)  Das Polynomende muss mit '#' markiert sein.
		2)  Es sind nur positive Exponenten zugelassen; diese
		    werden durch vorangestelltes '^' oder '**'
		    gekennzeichnet. Die Angabe des Exponenten 1
		    kann unterbleiben, ebenso die Angabe des
		    Exponenten 0; in letzterem Fall muss dann allerdings
		    auch die Angabe der entsprechenden Variablen unter-
		    bleiben.
		3)  Es sind beliebig grosse Koeffizienten zulaessig.
		    Das Vorzeichen des Koeffizienten kann durch Blanks
		    vom Koeffizienten getrennt werden. Die Angabe
		    des Koeffizienten 1 kann unterbleiben.
		    Koeffizient und zugehoerige Variablenliste
		    koennen durch beliebig viele Blanks oder durch
		    '*' und beliebig viele Blanks getrennt werden.
		    Diese Trennung ist nicht notwendig.
		4)  Variablennamen muessen in V aufgefuehrt sein
		    und duerfen nicht durch Sonderzeichen (wie z.B. CR)
		    getrennt werden. Einzelne Variablen mit ihren
		    Exponenten koennen durch beliebig viele Blanks
		    oder durch '*' und beliebig viele Blanks getrennt
		    werden. Diese Trennung ist nur dann notwendig,
		    wenn kein Exponent angegeben wurde.
		5)  Tritt in einem Monom eine Variable mehrfach auf, so
		    werden die verschiedenen Vorkommen geeignet
		    zusammengefasst.
		    Tritt ein Monom mehrfach auf, so werden die
		    verschiedenen Vorkommen geeignet zusammengefasst.
	getpr liefert den Ergebniswert
		P          falls der Programmablauf fehlerfrei war;
		ERROR      falls Fehler auftraten.



			getvl(  )                       (MACRO)

	"get variable list"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list getvl();
	V = getvl();
	getvl liest von stdin eine Liste von Variablennamen, deren
	Ende mit '#' markiert sein muss.
	Die Variablennamen muessen durch Blank, ',' oder ';' getrennt
	sein. Die einzelnen Variablennamen duerfen nur aus alpha-
	numerischen Zeichen bestehen und duerfen keine Sonderzeichen
	wie z.B. LF oder CR enthalten. Das erste Zeichen eines
	Variablennamens muss immer ein Buchstabe sein.
	getvl liefert als Ergebnis
		V         (= Liste der Variablennamen), falls getvl
			  fehlerfrei ablief;
		ERROR     falls Fehler auftraten.



			iafmsp1mpmpp( p, F, a, P, e, Q )

	"integral algebraic function over modular single primes,
	transcendence degree 1, minimal polynomial modulo power
	of an univariate prime polynomial over modular single primes"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol iafmsp1mpmpp(p,F,a,P,e,Q)  single p, e; pol F, a, P, Q;
	M = iafmsp1mpmpp(p,F,a,P,e,Q);
	Sei x eine Unbestimmte ueber (Z/pZ), wobei p eine single
	Primzahl ist.
	F ist das definierende Polynom einer separablen Algebra ueber
	(Z/pZ) (x) - dem rationalen Funktionenkoerper ueber (Z/pZ) -
	d.h. F ist ein normiertes, separables Polynom in einer
	Unbestimmten ueber dem Polynomring (Z/pZ) [x].
	a ist ein ganzes Element dieser Algebra und wird durch ein CD -
        Polynom repraesentiert ( siehe cdprfmsp1fcl ).
	P ist ein normiertes irreduzibles Polynom aus (Z/pZ) [x], fuer
	das eine Potenz	existiert, deren Produkt mit a in der
	Polynomordnung von F liegt.
	e ist eine positive single.
	Q ist eine Potenz von P, deren Produkt mit einem beliebigen
	Element der P-maximalen Ueberordnung der Polynomordnung von F
	in der Polynomordnung liegt.
	M ist modulo (P^e) kongruent zum Minimalpolynom von a ueber 
	(Z/pZ) [x]; M ist also ein normiertes Polynom in einer
	Unbestimmten ueber (Z/pZ [x]) / ( (P^e) * (Z/pZ [x]) ).



			iafmsp1mpol( p, F, a, Q )

	"integral algebraic function over modular single primes,
	transcendence degree 1, minimal polynomial"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol iafmsp1mpol(p,F,a,Q)  single p; pol F, a, Q;
	M = iafmsp1mpol(p,F,a,Q);
	Sei x eine Unbestimmte ueber (Z/pZ), wobei p eine single
	Primzahl ist.
	F ist das definierende Polynom einer separablen Algebra ueber
	(Z/pZ) (x) - dem rationalen Funktionenkoerper ueber (Z/pZ) -
	d.h. F ist ein normiertes, separables Polynom in einer
	Unbestimmten ueber dem Polynomring (Z/pZ) [x].
	a ist ein ganzes Element dieser Algebra und wird durch ein CD -
        Polynom repraesentiert ( siehe cdprfmsp1fcl ).
        Q ist ein normiertes Polynom aus (Z/pZ) [x].
	Q ist Potenz eines irreduziblen Polynoms P aus (Z/pZ) [x].
	Fuer dieses P existiert eine Potenz, deren Produkt mit a in der
	Polynomordnung von F liegt.
	Das Produkt von Q mit einem beliebigen Element der P-maximalen
	Ueberordnung der Polynomordnung von F liegt in der Polynomordnung.
	M ist das Minimalpolynom von a ueber (Z/pZ) [x]; M ist also ein
	normiertes Polynom in einer Unbestimmten ueber (Z/pZ) [x].



			infeminpmpp( F, a, p, e, Q )

	"integral number field element minimal polynomial modulo p-power"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol infeminpmpp(F,a,p,e,Q)  pol F,a; single p,e; int Q;
	M = infeminpmpp(F,a,p,e,Q);
	F ist das definierende Polynom einer separablen Algebra ueber den
        rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
        in einer Veraenderlichen ueber den ganzen Zahlen.     
	p ist eine single Primzahl und e eine positive single.
	a ist ein ganzes Element dieser Algebra, fuer das eine Potenz von 
        p existiert, deren Produkt mit a in der Polynomordnung von F liegt.
        a wird durch ein CD - Polynom repraesentiert ( siehe cdprfcl ).
	Q ist eine p - Potenz; das Produkt von Q und einem beliebigen
	Element einer p - maximalen Ueberordnung der Polynomordnung von F
	liegt in der Polynomordnung.
	( Siehe dazu Diplomarbeit R.Boeffgen p. 59, p. 72. und p. 134-136 )
	M ist modulo (p^e) kongruent zum Minimalpolynom von a ueber den
	ganzen Zahlen; M ist ein normiertes Polynom in einer Veraender -
        lichen ueber Z / (p^e) * Z.



			infempmppip( F, a, p, e, Q )

	"integral number field element minimal polynomial modulo p-power
	with respect to integer primes"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol infempmppip(F,a,p,e,Q)  pol F,a; int p; single e; int Q;
	M = infempmppip(F,a,p,e,Q);
	F ist das definierende Polynom einer separablen Algebra ueber den
        rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
        in einer Veraenderlichen ueber den ganzen Zahlen.     
	p ist eine Primzahl und e eine positive single.
	a ist ein ganzes Element dieser Algebra, fuer das eine Potenz von 
        p existiert, deren Produkt mit a in der Polynomordnung von F liegt.
        a wird durch ein CD - Polynom repraesentiert ( siehe cdprfcl ).
	Q ist eine p - Potenz; das Produkt von Q und einem beliebigen
	Element einer p - maximalen Ueberordnung der Polynomordnung von F
	liegt in der Polynomordnung.
	( Siehe dazu Diplomarbeit R.Boeffgen p. 59, p. 72. und p. 134-136 )
	M ist modulo (p^e) kongruent zum Minimalpolynom von a ueber den
	ganzen Zahlen; M ist ein normiertes Polynom in einer Veraender -
        lichen ueber Z / (p^e) * Z.



			isdipione( r, P )

        "is distributive polynomial over integers one ?"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single isdipione(r,P)  single r; pol P;
        t = isdipione(r,P);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Z.
        t = 1, falls P = 1;
        t = 0, sonst.



			isdipol( r, P )

        "is distributive polynomial ?"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single isdipol(r,P)  obj r, P;
        a = isdipol(r,P);
        r und P sind Objekte.
        a =  1,  falls P als Polynom in r (0<=r<BASIS) Variablen
                 in distributiver Darstellung interpretiert werden
                 kann;
             0,  sonst.



			isdippione( r1, r2, P )

        "is distributive polynomial over polynomials over integers one ?"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single isdippione(r1,r2,P)  single r1,r2; pol P;
        t = isdippione(r1,r2,P);
        P ist ein distributives Polynom in r1 (0 <= r1 < BASIS) Variablen 
	ueber einem Polynomring ueber Z in r2 (0 <= r2 < BASIS) Variablen.
        t = 1, falls P = 1;
        t = 0, sonst.



			isdiprfrone( r1, r2, P )

        "is distributive polynomial over rational functions over the
         rationals one ?"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        single isdiprfrone(r1,r2,P)  single r1,r2; pol P;
        t = isdiprfrone(r1,r2,P);
        P ist ein distributives Polynom in r1 (0 <= r1 < BASIS) Variablen 
	ueber rationalen Funktionen in r2 (0 <= r2 < BASIS) Variablen ueber 
	Q.
        t = 1, falls P = 1;
        t = 0, sonst.



			isdiprone( r, P )

        "is distributive polynomial over rationals one ?"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single isdiprone(r,P)  single r; pol P;
        t = isdiprone(r,P);
        P ist ein distributives Polynom in r (0 <= r < BASIS) Variablen 
	ueber Q.
        t = 1, falls P = 1;
        t = 0, sonst.



			isdpi( r, P )

	"is dense polynomial over integers?" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single isdpi(r,P)  obj r, P;
	a = isdpi(r,P);
	r und P sind Objekte.
	a = 1,  falls P als Polynom in dense-Darstellung in r Variablen
		(0<=r<BASIS) ueber Z interpretiert werden kann;
	    0,  sonst.



			isdpmi( r, m, P )

	"is dense polynomial over modular integers ?" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single isdpmi(r,m,P)  obj r,m,P;
	a = isdpmi(r,m,P);
	r, m und P sind Objekte.
	a = 1,  falls P als Polynom in dense-Darstellung in r
		Variablen ueber Z/mZ interpretiert werden kann,
		wobei m eine positive ganze Zahl und r eine
		nicht negative single ist.
	    0,  sonst.



			isdpms( r, m, P )

	"is dense polynomial over modular singles ?" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single isdpms(r,m,P) obj r,m,P;
	a = isdpms(r,m,P);
	r, m und P sind Objekte.
	a = 1,  falls P als Polynom in dense-Darstellung in r
		Variablen ueber Z/mZ (0<m<BASIS) interpretiert
		werden kann;
	    0,  sonst.



			isdpol( r, P )

	"is dense polynomial ?" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single isdpol(r,P) obj r,P;
	a = isdpol(r,P);
	r und P sind Objekte.
	a = 1,  falls P als Polynom in dense-Darstellung in r
		Variablen interpretiert werden kann;
	    0,  sonst.



			isdppf( r, p, P )

	"is dense polynomial over p-adic field ?" ( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	single isdppf( r, p, P)  single p; obj r, P;
	s = isdppf( r, p, P );
	Dabei muss gelten:
	      - p ist Primzahl.
	s = 1,  falls P als Polynom in dense-Darstellung in r Variablen
		( < BASIS ) ueber dem p-adischen Zahlkoerper Qp inter-
		pretiert werden kann;
	    0,  sonst.



			isdpr( r, P )

	"is dense polynomial over rationals?" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single isdpr(r,P)  obj r, P;
	a = isdpr(r,P);
	r und P sind Objekte.
	a = 1,  falls P als Polynom in dense-Darstellung in r Variablen
		(0<=r<BASIS) ueber Q interpretiert werden kann;
	    0,  sonst.



			isimupmi( p, A )

	"is irreducible, monic, univariate polynomial over modular
	integers ?"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single isimupmi(p,A)  int p; obj A;
	s = isimupmi(p,A);
	p ist eine Primzahl.
	s = 1,  falls A ein normiertes irreduzibles Polynom in einer
		Veraenderlichen ueber Z/pZ ist,
	    0,  sonst ( insbesondere auch im Fall A = 0 ).



			isimupms( p, A )

	"is irreducible, monic, univariate polynomial over modular
	 singles ?"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single isimupms(p,A)  single p; pol A;
	s = isimupms(p,A);
	Es muss gelten : p ist Primzahl.
		A ist normiertes Polynom vom Grad >= 1 in einer Variable
		ueber Z/pZ.
	s = 1, falls A irreduzibel ist,
	    0, sonst.



			isiupi( P )

	"is irreducible univariate polynomial over integers ?"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single isiupi(P)  pol P;
	s = isiupi(P);
	Es muss gelten : P ist ein Polynom in einer Variable ueber den
		ganzen Zahlen.
	s = 1, falls P irreduzibel ist,
	s = 0, falls P reduzibel oder 0 ist.
	Falls isiupi fehlerhaft verlaeuft, ist s = ERROR.



			isiupr( P )

	"is irreducible univariate polynomial over rationals ?"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single isiupr(P)  pol P;
	s = isiupr(P);
	Es muss gelten : P ist ein Polynom in einer Variable ueber den
		rationalen Zahlen.
	s = 1, falls P irreduzibel ist,
	s = 0, falls P reduzibel oder 0 ist.
	Falls isiupr fehlerhaft verlaeuft, ist s = ERROR.



			isiuspi( P )

	"is irreducible univariate squarefree polynomial over integers ?"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single isiuspi(P)  pol P;
	s = isiuspi(P);
	Es muss gelten : P ist ein primitives quadratfreies Polynom in
			 einer Variable ueber den ganzen Zahlen.
	s = 1, falls P irreduzibel ist,
	s = 0, falls P reduzibel oder 0 ist.
	Falls isiuspi fehlerhaft verlaeuft, ist s = ERROR.



			ispconst( r, P, pC )

	"is polynomial constant ?"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single ispconst(r,P,pC) single r; pol P; obj *pC;
	n = ispconst(r,P,pC);
	P ist ein Polynom in r (0<=r<BASIS) Variablen.
	Ist P ein konstantes Polynom, so ist n gleich 1 und in
	*pC wird die Konstante abgelegt; sonst ist n gleich 0
	und in *pC wird 0 abgelegt.



			ispgfs( r, p, AL, P )

	"is polynomial over Galois-field with single characteristic ?"
	(rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	single ispgfs(r,p,AL,P)  obj r, p, AL, P;
	a = ispgfs(r,p,AL,P);
	r, p, AL und P sind Objekte.
	a = 1,  falls p eine Primzahl < BASIS ist, AL = (G,AL1) als
		Arithmetikliste fuer GF(p^n) interpretiert werden kann
		(siehe gfsalgen), n = llength(AL1) + 1 gilt, und
		falls P als Polynom in r (0<=r<BASIS) Variablen ueber
		GF(p^n) interpretiert werden kann.
	    0,  sonst.



			ispi( r, P )

	"is polynomial over integers ?" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single ispi(r,P) obj r, P;
	a = ispi(r,P);
	r und P sind Objekte.
	a =  1,  falls P als Polynom in r (0<=r<BASIS) Variablen ueber
		 den ganzen Zahlen interpretiert werden kann;
	     0,  sonst.



			ispione( r, P )

	"is polynomial over integers equal one ?"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single ispione(r,P) single r; pol P;
	n = ispione(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	n =  1  falls P gleich 1 ist;
	     0  sonst.



			ispmi( r, m, P )

	"is polynomial over modular integer ?" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single ispmi(r,m,P) obj r,m,P;
	a = ispmi(r,m,P);
	r, m und P sind Objekte.
	a =  1,  falls P als Polynom in r (0<=r<BASIS) Variablen ueber
		 Z/mZ  ( 0 < m )  interpretiert werden kann;
	     0,  sonst.



			ispmiunit( r, m, P )

	"is polynomial over modular integers unit?"                          
        Quellbibliothek: srclib.pol1                                        
	Include-Datei:   _pol1.h                                            
	single ispmiunit(r,m,P)  single r; int m; pol P;                         
	n = ispmiunit(r,m,P);                                               
	m ist eine positive ganze Zahl.
	P ist ein Polynom in r (0<r<BASIS) Variablen ueber Z/mZ.
        n ist 1, falls P Einheit im Polynomring in r Variablen ueber Z/mZ   
	ist, und 0, sonst.



			ispmonom( r, P )

	"is polynomial monomial ?"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single ispmonom(r,P) single r; pol P;
	a = ispmonom(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen.
	ispmonom liefert der Wert 1, wenn P ein Monom ist, sonst 0.



			ispms( r, m, P )

	"is polynomial over modular singles ?" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single ispms(r,m,P) obj r,m,P;
	a = ispms(r,m,P);
	r, m und P sind Objekte.
	a =  1,  falls P als Polynom in r (0<=r<BASIS) Variablen ueber
		 Z/mZ (0<m<BASIS) interpretiert werden kann;
	     0,  sonst.



			ispmsunit( r, m, P )

	"is polynomial over modular singles unit?"                          
        Quellbibliothek: srclib.pol1                                        
	Include-Datei:   _pol1.h                                            
	single ispmsunit(r,m,P)  single r,m; pol P;                         
	n = ispmsunit(r,m,P);                                               
	m ist positiv.
	P ist ein Polynom in r (0<r<BASIS) Variablen ueber Z/mZ.
        n ist 1, falls P Einheit im Polynomring in r Variablen ueber Z/mZ   
        ist, und 0, sonst.                                                  



			ispol( r, P )

	"is polynomial ?" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single ispol(r,P) obj r, P;
	a = ispol(r,P);
	r und P sind Objekte.
	a =  1,  falls P als Polynom in r (0<=r<BASIS) Variablen
		 interpretiert werden kann;
	     0,  sonst.



			ispr( r, P )

	"is polynomial over rationals ?" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single ispr(r,P) obj r, P;
	a = ispr(r,P);
	r und P sind Objekte.
	a =  1,  falls P als Polynom in r (0<=r<BASIS) Variablen ueber
		 den rationalen Zahlen interpretiert werden kann;
	     0,  sonst.



			isuspi( P )

	" is univariate squarefree polynomial over integers "
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single isuspi(P)  pol P;
	s = isuspi(P);
	Es muss gelten : P ist ein primitives Polynom in einer Variablen
			 ueber den ganzen Zahlen.
	s = 1, falls P quadratfrei ist,
	s = 0, falls P nicht quadratfrei oder Null ist.
	Falls isuspi fehlerhaft verlaeuft, ist s = ERROR.



			isvarl( r, V )

	"is variable list ?"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single isvarl(r,V) obj r, V;
	a = isvarl(r,V);
	r und V sind Objekte.
	a =  Maximum der Laengen der Variablennamen, falls V als
		 Liste von r (1<=r<BASIS) Variablennamen
		 interpretiert werden kann;
	     1,  falls r gleich 0 und V die leere Liste ist;
	     0,  sonst.



			itopi( r, A )                   (MACRO)

	"integer to polynomial over integer"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol itopi(r, A)  single r; int A;
	p = itopi (r, A);    
	p = A, dabei ist p ein Polynom in r Variablen.



			lpbsorts( r, L )

        "list of polynomials bubble sort, special"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        list lpbsorts(r, L)  single r; list L;
        L1 = lpbsorts(r, L);
        L ist eine Liste der Form ( c, P1, e1, ..., PN, eN ), wobei Pi, 
	1 <= i <= N, Polynome in r Variablen sind, ei die zugehoerigen 
        Exponenten und c eine Zahl.
        L1 ist eine Liste der gleichen Form, geordnet nach dem
	Grad der Polynome bzgl. der Hauptvariablen.
        L wird veraendert.



			nfespecmpc1( F, a )

	"number field element special minimal polynomial, Collins
	algorithm, version1"
	Quellbibliothek : srclib.pol2
	Include - Datei : _pol2.h
	pol nfespecmpc1(F,a) pol F,a;
	M = nfespecmpc1(F,a);
	F ist das definierende Polynom einer separablen Algebra ueber den
	rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
	in einer Veraenderlichen ueber den ganzen Zahlen.
	a ist ein Element dieser Algebra und wird durch ein CD - Polynom
	repraesentiert (siehe cdprfcl ).
	M ist das Minimalpoynom von a ueber den ganzen Zahlen.
	Angewandt wird eine Berechnungsmethode von Collins.
	( Siehe Diplomarbeit R.Boeffgen p. 19-20. )



			nfespecmpc2( F, a )

	"number field element special minimal polynomial, Collins
	algorithm, version2"
	Quellbibliothek : srclib.pol2
	Include - Datei : _pol2.h
	pol nfespecmpc2(F,a) pol F,a;
	M = nfespecmpc2(F,a);
	F ist das definierende Polynom einer separablen Algebra ueber den
	rationalen Zahlen, d.h. F ist ein normiertes, separables Polynom
	in einer Veraenderlichen ueber den ganzen Zahlen.
	a ist ein Element dieser Algebra und wird durch ein CD - Polynom
	repraesentiert (siehe cdprfcl ).
	M ist das Minimalpoynom von a ueber den ganzen Zahlen, falls der 
	Aufruf von pirescspec die Resultante liefert, 
	M = 0 sonst ( siehe pirescspec ).
	Angewandt wird eine Berechnungsmethode von Collins.
	( Siehe Diplomarbeit R.Boeffgen p. 19-20. )



			pdegree( r, P )                 (MACRO)

	"polynomial degree, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single pdegree(r,P)  single r; pol P;
	a = pdegree(r,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen, und zwar
	entweder in sparse- oder in dense-Darstellung.
	a ist der Grad von P bezueglich der Hauptvariablen, falls
	P ungleich 0 ist, 0 sonst.



			pdegreesv( r, P, n )

	"polynomial degree, specified variable" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single pdegreesv (r,P,n) single r; pol P; single n;
	a = pdegree(r,P,n);
	P ist ein Polynom in r (1<=r<BASIS) Variablen.
	a ist der Grad von P bezueglich der n-ten Variablen, falls
	P ungleich 0 ist, 0 sonst.



			pdegvec( r, P )

	"polynomial degree vector" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list pdegvec(r,P) single r; pol P;
	L = pdegvec(r,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen X1,...,Xr,
	wobei Xr die Hauptvariable bezeichnet.
	L ist eine Liste (gr,...,g1), mit gn ist der Grad von P in Xn,
	falls P ungleich 0 ist, gn = 0 sonst.



			pflsum( r, P1, P2 )

	"polynomial over floating points sum" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pflsum(r,P1,P2)  single r; pol P1,P2;
	P3 = pflsum(r,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	floating points.
	P3 = P1 + P2.



			pgf2deriv( r, G, P )

	"polynomial over Galois-field with characteristic 2
	derivation, main variable"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgf2deriv( r, G ,P )  single r; obj G; pol P;
	P1 = pgf2deriv( r, G ,P );
        Dabei muss gelten:
	- P ist ein Polynom in r (1<=r<BASIS) Variablen ueber GF(2^n)
          in der speziellen Bit-Darstellung.
        - G ist ein irreduzibles normiertes Polynom in einer Variablen
          ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
          (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        Dann ist
	P1 = P' (bzgl. der Hauptvariablen) in der speziellen Bit-
        Darstellung.



			pgf2derivsv( r, G, P, i )

	"polynomial over Galois-field with characteristic 2 derivation,
        specified variable" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgf2derivsv( r, G, P, i )  single r; obj G; pol P; single i;
	P1 = pgf2derivsv( r, G, P, i );
        Dabei muss gelten:
	- P ist ein Polynom in r (1 <= r < BASIS) Variablen ueber GF(2^n)
          in der speziellen Bit-Darstellung.
        - G ist ein irreduzibles normiertes Polynom in einer Variablen
          ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
          (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
	- 1 <= i <= r.
        Dann ist
	P1 = P' (bzgl. der i-ten Variablen) in der speziellen Bit-
        Darstellung.



			pgf2dif( r, G, P1, P2 )         (MACRO)

	"polynomial over Galois-field with characteristic 2 difference"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgf2dif(r, G, P1, P2)  single r; obj G; pol P1,P2;
	P3 = pgf2dif(r, G, P1, P2);
        r ist eine nicht negative single.
	G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        P1 und P2 sind Polynome in r Veraenderlichen ueber GF(2^n) mit 
	Koeffizienten in spezieller Bit-Darstellung.
	P3 = P1 - P2.



			pgf2efe( r, GmtoGn, P )

	"polynomial over Galois-field with characteristic 2 
	 embedding in field extension" (rekursiv)
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol pgf2efe(r,GmtoGn,P)  single r; list GmtoGn; pol P;
	Q = pgf2efe( r,GmtoGn,P );
	r>=0 ist die Anzahl der Variablen von P.
	Die Liste GmtoGn "beschreibt" die Einbettung eines endlichen 
	Koerpers der Charakteristik 2 mit 2^m Elementen in einen 
	Erweiterungskoerper mit 2^n (m|n) Elementen. GmtoGn wird
	mit Hilfe des Programmes gf2ies erzeugt.
        (GmtoGn = ( Gn, re )  obj Gn; gf2el re; ist eine 2-elementige 
	Liste, deren erster Eintrag Gn ein irreduzibles Polynom in 
	einer Veraenderlichen in spezieller Bit-Darstellung ist, das
	den Erweiterungskoerper erzeugt, und deren zweiter Eintrag die
	Einbettung einer Nullstelle des den Grundkoerper definierenden
	irreduziblen Polynoms in den Erweiterungskoerper ist.)
	pgf2efe liefert die Einbettung Q eines Polynoms P ueber dem 
	Grundkoerper GF(2^m) in den Erweiterungskoerper GF(2^n).	



			pgf2eval( r, G, P, a )

	"polynomial over Galois-field with characteristic 2 evaluation, 
	 main variable"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgf2eval(r,G,P,a)  single r; obj G; pol P; gf2el a;
	P1 = pgf2eval(r,G,P,a);
	G ist ein irreduzibles, normiertes Polynom in einer Variablen 
	ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
	(vgl. udpm2tosb). G kann als ein erzeugendes Polynom fuer 
	GF(2^n) interpretiert werden.
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber GF(2^n).
	a ist ein Element aus GF(2^n).
	P1 = P(a) (Auswertung erfolgt bzgl. der Hauptvariablen).



			pgf2exp( r, G, P, n )

        "polynomial over Galois-field with characteristic 2 exponentiation"
	Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol pgf2exp(r, G, P, n)  single r; obj G; pol P; single n;
        P2 = pgf2exp(r, G, P, n);
        r ist eine nicht negative single.
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        P ist ein Polynom in r Veraenderlichen ueber GF(2^n) mit
	Koeffizienten in spezieller Bit-Darstellung.
	n ist eine positive single.
        P2 = P^n.



			pgf2expprem( r, G, F, E, M )

	"polynomial over Galois-field with characteristic 2,
	 exponentiation, polynomial remainder"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgf2expprem( r, G, F, E, M )  single r; obj G; pol F,M; int E;
	P1 = pgf2expprem( r, G, F, E, M );
        Dabei muss gelten:
        - r ist eine nicht negative single.
        - G ist ein irreduzibles normiertes Polynom in einer Variablen
          ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
          (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        - E ist nicht-negativ.
        - F, M sind Polynome in r Variablen ueber GF(2^n) in der speziellen
          Bit-Darstellung, und M ist ungleich dem Nullpolynom.
	P1 = F^E mod M.



			pgf2gf2prod( r, G, P, a )

	"polynomial over Galois-field with characteristic 2,
	Galois-field with characteristic 2 element product" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgf2gf2prod(r, G, P, a)  single r; obj G; pol P; gf2el a;
	P1 = pgf2gf2prod(r, G, P, a);
	r ist eine nicht negative single.
	G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        P ist ein Polynom in r Veraenderlichen ueber GF(2^n) mit 
	Koeffizienten in spezieller Bit-Darstellung.
	a ist ein Element aus GF(2^n), das als Polynom in einer
	Variablen ueber Z/2Z vom Grad < n in spezieller Bit-Notation
	dargestellt wird.
 	P1 = a * P.



			pgf2monic( r, G, P )

        "polynomial over Galois-field with characteristic 2 monic"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol pgf2monic(r, G, P)  single r; obj G; pol P;
        P1 = pgf2monic(r, G, P);
        r ist eine nicht negative single.
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        P ist ein Polynom in r Veraenderlichen ueber GF(2^n) mit
	Koeffizienten in spezieller Bit-Darstellung.
        P1 ist das zu P assoziierte normierte Polynom.



			pgf2neg( r, G, P )              (MACRO)

	"polynomial over Galois-field with characteristic 2 negation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgf2neg(r, G, P)  single r; obj G; pol P;
	P1 = pgf2neg(r, G, P);
        r ist eine nicht negative single.
	G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        P ist ein Polynom in r Veraenderlichen ueber GF(2^n) mit 
	Koeffizienten in spezieller Bit-Darstellung.
	P1 = -P.



			pgf2prod( r, G, P1, P2 )

        "polynomial over Galois-field with characteristic 2 product"
        (rekursiv)
	Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol pgf2prod(r, G, P1, P2)  single r; obj G; pol P1,P2;
        P3 = pgf2prod(r, G, P1, P2);
        r ist eine nicht negative single.
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        P1 und P2 sind Polynome in r Veraenderlichen ueber GF(2^n) mit
	Koeffizienten in spezieller Bit-Darstellung.
        P3 = P1 * P2.



			pgf2qrem( r, G, P1, P2, pR )

	"polynomial over Galois-field with characteristic 2 quotient
	and remainder" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgf2qrem(r, G, P1, P2, pR)  single r; obj G; pol P1, P2; pol *pR;
	P3 = pgf2qrem(r, G, P1, P2, pR);
	r ist eine nicht negative single.
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        P1 und P2 sind Polynome in r Veraenderlichen ueber GF(2^n) mit 
	Koeffizienten in spezieller Bit-Darstellung.
	P2 ist ungleich 0.
	*pR = P1 % P2.
	P3  = P1 / P2.



			pgf2quot( r, G, P1, P2 )        (MACRO)

	"polynomial over Galois-field with characteristic 2 quotient"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgf2quot( r, G, P1, P2 )  single r; obj G; pol P1,P2;
	P3 = pgf2quot( r, G, P1, P2 );
        r ist eine nicht negative single.
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
	P1 und P2 sind Polynome in r Variablen ueber GF(2^n) in der
        speziellen Bit-Darstellung.  P2 ist ungleich 0.
	P3 = P1 / P2 ist Polynom in der speziellen Bit-Darstellung.



			pgf2rem( r, G, P1, P2 )         (MACRO)

	"polynomial over Galois-field with characteristic 2 remainder"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgf2rem( r, G, P1, P2 )  single r; obj G; pol P1, P2;
	P3 = pgf2rem( r, G, P1, P2 );
        Dabei muss gelten:
        - G ist ein irreduzibles normiertes Polynom in einer Variablen
          ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
          (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
	- P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
          GF(2^n) in der speziellen Bit-Darstellung.
	- P2 ist ungleich 0.
        Dann ist
	P3 = P1 % P2 ein Polynom in der speziellen Bit-Darstellung.



			pgf2square( r, G, P )

        "polynomial over Galois-field with characteristic 2 square"
        (rekursiv)
	Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol pgf2square(r, G, P)  single r; obj G; pol P;
        P2 = pgf2square(r, G, P);
        r ist eine nicht negative single.
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        P ist ein Polynom in r Veraenderlichen ueber GF(2^n) mit 
	Koeffizienten in spezieller Bit-Darstellung.
        P2 = P^2.



			pgf2sum( r, G, P1, P2 )

        "polynomial over Galois-field with characteristic 2 sum"
        (rekursiv)
	Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol pgf2sum(r, G, P1, P2)  single r; obj G; pol P1,P2;
        P3 = pgf2sum(r, G, P1, P2);
        r ist eine nicht negative single.
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        P1 und P2 sind Polynome in r Veraenderlichen ueber GF(2^n) mit
	Koeffizienten in spezieller Bit-Darstellung.
        P3 = P1 + P2.



			pgf2topgfs( r, G, P )

	"polynomial over Galois-field with characteristic 2 to 
	 polynomial over Galois-field with single characteristic"
	(rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:	 _pol3.h
	pol pgf2topgfs(r,G,P)  single r; obj G; pol P;
	Q = pgf2topgfs( r,G,P );
	G ist ein irreduzibles, normiertes Polynom in einer Variablen 
	ueber Z/2Z vom Grad n in der speziellen Bitdarstellung 
	(vgl. udpm2tosb). G kann als ein erzeugendes Polynom fuer GF(2^n)
	interpretiert werden. 
	P ist ein Polynom in r Variablen ueber GF(2^n), d.h. die Koeffi-
	zienten sind dargestellt als Polynome in einer Variablen ueber 
	Z/2Z vom Grad < n in spezieller Bit-Notation (Typ gf2el).
	Q entsteht aus P, indem jeder Koeffizient dargestellt wird als
	sparse-Polynom ueber Z/2Z (Typ gfel).



			pgf2transf( r1, G, P1, V1, r2, P2, V2, Vn, pV3 )

	"polynomial over Galois-field with characteristic 2 
	transformation"    
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgf2transf(r1,G,P1,V1,r2,P2,V2,Vn,pV3)  single r1; obj G; 
		pol P1; list V1; single r2; pol P2; list V2,Vn,*pV3;
	P3 = pgf2transf(r1,G,P1,V1,r2,P2,V2,Vn,pV3);
	G ist ein irreduzibles, normiertes Polynom in einer Variablen
	ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
	(vgl. udpm2tosb). G kann als ein erzeugendes Polynom fuer 
	GF(2^n) interpretiert werden.
	P1 ist ein Polynom in r1 (1<=r1<BASIS) Variablen ueber GF(2^n); 
	V1 ist die zugehoerige Variablenliste.
	P2 ist ein Polynom in r2 (0<=r2<BASIS) Variablen ueber GF(2^n);
	V2 ist die zugehoerige Variablenliste.
	Vn ist eine Liste, die einen in V1 auftretenden Variablennamen
	repraesentiert.
	P3 ist das Polynom, das entsteht, wenn in P1 die Variable Vn
	durch das Polynom P2 ersetzt wird, und die zugehoerige, in
	*pV3 abgelegte Variablenliste alphabetisch sortiert ist.
	(Die in *pV3 abgelegte Variablenliste ist die Vereinigung von
	V1 und V2.)



			pgfsderiv( r, p, AL, P )

	"polynomial over Galois-field with single characteristic
	derivation, main variable"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsderiv(r,p,AL,P)  single r,p; list AL; pol P;
	P1 = pgfsderiv(r,p,AL,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P1 = P' (bzgl. der Hauptvariablen).



			pgfsderivsv( r, p, AL, P, i )

	"polynomial over Galois-field with single characteristic
	derivation, specified variable" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsderivsv(r,p,AL,P,i)  single r,p; list AL; pol P; single i;
	P1 = pgfsderivsv(r,p,AL,P,i);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	i ist eine ganze Zahl mit 1 <= i <= r.
	P1 = P' (bzgl. der i-ten Variablen).



			pgfsdif( r, p, AL, P1, P2 )

	"polynomial over Galois-field with single characteristic
	difference" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsdif(r,p,AL,P1,P2)  single r,p; list AL; pol P1,P2;
	P3 = pgfsdif(r,p,AL,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber GF(p^n),
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P3 = P1 - P2.



			pgfsefe( r, p, ALm, P, g )

	"polynomial over Galois-field with single characteristic 
	 embedding in field extension" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsefe(r,p,ALm,P,g)  single r,p; list ALm; pol P; gfel g;
	Q = pgfsefe( r,p,ALm,P,g );
	Es wird das Polynom P ueber GF(p^n) dargestellt als Polynom 
	ueber einer Koerpererweiterung GF(p^m) (p Primzahl, 1<n,m<BASIS,
	n teilt echt m), deren Arithmetikliste mittels gfsalgenies 
	erzeugt wurde. Die Liste ALm entspricht der Arithmetikliste
	von GF(p^m), wie sie einer Ausgabe von gfsalgen entspricht, 
	g als Polynom in einer Unbestimmten entspricht dem Bild des
	separablen Erzeugers von GF(p^n) ueber GF(p) unter der von
	gfsalgenies gefundenen isomorphen Einbettung von GF(p^n) in 
	GF(p^m) (vgl. gfsalgen, gfsalgenies).
	r>=0 ist die Anzahl der Variablen von P.
	Q ist die Darstellung von P als Polynom ueber GF(p^m).
!!!     HINWEIS: g ist vom Typ gfel, d.h. ein sparse-Polynom in einer
		 Unbestimmten mit Koeffizienten aus Z/pZ.



			pgfseval( r, p, AL, P, a )

	"polynomial over Galois-field with single characteristic
	evaluation, main variable"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfseval(r,p,AL,P,a)  single r,p; list AL; pol P; gfel a;
	P1 = pgfseval(r,p,AL,P,a);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	a ist ein Element aus GF(p^n).
	P1 = P(a) (Auswertung erfolgt bzgl. der Hauptvariablen).



			pgfsevalsv( r, p, AL, P, d, a )

	"polynomial over Galois-field with single characteristic
	evaluation, specified variable" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsevalsv(r,p,AL,P,d,a)  single r,p; list AL; pol P; single d;
				      gfel a;
	P1 = pgfsevalsv(r,p,AL,P,d,a);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	d ist eine ganze Zahl mit 1<=d<=r.
	a ist ein Element aus GF(p^n).
	P1 = P(a) (Auswertung erfolgt bzgl. der d-ten Variablen).



			pgfsexp( r, p, AL, P, m )

	"polynomial over Galois-field with single characteristic
	exponentiation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsexp(r,p,AL,P,m)  single r,p; list AL; pol P; single m;
	P1 = pgfsexp(r,p,AL,P,m);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	m ist eine ganze Zahl aus [0,BASIS-1].
	P1 = P ^ m.



			pgfsexpprem( r, p, AL, F, E, M )

	"polynomial over Galois-field with single characteristic,
	 exponentiation, polynomial remainder"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsexpprem( r, p, AL, F, E, M )  single r,p; list AL; pol F,M;
                                              int E;
	P1 = pgfsexpprem( r, p, AL, F, E, M );
        Dabei muss gelten:
        - p ist eine Primzahl < BASIS,
        - AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) interpretiert
          werden (siehe gfsalgen), wobei n = llength(AL1) + 1.
        - E ist nicht-negativ.
        - F, M sind Polynome in r Variablen ueber GF(p^n), und M ist ungleich 
          dem Nullpolynom.
	P1 = F^E mod M.



			pgfsgfsprod( r, p, AL, P, a )

	"polynomial over Galois-field with single characteristic,
	Galois-field with single characteristic element product" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsgfsprod(r,p,AL,P,a)  single r,p; list AL; pol P; gfel a;
	P1 = pgfsgfsprod(r,p,AL,P,a);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	a ist ein Element aus GF(p^n).
	P1 = a * P.



			pgfsgfsquot( r, p, AL, P, a )

	"polynomial over Galois-field with single characteristic,
	 Galois-field with single characteristic element quotient" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsgfsquot(r,p,AL,P,a) single r,p; list AL; pol P; gfel a;
	P1 = pgfsgfsquot(r,p,AL,P,a);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen) und es gilt
	n = llength(AL1) + 1.
	a ist ein Element ungleich 0 aus GF(p^n).
	P1 = P / a.



			pgfsmonic( r, p, AL, P )

	"polynomial over Galois-field with single characteristic monic"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsmonic(r,p,AL,P)  single r,p; list AL; pol P;
	P1 = pgfsmonic(r,p,AL,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P1 ist das zu P assoziierte normierte Polynom.



			pgfsneg( r, p, AL, P )

	"polynomial over Galois-field with single characteristic negation"
	(rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsneg(r,p,AL,P)  single r,p; list AL; pol P;
	P1 = pgfsneg(r,p,AL,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber GF(p^n), wobei
	p eine Primzahl < BASIS ist, AL = (G,AL1) als Arithmetikliste fuer
	GF(p^n) interpretiert werden kann (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P1 = -P.



			pgfsprod( r, p, AL, P1, P2 )

	"polynomial over Galois-field with single characteristic product"
	(rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsprod(r,p,AL,P1,P2)  single r,p; list AL; pol P1,P2;
	P3 = pgfsprod(r,p,AL,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P3 = P1 * P2.



			pgfsqrem( r, p, AL, P1, P2, pR )

	"polynomial over Galois-field with single characteristic quotient
	 and remainder" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsqrem(r,p,AL,P1,P2,pR)  single r,p; list AL; pol P1,P2; 
				       pol *pR;
	P3 = pgfsqrem(r,p,AL,P1,P2,pR);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1. P2 ist ungleich 0.
	*pR = P1 % P2.
	P3  = P1 / P2.



			pgfsquot( r, p, AL, P1, P2 )    (MACRO)

	"polynomial over Galois-field with single characteristic quotient"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsquot(r,p,AL,P1,P2)  single r,p; list AL; pol P1,P2;
	P3 = pgfsquot(r,p,AL,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1. P2 ist ungleich 0.
	P3 = P1 / P2.



			pgfsrem( r, p, AL, P1, P2 )     (MACRO)

	"polynomial over Galois-field with single characteristic remainder"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfsrem(r,p,AL,P1,P2)  single r,p; list AL; pol P1,P2;
	P3 = pgfsrem(r,p,AL,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1. P2 ist ungleich 0.
	P3 = P1 % P2.



			pgfsres( r, p, AL, P1, P2 )

        "polynomial over Galois-field with single characteristic resultant"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        pol pgfsres(r,p,AL,P1,P2) single r,p; list AL; pol P1,P2; 
        P3 = pgfsres(r,p,AL,P1,P2);
        P1 und P2 sind Polynome in r (1<=r<BASIS) Variablen ueber dem endlichen
        Koerper GF( p^n ) mit Primzahlcharakteristik p (1<p<BASIS) und Arith-
        metikliste AL (siehe gfsalgen).
        P3 ist die Resultante nach der Hauptvariablen von P1 und P2, berechnet
        mit Hilfe der Sylvestermatrix. P3 ist Polynom mit Variablenliste 
        (X1, ..., Xr-1).



			pgfssum( r, p, AL, P1, P2 )

	"polynomial over Galois-field with single characteristic sum"
	(rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfssum(r,p,AL,P1,P2)  single r,p; list AL; pol P1,P2;
	P3 = pgfssum(r,p,AL,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P3 = P1 + P2.



			pgfstopgf2( r, G, P )

	"polynomial over Galois-field with single characteristic  
	 to polynomial over Galois-field with characteristic 2"
	(rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfstopgf2(r, G, P)  single r; obj G; pol P;
	Q = pgfstopgf2( r, G, P );
	G ist ein irreduzibles, normiertes Polynom in einer Variablen 
	ueber Z/2Z vom Grad n in der speziellen Bitdarstellung 
	(vgl. udpm2tosb). G kann als ein erzeugendes Polynom fuer 
	GF(2^n) interpretiert werden. 
	P ist ein Polynom in r (r>=0) Variablen, dessen Basiskoeffizien-
	ten dargestellt sind als sparse-Polynome vom Grad < n ueber Z/2Z 
	(Typ gfel).
	Q ist die Darstellung von P als Polynom ueber GF(2^n), d.h. die
	Basiskoeffizienten sind dargestellt als Polynome in einer 
	Variablen ueber Z/2Z vom Grad < n in spezieller Bit-Notation 
	(Typ gf2el).



			pgfstransf( r1, p, AL, P1, V1, r2, P2, V2, Vn, pV3 )

	"polynomial over Galois-field with single characteristic 
	 transformation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pgfstransf(r1,p,AL,P1,V1,r2,P2,V2,Vn,pV3)  
		single r1,p; list AL; pol P1; list V1; 
		single r2; pol P2; list V2; list Vn,*pV3;
	P3 = pgfstransf(r1,p,AL,P1,V1,r2,P2,V2,Vn,pV3);
	p ist eine Primzahl. AL=(G,AL1) kann als Arithmetikliste fuer 
	GF(p^n) interpretiert werden (siehe gfsalgen).
	P1 ist ein Polynom in r1 (1<=r1<BASIS) Variablen ueber GF(p^n); 
	V1 ist die zugehoerige Variablenliste.
	P2 ist ein Polynom in r2 (0<=r2<BASIS) Variablen ueber GF(p^n);
	V2 ist die zugehoerige Variablenliste.
	Vn ist eine Liste, die einen in V1 auftretenden Variablennamen
	repraesentiert.
	P3 ist das Polynom, das entsteht, wenn in P1 die Variable Vn
	durch das Polynom P2 ersetzt wird, und die zugehoerige, in
	*pV3 abgelegte Variablenliste alphabetisch sortiert ist.
	(Die in *pV3 abgelegte Variablenliste ist die Vereinigung von
	V1 und V2.)



			piabs( r, P )

	"polynomial over integers absolute value"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol piabs(r,P) single r; pol P;
	P1 = piabs(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den ganzen
	Zahlen.
	P1 = P  falls der fuehrende Basiskoeffizient (bzgl. der Haupt-
		variablen) positiv ist;
	     -P sonst.



			pibezout( r, P1, P2 )

	"polynomial over integers Bezout-matrix"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	matrix pibezout(r,P1,P2) single r; pol P1,P2;
	M = pibezout(r,P1,P2);
	P1 und P2 sind Polynome in r (1<=r<BASIS) Variablen ueber
	den ganzen Zahlen mit
		pdegree(r,P1) >= pdegree(r,P2) >= 1.
	M ist die Bezout-Matrix zu P1 und P2.
	(Die Determinante von M stimmt - moeglicherweise bis auf
	den Faktor -1 - mit der Resultante von P1 und P2 ueberein.
	Man vgl. piresbez.)



			picevalp( r, P, sA )

	"polynomial over integers choice of evaluation points"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol picevalp( r, P, sA )  single r; pol P; list *sA;
	P1 = picevalp( r, P, sA );
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	ganzen Zahlen. P ist quadratfrei bzgl. seiner Hauptvariablen X.
	Dann ist sA = (s(1),..,s(r-1)) eine Liste von singles, minimal
	bzgl. der revers-lexikographischen Ordnung ( 0<1<-1<2<-2<.. ).
	D.h., es werden fuer jede Koordinate Xi,(1<=i<=r-1), die Zahlen
	0,1,-1,2,-2,.. genau in dieser Reihenfolge eingesetzt, und ein
	Geeignetes wird dann als s(i) uebernommen, sodass dann:
	Grad(P(X1,..,Xr-1,X)) = Grad(P(s(1),..,s(r-1),X)) bzgl. X.
	P1 = P(s(1),..,s(r-1),X) , P1 ist univariat und quadratfrei.



			picont( r, P )

	"polynomial over integers content"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol picont(r,P) single r; pol P;
	P1 = picont(r,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den ganzen
	Zahlen.
	P1 ist der Inhalt von P (bzgl. der Hauptvariablen).



			picontpp( r, P, pPP )

	"polynomial over integers content and primitive part"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol picontpp(r,P,pPP) single r; pol P; pol *pPP;
	P1 = picont(r,P,pPP);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	P1 ist der Inhalt von P, *pPP der primitive Anteil von P
	(bzgl. der Hauptvariablen).



			picra( r, P1, P2, M, m, a )

	"polynomial over integers chinese remainder algorithm"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol picra(r,P1,P2,M,m,a)  single r; pol P1,P2; int M; single m,a;
	P3 = picra(r,P1,P2,M,m,a);
	M ist eine ganze Zahl groesser 0. m ist eine Zahl aus
	[1,BASIS[ mit ggt(M,m) gleich 1. a ist das multiplikativ
	Inverse von mshom(m,M).
	P1 ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen, dessen Basis-Koeffizienten Einheiten in
	Z/MZ sind.
	P2 ist ein Polynom in r Variablen ueber Z/mZ.
	P3 ist das eindeutig bestimmte Polynom in r Variablen,
	dessen Basis-Koeffizienten Einheiten in Z/MmZ sind und das
	modulo M kongruent zu P1 und modulo m kongruent zu P2 ist.



			pideriv( r, P )

	"polynomial over integers derivation, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pideriv(r,P) single r; pol P;
	P1 = pideriv(r,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	P1 = P' (bzgl. der Hauptvariablen).



			piderivsv( r, P, n )

	"polynomial over integers derivation, specified variable"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol piderivsv(r,P,n) single r; pol P; single n;
	P1 = piderivsv(r,P,n);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	n ist eine ganze Zahl mit 1<=n<=r.
	P1 = P' (bzgl. der n-ten Variablen).



			pidif( r, P1, P2 )

	"polynomial over integers difference" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pidif(r,P1,P2) single r; pol P1,P2;
	P3 = pidif(r,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	den ganzen Zahlen.
	P3 = P1 - P2.



			pidiscr( r, P, n )

	"polynomial over integers discriminant"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pidiscr(r, P, n)  single r; pol P; single n;
	P1 = pidiscr(r, P, n);
	P ist ein Polynom in r (1 <= r < BASIS) Variablen ueber den
	ganzen Zahlen, dessen Grad bzgl. der Hauptvariablen groesser
	gleich 2 ist.
	P1 ist die Diskriminante von P (bzgl. der Hauptvariablen),
	also ein Polynom in r-1 Variablen.
	n gibt den zu verwenden Algorithmus an:  
	Im Falle n < 4 wir die Resultante von p und p' berechnet, wie 
	folgt:
	    n = 1:  Berechnung der Determinante der Sylvester-Matrix
		    (man vgl. piressylv);
	    n = 2:  Collins-Algorithmus ueber Z, Sylvester-Matrix
		    ueber Z/mZ;
	    n = 3:  Collins-Algorithmus ueber Z und Z/mZ.
	Im Falle n = 4 wir die Hankel-Matrix zur direkten Berechnung 
	der Diskriminante verwendet (siehe pidiscrhank). 
	Im Zweifelsfalle sollte zunaechst n=4 versucht werden, 
	insbesondere dann, wenn das Polynom normiert bezueglich der 
	Hauptvariablen ist.   
	Fuer n < 4 und r = 1 wird der Collins-Algorithmus verwendet.



			pidiscrhank( r, P )

	"polynomial over integers discriminant via Hankel- matrix"
	Quellbibliothek: srclib.pol2            
	Include-Datei:   _pol2.h
	pol pidiscrhank(r, P)  single r; pol P;
	P1 = pidiscrhank(r, P);
	P ist ein nichtkonstantes Polynom in r (1 <= r < BASIS) Variablen 
	ueber den ganzen Zahlen.
	P1 ist die Diskriminante von P (bzgl. der Hauptvariablen),
	also ein Polynom in r-1 Variablen.
	Zum Algorithmus vgl. E. Weiss, Algebraic Number theory, S. 105.



			pieuklnorm( r, P )

	"polynomial over integers Euklid norm" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	int pieuklnorm(r,P) single r; pol P;
	A = pieuklnorm(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	A ist die Euklidische Norm von P, d. h. A ist die Wurzel aus
	der Summe der Quadrate der Basis-Koeffizienten-Betraege.
	( A ist nichtnegative ganze Zahl. )



			pieval( r, P, A )

	"polynomial over integers evaluation, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pieval(r,P,A) single r; pol P; int A;
	P1 = pieval(r,P,A);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	A ist eine ganze Zahl.
	P1 = P(A) (Auswertung erfolgt bzgl. der Hauptvariablen).



			pievalsv( r, P, n, A )

	"polynomial over integers evaluation, specified variable"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pievalsv(r,P,n,A) single r; pol A; single n; int A;
	P1 = pievalsv(r,P,n,A);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	n ist eine ganze Zahl mit 1<=n<=r.
	A ist eine ganze Zahl.
	P1 = P(A) (Auswertung erfolgt bzgl. der n-ten Variablen).



			piexp( r, P, n )

	"polynomial over integers exponentiation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol piexp(r,P,n) single r; pol P; single n;
	P1 = piexp(r,P,n);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	n ist eine ganze Zahl aus [0,BASIS-1].
	P1 = P ^ n.



			pifact( r, P )

	"polynomial over integers factorization"(rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list pifact(r,P)  single r;pol P;
	L = pifact(r,P);
	P ist ein Polynom in r Variablen ueber den ganzen Zahlen,
	ungleich Null.(r >=1 ).
	L = ( c, P1,e1, ..., Pk,ek ) fuer k>=1; c=sign(P)*cont(P);
	Fuer 1<=i<=k sind ei positive ganze Zahlen und Pi paarweise
	verschiedene positive irreduzible Faktoren von P, so dass
	P = c * P1^e1 *...* Pk^ek.
	Tritt ein Fehler auf, so ist L = ERROR.



			pifcb( L )

	"polynomial over integers factor coefficient bound"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single pifcb(L) list L;
	a = pifcb(L);
	L ist eine nicht leere Liste (gr,...,g1), wobei gn (1<=n<=r)
	den Grad eines von 0 verschiedenen Polynoms P aus Z[X1,...,Xr]
	in Xn bezeichnet.
	a ist eine nicht negative ganze Zahl derart, dass fuer
	irgendwelche Teiler P1,...,Ps von P mit P1*...*Ps teilt P gilt
	pimaxnorm(r,P1) * ... * pimaxnorm(r,Ps) <= 2^a * pimaxnorm(r,P).
	(Die Gelfond-Schranke wird benutzt).



			pigcdcf( r, P1, P2, pQ1, pQ2 )

	"polynomial over integers greatest common divisor and cofactors"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pigcdcf(r,P1,P2,pQ1,pQ2) single r; pol P1,P2; pol *pQ1,*pQ2;
	P3 = pigcdcf(r,P1,P2,pQ1,pQ2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	P3 ist der groesste gemeinsame Teiler von P1 und P2.
	*pQ1 = P1 / P3, *pQ2 = P2 / P3,  falls P3 ungleich 0 ist;
	*pQ1 = 0 = *pQ2, sonst.



			pigf2evalfvs( r, G, P )

	"polynomial over integers Galois-field with characteristic 2
	 element evaluation first variable special version" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pigf2evalfvs(r,G,P)  single r; obj G; pol P;
	Q = pigf2evalfvs(r,G,P);
	Dabei muss gelten:
	      - G ist ein irreduzibles, normiertes Polynom in einer
		Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
		Darstellung (vgl. udpm2tosb). 
		G kann als erzeugendes Polynom fuer GF(2^n) 
		interpretiert werden.
	      - P ist ein Polynom in r >= 1 Variablen ueber Z.
	Die erste Variable der zu P gehoerigen Variablenliste wird
	durch das erzeugende Element des durch G bestimmten endlichen
	Koerpers ersetzt.
	Q ist dann ein Polynom in r-1 Variablen ueber diesem endlichen 
	Koerper.



			pigfcb( r, P )

	"polynomial over integers Gelfond-factor coefficient bound"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single pigfcb(r,P) single r; pol P;
	B = pigfcb(r,P);
	P ist ein r-variates Polynom ueber Z, r > 0.
	B ist eine nicht negative ganze Zahl mit:
	B = 2^s * sumnorm(P), wobei
	s = ( [ summe(i=1,..,r){max(o,2*ni-1)} ] / 2 )  , und
	ni ist der Grad von P in der Variablen Xi.



			pigfsevalfvs( r, p, AL, P )

	"polynomial over integers Galois-field with single characteristic
	 element evaluation first variable special version" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pigfsevalfvs(r,p,AL,P)  single r,p; list AL; pol P;
	Q = pigfsevalfvs(r,p,AL,P);
	Dabei muss gelten:
	      - AL ist die Arithmetikliste fuer GF(p^n) (1<p<BASIS,
		p Primzahl)
	      - P ist ein Polynom in r >= 1 Variablen ueber Z.
	Die erste Variable der zu P gehoerigen Variablenliste wird
	durch das erzeugende Element des durch AL bestimmten endlichen
	Koerpers ersetzt.
	Q ist dann ein Polynom in r-1 Variablen ueber diesem endlichen 
	Koerper.



			pihlfa( r, p, L, M, S, P )

	"polynomial over integers, Hensel lemma factorization
	approximation"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list pihlfa(r,p,L,M,S,P) single r,p;list L,S;int M;pol P;
	L1 = pihlfa(r,p,L,M,S,P);
	p ist eine Primzahl.
	P ist ein Polynom in r Variablen ueber Z,
	dessen Leitkoeffizient nicht von p geteilt wird.
	L = ( PU_1, .. , PU_n ) ist eine Liste normierter, paarweise
	teilerfremder Polynome positiven Grades in einer Variablen
	ueber Z/p*Z.
	P(0,..,0,X) = PU_1 * .. * PU_n mod p.
	S ist eine Liste (s(1),..,s(r-1)) nicht-negativer singles.
	M ist eine positive ganze Zahl: M = p**j , mit einer
	positiven ganzen Zahl j.
	Dann ist L1 = ( H_1, .. ,H_n ) eine Liste von normierten
	Polynomen aus Z/M*Z[X1,..,Xr-1,X]/(X1**s(1),..,Xr-1**s(r-1)).
	P = H_1 * .. * H_n mod M.
	Dabei gelten fuer 1 <= i <= n :
	H_i ist kongruent zu  PU_i und
	Grad(H_i) = Grad(PU_i) mit dem Grad bzgl. X.



			piicont( r, P )

	"polynomial over integers integer content" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	int piicont(r,P) single r; pol P;
	A = piicont(r,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	A ist der Inhalt (ueber den ganzen Zahlen) von P, falls
	P ungleich 0 ist, und 0 sonst.



			piiprod( r, P, A )

	"polynomial over integers, integer product" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol piiprod(r,P,A) single r; pol P; int A;
	P1 = piiprod(r,P,A);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	A ist eine ganze Zahl.
	P1 = A * P.



			piiquot( r, P, A )

	"polynomial over integers, integer quotient" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol piiquot(r,P,A) single r; pol P; int A;
	P1 = piiquot(r,P,A);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	A ist eine ganze Zahl ungleich 0, die P teilt.
	P1 = P / A.



			pilmfcb( r, P )

	"polynomial over integers Landau- Mignotte- factor coefficient 
	 bound"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single pilmfcb(r,P)  single r; pol P;
	B = pilmfcb(r,P);
	P ist ein Polynom in r Variablen ueber Z, r > 0.
	B ist eine nicht negative ganze Zahl mit:
	B >= maxnorm(P), wobei B gewaehlt wird als
	B = B([n1/2],n1)*...*B([nr/2],nr) * pieuklnorm(r,P),
	mit dem Binomialkoeffizienten B(n,k) und der Euklidischen
	Norm pieuklnorm(r,P).
	ni ist der Grad von P in der Variablen Xi.
	(Die Landau-Mignotte-Schranke wird benutzt.)



			pimaxnorm( r, P )

	"polynomial over integers maximum norm" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pimaxnorm(r,P) single r; pol P;
	A = pimaxnorm(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	A ist die Maximumnorm von P, d. h. A ist das Maximum der
	Betraege der Basis-Koeffizienten.



			pimidhom( r, S, P )

	"polynomial over integers modular ideal homomorphism"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pimidhom(r,S,P) single r;list S;pol P;
	P1 = pimidhom(r,S,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen
	ueber den ganzen Zahlen.
	S ist ein Liste (s(1),..,s(r-1)) nicht-negativer singles.
	P1 = P mod (X1**s(1),..,X(r-1)**s(r-1)).



			pimidprod( r, S, P1, P2 )

	"polynomial over integers modular ideal product"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pimidprod(r,S,P1,P2) single r; list S; pol P1,P2;
	P = pimidprod(r,S,P1,P2);
	r ist positiv, ( 1<=r<BASIS ).
	S ist eine Liste (s(1),..,s(r-1)) nicht-negativer singles.
	P1,P2 sind aus Z[X1,..,Xr-1,Y]/(X1**s1,..,Xr-1**s(r-1)).
	P = P1 * P2.



			pimidqhl( r, p, S, P1, P2, F1, F2, M, H, pB )

	"polynomial over integers, modular ideal, Hensel lemma
	quadratic step"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pimidqhl(r,p,S,P1,P2,F1,F2,M,H,pB)  single r,p; int M; list S;
				      		pol P1,P2,F1,F2,H,*pB;
	PA = pimidqhl(r,p,S,P1,P2,F1,F2,M,H,pB);
	r ist positiv.
	p ist Primzahl.
	S ist eine Liste (s(1),..,s(r-1)) nicht-negativer singles.
	P1,P2,F1,F2 sind Elemente aus
	Z/p*Z[X1,..,Xr-1,Y]/(X1**s(1),..,Xr-1**s(r-1)),
	wobei P1 normiert und positiven Grades in Y ist.
	P1,P2,F1 und F2 erfuellen die Gleichung:
	P1 * F1 + P2 * F2 = 1 .
	H ist ein Polynom in r Variablen ueber den ganzen Zahlen,
	mit: P1 * P2 ist kongruent H.
	M ist eine positive ganze Zahl: M = p**j , mit einer
	positiven ganzen Zahl j.
	Dann sind PA und pB aus
	Z/M*Z[X1,..,Xr-1,Y]/(X1**s(1),..,Xr-1**s(r-1)),  mit
	PA normiert. Es gelten:
	PA ist kongruent P1,
	pB ist kongruent P2,
	Grad(PA) = Grad(P1) , mit dem Grad bzgl. Y und
	PA * pB ist kongruent H.



			pineg( r, P )

	"polynomial over integers negation" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pineg(r,P) single r; pol P;
	P1 = pineg(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber
	den ganzen Zahlen.
	P1 = -P.



			pinfevalfvs( r, F, P )

	"polynomial over integers number field element evaluation first
         variable special version"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pinfevalfvs( r, F, P )  single r;  pol F, P;
	Q = pinfevalfvs( r, F, P );
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom vom Grad >= 1 in einer
		Variablen ueber Z in dense-Darstellung.
	      - P ist ein Polynom in r >= 1 Variablen ueber Z.
        Die erste Variable der zu P gehoerigen Variablenliste wird durch
	das erzeugende Element des durch F bestimmten Zahlkoerpers ersetzt.
	Q ist ein Polynom in r-1 Variablen ueber diesem Zahlkoerper.



			piprimpart( r, P )              (MACRO)

	"polynomial over integers primitive part"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol piprimpart(r,P) single r; pol P;
	P1 = piprimpart(r,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	P1 ist der primitive Anteil von P (bzgl. der Hauptvariablen).



			piprod( r, P1, P2 )

	"polynomial over integers product" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol piprod(r,P1,P2) single r; pol P1,P2;
	P3 = piprod(r,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	den ganzen Zahlen.
	P3 = P1 * P2.



			pipsrem( r, P1, P2 )

	"polynomial over integers pseudo remainder"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pipsrem(r,P1,P2) single r; pol P1,P2;
	P3 = pipsrem(r,P1,P2);
	P1 und P2 sind Polynome in r (1<=r<BASIS) Variablen ueber
	den ganzen Zahlen.
	P2 ist ungleich 0.
	P3 ist der Pseudo-Rest von P1 und P2, d. h.
	P3 = (P1 * k^(Grad(P1)-Grad(P2)+1)) % P2, wobei k der fuehrende
	Koeffizient von P2 ist und Grad(P1) groesser gleich Grad(P2);
	sonst ist P3 = P1.



			piqrem( r, P1, P2, pR )

	"polynomial over integers quotient and remainder" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol piqrem(r,P1,P2,pR) single r; pol P1,P2; pol *pR;
	P3 = piqrem(r,P1,P2,pR);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	den ganzen Zahlen; P2 ist ungleich 0.
	*pR = P1 % P2.
	P3 = P1 / P2.



			piquot( r, P1, P2 )             (MACRO)

	"polynomial over integers quotient"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol piquot(r,P1,P2) single r; pol P1,P2;
	P3 = piquot(r,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	den ganzen Zahlen; P2 ist ungleich 0.
	P3 = P1 / P2.



			pirem( r, P1, P2 )              (MACRO)

	"polynomial over integers remainder"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pirem(r,P1,P2) single r; pol P1,P2;
	P3 = pirem(r,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	den ganzen Zahlen; P2 ist ungleich 0.
	P3 = P1 % P2.



			piresbez( r, P1, P2 )

	"polynomial over integers resultant, Bezout algorithm"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol piresbez(r,P1,P2) single r; pol P1,P2;
	P3 = piresbez(r,P1,P2);
	P1 und P2 sind Polynome in r (1<=r<BASIS) Variablen ueber
	den ganzen Zahlen.
	piresbez berechnet, falls noetig, die Determinante der
	Bezout-Matrix zu P1 und P2. Diese stimmt - eventuell bis
	auf Vorzeichen - mit der Resultante von P1 und P2 ueberein.
	P3 ist (mit obigen Einschraenkungen) die Resultante von P1
	und P2, d. h. ein Polynom in r-1 Variablen ueber Z.
	Man vgl. auch pirescoll und piressylv.



			pirescoll( r, P1, P2, n )

	"polynomial over integers resultant, Collins algorithm"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pirescoll(r,P1,P2,n) single r; pol P1,P2; single n;
	P3 = pirescoll(r,P1,P2,n);
	P1 und P2 sind Polynome in r (1<=r<BASIS) Variablen ueber
	den ganzen Zahlen.
	P3 ist die Resultante von P1 und P2 bzgl. der Hauptvariablen,
	also ein Polynom in r-1 Variablen ueber Z.
	pirescoll arbeitet, falls noetig, auf der Basis des
	Collins-Algorithmus fuer Resultanten von Polynomen ueber Z.
	n gibt fuer r ungleich 1 den Algorithmus zur Berechnung der
	Resultante von P1 und P2 ueber Z/mZ an:
	    n = 1:  Berechnung der Determinante der Sylvester-Matrix
		    (man vgl. psylvester);
	    n = 2:  Collins-Algorithmus (man vgl. pmsrescoll).
	Fuer r gleich 1 wird der Collins-Algorithmus angewendet.
	(vgl. G.E. Collins, The Calculation of Multivariate Polynomial
	Resultants, Journal ACM, No. 4,18 (Oct. 1971), 515-532.)



			pirescspec( r, P1, P2, n )

	"polynomial over the integers resultant, Collins algorithm
        special"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pirescspec(r,P1,P2,n) single r; pol P1,P2; single n;
	P3 = pirescspec(r,P1,P2,n);
	P1 und P2 sind Polynome in r (1<=r<BASIS) Veraenderlichen 
	ueber den ganzen Zahlen.
	P3 ist entweder die Resultante von P1 und P2 bzgl. der 
        Hauptvariablen,	also ein Polynom in r-1 Veraenderlichen
	ueber den ganzen Zahlen,
        oder gleich Null, falls in der Primzahlliste LIST_GSP zur
	Berechnung der Resultante nicht ausreichend viele Primzahlen
	stehen ( siehe dazu auch pirescoll ).
	pirescspec arbeitet, falls noetig, auf der Basis des
	Collins-Algorithmus fuer Resultanten von Polynomen ueber Z.
	n gibt fuer r ungleich 1 den Algorithmus zur Berechnung der
	Resultante von P1 und P2 ueber Z/mZ an:
	    n = 1:  Berechnung der Determinante der Sylvester-Matrix
		    (man vgl. psylvester);
	    n = 2:  Collins-Algorithmus (man vgl. pmsrescoll).
	Fuer r gleich 1 wird der Collins-Algorithmus angewendet.
	(vgl. G.E. Collins, The Calculation of Multivariate Polynomial
	Resultants, Journal ACM, No. 4,18 (Oct. 1971), 515-532.)



			piressylv( r, P1, P2 )

	"polynomial over integers resultant, Sylvester algorithm"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol piressylv(r,P1,P2) single r; pol P1,P2;
	P3 = piressylv(r,P1,P2);
	P1 und P2 sind Polynome in r (1<=r<BASIS) Variablen ueber
	den ganzen Zahlen.
	piressylv berechnet, falls noetig, die Determinante der
	Sylvester-Matrix zu P1 und P2.
	P3 ist die Resultante von P1 und P2, d. h. ein Polynom in
	r-1 Variablen ueber Z.
	Man vgl. auch piresbez und pirescoll.



			pisfact( r, P )

	"polynomial over integers squarefree factorization"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list pisfact(r,P)  single r; pol P;
	L = pisfact(r,P);
	P ist ein primitives Polynom positiven Grades in r (1<=r<BASIS)
	Variablen ueber den ganzen Zahlen, dessen fuehrender Basis-
	koeffizient positiv ist.
	L ist eine Liste
	    L = ( ( e1 , P1 ) , ... , ( en , Pn ) )
	mit
	    1 <= e1 < e2 < ... < en;
	    Pi (1<=i<=n) (bzgl. der Hauptvariablen) quadratfreier Faktor
	    von P
	    P = P1^e1 * ... * Pn^en.



			pisign( r, P )

	"polynomial over integers sign, base variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single pisign(r,P) single r; pol P;
	a = pisign(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den ganzen
	Zahlen.
	a ist das Vorzeichen des fuehrenden Basiskoeffizienten (bzgl.
	der Hauptvariablen) von P.



			pisubst( r, P1, P2 )

	"polynomial over integers substitution, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pisubst(r,P1,P2) single r; pol P1; pol P2;
	P3 = pisubst(r,P1,P2);
	P1 ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	P2 ist ein Polynom in r-1 Variablen ueber den ganzen Zahlen.
	P3 = P1(P2) ist ebenfalls ein Polynom in r-1 Variablen ueber
	den ganzen Zahlen (Substitution der Hauptvariablen).



			pisubstsv( r, P1, n, P2 )

	"polynomial over integers substitution, specified variable"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pisubstsv(r,P1,n,P2) single r; pol P1; single n; pol P2;
	P3 = pisubstsv(r,P1,n,P2);
	P1 ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	n ist eine ganze Zahl mit 1<=n<=r.
	P2 ist ein Polynom in n-1 Variablen ueber den ganzen Zahlen.
	P3 = P1(P2) (Substitution der n-ten Variablen).



			pisum( r, P1, P2 )

	"polynomial over integers sum" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pisum(r,P1,P2) single r; pol P1,P2;
	P3 = pisum(r,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	den ganzen Zahlen.
	P3 = P1 + P2;



			pisumnorm( r, P )

	"polynomial over integers sum norm" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pisumnorm(r,P) single r; pol P;
	A = pisumnorm(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	A ist die Summennorm von P, d. h. A ist die Summe der
	Betraege der Basis-Koeffizienten.



			pitopmi( r, P, M )

	"polynomial over integers to polynomial over modular integers"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pitopmi(r,P,M) single r; pol P; int M;
	P1 = pitopmi(r,P,M);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	M ist eine positive ganze Zahl.
	P1 = P (aufgefasst als Polynom ueber Z/M*Z).



			pitopms( r, P, m )

	"polynomial over integers to polynomial over modular singles"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pitopms(r,P,m) single r; pol P; single m;
	P1 = pitopms(r,P,m);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	m ist eine ganze Zahl mit 0<m<BASIS.
	P1 = P (aufgefasst als Polynom ueber Z/mZ).



			pitopnf( r, P )

	"polynomial over the integers to polynomial over a number field"
	(rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pitopnf(r,P) single r; pol P;
	P1 = pitopnf(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	P1 = P (aufgefasst als Polynom ueber einem Zahlkoerper).



			pitoppf( r, P, p, d )

	"polynomial over integers to polynomial over p-adic field"
	( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pitoppf( r, P, p, d )  single r, p, d;  pol P;
	P1 = pitoppf( r, P, p, d );
	Dabei muss gelten:
		- p ist Primzahl.
		- P ist Polynom in r ( 0 <= r < BASIS ) Variablen ueber
		  den ganzen Zahlen mit den Koeffizienten Ai.
	Die Koeffizienten von P1 seien ai.
	Dabei sind die ai jeweils Approximationen von Ai aus Qp vom Grad
	d, fuer die bzgl. der additiven p-adischen Bewertung vp gilt:
		vp( Ai - ai ) >= d
	und     ai = 0                              , falls d < vp( Ai )
	sonst   ai = ai_vp( Ai ) * p^vp( Ai ) + ... + ai_d * p^d,
	wobei   ai_vp( Ai ) != 0        und
		0 <= ai_j <= p - 1
	Fuer ai ergibt sich folgende Form:
		ai = 0                   , falls a = 0 oder d < vp( Ai )
		     ( d, vp( Ai ), ai_vp( Ai ), ..., ai_d )     , sonst
	P1 = P ( aufgefasst als Polynom ueber dem p-adischen Zahlkoerper
		 mit den approximierten Koeffizienten ai )
	ACHTUNG: Ist die Approximation fuer den hoechsten Koeffizienten 0,
	-------  wird das Polynom im Grad reduziert.



			pitopr( r, P )

	"polynomial over integers to polynomial over rationals"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pitopr(r,P) single r; pol P;
	P1 = pitopr(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	P1 = P (aufgefasst als Polynom ueber den rationalen Zahlen).



			pitrans( r, P, A )

	"polynomial over integers translation, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pitrans(r,P,A) single r; pol P; int A;
	P1 = pitrans(r,P,A);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	ganzen Zahlen. A ist eine ganze Zahl.
	P1(X1,...,Xr) = P(X1,...,X(r-1),Xr+A).



			pitransav( r, P, LI )

	"polynomial over integers translation, all variables"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pitransav(r,P,LI) single r; pol P; list LI;
	P1 = pitransav(r,P,LI);
	P ist ein Polynom in r (1<=r<BASIS) Variablen X1,...Xr
	ueber den ganzen Zahlen. LI ist eine Liste von r ganzen
	Zahlen: LI = ( Ar ,..., A1 ).
	P1(X1,...,Xr) = P(X1+A1,...,Xr+Ar);



			pitransf( r1, P1, V1, r2, P2, V2, Vn, pV3 )

	"polynomial over the integers transformation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pitransf(r1,P1,V1,r2,P2,V2,Vn,pV3) single r1; pol P1; list V1;
					       single r2; pol P2; list V2;
					       list Vn; list *pV3;
	P3 = pitransf(r1,P1,V1,r2,P2,V2,Vn,pV3);
	P1 ist ein Polynom in r1 (1<=r1<BASIS) Variablen ueber den
	ganzen Zahlen; V1 ist die zugehoerige Variablenliste.
	P2 ist ein Polynom in r2 (0<=r2<BASIS) Variablen ueber den
	ganzen Zahlen; V2 ist die zugehoerige Variablenliste.
	Vn ist eine Liste, die einen in V1 auftretenden Variablennamen
	repraesentiert.
	P3 ist das Polynom, das entsteht, wenn in P1 die Variable Vn
	durch das Polynom P2 ersetzt wird, und die zugehoerige, in
	*pV3 abgelegte Variablenliste alphabetisch sortiert ist.
	(Die in *pV3 abgelegte Variablenliste ist die Vereinigung von
	V1 und V2.)



			pitrprod( r, S, P1, P2 )

	"polynomial over integers truncation product" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pitrprod(r,S,P1,P2) single r; list S; pol P1,P2;
	P = pitrprod(r,S,P1,P2);
	r ist positiv, ( 1<=r<BASIS ).
	S ist eine Liste (s1,..,sr) nicht-negativer singles.
	P1,P2 sind Polynome in r Variablen ueber den
	ganzen Zahlen modulo (X1**s1,..,Xr**sr), d.h.
	P1,P2 sind aus Z[X1,..,Xr]/(X1**s1,..,Xr**sr).
	P = P1 * P2.



			pitrunc( r, S, P )

	"polynomial over integers truncation" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pitrunc(r,S,P) single r;list S;pol P;
	P1 = pitrunc(r,S,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen
	ueber den ganzen Zahlen.
	S ist ein Liste (s1,..,sr) nicht-negativer singles.
	P1 = P mod (X1**s1,..,Xr**sr).



			plbc( r, P )

	"polynomial leading base coefficient, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	obj plbc(r,P) single r; pol P;
	a = plbc(r,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen.
	a ist der fuehrende Basiskoeffizient von P bzgl. der
	Hauptvariablen, falls P ungleich 0 ist, 0 sonst.



			plc( r, P )                     (MACRO)

	"polynomial leading coefficient, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol plc(r,P) single r; pol P;
	P1 = plc(r,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen.
	P1 ist der fuehrende Koeffizient von P bzgl. der Hauptvariablen,
	falls P ungleich 0 ist, 0 sonst.



			pm2topgf2( r, P )

	"polynomial over modular 2 to polynomial over Galois-field with 
	 characteristic 2" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pm2topgf2(r,P)  single r; pol P;
	Q = pm2topgf2(r,P);
	Dabei ist P ein Polynom in r (r>=0) Variablen ueber Z/2Z.
	Q ist das Polynom P aufgefasst als Polynom ueber GF(2^n).



			pmakevl( s )

	"polynomial make list of variables"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list pmakevl(s)  char* s;
	V = pmakevl(s);    
	s ist ein String. 
	aus s wird eine Variablenliste erzeugt, wie sie zum 
	Beispiel in getp... oder putp... benoetigt wird.
	Die Variablennamen duerfen nur alphanumerische
	Zeichen enthalten, alle nicht alphanumerischen 
	Zeichen (zum Beispiel Blanks) werden als 
	Trennzeichen zwischen den Namen interpretiert. 
	Beispiele (zum Aufruf p = getpi(r, V);):    
	r=1, und p soll als Polynom in x interpretiert werden:
	V = pmakevl("x");
	r=6, und p soll als Polynom in a1, a2, a3, a4, a5, z
	interpretiert werden: V = pmakevl("a1 a2 a3 a4 a5 z");



			pmibezout( r, m, P1, P2 )

	"polynomial over modular integers Bezout-matrix"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	matrix pmibezout(r,m,P1,P2)  single r; int m; pol P1,P2;
	M = pmibezout(r,m,P1,P2);
	m ist eine Primzahl.
	P1 und P2 sind Polynome in r (1<=r<BASIS) Variablen ueber
	Z/mZ. Es gilt pdegree(r,P1) >= pdegree(r,P2) >= 1.
	M ist die Bezout-Matrix zu P1 und P2.
	(Die Determinante von M stimmt - moeglicherweise bis auf
	den Faktor -1 - mit der Resultante von P1 und P2 ueberein.
	Man vgl. pmires.)



			pmideriv( r, M, P )

	"polynomial over modular integers derivation, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmideriv(r,M,P)  single r; int M; pol P;
	P1 = pmideriv(r,M,P);
	M ist eine positive ganze Zahl.
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z / M*Z.
	P1 = P' (Ableitung bzgl. der Hauptvariablen).



			pmiderivsv( r, m, P, n )

	"polynomial over modular integers derivation, specified variable"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmiderivsv(r,m,P,n)  single r; int m; pol P; single n;
	P1 = pmiderivsv(r,m,P,n);
	m ist eine positive ganze Zahl.
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z/mZ.
	n ist eine ganze Zahl mit 1<=n<=r.
	P1 = P' (bzgl. der n-ten Variablen).



			pmidif( r, M, P1, P2 )

	"polynomial over modular integers difference" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmidif(r,M,P1,P2) single r; int M; pol P1,P2;
	P3 = pmidif(r,M,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	Z/MZ (M eine ganze Zahl groesser 0):
	P3 = P1 - P2.



			pmidiscr( r, M, P, n )

	"polynomial over modular integers discriminant"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmidiscr(r, M, P, n)  single r; int M; pol P; single n;
	P1 = pmidiscr(r, M, P, n);
	P ist ein Polynom in r (1 <= r < BASIS) Variablen ueber Z/MZ, 
	wobei M eine Primzahl ist.
	P1 ist die Diskriminante von P (bzgl. der Hauptvariablen),
	also ein Polynom in r-1 Variablen ueber Z/MZ.
	Falls n = 3  ist, erfolgt die Berechnung der Diskriminante 
	mit der Hankel-Matrix (man vgl. pmidiscrhank);
	sonst gibt n den Algorithmus zur Berechnung der Resultante 
	von P und P' an (Ausnahmen siehe unten):
	    n = 1:  Berechnung der Determinante der Sylvester-Matrix
		    (man vgl. psylvester);
	    n = 2:  Collins-Algorithmus (man vgl. pmirescoll);
		    !! Warnung !! der Collins-Algorithmus fuehrt
		    moeglicherweise nicht zum Ziel; es wird dann
		    ERROR als Ergebnis geliefert.  
	Falls M den Grad von P1 teilt, wird der Algorithmus mit 
	der Hankel-Matrix angewendet. Sonst wird fuer r = 1 der 
	Collins-Algorithmus angewendet. 
	Im Zweifelsfall sollte insbesondere fuer normierte Polynome
	n = 3 versucht werden. 



			pmidiscrhank( r, M, P )

	"polynomial over modular integers discriminant via Hankel matrix"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmidiscrhank(r, M, P)  single r; int M; pol P; single n;
	P1 = pmidiscrhank(r, M, P);
	M ist Primzahl.
	P ist ein nichtkonstantes Polynom in r (1 <= r < BASIS) Variablen 
	ueber Z/MZ.
	P1 ist die Diskriminante von P (bzgl. der Hauptvariablen),
	also ein Polynom in r-1 Variablen.
	Zum Algorithmus vgl. E. Weiss, Algebraic Number theory, S. 105.



			pmieval( r, M, P, A )

	"polynomial over modular integers evaluation, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmieval(r,M,P,A)  single r; int M; pol P; int A;
	P1 = pmieval(r,M,P,A);
	M ist eine positive ganze Zahl.
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z / M*Z.
	A ist ein Element aus Z / M*Z.
	P1 = P(A) (Auswertung erfolgt bzgl. der Hauptvariablen).



			pmievalsv( r, m, P, n, a )

	"polynomial over modular integers evaluation, specified variable"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmievalsv(r,m,P,n,a)  single r; int m; pol P; single n; int a;
	P1 = pmievalsv(r,m,P,n,a);
	m ist eine positive ganze Zahl.
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z/mZ.
	n ist eine ganze Zahl mit 1<=n<=r.
	a ist ein Element aus Z/mZ.
	P1 = P(a) (Auswertung erfolgt bzgl. der n-ten Variablen).



			pmiexp( r, m, P, n )

	"polynomial over modular integers exponentiation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmiexp(r,m,P,n)  single r; int m; pol P; single n;
	P1 = pmiexp(r,m,P,n);
	m ist eine positive ganze Zahl.
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber Z/mZ.
	n ist eine ganze Zahl aus [0,BASIS-1].
	P1 = P ^ n.



			pmigcdcf( r, m, P1, P2, pQ1, pQ2 )

	"polynomial over modular integers greatest common divisor and
	cofactors" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmigcdcf(r,m,P1,P2,pQ1,pQ2)  single r; int m; pol P1,P2;
					 pol *pQ1,*pQ2;
	P3 = pmigcdcf(r,m,P1,P2,pQ1,pQ2);
	m ist eine Primzahl.
	P1 und P2 sind Polynome in r (1<=r<BASIS) Variablen ueber Z/mZ.
	P3 ist der groesste gemeinsame Teiler von P1 und P2.
	*pQ1 = P1 / P3, *pQ2 = P2 / P3,  falls P3 ungleich 0 ist;
	*pQ1 = 0 = *pQ2, sonst.
	Sollte pmigcdcf nicht in der Lage sein, den groessten
	gemeinsamen Teiler von P1 und P2 zu berechnen, wird ERROR
	als Ergebnis geliefert, und *pQ1 und *pQ2 sind 0.



			pmiinter( r, m, P1, P2, P3, a, b )

	"polynomial over modular integers interpolation" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmiinter(r,m,P1,P2,P3,a,b)  single r; int m; pol P1,P2,P3;
					int a,b;
	P4 = pmiinter(r,m,P1,P2,P3,a,b);
	m ist eine Primzahl.
	P1 ist ein Polynom in einer Variablen X1 ueber Z/mZ.
	P2 ist ein Polynom in r (1<=r<BASIS) Variablen X1,...,Xr
	ueber Z/mZ mit P2 gleich 0 oder Grad(P2) (bzgl. X1)
	kleiner Grad(P1).
	P3 ist ein Polynom in r-1 Variablen X2,...,Xr ueber Z/mZ.
	a ist ein Element aus Z/mZ mit P1(a) ungleich 0.
	b = P1(a)^-1.
	P4 ist das eindeutig bestimmte Polynom in X1,...,Xr ueber
	Z/mZ, so dass folgendes gilt:
	    P4(X1,...,Xr) kongruent P2(X1,...,Xr) modulo P1(X1);
	    P4(a,X2,...,Xr) = P3(X2,...,Xr);
	    Grad(P4) (bzgl. X1) < Grad(P1).



			pmimidprod( r, M, S, P1, P2 )

	"polynomial over modular integers, modular ideal product"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmimidprod(r,S,P1,P2) single r;int M;list S;pol P1,P2;
	P = pmimidprod(r,M,S,P1,P2);
	r ist positiv, ( 1<=r<BASIS ). M ist positiv.
	S ist eine Liste (s(1),..,s(r-1)) nicht-negativer singles.
	P1,P2 sind aus Z/M*Z[X1,..,Xr-1,Y]/(X1**s1,..,Xr-1**s(r-1)).
	P = P1 * P2.



			pmimidqhl( r, p, S, P1, P2, F1, F2, M, SL, H, pB )

	"polynomial over modular integers, modular ideal, Hensel lemma
	quadratic step"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmimidqhl(r,p,S,P1,P2,F1,F2,M,SL,H,pB) single r,p;int M;
					list S,SL;pol P1,P2,F1,F2,H,*pB;
	PA = pmimidqhl(r,p,S,P1,P2,F1,F2,M,SL,H,pB);
	r ist positiv, ( 1<=r<BASIS ).
	p ist Primzahl.
	S ist eine Liste (s(1),..,s(r-1)) positiver singles und
	SL ist eine Liste (sl(1),..,sl(r-1)) positiver singles.
	M ist eine positive ganze Zahl: M = p**j , mit einer
	positiven ganzen Zahl j.
	P1,P2,F1,F2 sind Elemente aus
	Z/p*Z[X1,..,Xr-1,Y]/(X1**s(1),..,Xr-1**s(r-1)),
	wobei P1 normiert und positiven Grades in Y ist.
	P1,P2,F1 und F2 erfuellen die Gleichung:
	P1 * F1 + P2 * F2 = 1 .
	H ist ein Polynom in r Variablen ueber Z, mit:
	P1 * P2 ist kongruent H.
	Dann sind PA und pB aus
	Z/p*Z[X1,..,Xr-1,Y]/(X1**sl(1),..,Xr-1**sl(r-1)).
	PA ist  normiert. Es gelten:
	PA ist kongruent P1,
	pB ist kongruent P2,
	Grad(PA) = Grad(P1) , mit dem Grad bzgl. Y und
	PA * pB ist kongruent H.



			pmimidqhls( r, M, S, P1, P2, F1, F2, i, l, H )

	"polynomial over modular integers, modular ideal, Hensel lemma
	quadratic step on a single variable"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list pmimidqhls(r,M,S,P1,P2,F1,F2,i,l,H) single r,i,l;int M;
					list S;pol P1,P2,F1,F2,H;
	L = pmimidqhls(r,M,S,P1,P2,F1,F2,i,l,H);
	r ist positiv, ( 2<=r<BASIS ).
	S ist eine Liste (s(1),..,s(r-1)) positiver singles.
	M ist eine positive ganze Zahl.
	P1,P2,F1,F2 sind Elemente aus
	Z/M*Z[X1,..,Xr-1,Y]/(X1**s(1),..,Xr-1**s(r-1)),
	wobei P1 normiert und positiven Grades in Y ist.
	P1,P2,F1 und F2 erfuellen die Gleichung:
	P1 * F1 + P2 * F2 = 1 .
	H ist ein Polynom in r Variablen ueber Z/M*Z, mit:
	P1 * P2 ist kongruent H.
	i ist positiv,(1<=i<r). n ist nicht-negativ.
	Dann ist L = ( Q1 , Q2, G1 , G2 ), wobei:
	Q1,Q2,G1 und G2 aus Z/M*Z[X1,..,Xr-1,Y] modulo dem Ideal
	(X1**s(1),..,Xi-1**s(i-1),Xi**l,Xi+1**s(i+1),..,Xr-1**s(r-1)).
	Q1 normiert. Es gelten:
	Q1 ist kongruent P1,
	Q2 ist kongruent P2,
	G1 ist kongruent F1,
	G2 ist kongruent F2,
	Grad(Q1) = Grad(P1) , mit dem Grad bzgl. Y und
	Q1 * Q2 ist kongruent H.
	S wird veraendert zu (s(1),..,s(i-1),l,s(i+1),..,s(r-1)).



			pmimidqrem( r, M, S, P1, P2, pR )

	"polynomial over modular integers monic, modular ideal
	quotient and remainder"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmimidqrem(r,M,S,P1,P2,pR) single r;int M;list S; pol P1,P2;
				      pol *pR;
	P = pmimidqrem(r,M,S,P1,P2,pR);
	r ist positiv, ( 1<=r<BASIS ). M ist positiv.
	S ist eine Liste (s(1),..,s(r-1)) nicht-negativer singles.
	P1,P2 sind aus Z/M*Z[X1,..,Xr-1,Y]/(X1**s1,..,Xr-1**s(r-1)),
	wobei P2 normiert ist.
	pR = P1 % P2.
	P  = P1 / P2.
	Hierbei gilt: Grad(pR) < Grad(P1) , mit dem Grad bzgl. Y.



			pmimidse( r, M, S, P1, P2, F1, F2, H, pV )

	"polynomial over modular integers modular ideal
	solution of equation"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmimidse(r,M,S,P1,P2,F1,F2,H,pV) single r;int M;list S;
				      pol P1,P2,F1,F2,H,*pV;
	PU = pmimidse(r,M,S,P1,P2,F1,F2,H,pV);
	r ist positiv, ( 1<=r<BASIS ). M ist positiv.
	S ist eine Liste (s(1),..,s(r-1)) nicht-negativer singles.
	P1,P2,F1,F2 und H sind Elemente aus
	Z/M*Z[X1,..,Xr-1,Y]/(X1**s1,..,Xr-1**s(r-1)),
	wobei P1 normiert und positiven Grades in Y ist.
	P1,P2,F1 und F2 erfuellen die Gleichung:
	P1 * F1 + P2 * F2 = 1 .
	Dann sind PU und pV auch aus
	Z/M*Z[X1,..,Xr-1,Y]/(X1**s1,..,Xr-1**s(r-1)),  mit
	P1 * PU + P2 * pV = H.
	Hierbei gilt: Grad(pV) < Grad(P1) mit dem Grad bzgl. Y.



			pmimiprod( r, M, P, A )

	"polynomial over modular integers, modular integers product"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmimiprod(r,M,P,A) single r; int A,M; pol P;
	P1 = pmimiprod(r,M,P,A);
	r ist nicht negativ, M ist positiv.
	P ist ein Polynom in r Variablen ueber Z/M*Z.
	A ist ein Element aus Z/M*Z.
	P1 = A * P.



			pmimiquot( r, m, P, a )

	"polynomial over modular integers, modular integer quotient"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmimiquot(r,m,P,a)  single r; int m; pol P; int a;
	P1 = pmimiquot(r,m,P,a);
	m ist eine positive ganze Zahl.
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber Z/mZ.
	a ist ein invertierbares Element aus Z/mZ.
	P1 = P / a.



			pmimonic( r, M, P )

	"polynomial over modular integers monic"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmimonic(r,M,P)  single r; int M; pol P;
	P1 = pmimonic(r,M,P);
	r ist nicht negativ, M ist positiv.
	P ist ein Polynom in r Variablen ueber Z/M*Z; der fuehrende
	Basiskoeffizient (bzgl. der Hauptvariablen) ist eine Einheit.
	Dann ist P1 das zu P assoziierte normierte Polynom.



			pmineg( r, M, P )

	"polynomial over modular integers negation" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmineg(r,M,P) single r; int M; pol P;
	P1 = pmineg(r,M,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber Z/MZ
	(M ist eine ganze Zahl groesser 0).
	P1 = -P.



			pmiprod( r, M, P1, P2 )

	"polynomial over modular integers product" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmiprod(r,M,P1,P2) single r; int M; pol P1,P2;
	P3 = pmiprod(r,M,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	Z/MZ (M eine ganze Zahl groesser 0).
	P3 = P1 * P2.



			pmipsrem( r, m, P1, P2 )

	"polynomial over modular integers pseudo remainder"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmipsrem(r,m,P1,P2)  single r; int m; pol P1,P2;
	P3 = pmipsrem(r,m,P1,P2);
	m ist eine Primzahl.
	P1 und P2 sind Polynome in r (1<=r<BASIS) Variablen ueber Z/mZ.
	P2 ist ungleich 0.
	P3 ist der Pseudo-Rest von P1 und P2, d.h.
	P3 = (P1 * k^(Grad(P1)-Grad(P2)+1)) % P2, wobei k der fuehrende
	Koeffizient von P2 ist und Grad(P1) groesser gleich Grad(P2);
	sonst ist P3 = P1.



			pmiqrem( r, M, P1, P2, pR )

	"polynomial over modular integers quotient and remainder"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmiqrem(r,M,P1,P2,pR) single r; int M; pol P1,P2;
				  pol *pR;
	P3 = pmiqrem(r,M,P1,P2,pR);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	Z/MZ, wobei M eine Primzahl ist; P2 ist ungleich 0.
	*pR = P1 % P2.
	P3 = P1 / P2.



			pmiquot( r, M, P1, P2 )         (MACRO)

	"polynomial over modular integers quotient"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmiquot(r,M,P1,P2) single r; int M; pol P1,P2;
	P3 = pmsquot(r,M,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	Z/MZ, wobei M eine Primzahl ist; P2 ungleich 0.
	P3 = P1 / P2.



			pmirem( r, M, P1, P2 )          (MACRO)

	"polynomial over modular integers remainder"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmirem(r,M,P1,P2)  single r; int M; pol P1,P2;
	P3 = pmsrem(r,M,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	Z/MZ, wobei M eine Primzahl ist; P2 ungleich 0.
	P3 = P1 % P2.



			pmires( r, m, P1, P2, n )

	"polynomial over modular integers resultant"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmires(r,m,P1,P2,n)  single r; int m; pol P1,P2; single n;
	P3 = pmires(r,m,P1,P2,n);
	m ist eine Primzahl.
	P1 und P2 sind Polynome in r (1<=r<BASIS) Variablen ueber Z/mZ.
	n gibt fuer r ungleich 1 den Algorithmus zur Berechnung der
	Resultante an:
	    n = 1:  Berechnung der Determinante der Sylvester-Matrix
		    (man vgl. psylvester);
	    n = 2:  Berechnung der Determinante der Bezout-Matrix;
		    (man vgl. pmibezout);
		    !! Warnung !! die Determinante der Bezout-Matrix
		    kann sich um den Faktor -1 von der Resultante
		    unterscheiden;
	    n = 3:  Collins-Algorithmus (man vgl. pmirescoll);
		    !! Warnung !! der Collins-Algorithmus fuehrt
		    moeglicherweise nicht zum Ziel; es wird dann
		    ERROR als Ergebnis geliefert.
	Fuer r gleich 1 wird der Collins-Algorithmus angewendet.
	P3 ist (mit obigen Einschraenkungen) die Resultante von P1
	und P2, d.h. ein Polynom in r-1 Variablen ueber Z/mZ.



			pmirescoll( r, m, P1, P2 )

	"polynomial over modular integers resultant, Collins algorithm"
	(rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmirescoll(r,m,P1,P2)  single r; int m; pol P1,P2;
	P3 = pmirescoll(r,m,P1,P2);
	m ist eine Primzahl.
	P1 und P2 sind Polynome positiven Grades in r (1<=r<BASIS)
	Variablen ueber Z/mZ.
	P3 ist die Resultante von P1 und P2, d.h. ein Polynom in
	r-1 Variablen ueber Z/mZ.
	pmirescoll arbeitet auf der Basis des Collins-Algorithmus und
	liefert ERROR, falls dieser nicht zum Ziel fuehrt.
	(vgl. G.E. Collins, The Calculation of Multivariate Polynomial
	Resultants, Journal ACM, No. 4,18 (Oct. 1971), 515-532.)
	(Man vgl. pmires.)



			pmisubst( r, m, P1, P2 )

	"polynomial over modular integers substitution, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmisubst(r,m,P1,P2)  single r; int m; pol P1; pol P2;
	P3 = pmisubst(r,m,P1,P2);
	m ist eine positive ganze Zahl.
	P1 ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z/mZ.
	P2 ist ein Polynom in r-1 Variablen ueber Z/mZ.
	P3 = P1(P2) ist ebenfalls ein Polynom in r-1 Variablen ueber Z/mZ
	(Substitution der Hauptvariablen).



			pmisubstsv( r, m, P1, n, P2 )

	"polynomial over modular integers substitution, specified
	variable" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmisubstsv(r,m,P1,n,P2)  single r,n; int m; pol P,P2;
	P3 = pmisubstsv(r,m,P1,n,P2);
	m ist eine positive ganze Zahl.
	P1 ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z/mZ.
	n ist eine ganze Zahl mit 1<=n<=r.
	P2 ist ein Polynom in n-1 Variablen ueber Z/mZ.
	P3 = P1(P2) (Substitution der n-ten Variablen).



			pmisum( r, M, P1, P2 )

	"polynomial over modular integers sum" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmisum(r,M,P1,P2) single r; int M; pol P1,P2;
	P3 = pmisum(r,M,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	Z/MZ (M eine ganze Zahl groesser 0).
	P3 = P1 + P2.



			pmitos( r, M, P )

	"polynomial over modular integers to symmetric remainder system"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmitos(r,M,P)  single r; int M; pol P;
	Ps= pmitos(r,M,P);
	r ist nicht negativ, M ist positiv.
	P ist ein Polynom ueber Z in r Variablen mit Koeffizienten aus
	dem positiven Restsystem modulo M.
	Ps ist ein Polynom ueber Z mit Koeffizienten aus dem symmetri-
	schen Restsystem modulo M, kongruent zu P modulo M.



			pmitrans( r, m, P, a )

	"polynomial over modular integers translation, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmitrans(r,m,P,a)  single r; int m; pol P; int a;
	P1 = pmitrans(r,m,P,a);
	m ist eine positive ganze Zahl.
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z/mZ.
	a ist ein Element aus Z/mZ.
	P1(X1,...,Xr) = P(X1,...,X(r-1),Xr+a).



			pmitransav( r, m, P, Lmi )

	"polynomial over modular integers translation, all variables"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmitransav(r,m,P,Lmi)  single r; int m; pol P; list Lmi;
	P1 = pmitransav(r,m,P,Lmi);
	m ist eine positive ganze Zahl.
	P ist ein Polynom in r (1<=r<BASIS) Variablen X1,...Xr
	ueber Z/mZ. Lmi ist eine Liste von r Elementen aus Z/mZ,
	es sei Lmi = ( ar ,..., a1 ).
	P1(X1,...,Xr) = P(X1+a1,...,Xr+ar);



			pmitransf( r1, m, P1, V1, r2, P2, V2, Vn, pV3 )

	"polynomial over modular integers transformation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmitransf(r1,m,P1,V1,r2,P2,V2,Vn,pV3)  single r1,r2; int m;
					 pol P1,P2; list V1,V2,Vn,*pV3;
	P3 = pmitransf(r1,m,P1,V1,r2,P2,V2,Vn,pV3);
	m ist eine positive ganze Zahl.
	P1 ist ein Polynom in r1 (1<=r1<BASIS) Variablen ueber Z/mZ mit
	zugehoerige Variablenliste V1.
	P2 ist ein Polynom in r2 (0<=r2<BASIS) Variablen ueber Z/mZ mit
	zugehoerige Variablenliste V2.
	Vn ist eine Liste, die einen in V1 auftretenden Variablennamen
	repraesentiert, d.h. man kann alle korrekten Listen Vn erhalten
	durch eine Zuweisung Vn = lelt(V1,l), wobei l eine Zahl ist mit
	1 <= l <= llength(V1).
	P3 ist das Polynom, das entsteht, indem in P1 die durch Vn 
	repraesentierte Variable durch das Polynom P2 ersetzt wird,
	d.h. P3 ist ein Polynom in #(V1 U V2) Variablen ueber Z/mZ.
	V1 U V2 ist alphabetisch geordnet in *pV3 abgelegt.



			pmiucont( r, m, P )

	"polynomial over modular integers univariate content" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmiucont(r,m,P)  single r; int m; pol P;
	P1 = pmiucont(r,m,P);
	m ist eine Primzahl.
	P ist ein Polynom aus Z/mZ[X1,...,Xr] mit 2<=r<BASIS.
	P1 ist der Inhalt von P ueber Z/mZ[X1].



			pmiupmiprod( r, m, P1, P2 )

	"polynomial over modular integers, univariate polynomial over
	modular integers product" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmiupmiprod(r,m,P1,P2)  single r; int m; pol P1,P2;
	P3 = pmiupmiprod(r,m,P1,P2);
	m ist eine ganze Zahl.
	P1 ist ein Polynom aus Z/mZ[X1,...,Xr] mit 1<=r<BASIS.
	P2 ist ein Polynom aus Z/mZ[X1].
	P3 = P1 * P2.



			pmiupmiquot( r, m, P1, P2 )

	"polynomial over modular integers, univariate polynomial over
	modular integers quotient" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmiupmiquot(r,m,P1,P2)  single r; int m; pol P1,P2;
	P3 = pmiupmiquot(r,m,P1,P2);
	m ist eine Primzahl.
	P1 ist ein Polynom aus Z/mZ[X1,...,Xr] mit 2<=r<BASIS.
	P2 ist ein Polynom aus Z/mZ[X1], das P1 teilt.
	P3 = P1 / P2.



			pmsbezout( r, m, P1, P2 )

	"polynomial over modular singles Bezout-matrix"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	matrix pmsbezout(r,m,P1,P2) single r,m; pol P1,P2;
	M = pmsbezout(r,m,P1,P2);
	P1 und P2 sind Polynome in r (1<=r<BASIS) Variablen ueber
	Z/mZ, m Primzahl aus [2,BASIS), mit
		pdegree(r,P1) >= pdegree(r,P2) >= 1.
	M ist die Bezout-Matrix zu P1 und P2.
	(Die Determinante von M stimmt - moeglicherweise bis auf
	den Faktor -1 - mit der Resultante von P1 und P2 ueberein.
	Man vgl. pmsres.)



			pmsderiv( r, m, P )

	"polynomial over modular singles derivation, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmsderiv(r,m,P) single r; single m; pol P;
	P1 = pmsderiv(r,m,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z/mZ
	(0<m<BASIS).
	P1 = P' (bzgl. der Hauptvariablen).



			pmsderivsv( r, m, P, n )

	"polynomial over modular singles derivation, specified variable"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmsderivsv(r,m,P,n) single r; single m; pol P; single n;
	P1 = pmsderivsv(r,m,P,n);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z/mZ
	(0<m<BASIS).
	n ist eine ganze Zahl mit 1<=n<=r.
	P1 = P' (bzgl. der n-ten Variablen).



			pmsdif( r, m, P1, P2 )

	"polynomial over modular singles difference" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmsdif(r,m,P1,P2) single r; single m; pol P1,P2;
	P3 = pmsdif(r,m,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	Z/mZ (0<m<BASIS).
	P3 = P1 - P2.



			pmsdiscr( r, m, P, n )

	"polynomial over modular singles discriminant"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmsdiscr(r, m, P, n)  single r, m; pol P; single n;
	P1 = pmsdiscr(r, m, P, n);
	P ist ein Polynom in r (1 <= r < BASIS) Variablen ueber Z/mZ, 
	wobei m eine Primzahl aus [2, BASIS] ist.
	P1 ist die Diskriminante von P (bzgl. der Hauptvariablen),
	also ein Polynom in r - 1 Variablen ueber Z/mZ.
	n gibt den Algorithmus zur Berechnung der Resultante von P 
	und P' an (n = 1, 2) bzw. den Algorithmus zur Berechnung der 
	Diskriminante (n = 3):
	    n = 1:  Berechnung der Determinante der Sylvester-Matrix
		    (man vgl. psylvester);
	    n = 2:  Collins-Algorithmus (man vgl. pmsrescoll);
		    !! Warnung !! der Collins-Algorithmus fuehrt
		    moeglicherweise nicht zum Ziel; es wird dann
		    ERROR als Ergebnis geliefert.   
	    n = 3:  Berechnung der Diskriminante mit Hankel-Matrix
		    (man vgl. pmidiscrhank);
	Falls M den Grad von P1 teilt, wird der Algorithmus mit 
	der Hankel-Matrix angewendet. Sonst wird fuer r = 1 der 
	Collins-Algorithmus angewendet.
	Im Zweifelsfalle sollte insbesondere fuer normierte Polynome
	n = 3 versucht werden. 



			pmseval( r, m, P, a )

	"polynomial over modular singles evaluation, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmseval(r,m,P,a) single r; single m; pol P; single a;
	P1 = pmseval(r,m,P,a);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z/mZ
	(0<m<BASIS).
	a ist ein Element aus Z/mZ.
	P1 = P(a) (Auswertung erfolgt bzgl. der Hauptvariablen).



			pmsevalsv( r, m, P, n, a )

	"polynomial over modular singles evaluation, specified variable"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmsevalsv(r,m,P,n,a) single r; single m; pol P; single n;
				 single a;
	P1 = pmsevalsv(r,m,P,n,a);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z/mZ
	(0<m<BASIS).
	n ist eine ganze Zahl mit 1<=n<=r.
	a ist ein Element aus Z/mZ.
	P1 = P(a) (Auswertung erfolgt bzgl. der n-ten Variablen).



			pmsexp( r, m, P, n )

	"polynomial over modular singles exponentiation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmsexp(r,m,P,n) single r,m; pol P; single n;
	P1 = pmsexp(r,m,P,n);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber Z/mZ
	mit m aus [1,BASIS-1]
	n ist eine ganze Zahl aus [0,BASIS-1].
	P1 = P ^ n.



			pmsgcdcf( r, m, P1, P2, pQ1, pQ2 )

	"polynomial over modular singles greatest common
	divisor and cofactors" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmsgcdcf(r,m,P1,P2,pQ1,pQ2) single r,m; pol P1,P2;
					pol *pQ1,*pQ2;
	P3 = pmsgcdcf(r,m,P1,P2,pQ1,pQ2);
	P1 und P2 sind Polynome in r (1<=r<BASIS) Variablen ueber
	Z/mZ, wobei 0<m<BASIS und m Primzahl sein muss.
	P3 ist der groesste gemeinsame Teiler von P1 und P2.
	*pQ1 = P1 / P3, *pQ2 = P2 / P3,  falls P3 ungleich 0 ist;
	*pQ1 = 0 = *pQ2, sonst.
	Sollte pmsgcdcf nicht in der Lage sein, den groessten
	gemeinsamen Teiler von P1 und P2 zu berechnen, wird -BASIS-1
	als Ergebnis geliefert und *pQ1 und *pQ2 sind 0.



			pmsinter( r, m, P1, P2, P3, a, b )

	"polynomial over modular singles interpolation" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmsinter(r,m,P1,P2,P3,a,b) single r,m; pol P1,P2,P3;
				       single a,b;
	P4 = pmsinter(r,m,P1,P2,P3,a,b);
	P1 ist ein Polynom in einer Variablen X1 ueber Z/mZ mit
	0<m<BASIS und m prim.
	P2 ist ein Polynom in r (1<=r<BASIS) Variablen X1,...,Xr
	ueber Z/mZ mit P2 gleich 0 oder Grad(P2) (bzgl. X1)
	kleiner Grad(P1).
	P3 ist ein Polynom in r-1 Variablen X2,...,Xr ueber Z/mZ.
	a ist ein Element aus Z/mZ mit P1(a) ungleich 0.
	b = P1(a)^-1.
	P4 ist das eindeutig bestimmte Polynom in X1,...,Xr ueber
	Z/mZ, so dass folgendes gilt:
	    P4(X1,...,Xr) kongruent P2(X1,...,Xr) modulo P1(X1);
	    P4(a,X2,...,Xr) = P3(X2,...,Xr);
	    Grad(P4) (bzgl. X1) < Grad(P1).



			pmsmonic( r, m, P )

	"polynomial over modular singles monic"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmsmonic(r,m,P) single r,m; pol P;
	P1 = pmsmonic(r,m,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z/mZ
	(0<m<BASIS); der fuehrende Basiskoeffizient (bzgl. der Haupt-
	variablen) ist eine Einheit in Z/mZ.
	P1 ist das zu P assoziierte normierte Polynom.



			pmsmsprod( r, m, P, a )

	"polynomial over modular singles, modular single product"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmsmsprod(r,m,P,a) single r; single m; pol P; single a;
	P1 = pmsmsprod(r,m,P,a);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber Z/mZ
	(0<m<BASIS).
	a ist ein Element aus Z/mZ.
	P1 = a * P.



			pmsmsquot( r, m, P, a )

	"polynomial over modular singles, modular single quotient"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmsmsquot(r,m,P,a) single r; single m; pol P; single a;
	P1 = pmsmsquot(r,m,P,a);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber Z/mZ
	(0<m<BASIS).
	a ist ein invertierbares Element aus Z/mZ.
	P1 = P / a.



			pmsneg( r, m, P )

	"polynomial over modular singles negation" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmsneg(r,m,P) single r; single m; pol P;
	P1 = pmsneg(r,m,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber Z/mZ
	(0<m<BASIS).
	P1 = -P.



			pmsprod( r, m, P1, P2 )

	"polynomial over modular singles product" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmsprod(r,m,P1,P2) single r; single m; pol P1,P2;
	P3 = pmsprod(r,m,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	Z/mZ (0<m<BASIS).
	P3 = P1 * P2.



			pmspsrem( r, m, P1, P2 )

	"polynomial over modular singles pseudo remainder"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmspsrem(r,m,P1,P2) single r,m; pol P1,P2;
	P3 = pmspsrem(r,m,P1,P2);
	P1 und P2 sind Polynome in r (1<=r<BASIS) Variablen
	ueber Z/mZ mit m Primzahl aus [2,BASIS].
	P2 ist ungleich 0.
	P3 ist der Pseudo-Rest von P1 und P2, d. h.
	P3 = (P1 * k^(Grad(P1)-Grad(P2)+1)) % P2, wobei k der fuehrende
	Koeffizient von P2 ist und Grad(P1) groesser gleich Grad(P2);
	sonst ist P3 = P1.



			pmsqrem( r, m, P1, P2, pR )

	"polynomial over modular singles quotient and remainder"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmsqrem(r,m,P1,P2,pR) single r; single m; pol P1,P2;
				  pol *pR;
	P3 = pmsqrem(r,m,P1,P2,pR);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	Z/mZ (0<m<BASIS); m muss Primzahl sein; P2 ist ungleich 0.
	*pR = P1 % P2.
	P3 = P1 / P2.



			pmsquot( r, m, P1, P2 )         (MACRO)

	"polynomial over modular singles quotient"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmsquot(r,m,P1,P2) single r; single m; pol P1,P2;
	P3 = pmsquot(r,m,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	Z/mZ (0<m<BASIS) und m ist Primzahl; P2 ungleich 0.
	P3 = P1 / P2.



			pmsrem( r, m, P1, P2 )          (MACRO)

	"polynomial over modular singles remainder"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmsrem(r,m,P1,P2) single r; single m; pol P1,P2;
	P3 = pmsrem(r,m,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	Z/mZ (0<m<BASIS) und m ist Primzahl; P2 ungleich 0.
	P3 = P1 % P2.



			pmsres( r, m, P1, P2, n )

	"polynomial over modular singles resultant"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmsres(r,m,P1,P2,n) single r,m; pol P1,P2; single n;
	P3 = pmsres(r,m,P1,P2,n);
	P1 und P2 sind Polynome in r (1<=r<BASIS) Variablen ueber
	Z/mZ, wobei m eine Primzahl aus [2,BASIS] ist.
	n gibt fuer r ungleich 1 den Algorithmus zur Berechnung der
	Resultante an:
	    n = 1:  Berechnung der Determinante der Sylvester-Matrix
		    (man vgl. psylvester);
	    n = 2:  Berechnung der Determinante der Bezout-Matrix;
		    (man vgl. pmsbezout);
		    !! Warnung !! die Determinante der Bezout-Matrix
		    kann sich um den Faktor -1 von der Resultante
		    unterscheiden;
	    n = 3:  Collins-Algorithmus (man vgl. pmsrescoll);
		    !! Warnung !! der Collins-Algorithmus fuehrt
		    moeglicherweise nicht zum Ziel; es wird dann
		    -BASIS-1 als Ergebnis geliefert.
	Fuer r gleich 1 wird der Collins-Algorithmus angewendet.
	P3 ist (mit obigen Einschraenkungen) die Resultante von P1
	und P2, d. h. ein Polynom in r-1 Variablen ueber Z/mZ.



			pmsrescoll( r, m, P1, P2 )

	"polynomial over modular singles resultant, Collins algorithm"
	(rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmsrescoll(r,m,P1,P2) single r,m; pol P1,P2;
	P3 = pmsrescoll(r,m,P1,P2);
	P1 und P2 sind Polynome positiven Grades in r (1<=r<BASIS)
	Variablen ueber Z/mZ, wobei m eine Primzahl aus [2,BASIS]
	ist.
	P3 ist die Resultante von P1 und P2, d. h. ein Polynom in
	r-1 Variablen ueber Z/mZ.
	pmsrescoll arbeitet auf der Basis des Collins-Algorithmus und
	liefert -BASIS-1, falls dieser nicht zum Ziel fuehrt.
	(vgl. G.E. Collins, The Calculation of Multivariate Polynomial
	Resultants, Journal ACM, No. 4,18 (Oct. 1971), 515-532.)
	(Man vgl. pmsres.)



			pmssubst( r, m, P1, P2 )

	"polynomial over modular singles substitution, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmssubst(r,m,P1,P2) single r; single m; pol P1; pol P2;
	P3 = pmssubst(r,m,P1,P2);
	P1 ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z/mZ
	(0<m<BASIS).
	P2 ist ein Polynom in r-1 Variablen ueber Z/mZ.
	P3 = P1(P2) ist ebenfalls ein Polynom in r-1 Variablen ueber Z/mZ
	(Substitution der Hauptvariablen).



			pmssubstsv( r, m, P1, n, P2 )

	"polynomial over modular singles substitution, specified
	variable" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmssubstsv(r,m,P1,n,P2) single r; single m; pol P;
				    single n; pol P2;
	P3 = pmssubstsv(r,m,P1,n,P2);
	P1 ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z/mZ
	(0<m<BASIS).
	n ist eine ganze Zahl mit 1<=n<=r.
	P2 ist ein Polynom in n-1 Variablen ueber Z/mZ.
	P3 = P1(P2) (Substitution der n-ten Variablen).



			pmssum( r, m, P1, P2 )

	"polynomial over modular singles sum" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmssum(r,m,P1,P2) single r; single m; pol P1,P2;
	P3 = pmssum(r,m,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	Z/mZ (0<m<BASIS).
	P3 = P1 + P2.



			pmstopgfs( r, p, P )

	"polynomial over modular singles to polynomial over Galois-field
	with single characteristic" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pmstopgfs(r,p,P) single r,p; pol P;
	P1 = pmstopgfs(r,p,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber Z/pZ.
	p ist eine Primzahl kleiner BASIS.
	Dann gilt fuer eine beliebige natuerliche Zahl n aus [1,(BASIS-1)]:
	P1 = P (aufgefasst als Polynom ueber GF(p^n)).
	Das heisst die Basiskoeffizienten werden von Z/pZ nach GF(p^n)
	eingebettet.



			pmstrans( r, m, P, a )

	"polynomial over modular singles translation, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmstrans(r,m,P,a) single r,m; pol P; single a;
	P1 = pitrans(r,m,P,a);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber Z/mZ
	(0<m<BASIS). a ist ein Element aus Z/mZ.
	P1(X1,...,Xr) = P(X1,...,X(r-1),Xr+a).



			pmstransav( r, m, P, Lms )

	"polynomial over modular singles translation, all variables"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmstransav(r,m,P,Lms) single r,m; pol P; list Lms;
	P1 = pmstransav(r,m,P,Lms);
	P ist ein Polynom in r (1<=r<BASIS) Variablen X1,...Xr
	ueber Z/mZ (0<m<BASIS). Lms ist eine Liste von r Elementen
	aus Z/mZ: Lms = ( ar ,..., a1 ).
	P1(X1,...,Xr) = P(X1+a1,...,Xr+ar);



			pmstransf( r1, m, P1, V1, r2, P2, V2, Vn, pV3 )

	"polynomial over modular singles transformation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pmstransf(r1,m,P1,V1,r2,P2,V2,Vn,pV3) single r1,m; pol P1;
					list V1; single r2; pol P2;
					list V2; list Vn; list *pV3;
	P3 = pmstransf(r1,m,P1,V1,r2,P2,V2,Vn,pV3);
	P1 ist ein Polynom in r1 (1<=r1<BASIS) Variablen ueber Z/mZ
	(0<m<BASIS); V1 ist die zugehoerige Variablenliste.
	P2 ist ein Polynom in r2 (0<=r2<BASIS) Variablen ueber Z/mZ
	(0<m<BASIS); V2 ist die zugehoerige Variablenliste.
	Vn ist eine Liste, die einen in V1 auftretenden Variablennamen
	repraesentiert.
	P3 ist das Polynom, das entsteht, wenn in P1 die Variable Vn
	durch das Polynom P2 ersetzt wird, und die zugehoerige, in
	*pV3 abgelegte Variablenliste alphabetisch sortiert ist.
	(Die in *pV3 abgelegte Variablenliste ist die Vereinigung von
	V1 und V2.)



			pmsucont( r, m, P )

	"polynomial over modular singles univariate content" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmsucont(r,m,P) single r,m; pol P;
	P1 = pmsucont(r,m,P);
	P ist ein Polynom aus Z/mZ[X1,...,Xr] mit 0<m<BASIS,
	m Primzahl und 2<=r<BASIS.
	P1 ist der Inhalt von P ueber Z/mZ[X1].



			pmsupmsprod( r, m, P1, P2 )

	"polynomial over modular singles, univariate polynomial
	over modular singles product" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmsupmsprod(r,m,P1,P2) single r,m; pol P1,P2;
	P3 = pmsupmsprod(r,m,P1,P2);
	P1 ist ein Polynom aus Z/mZ[X1,...,Xr], wobei:
	1<=r<BASIS,  0<m<BASIS.
	P2 ist ein Polynom aus Z/mZ[X1].
	P3 = P1 * P2.



			pmsupmsquot( r, m, P1, P2 )

	"polynomial over modular singles, univariate polynomial
	over modular singles quotient" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol pmsupmsquot(r,m,P1,P2) single r,m; pol P1,P2;
	P3 = pmsupmsquot(r,m,P1,P2);
	P1 ist ein Polynom aus Z/mZ[X1,...,Xr], wobei:
	2<=r<BASIS,  0<m<BASIS, m Primzahl.
	P2 ist ein Polynom aus Z/mZ[X1], das P1 teilt.
	P3 = P1 / P2.



			pnfderiv( r, F, P )

	"polynomial over number field derivation, main variable"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfderiv(r,F,P)  single r; pol F,P;
	P1 = pnfderiv(r,F,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber einem Zahl-
	koerper K. F ist das zugehoerige Minimalpolynom in einer Variablen
	ueber Z vom Grad n >= 1 in dense-Darstellung, d.h. K entsteht
	durch Adjunktion einer Nullstelle von F.
	P1 = P' (bzgl. der Hauptvariablen).



			pnfderivsv( r, F, P, n )

	"polynomial over number field derivation, specified variable"
	(rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfderivsv(r,F,P,n)  single r; pol F,P; single n;
	P1 = pnfderivsv(r,F,P,n);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber einem Zahl-
	koerper K. F ist das zugehoerige Minimalpolynom in einer Variablen
	ueber Z vom Grad n >= 1 in dense-Darstellung, d.h. K entsteht
	durch Adjunktion einer Nullstelle von F.
	n ist eine ganze Zahl mit 1 <= n <= r.
	P1 = P' (bzgl. der n-ten Variablen).



			pnfdif( r, F, P1, P2 )

	"polynomial over number field difference" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfdif(r,F,P1,P2) single r; pol F,P1,P2;
	P3 = pnfdif(r,F,P1,P2);
	F ist ein irreduzibles Polynom ueber Z in einer Variablen in
	dense-Darstellung, das einen Zahlkoerper K erzeugt.
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber K.
	P3 = P1 - P2.



			pnfeval( r, F, P, a )

	"polynomial over number field evaluation, main variable"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfeval(r,F,P,a) single r; pol F,P; nfel a;
	P1 = pnfeval(r,F,P,a);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber einem Zahl-
	koerper K. F ist das zugehoerige Minimalpolynom in einer Variablen
	ueber Z vom Grad n >= 1 in dense-Darstellung, d.h. K entsteht
	durch Adjunktion einer Nullstelle von F.
	a ist ein Element des Zahlkoerpers K.
	P1 = P(a) (Auswertung erfolgt bzgl. der Hauptvariablen).



			pnfevalsv( r, F, P, n, a )

	"polynomial over number field evaluation, specified variable"
	(rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfevalsv(r,F,P,n,a) single r; pol F,P; single n; nfel a;
	P1 = pnfevalsv(r,F,P,n,a);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber einem Zahl-
	koerper K. F ist das zugehoerige Minimalpolynom in einer Variablen
	ueber Z vom Grad n >= 1 in dense-Darstellung, d.h. K entsteht
	durch Adjunktion einer Nullstelle von F.
	a ist ein Element des Zahlkoerpers K.
	n ist eine ganze Zahl mit 1<=n<=r.
	P1 = P(a) (Auswertung erfolgt bzgl. der n-ten Variablen).



			pnfexp( r, F, P, n )

	"polynomial over number field exponentiation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfexp(r,F,P,n)  single r;  pol F, P;  single n;
	P1 = pnfexp(r,F,P,n);
	F ist ein irreduzibles Polynom ueber Z in einer Variablen in
	dense-Darstellung, das einen Zahlkoerper K erzeugt.
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber K.
	n ist eine ganze Zahl aus [0,BASIS-1].
	P1 = P ^ n.



			pnfmonic( r, F, P )

	"polynomial over number field monic"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfmonic(r,F,P)  single r; pol F, P;
	P1 = pnfmonic(r,F,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber einem Zahl-
	koerper K. F ist das zugehoerige Minimalpolynom in einer Variablen
	ueber Z vom Grad n >= 1 in dense-Darstellung, d.h. K entsteht
	durch Adjunktion einer Nullstelle von F.
	Dann ist P1 das zu P assoziierte normierte Polynom.
	( Im Fall P = 0 ist dann P1 = 0 ).



			pnfneg( r, F, P )

	"polynomial over number field negation" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfneg(r,F,P) single r; pol F,P;
	P1 = pnfneg(r,F,P);
	F ist ein irreduzibles Polynom ueber Z in einer Variablen in
	dense-Darstelung, das einen Zahlkoerper K erzeugt.
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber K.
	P1 = -P.



			pnfnfprod( r, F, P, a )

	"polynomial over number field, number field element product"
	(rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfnfprod(r,F,P,a) single r; pol F,P; nfel a;
	P1 = pnfnfprod(r,F,P,a);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber einem Zahl-
	koerper K. F ist das zugehoerige Minimalpolynom in einer Variablen
	ueber Z vom Grad n >= 1 in dense-Darstellung, d.h. K entsteht
	durch Adjunktion einer Nullstelle von F.
	a ist ein Element des Zahlkoerpers K.
	P1 = a * P.



			pnfnfquot( r, F, P, a )

	"polynomial over number field, number field element quotient"
	(rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfnfquot(r,F,P,a) single r; pol F,P; nfel a;
	P1 = pnfnfquot(r,F,P,a);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber einem Zahl-
	koerper K. F ist das zugehoerige Minimalpolynom in einer Variablen
	ueber Z vom Grad n >= 1 in dense-Darstellung, d.h. K entsteht
	durch Adjunktion einer Nullstelle von F.
	a ist ein Element des Zahlkoerpers K, a ist ungleich Null.
	P1 = P/a.



			pnfprod( r, F, P1, P2 )

	"polynomial over number field product" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfprod(r,F,P1,P2) single r; pol F,P1,P2;
	P3 = pnfprod(r,F,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber einem
	Zahlkoerper K. F ist das zugehoerige Minimalpolynom in einer
	Variablen ueber Z vom Grad n >= 1 in dense-Darstellung, d.h. K
	entsteht durch Adjunktion einer Nullstelle von F.
	P3 = P1 * P2.



			pnfqrem( r, F, P1, P2, pR )

	"polynomial over number field quotient and remainder" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfqrem(r,F,P1,P2,pR) single r; pol F,P1,P2; pol *pR;
	P3 = pnfqrem(r,F,P1,P2,pR);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber einem
	Zahlkoerper K. F ist das zugehoerige Minimalpolynom in einer
	Variablen ueber Z vom Grad n >= 1 in dense-Darstellung, d.h. K
	entsteht durch Adjunktion einer Nullstelle von F.
	*pR = P1 % P2.
	P3  = P1 / P2.



			pnfquot( r, F, P1, P2 )         (MACRO)

	"polynomial over number field quotient"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfquot(r,F,P1,P2) single r; pol F,P1,P2;
	P3 = pnfquot(r,F,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber einem
	Zahlkoerper K. F ist das zugehoerige Minimalpolynom in einer
	Variablen ueber Z vom Grad n >= 1 in dense-Darstellung, d.h. K
	entsteht durch Adjunktion einer Nullstelle von F.
	P3  = P1 / P2.



			pnfrem( r, F, P1, P2 )          (MACRO)

	"polynomial over number field remainder"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfrem(r,F,P1,P2) single r; pol F,P1,P2;
	P3 = pnfrem(r,F,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber einem
	Zahlkoerper K. F ist das zugehoerige Minimalpolynom in einer
	Variablen ueber Z vom Grad n >= 1 in dense-Darstellung, d.h. K
	entsteht durch Adjunktion einer Nullstelle von F.
	P3  = P1 % P2.



			pnfsum( r, F, P1, P2 )

	"polynomial over number field sum" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnfsum(r,F,P1,P2) single r; pol F,P1,P2;
	P3 = pnfsum(r,F,P1,P2);
	F ist ein irreduzibles Polynom ueber Z in einer Variablen in
	dense-Darstellung, das einen Zahlkoerper K erzeugt.
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber K.
	P3 = P1 + P2;



			pnftopr( r, P )

	"polynomial over number field to polynomial over rationals"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnftopr(r, P)  single r;  pol P;
	Q = pnftopr(r, P);
        P ist ein Polynom in r Variablen ueber einem Zahlkoerper.
	Q ist ein Polynom in r + 1 Variablen ueber Q, das aus P
	hervorgegangen ist durch Umformung der Koeffizienten von P,
	die algebraische Zahlen sind, in Polynome in einer
	Variablen ueber Q.



			pnftransf( r1, F, P1, V1, r2, P2, V2, Vn, pV3 )

	"polynomial over number field transformation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol pnftransf(r1,F,P1,V1,r2,P2,V2,Vn,pV3)  single r1,r2; 
				pol F,P1,P2; list V1,V2,Vn,*pV3;
	P3 = pnftransf(r1,F,P1,V1,r2,P2,V2,Vn,pV3);
	Dabei muss gelten:
	      - 1 <= r1 < BASIS.
	      - F ist ein irreduzibles Polynom ueber Z in einer Variab-
	        len in dense-Darstellung, das einen Zahlkoerper K er-
		zeugt.	
	      - P1 ist ein Polynom in r1 Variablen ueber K.
	      - V1 ist die zum Polynom P1 gehoerige Variablenliste.
	      - 0 <= r2 < BASIS.
	      - P2 ist ein Polynom in r2 Variablen ueber K.
	      - V2 ist die zum Polynom P2 gehoerige Variablenliste.
	      - Vn ist eine Liste, die einen in V1 auftretenden Variab-
		lennamen repraesentiert.
	      - In *pV3 ist die Vereinigung der Variablenlisten V1 und
	        V2 abgelegt, und zwar alphabetisch sortiert.
	P3 ist das Polynom, das entsteht, indem in P1 die durch Vn 
	repraesentierte Variable durch das Polynom P2 ersetzt wird.



			ppfderiv( r, p, P )

	"polynomial over p-adic field derivation, main variable" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfderiv( r, p, P )  single r,p; pol P;
	P1 = ppfderiv( r, p, P );
	Dabei muss gelten:
		- p ist Primzahl.
		- P ist Polynom in r ( 1 <= r < BASIS ) Variablen ueber
		  den p-adischen Zahlen.
	Dabei sind die Koeffizienten der Polynome jeweils Approximationen
	von Zahlen aus Qp.
	P1 = P' ( nach der Hauptvariablen )



			ppfderivsv( r, p, P, n )

	"polynomial over p-adic field derivation, selected variable"
	 ( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfderivsv( r, p, P, n )  single r,p,n; pol P;
	P1 = ppfderivsv( r, p, P, n );
	Dabei muss gelten:
		- p ist Primzahl.
		- P ist Polynom in r ( 1 <= r < BASIS ) Variablen ueber
		  den p-adischen Zahlen.
		- n ist die "Nummer" der Variablen, bzgl. der abgeleitet
		  werden soll. Daher muss gelten:
			0 < n <= r
	Dabei sind die Koeffizienten der Polynome jeweils Approximationen
	von Zahlen aus Qp.
	P1 = P' ( nach der n-ten Variablen )



			ppfdif( r, p, P1, P2 )

	"polynomial over p-adic field difference"   ( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfdif( r, p, P1, P2 )  single p,r; pol P1,P2;
	P3 = ppfdif( r, p, P1, P2 );
	Dabei muss gelten:
		- p ist Primzahl.
		- P1 und P2 sind Polynome in r ( 0 <= r < BASIS ) Variab-
		  len ueber den p-adischen Zahlen.
	Dabei sind die Koeffizienten der Polynome jeweils Approximatio-
	nen von Zahlen aus Qp.
	P3 = P1 - P2    ( p-adisch )



			ppfeval( r, p, P, A )

	"polynomial over p-adic field evaluation, main variable"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfeval( r, p, P, A )  single r,p; pol P; pfel A;
	P1 = ppfeval( r, p, P, A );
	Dabei muss gelten:
		- p ist Primzahl.
		- P ist Polynom in r ( 1 <= r < BASIS ) Variablen ueber
		  den p-adischen Zahlen.
	Dabei sind die Koeffizienten des Polynoms jeweils Approximationen
	von Zahlen aus Qp.
	P1 = P( A )     ( bzgl. der Hauptvariablen )
	Achtung: Ist P Polynom in einer Variablen, ist P( A ) sowohl vom
	-------  Typ pol als auch vom Typ pfel.



			ppfevalsv( r, p, P, n, A )

	"polynomial over p-adic field evaluation, selected variable"
	 ( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfevalsv( r, p, P, n, A )  single r, p, n; pol P; pfel A;
	P1 = ppfevalsv( r, p, P, n, A );
	Dabei muss gelten:
		- p ist Primzahl.
		- P ist Polynom in r ( 1 <= r < BASIS ) Variablen ueber
		  den p-adischen Zahlen.
		- n ist die "Nummer" der Variablen bzgl. der ausgewertet
		  werden soll. Daher muss gelten:
			0 < n <= r
	Dabei sind die Koeffizienten des Polynoms jeweils Approximationen
	von Zahlen aus Qp.
	P1 = P( A )     ( bzgl. der n-ten Variablen )
	Achtung: Ist P Polynom in einer Variablen, ist P( A ) sowohl vom
	-------  Typ pol, als auch vom Typ pfel.



			ppfexp( r, p, P, n )

	"polynomial over p-adic field exponentiation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfexp( r, p, P, n )  single p, r, n; pol P;
	P1 = ppfexp( r, p, P, n );
	Dabei muss gelten:
		- p ist Primzahl.
		- P ist Polynom in r ( 0 <= r < BASIS ) Variablen ueber
		  den p-adischen Zahlen.
		- n ist eine ganze Zahl aus [ 0,BASIS-1 ].
	Dabei sind die Koeffizienten des Polynoms jeweils Approximationen
	von Zahlen aus Qp.
	P1 = P^n   ( p-adisch )



			ppffit( r, p, P, d )

	"polynomial over p-adic field fitting"    ( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppffit( r, p, P, d )  single r, p, d; pol P;
	Pd = ppffit( r, p, P, d );
	Dabei muss gelten:
	      - p ist Primzahl.
	      - P ist Polynom in r Variablen ( 0 <= r < BASIS ) ueber
		dem p-adischen Zahlkoerper mit den Koeffizienten ai.
	      - P ist  u n g l e i c h  dem Nullpolynom.
	      - d ist die maximal gemeinsame Genauigkeit der von Null
		verschiedenen Koeffizienten ai. ( also: d = ppford(r,p,P) )
	Dabei sind die ai jeweils Approximationen von Ai aus Qp vom Grad
	di, fuer die bzgl. der additiven p-adischen Bewertung
	vp gilt:
		vp( Ai - ai ) >= di
	und     ai = 0                             , falls di < vp( Ai )
	sonst   ai = ai_vp( Ai ) * p^vp( Ai ) + ... + ai_di * p^di,
	wobei   ai_vp( Ai ) != 0          und
		0 <= ai_j <= p - 1
	Fuer ai ergibt sich folgende Form:
		ai = 0                   , falls a = 0 oder di < vp( Ai )
		     ( di, ai_vp( Ai ), ..., ai_di )             , sonst
	Pd = Polynom, dessen Koeffizienten ai != 0 auf ihre maximal ge-
	     meinsame Genauigkeit d angepasst werden.



			ppfiprod( r, p, P, i )

	"polynomial over p-adic field integer product"    ( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfiprod( r, p, P, i )  single p,r; pol P; int i;
	P1 = ppfiprod( r, p, P, i );
	Dabei muss gelten:
		- p ist Primzahl.
		- P ist Polynom in r ( 0 <= r < BASIS ) Variablen ueber
		  den p-adischen Zahlen.
	Dabei sind die Koeffizienten des Polynoms jeweils Approximationen
	von Zahlen aus Qp.
	P1 = P * i  ( p-adisch )



			ppfneg( r, p, P )

	"polynomial over p-adic field negation"  ( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfneg( r, p, P )  single p, r; pol P;
	P1 = ppfneg( r, p, P );
	Dabei muss gelten:
		- p ist prim.
		- P ist Polynom in r ( 0 <= r < BASIS ) Variablen ueber
		  den p-adischen Zahlen.
	Dabei sind die Koeffizienten des Polynoms jeweils Approximationen
	von Zahlen aus Qp.
	P1 = -P ( p-adisch )



			ppford( r, p, P )

	"polynomial over p-adic field order"    ( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	single ppford( r, p, P )  single p,r; pol P;
	d = ppford( r, p, P );
	Dabei muss gelten:
	      - p ist Primzahl.
	      - P ist Polynom in r Variablen ( 0 <= r < BASIS ) ueber
		dem p-adischen Zahlkoerper Qp mit den Koeffizienten ai.
	      - P ist  u n g l e i c h  dem Nullpolynom.
	Dabei sind die ai jeweils Approximationen von Ai aus Qp vom Grad
	di, fuer die bzgl. der additiven p-adischen Bewertung
	vp gilt:
		vp( Ai - ai ) >= di
	und     ai = 0                            , falls di <= vp( Ai )
	sonst   ai = ai_vp( Ai ) * p^vp( Ai ) + ... + ai_di * p^di,
	wobei   ai_vp( Ai ) != 0          und
		0 <= ai_j <= p - 1
	Fuer ai ergibt sich folgende Form:
		ai = 0                  , falls a = 0 oder alle ai_j = 0
		     ( di, ai_vp( Ai ), ..., ai_di )             , sonst
	d = min{ di | ai != 0 }
	ist die maximal gemeinsame Genauigkeit aller Koeffizienten von P.



			ppfpfprod( r, p, P, b )

	"polynomial over p-adic field p-adic field element product"
	( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfpfprod( r, p, P, b )  single r,p; pol P; pfel b;
	P1 = ppfpfprod( r, p, P, b );
	Dabei muss gelten:
		- p ist Primzahl.
		- P ist Polynom in r ( 0 <= r < BASIS ) Variablen ueber
		  den p-adischen Zahlen.
	Dabei sind die Koeffizienten des Polynoms jeweils Approximationen
	von Zahlen aus Qp.
	P1 = P * b    ( p-adisch )



			ppfpprod( r, p, P, i )

	"polynomial over p-adic field prime power product"  ( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfpprod( r, p, P, i )  single p, r, i; pol P;
	P1 = ppfpprod( r, p, P, i );
	Dabei muss gelten:
		- p ist Primzahl.
		- P ist Polynom in r ( 0 <= r < BASIS ) Variablen ueber
		  den p-adischen Zahlen.
	Dabei sind die Koeffizienten des Polynoms jeweils Approximationen
	von Zahlen aus Qp.
	P1 = P * p^i    ( p-adisch )



			ppfprod( r, p, P1, P2 )

	"polynomial over p-adic field product"   ( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfprod( r, p, P1, P2 )  single p,r; pol P1,P2;
	P3 = ppfprod( r, p, P1, P2 );
	Dabei muss gelten:
		- p ist Primzahl.
		- P1 und P2 sind Polynome in r ( 0 <= r < BASIS ) Variab-
		  len ueber den p-adischen Zahlen.
	Dabei sind die Koeffizienten der Polynome jeweils Approximationen
	von Zahlen aus Qp.
	P3 = P1 * P2    ( p-adisch )



			ppfrprod( r, p, P, R )

	"polynomial over p-adic field rational number product"  (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfrprod( r, p, P, R )  single p,r; pol P; rat R;
	P1 = ppfrprod( r, p, P, R );
	Dabei muss gelten:
		- p ist Primzahl.
		- P ist Polynom in r ( 0 <= r < BASIS ) Variablen ueber
		  den p-adischen Zahlen.
	Dabei sind die Koeffizienten des Polynoms jeweils Approximationen
	von Zahlen aus Qp.
	P1 = P * R      ( p-adisch )



			ppfsubst( r, p, P1, P2 )

	"polynomial over p-adic field substitution, main variable"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfsubst( r, p, P1, P2 )  single r,p; pol P1,P2;
	P = ppfsubst( r, p, P1, P2 );
	Dabei muss gelten:
		- p ist Primzahl.
		- P1 ist Polynom in r ( 1 <= r < BASIS ) Variablen ueber
		  den p-adischen Zahlen.
		- P2 ist Polynom in r - 1 Variablen ueber den p-adischen
		  Zahlen.
	Dabei sind die Koeffizienten der Polynome jeweils Approximationen
	von Zahlen aus Qp.
	P = P1( P2 )     ( bzgl. der Hauptvariablen )
	Achtung: Ist P1 Polynom in einer Variablen, ist P1( P2 ) sowohl
	-------  vom Typ pol als auch vom Typ pfel.



			ppfsubstsv( r, p, P1, n, P2 )

	"polynomial over p-adic field substitution, selected variable"
	 ( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfsubstsv( r, p, P1, n, P2 )  single r, p, n; pol P1,P2;
	P = ppfsubstsv( r, p, P1, n, P2 );
	Dabei muss gelten:
		- p ist Primzahl.
		- P1 ist Polynom in r ( 1 <= r < BASIS ) Variablen ueber
		  den p-adischen Zahlen.
		- n ist die "Nummer" der Variablen bzgl. der substituiert
		  wird. Daher muss gelten:
			0 < n <= r
		- P2 ist Polynom in n - 1 Variablen ueber den p-adischen
		  Zahlen.
	Dabei sind die Koeffizienten der Polynome jeweils Approximationen
	von Zahlen aus Qp.
	P = P1( P2 )     ( bzgl. der n-ten Variablen )
	Achtung: Ist P1 Polynom in einer Variablen, ist P1( P2 ) sowohl
	-------  vom Typ pol als auch vom Typ pfel.



			ppfsum( r, p, P1, P2 )

	"polynomial over p-adic field sum"   ( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppfsum( r, p, P1, P2 )  single p,r; pol P1,P2;
	P3 = ppfsum( r, p, P1, P2 );
	Dabei muss gelten:
		- p ist Primzahl.
		- P1 und P2 sind Polynome in r ( 0 <= r < BASIS ) Variab-
		  len ueber den p-adischen Zahlen.
	Dabei sind die Koeffizienten der Polynome jeweils Approximationen
	von Zahlen aus Qp.
	P3 = P1 + P2    ( p-adisch )



			ppftrans( r, p, P, A )

	"polynomial over p-adic field translation, main variable"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppftrans( r, p, P, A )  single r,p; pol P; pfel A;
	P1 = ppftrans( r, p, P, A );
	Dabei muss gelten:
		- p ist Primzahl.
		- P ist Polynom in r ( 1 <= r < BASIS ) Variablen ueber
		  den p-adischen Zahlen.
	Dabei sind die Koeffizienten des Polynoms jeweils Approximationen
	von Zahlen aus Qp.
	P1( X1, ..., Xr ) = P( X1, ..., X( r-1 ), Xr+A )



			ppftransav( r, p, P, Lpf )

	"polynomial over p-adic field translation, all variables"
	 ( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppftransav( r, p, P, Lpf )  single r,p; pol P; list Lpf;
	P1 = ppftransav( r, p, P, Lpf );
	Dabei muss gelten:
		- p ist Primzahl.
		- P ist Polynom in r ( 1 <= r < BASIS ) Variablen ueber
		  den p-adischen Zahlen.
		- Lpf ist eine Liste von r Elementen vom Typ pfel,
			Lpf = ( B1, ..., Br ).
	Dabei sind die Koeffizienten des Polynoms jeweils Approximationen
	von Zahlen aus Qp.
	P1( X1, ..., Xr ) = P( X1+B1, .., Xr+Br )



			ppftransf( r1, p, P1, V1, r2, P2, V2, Vn, pV3 )

	"polynomial over p-adic field transformation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol ppftransf( r1, p, P1, V1, r2, P2, V2, Vn, pV3 )
		single r1, p, r2;  pol P1,P2;  list V1, V2, Vn, *pV3;
	P3 = ppftransf( p, r1, P1, V1, r2, P2, V2, Vn, pV3);
	Dabei muss gelten:
	      - p ist Primzahl.
	      - P1 ist Polynom in r1 ( 1 <= r1 < BASIS ) Variablen ueber
		den p-adischen Zahlen. V1 ist die zugehoerige Variablen-
		liste.
	      - P2 ist Polynom in r2 ( 1 <= r2 < BASIS ) Variablen ueber
		den p-adischen Zahlen. V2 ist die zugehoerige Variablen-
		liste.
	      - Vn ist eine Liste, die einen in V1 auftretenden Variab-
		lennamen repraesentiert.
	P3 ist das Polynom, das entsteht, indem in P1 die Variable Vn
	durch das Polynom P2 ersetzt wird, und die zugehoerige, in *pV3
	abgelegte Variablenliste alphabetisch sortiert ist.
	( Die Variablenliste *pV3 ist die Vereinigung von V1 und V2. )



			ppmvprod( r, P, n )

	"polynomial product by power of main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol ppmvprod(r,P,n) single r; pol P; single n;
	P1 = ppmvprod(r,P,n);
	P ist ein Polynom in r (1<=r<BASIS) Variablen.
	n ist eine ganze Zahl aus [0,BASIS).
	P1 ist das Produkt von P und der n-ten Potenz der Haupt-
	variablen.



			ppmvquot( r, P, n )

	"polynomial quotient by power of main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol ppmvquot(r,P,n) single r; pol P; single n;
	P1 = ppmvquot(r,P,n);
	P ist ein Polynom in r (1<=r<BASIS) Variablen.
	n ist eine ganze Zahl aus [0,BASIS).
	P1 ist der Quotient von P und der n-ten Potenz der Haupt-
	variablen.



			pprmsp1ress( r, p, P1, P2 )

	"polynomial over polynomial ring over modular single prime,
	transcendence degree 1, resultant, Sylvester algorithm"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol pprmsp1ress(r,p,P1,P2) single r,p; pol P1,P2;
	P3 = pprmsp1ress(r,p,P1,P2);                      
	r ist eine nicht negative single, so dass r+1 ebenfalls noch eine
	single ist.
	Sei x eine Unbestimmte ueber Z/pZ, wobei p eine single Primzahl
	ist.
	P1 und P2 sind Polynome in r Unbestimmten ueber (Z/pZ) [x] -
	dem Polynomring in x ueber Z/pZ.
	P3 ist die Resultante von P1 und P2 bezueglich der Hauptvariablen,
	also ein Polynom in r-1 Unbestimmten ueber (Z/pZ) [x].	



			ppvquot( r, P, i, n )

	"polynomial quotient by power of variable" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol ppvquot(r,P,i,n)  single r; pol P; single i,n;
	P1 = ppvquot(r,P,i,n);
	P ist ein Polynom in r (1<=r<BASIS) Variablen.
	i ist eine ganze Zahl mit 1<=i<=r.
	n ist eine ganze Zahl aus [0,BASIS), wobei die
	n-te Potenz der Variablen Xi das Polynom P teilt.
	P1 ist der Quotient von P und der n-ten Potenz der
	Variablen Xi.



			prderiv( r, P )

	"polynomial over rationals derivation, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prderiv(r,P) single r; pol P;
	P1 = prderiv(r,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	P1 = P' (bzgl. der Hauptvariablen).



			prderivsv( r, P, n )

	"polynomial over rationals derivation, specified variable"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prderivsv(r,P,n) single r; pol P; single n;
	P1 = prderivsv(r,P,n);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	n ist eine ganze Zahl mit 1<=n<=r.
	P1 = P' (bzgl. der n-ten Variablen).



			prdif( r, P1, P2 )

	"polynomial over rationals difference" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prdif(r,P1,P2) single r; pol P1,P2;
	P3 = prdif(r,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	den rationalen Zahlen.
	P3 = P1 - P2.



			pred( r, P )                    (MACRO)

	"polynomial reductum"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pred(r,P) single r; pol P;
	P1 = pred(r,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen.
	P1 ist das Polynomreduktum von P, d. h.
	P1 = P-(Terme hoechsten Grades in der Hauptvariablen), falls
	P ungleich 0, 0 sonst.



			preval( r, P, A )

	"polynomial over rationals evaluation, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol preval(r,P,A) single r; pol P; rat A;
	p1 = preval(r,P,A);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	A ist eine rationale Zahl.
	P1 = P(A) (Auswertung erfolgt bzgl. der Hauptvariablen).



			prevalsv( r, P, n, A )

	"polynomial over rationals evaluation, specified variable"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prevalsv(r,P,n,A) single r; pol P; single n; rat A;
	P1 = prevalsv(r,P,n,A);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	n ist eine ganze Zahl mit 1<=n<=r.
	A ist eine rationale Zahl.
	P1 = P(A) (Auswertung erfolgt bzgl. der n-ten Variablen).



			prexp( r, P, n )

	"polynomial over rationals exponentiation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prexp(r,P,n) single r; pol P; single n;
	P1 = prexp(r,P,n);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	n ist eine ganze Zahl aus [0,BASIS-1].
	P1 = P ^ n.



			prfmsp1deriv( r, p, P )

	"polynomial over rational functions over modular single prime,
	transcendence degree 1,	derivation, main variable"
	Quellbibliothek: srclib.pol4
	Include - Datei: _pol4.h
	pol prfmsp1deriv(r,p,P) single r,p; pol P;
	P1 = prfmsp1deriv(r,p,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber dem
	rationalen Funktionenkoerper ueber (Z/pZ), wobei p eine
	single Primzahl ist.
	P1 = P' (bzgl. der Hauptvariablen).



			prfmsp1dif( r, p, P1, P2 )

	"polynomial over rational functions over modular single
	prime, transcendence degree 1, difference" (rekursiv)
	Quellbibliothek: srclib.pol4
	Include - Datei: _pol4.h
	pol prfmsp1dif(r,p,P1,P2) single r, p; pol P1, P2;
	P3 = prfmsp1dif(r,p,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	dem rationalen Funktionenkoerper ueber (Z/pZ), wobei p eine
	single Primzahl ist.
	P3 = P1 - P2.



			prfmsp1neg( r, p, P )

	"polynomial over rational functions over modular single
	prime, transcendence degree 1, negation" (rekursiv)
	Quellbibliothek: srclib.pol4
	Include - Datei: _pol4.h
	pol prfmsp1neg(r,p,P) single r, p; pol P;
	P1 = prfmsp1neg(r,p,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber dem 
	rationalen Funktionenkoerper ueber (Z/pZ), wobei p eine 
	single Primzahl ist.
	P1 = -P.



			prfmsp1prod( r, p, P1, P2 )

	"polynomial over rational functions over modular single
	prime, transcendence degree 1, product" (rekursiv)
	Quellbibliothek: srclib.pol4
	Include - Datei: _pol4.h
	pol prfmsp1prod(r,p,P1,P2) single r, p; pol P1, P2;
	P3 = prfmsp1prod(r,p,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	dem rationalen Funktionenkoerper ueber (Z/pZ), wobei p eine
	single Primzahl ist.
	P3 = P1 * P2.



			prfmsp1qrem( r, p, P1, P2, pR )

	"polynomial over rational functions over modular single
	prime, transcendence degree 1, quotient and remainder"
	(rekursiv)
	Quellbibliothek: srclib.pol4
	Include - Datei: _pol4.h
	pol prfmsp1qrem(r,p,P1,P2,pR) single r,p; pol P1,P2; pol *pR;
	P3 = prfmsp1qrem(r,p,P1,P2,pR);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	dem rationalen Funktionenkoerper ueber (Z/pZ), wobei p eine
	single Primzahl ist. P2 ist ungleich 0.
	*pR = P1 % P2.
	P3 = P1 / P2.



			prfmsp1rfprd( r, p, P, a )

	"polynomial over rational functions over modular single
	prime, transcendence degree 1, rational function over
	modular single prime, transcendence degree 1, product"
	(rekursiv)
	Quellbibliothek: srclib.pol4
	Include - Datei: _pol4.h
	pol prfmsp1rfprd(r,p,P,a) single r,p; pol P; rfunc a;
	P1 = prfmsp1rfprd(r,p,P,a);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber dem
	rationalen Funktionenkoerper ueber (Z/pZ), wobei p eine
	single Primzahl ist.
	a ist ein Element aus obigem rationalen Funktionenkoerper.
	P1 = a * P.



			prfmsp1sum( r, p, P1, P2 )

	"polynomial over rational functions over modular single
	prime, transcendence degree 1, sum" (rekursiv)
	Quellbibliothek: srclib.pol4
	Include - Datei: _pol4.h
	pol prfmsp1sum(r,p,P1,P2) single r, p; pol P1, P2;
	P3 = prfmsp1sum(r,p,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	dem rationalen Funktionenkoerper ueber (Z/pZ), wobei p eine
	single Primzahl ist.
	P3 = P1 + P2.



			printegr( r, P )

	"polynomial over rationals integration, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol printegr(r,P) single r; pol P;
	P1 = printegr(r,P);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	P1 ist das Integral von P (bzgl. der Hauptvariablen);
	die Integrationskonstante ist 0.



			prneg( r, P )

	"polynomial over rationals negation" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prneg(r,P) single r; pol P;
	P1 = prneg(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	P1 = -P.



			prnfevalfvs( r, F, P )

	"polynomial over rationals number field element evaluation first
         variable special version"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol prnfevalfvs( r, F, P )  single r;  pol F, P;
	Q = prnfevalfvs( r, F, P );
	Dabei muss gelten:
	      - F ist ein irreduzibles Polynom vom Grad >= 1 in einer
		Variablen ueber Z in dense-Darstellung.
	      - P ist ein Polynom in r >= 1 Variablen ueber Q.
        Die erste Variable der zu P gehoerigen Variablenliste wird durch
	das erzeugende Element des durch F bestimmten Zahlkoerpers ersetzt.
	Q ist ein Polynom in r-1 Variablen ueber diesem Zahlkoerper.



			prnumden( r, P, pA )

	"polynomial over the rationals numerator and denominator"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prnumden(r,P) single r; pol P; int *pA;
	P1 = prnumden(r,P,pA);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	*pA ist eine ganze Zahl und P1 ein Polynom ueber den ganzen
	Zahlen derart, dass P = P1/(*pA), wobei *pA und der GGT der
	Basis-Koeffizienten von P1 teilerfremd sind.
	*pA ist 1, wenn P gleich 0 ist.



			prprod( r, P1, P2 )

	"polynomial over rationals product" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prprod(r,P1,P2) single r; pol P1,P2;
	P3 = prprod(r,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	den rationalen Zahlen.
	P3 = P1 * P2.



			prqrem( r, P1, P2, pR )

	"polynomial over rationals quotient and remainder" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prqrem(r,P1,P2,pR) single r; pol P1,P2; pol *pR;
	P3 = prqrem(r,P1,P2,pR);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	den rationalen Zahlen; P2 ist ungleich 0.
	P3 = P1 / P2.
	*pR = P1 % P2.



			prquot( r, P1, P2 )             (MACRO)

	"polynomial over rationals quotient"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prquot(r,P1,P2) single r; pol P1,P2;
	P3 = prquot(r,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	den rationalen Zahlen; P2 ist ungleich 0.
	P3 = P1 / P2.



			prrem( r, P1, P2 )              (MACRO)

	"polynomial over rationals remainder"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prrem(r,P1,P2) single r; pol P1,P2;
	P3 = prrem(r,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	den rationalen Zahlen; P2 ist ungleich 0.
	P3 = P1 % P2.



			prrprod( r, P, A )

	"polynomial over rationals, rational number product" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prrprod(r,P,A)  single r; pol P; rat A;
	P1 = prrprod(r,P,A);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	P1 = A * P.



			prrquot( r, P, A )

	"polynomial over rationals, rational quotient"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prrquot(r,P,A) single r; pol P; rat A;
	P1 = prrquot(r,P,A);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	A ist eine rationale Zahl ungleich 0.
	P1 = P / A.



			prsubst( r, P1, P2 )

	"polynomial over rationals substitution, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prsubst(r,P1,P2) single r; pol P1; pol P2;
	P3 = prsubst(r,P1,P2);
	P1 ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	P2 ist ein Polynom in r-1 Variablen ueber den rationalen
	Zahlen.
	P3 = P1(P2) (Substitution der Hauptvariablen).



			prsubstsv( r, P1, n, P2 )

	"polynomial over rationals substitution, specified variable"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prsubstsv(r,P1,n,P2) single r; pol P1; single n; pol P2;
	P3 = prsubstsv(r,P1,n,P2);
	P1 ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	n ist eine ganze Zahl mit 1<=n<=r.
	P2 ist ein Polynom in n-1 Variablen ueber den rationalen Zahlen.
	P3 = P2(P1) (Substitution der n-ten Variablen).



			prsum( r, P1, P2 )

	"polynomial over rationals sum" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prsum(r,P1,P2) single r; pol P1,P2;
	P3 = prsum(r,P1,P2);
	P1 und P2 sind Polynome in r (0<=r<BASIS) Variablen ueber
	den rationalen Zahlen.
	P3 = P1 + P2.



			prtopmi( r, P, M )

	"polynomial over rationals to polynomial over modular integers"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prtopmi(r,P,M)  single r; pol P; int M;
	P1 = prtopmi(r,P,M);
	P ist ein Polynom in r (r>=0) Variablen ueber den rationalen 
	Zahlen.
	M ist positiv.     
	Die Nenner der Koeffizienten von P muessen teilerfremd zu M sein.
	P1 = P (aufgefasst als Polynom ueber Z/M*Z).



			prtopnf( r, P )

	"polynomial over rationals to polynomial over number field"
	(rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol prtopnf(r,P)  single r; pol P;
	P1 = prtopnf(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	P1 = P (aufgefasst als Polynom ueber einem Zahlkoerper).



			prtoppf( r, P, p, d )

	"polynomial over rationals to polynomial over p-adic field"
	( rekursiv )
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol prtoppf( r, P, p, d )  single r, p, d; pol P;
	P1 = prtoppf( r, P, p, d );
	Dabei muss gelten:
		- p ist Primzahl.
		- P ist Polynom in r ( 0 <= r < BASIS ) Variablen ueber
		  den rationalen Zahlen mit den Koeffizienten Ai.
	Die Koeffizienten von P1 seien ai.
	Dabei sind die ai jeweils Approximationen von Ai aus Qp vom Grad
	d, fuer die bzgl. der additiven p-adischen Bewertung vp gilt:
		vp( Ai - ai ) >= d
	und     ai = 0                              , falls d < vp( Ai )
	sonst   ai = ai_vp( Ai ) * p^vp( Ai ) + ... + ai_d * p^d,
	wobei   ai_vp( Ai ) != 0        und
		0 <= ai_j <= p - 1
	Fuer ai ergibt sich folgende Form:
		ai = 0                              , falls d < vp( Ai )
		     ( d, vp( Ai ), ai_vp( Ai ), ..., ai_d )     , sonst
	P1 = P ( aufgefasst als Polynom ueber dem p-adischen Zahlkoerper
		 mit den approximierten Koeffizienten ai )
	ACHTUNG: Ist die Approximation fuer den hoechsten Koeffizienten 0,
	-------  so wird das Polynom im Grad reduziert.



			prtrans( r, P, A )

	"polynomial over rationals translation, main variable"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prtrans(r,P,A) single r; pol P; rat A;
	P1 = prtrans(r,P,A);
	P ist ein Polynom in r (1<=r<BASIS) Variablen ueber den
	rationalen Zahlen. A ist eine rationale Zahl.
	P1(X1,...,Xr) = P(X1,...,X(r-1),Xr+A).



			prtransav( r, P, LR )

	"polynomial over rationals translation, all variables"
	(rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prtransav(r,P,LR) single r; pol P; list LR;
	P1 = prtransav(r,P,LR);
	P ist ein Polynom in r (1<=r<BASIS) Variablen X1,...Xr
	ueber den rationalen Zahlen. LR ist eine Liste von r rationalen
	Zahlen: LI = ( Ar ,..., A1 ).
	P1(X1,...,Xr) = P(X1+A1,...,Xr+Ar);



			prtransf( r1, P1, V1, r2, P2, V2, Vn, pV3 )

	"polynomial over the rationals transformation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol prtransf(r1,P1,V1,r2,P2,V2,Vn,pV3) single r1; pol P1; list V1;
					       single r2; pol P2; list V2;
					       list Vn; list *pV3;
	P3 = prtransf(r1,P1,V1,r2,P2,V2,Vn,pV3);
	P1 ist ein Polynom in r1 (1<=r1<BASIS) Variablen ueber den
	rationalen Zahlen; V1 ist die zugehoerige Variablenliste.
	P2 ist ein Polynom in r2 (0<=r2<BASIS) Variablen ueber den
	rationalen Zahlen; V2 ist die zugehoerige Variablenliste.
	Vn ist eine Liste, die einen in V1 auftretenden Variablennamen
	repraesentiert.
	P3 ist das Polynom, das entsteht, wenn in P1 die Variable Vn
	durch das Polynom P2 ersetzt wird, und die zugehoerige, in
	*pV3 abgelegte Variablenliste alphabetisch sortiert ist.
	(Die in *pV3 abgelegte Variablenliste ist die Vereinigung von
	V1 und V2.)



			psylvester( r, P1, P2 )

	"polynomial Sylvester matrix"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	matrix psylvester(r,P1,P2) single r; pol P1,P2;
	M = psylvester(r,P1,P2);
	P1 und P2 sind Polynome positiven Grades in r (1<=r<BASIS)
	Variablen.
	M ist die Sylvester-Matrix zu P1 und P2.
	(Die Determinante von M ist die Resultante von P1 und P2.
	Man vgl. piressylv und pmsressylv.)



			ptbc( r, P )

	"polynomial trailing base coefficient" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	obj ptbc(r,P)  single r;  pol P;
	C = ptbc(r,P);
	r ist nicht negativ, P ein Polynom in r Variablen.
	C ist aus dem Koeffizientenring zu P. Fuer P=0 ist C=0.
	Andernfalls ist C der freie Koeffizient von P.



			ptodip( r, P )

	"polynomial to distributive polynomial" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol ptodip(r,P)  single r; pol P;
	P1 = ptodip(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen.
	P1 = P (distributive Darstellung).



			ptodp( r, P )

	"polynomial to dense polynomial" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol ptodp(r,P) single r; pol P;
	P1 = ptodp(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen.
	P1 = P. (dense-Darstellung).



			ptoup( r, P )

	"polynomial to univariate polynomial"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol ptoup(r,P) single r; pol P;
	P1 = ptoup(r,P);
	P ist ein Polynom in r (0<=r<BASIS) Variablen.
	P1 ist dann ein Polynom in einer Variablen, wobei
	P1 = P(0,..,0,X).



			putdipdim( r, dim, S, M, VL )   (MACRO)

	"put distributive polynomial dimension"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single putdipdim(r,dim,S,M,VL)  single r,dim; list S,M,VL;
        a = putdipdim(r,dim,S,M,VL);
        dim, S und M sind die in dipdimpolid  berechneten  Groessen,  d.h.
          - dim = die Dimension des von G erzeugten Ideals,
          - S   = die maximal unabhaengige Menge von Variablen  und
          - M   = die Menge aller maximal unabhaengigen Mengen  von  Vari-
                  ablen  aus  VL ist.
        VL  ist  die  Variablenliste  des Polynomideals der Laenge r (0<=r
        <BASIS).  Ist r gleich 0, so muss VL  die leere Liste sein;  sonst
        ist VL eine Liste VL = (V1, ..., Vr), wobei die Elemente Vi von VL
        die Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
	putdipdim schreibt die Groessen  dim, S und M  auf stdout.
        putdipdim liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			putdipgfsl( r, p, AL, PL, VL, Vgfs )(MACRO)

	"put distributive polynomial over Galois-field with single
         characteristic list"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        single putdipgfsl(r,p,AL,PL,VL,Vgfs)  single r,p;
               list AL,PL,VL,Vgfs;
        a = putdipgfsl(r,p,AL,PL,VL,Vgfs);
        PL  ist eine Liste von Polynomen in distributiver Darstellung in r
        (0<=r<BASIS)  Variablen  ueber  einem  endlichen Koerper GF(q) der
        Charakteristik p, wobei AL die Arithmetikliste zu GF(q) ist.
        Ist r gleich 0, so  muss  VL  die  leere  Liste  sein;  sonst  ist
        VL  eine Liste VL = (V1, ..., Vr),  wobei die  Elemente  Vi von VL
        die Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen.
	Analog ist Vgfs eine  einelementige  Variablenliste, die den Namen
	eines  primitiven  Elementes  der  Koerpererweiterung GF(q)/(Z/pZ)
	repraesentiert.
        putdipgfsl schreibt die Liste PL von Polynomen auf  stdout  in der
        Form { p1, ..., pm }.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        putdipgfsl liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			putdipil( r, PL, VL )           (MACRO)

	"put distributive polynomial over integers list"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single putdipil(r,PL,VL)  single r; list PL,VL;
        a = putdipil(r,PL,VL);
        PL  ist eine Liste von Polynomen in distributiver Darstellung in r
        (0<=r<BASIS)  Variablen ueber den ganzen Zahlen.  Ist  r gleich 0,
        so  muss  VL  die  leere  Liste  sein;  sonst  ist  VL  eine Liste
        VL = (V1, ..., Vr),  wobei die  Elemente  Vi von VL die Variablen-
        namen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen.
        putdipil  schreibt  die Liste PL von Polynomen  auf  stdout in der
        Form { p1, ..., pm }.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        putdipil liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			putdipmipl( r, p, PL, VL )      (MACRO)

	"put distributive polynomial over modular integer primes list"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single putdipmipl(r,p,PL,VL)  single r; int p; list PL,VL; 
		FILE *pf;
        a = putdipmipl(r,p,PL,VL);
        PL  ist eine Liste von Polynomen in distributiver Darstellung in r
        (0<=r<BASIS) Variablen ueber Z/pZ  (p Primzahl).  Ist  r gleich 0,
        so  muss  VL  die  leere  Liste  sein;  sonst  ist  VL  eine Liste
        VL = (V1, ..., Vr),  wobei die  Elemente  Vi von VL die Variablen-
        namen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen.
        putdipmipl schreibt die Liste PL von Polynomen auf  stdout  in der
        Form { p1, ..., pm }.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        putdipmipl liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			putdipmspl( r, p, PL, VL )      (MACRO)

	"put distributive polynomial over modular single primes list"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single putdipmspl(r,p,PL,VL)  single r,p; list PL,VL;
        a = putdipmspl(r,p,PL,VL);
        PL  ist eine Liste von Polynomen in distributiver Darstellung in r
        (0<=r<BASIS)  Variablen ueber Z/pZ (p Primzahl).  Ist  r gleich 0,
        so  muss  VL  die  leere  Liste  sein;  sonst  ist  VL  eine Liste
        VL = (V1, ..., Vr),  wobei die  Elemente  Vi von VL die Variablen-
        namen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen.
        putdipmspl schreibt die Liste PL von Polynomen auf  stdout  in der
        Form { p1, ..., pm }.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        putdipmspl liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			putdipnfl( r, F, PL, VL, Vnf )  (MACRO)

	"put distributive polynomial over number field list"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        single putdipnfl(r,F,PL,VL,Vnf)  single r; pol F; list PL,VL,Vgfs;
        a = putdipnfl(r,F,PL,VL,Vnf);
        PL  ist eine Liste von Polynomen in distributiver Darstellung in r
        (0<=r<BASIS)  Variablen  ueber einem  Zahlkoerper k. F ist das zu-
        gehoerige irreduzible Polynom in einer Variablen ueber Z,  das den
        Zahlkoerper erzeugt, d.h. k entsteht durch  Adjunktion einer Null-
        stelle von F.
        Ist r gleich 0, so  muss  VL  die  leere  Liste  sein;  sonst  ist
        VL  eine Liste VL = (V1, ..., Vr),  wobei die  Elemente  Vi von VL
        die Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen.
	Analog ist Vnf eine einelementige Variablenliste,  die  den  Namen
        einer Nullstelle von F repraesentiert.
        putdipnfl  schreibt die Liste PL von Polynomen auf  stdout  in der
        Form { p1, ..., pm }.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        putdipnfl liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			putdippicgb( r1, r2, CGBL, i, VL1, VL2 )(MACRO)

	"put distributive polynomial over polynomials over integers
         comprehensive Groebner basis"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single putdippicgb(r1,r2,CGBL,i,VL1,VL2)  single r1,r2;
               list CGBL; single i; list VL1,VL2;
        a = putdippicgb(r1,r2,CGBL,i,VL1,VL2,pf);
        CGBL ist eine von "dippicgb" bzw. "dippircgb" erstellte Liste, die
        eine  parametrische  bzw. eine reduzierte parametrische  Groebner-
        basis repraesentiert.
        i ist die Anzahl der "Zweige" des dazugehoerigen Groebnersystems.
        Die Polynome der Basis liegen in  distributiver  Darstellung in r1
        (0<=r1<BASIS)  Variablen ueber dem Polynomring vor,  der entsteht,
        wenn man zu den ganzen  Zahlen die  Variablen  aus VL2 adjungiert.
        Ist r2 gleich 0, so muss VL2  die leere Liste  sein; sonst ist VL2
        eine Liste VL2 = (V1, ..., Vr),  wobei die Elemente Vi von VL2 die
        Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen. Der
        Aufbau der Variablenliste VL1 ist identisch mit dem der Liste VL2.
        putdippicgb  schreibt  die  Liste CGBL  und die Zahl i  auf stdout 
	in der Form
        {
         p1
         ...
         pm
        }
        i condition(s)
        wobei die pi, i=1,...,m, die Polynome der Basis sind.
        putdippicgb liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			putdippidim( r1, r2, DIML, VL1, VL2 )(MACRO)

	"put distributive polynomial over polynomials over integers
         dimension"
	Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single putdippidim(r1,r2,DIML,VL1,VL2)  single r1,r2;
               list DIML,VL1,VL2;
        a = putdippidim(r1,r2,DIML,VL1,VL2);
        DIML ist eine Liste von Bedingungen und Dimensionen.
        (cf. V. Weispfenning, Comprehensive Groebner Bases, MIP 9003
             oder
             E. Schoenfeld, Diplomarbeit: Parametrische Groebnerbasen im
             Computer Algebra System ALDES/SAC2 1991 (Passau)            )
        putdippidim schreibt die Liste DIML auf stdout.
        Dabei liegen die in den  Bedingungen  vorkommenden  Koeffizienten-
	polynome in r2  (0<=r2<BASIS)  Variablen  vor.  Ist  r2  gleich 0,
        so  muss  VL2  die  leere  Liste  sein;  sonst  ist VL2 eine Liste
        VL2 = (V1, ..., Vr), wobei die Elemente Vi von VL2 die  Variablen-
        namen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen. Der
        Aufbau der Variablenliste VL1 ist identisch mit dem der Liste VL2.
        Die jeweiligen Polynomenden werden mit '#'  markiert.  putdippidim
        ist insbesondere in der Lage,  die von  dippidim  berechnete Liste
        auf stdout zu schreiben.
        putdippidim liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			putdippigbs( r1, r2, GS, VL1, VL2, cs )(MACRO)

	"put distributive polynomial over polynomials over integers
         Groebner system"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single putdippigbs(r1, r2, GS, VL1, VL2, cs)  single r1, r2;
		list GS, VL1, VL2; single cs;
        a = putdippigbs(r1, r2, GS, VL1, VL2, cs);
        GS ist ein Groebnersystem, d.h. eine Art Baum,  der in jedem Zweig
        ein Koeffizientenlistenpaar  und  eine dazugehoerige Groebnerbasis
        enthaelt (siehe auch dippicgb).
        Die  Koeffizientenlistenpaare  sind  Listen  von  Polynomen  in r2
        (0<=r2<BASIS)  Variablen ueber den ganzen Zahlen. Ist r2 gleich 0,
        so  muss  VL2  die  leere  Liste  sein;  sonst  ist VL2 eine Liste
        VL2 = (V1, ..., Vr),  wobei die Elemente Vi von VL2 die Variablen-
        namen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein Variablenname muss immer mit einem Buchstaben beginnen.
        Die Groebnerbasen sind Listen von Polynomen in distributiver  Dar-
        stellung in r1 (0<=r1<BASIS)  Variablen ueber dem Polynomring, der
        entsteht, wenn  man zu den  ganzen  Zahlen die  Variablen  aus VL2
        adjungiert. Der Aufbau  der  Variablenliste VL1  ist identisch mit
        dem der Liste VL2.
        cs ist ein Schalter,  mit  dessen  Hilfe man die Groebnerbasen zu-
        saetzlich ohne die Monome ausgeben kann,  deren Koeffizient gleich
        0 sind:
        cs gleich 1   bewirkt die  zusaetzliche  Ausgabe  der  Basen  ohne
        Monome mit  Koeffizienten gleich 0.
        cs gleich 0   bewirkt die Ausgabe der Basen mit allen Monomen.
        putdippigbs schreibt ein Groebnersystem auf stdout.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        putdippigbs liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			putdippigt( r1, r2, C, PP, CGB0, CGB1, VL1, VL2 )(MACRO)

        "put distributive polynomial over polynomials over integers
         Groebner test"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single putdippigt(r1,r2,C,PP,CGB0,CGB1,VL1,VL2)  single r1,r2;
               list C,PP,CGB0,CGB1,VL1,VL2;
        a = putdippigt(r1,r2,C,PP,CGB0,CGB1,VL1,VL2);
        C  ist  eine  Fallunterscheidung,  d.h.  entweder  die leere Liste
        ("{}")  oder  eine  Liste,  die aus einer geraden Anzahl von Teil-
        listen besteht,  wobei die Teillisten mit ungerader Laufnummer die
        Koeffizientenpolynome enthalten, die  gleich  Null  sind, und  die
        mit  gerader  Laufnummer  die  Koeffizientenpolynome, die ungleich
        Null sind.
        Sei z.B. VL2 = a,b,c,d.
        Dann kann die Fallunterscheidung wie folgt aussehen:
             {{a^2-d# c+d#}{a#}{}{a^4-b*a^3+c*d}},
                            d.h. a^2-d==0, c+d==0, a!=0, a^4-b*a^3+c*d!=0;
             oder
             {{a^2-d# c+d#}{a#}}, d.h. a^2-d==0, c+d==0, a!=0;
             oder
             {{}{b^2-d^3+c# a# c#}}, d.h. b^2-d^3+c!=0, a!=0, c!=0;
             oder
             {{b# c# a^5-d^4+d^3+d#}{}},
                                        d.h. b==0, c==0, a^5-d^4+d^3+d==0.
        PP ist eine Liste von Polynomen in distributiver Darstellung in r1
        (0<=r1<BASIS)  Variablen ueber dem Polynomring, der entsteht, wenn
        man zu den  ganzen  Zahlen die  Variablen  aus VL2 adjungiert. Ist
        r2 gleich 0, so muss VL2  die  leere  Liste  sein;  sonst  ist VL2
        eine Liste VL2 = (V1, ..., Vr),  wobei die Elemente Vi von VL2 die
        Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen. Der
        Aufbau der Variablenliste VL1 ist identisch mit dem der Liste VL2.
        CGB0 enthaelt die Nachfolger von C, so dass P  eine  Groebnerbasis
        ist;
        CGB1 enthaelt die Nachfolger von C, so dass P  keine Groebnerbasis
        ist.
	putdippigt schreibt die Listen  C, PP, CGB0 und CGB1  auf  stdout.
        putdippigt liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			putdippil( r1, r2, PL, VL1, VL2 )(MACRO)

	"put distributive polynomial over polynomials over integers
         list"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single putdippil( r1, r2, PL, VL1, VL2)  single r1, r2; 
		list PL, VL1, VL2;
        a = putdippil(r1, r2, PL, VL1, VL2);
        PL ist eine Liste von Polynomen in distributiver Darstellung in r1
        (0<=r1<BASIS)  Variablen ueber dem Polynomring, der entsteht, wenn
        man zu den  ganzen  Zahlen die  Variablen  aus VL2 adjungiert. Ist
        r2 gleich 0, so muss VL2  die  leere  Liste  sein;  sonst  ist VL2
        eine Liste VL2 = (V1, ..., Vr),  wobei die Elemente Vi von VL2 die
        Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen. Der
        Aufbau der Variablenliste VL1 ist identisch mit dem der Liste VL2.
        putdippil  schreibt die Liste PL von Polynomen  auf  stdout in der
        Form  { p1, ..., pm }.  Die jeweiligen Polynomenden werden mit '#' 
	markiert.
        putdippil liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			putdippipim( r1, r2, NOUT, VL1, VL2 )(MACRO)

        "put distributive polynomial over polynomials over integers
         parametric ideal membership test"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single putdippipim(r1,r2,NOUT,VL1,VL2)  single r1,r2;
               list NOUT,VL1,VL2;
        a = putdippipim(r1,r2,NOUT,VL1,VL2);
        NOUT ist eine Liste,  die  die  Polynome  enthaelt,  die auf para-
        metrische Idealmitgliedschaft getestet wurden, und die Bedingungen
        und Normalformen,  so dass das Polynom ein Element des Ideals ist,
        und solche Bedingungen und Normalformen,  so dass das Polynom kein
        Element des Ideals ist.  Die Polynome  liegen  in ihrer Normalform
        vor.
        Die  Polynome  sind  Polynome  in  distributiver Darstellung in r1
        (0<=r1<BASIS)  Variablen ueber dem Polynomring, der entsteht, wenn
        man zu den  ganzen  Zahlen die  Variablen  aus VL2 adjungiert. Ist
        r2 gleich 0, so muss VL2  die  leere  Liste  sein;  sonst  ist VL2
        eine Liste VL2 = (V1, ..., Vr),  wobei die Elemente Vi von VL2 die
        Variablennamen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen. Der
        Aufbau der Variablenliste VL1 ist identisch mit dem der Liste VL2.
        putdippipim schreibt die Liste NOUT auf stdout in der Form
          tested polynomial
          TP1 #
          polynomial completely reduced for
          the following condition(s)
          condition:
          {
          { cfp11 # ... cfp1m # } == 0
          { cfp21 # ... cfp2n # } != 0
          }
          factor
          cff1 #
          .
          .
          .
          polynomial not completely reduced for
          the following condition(s)
          condition:
          {
          { cfp31 # ... cfp3l # } == 0
          { cfp41 # ... cfp4k # } != 0
          }
          reduced to
          RTP1 #
          factor
          cff2 #
          .
          .
          .
          quantifier free formula for
          parametric ideal membership
          ( ( a == 0 )  and ... and  ( b == 0 )  and ( c != 0 )  and
          ... and  ( d != 0 ) )
          or
          .
          .
          .
          or
          ( ( e == 0 )  and ... and  ( f == 0 )  and ( g != 0 )  and
          ... and  ( h != 0 ) )
          tested polynomial
          TP2 #
          .
          .
          .                                                      ,
        wobei TP1, TP2 die zu testenden Polynome sind, die  cfpij  Koeffi-
        zientenpolynome sind, die  die  Fallunterscheidung  erzeugen, und 
	RTP1 das zu TP1 gehoerige reduzierte Polynom ist.  a, b, c, d usw. 
	sind wieder Koeffizientenpolynome.
	putdippipim liefert den Ergebniswert
	    0	   falls der Programmlauf fehlerfrei war;
	    ERROR  falls Fehler auftraten.



			putdippiqff( r1, r2, QFFL, VL1, VL2 )(MACRO)

	"put distributive polynomial over polynomials over integers
         quantifier free formula"
        Quellbibliothek: srclib.pol2
        Include-Datei:   _pol2.h
        single putdippiqff(r1,r2,QFFL,VL1,VL2)  single r1,r2;
               list QFFL,VL1,VL2;
        a = putdippiqff(r1,r2,QFFL,VL1,VL2);
        QFFL ist die quantorenfreie Formel einer Basis.
        (cf. V. Weispfenning, Comprehensive Groebner Bases, MIP 9003
             oder
             E. Schoenfeld, Diplomarbeit: Parametrische Groebnerbasen im
             Computer Algebra System ALDES/SAC2 1991 (Passau)            )
        putdippiqff  schreibt die Liste  QFFL  von  Koeffizientenpolynomen
        auf stdout in der Form
             ( ( a == 0 )  or
             ( b != 0 ) or ( c != 0 ) )  and
             ( ( d == 0 )  or
             ( e != 0 ) or ( f != 0 ) )  and
             .                      
             .
             .
             ( ( g == 0 )  or
             ( h != 0 ) or ( k != 0 ) )      ;
        dabei sind a, b, c, d, e, f, g, h, k Koeffizientenpolynome  in  r2
        (0<=r2<BASIS) Variablen. Ist r2 gleich 0,  so muss VL2  die  leere
        Liste  sein;  sonst  ist VL2 eine Liste VL2 = (V1, ..., Vr), wobei
        die Elemente Vi von VL2 die  Variablennamen  repraesentieren,  und
        zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen. Der
        Aufbau der Variablenliste VL1 ist identisch mit dem der Liste VL2.
        Die jeweiligen  Polynomenden  werden mit '#' markiert. putdippiqff
        ist insbesondere in der Lage,  die von  dippiqff  berechnete Liste
        auf stdout zu schreiben.
        putdippiqff liefert den Ergebniswert
                    0      falls der Programmablauf fehlerfrei war;
                    ERROR  falls Fehler auftraten.



			putdiprfrl( r1, r2, PL, VL1, VL2 )(MACRO)

	"put distributive polynomial over rational functions over the
	 rationals list"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        single putdiprfrl(r1,r2,PL,VL1,VL2) single r1,r2; list PL,VL1,VL2;
        a = putdiprfrl(r1,r2,PL,VL1,VL2);
        PL ist eine Liste von Polynomen in distributiver Darstellung in r1
        (0<=r1<BASIS)  Variablen  ueber  dem  Funktionenkoerper, der  ent-
        steht, wenn man zu den  rationalen  Zahlen die  Variablen  aus VL2
        adjungiert. Ist r2 gleich 0, so muss VL2  die  leere  Liste  sein;
        sonst  ist VL2 eine Liste VL2 = (V1, ..., Vr),  wobei die Elemente
        Vi  von  VL2  die  Variablennamen repraesentieren, und zwar in der
        Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen. Der
        Aufbau der Variablenliste VL1 ist identisch mit dem der Liste VL2.
        putdiprfrl schreibt die Liste PL von Polynomen auf  stdout  in der
        Form  { p1, ..., pm },  wobei  die  pi, i=1,...,m,  als  rationale
        Funktionen dargestellt sind.
        putdiprfrl liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			putdiprl( r, PL, VL )           (MACRO)

	"put distributive polynomial over rationals list"
        Quellbibliothek: srclib.pol1
        Include-Datei:   _pol1.h
        single putdiprl(r,PL,VL)  single r; list PL,VL;
        a = putdiprl(r,PL,VL);
        PL  ist eine Liste von Polynomen in distributiver Darstellung in r
        (0<=r<BASIS)   Variablen  ueber  den  rationalen  Zahlen.   Ist  r
        gleich 0, so muss VL die leere Liste sein; sonst ist VL eine Liste
        VL = (V1, ..., Vr),  wobei die  Elemente  Vi von VL die Variablen-
        namen repraesentieren, und zwar in der Form:
          Vi = ( ascii(Bu), ascii(BZ2), ... , ascii(BZn) )
             falls der Name der i-ten Variablen aus den n alphanumerischen
             Zeichen Bu,BZ2,...,BZn besteht.
        Ein  Variablenname  muss  immer mit einem Buchstaben beginnen.
        putdiprl  schreibt  die  Liste PL  von Polynomen auf stdout in der
        Form { p1, ..., pm }.
        Die jeweiligen Polynomenden werden mit '#' markiert.
        putdiprl liefert den Ergebniswert
                     0      falls der Programmablauf fehlerfrei war;
                     ERROR  falls Fehler auftraten.



			putpgf2( r, G, P, V, Vgf2 )     (MACRO)

	"put polynomial over Galois-field with characteristic 2"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	single putpgf2(r, G, P, V, Vgf2)  single r; obj G; pol P;
					  list V,Vgf2;
	a = putpgf2(r, G, P, V, Vgf2);
	r ist eine ganze Zahl mit 0 <= r < BASIS.
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
	P ist ein Polynom in r Variablen ueber GF(2^n) mit Koeffizienten
	in spezieller Bit-Darstellung.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	Vgf2 ist eine einelementige Variablenliste, die den Namen
	eines primitiven Elementes der Koerpererweiterung GF(2^n)/(Z/2Z)
	repraesentiert.
	putpgf2 schreibt ein Polynom in r Variablen ueber GF(2^n) auf
	die Datei stdout. Das Polynomende wird mit '#' markiert.
	putpgf2 liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			putpgfs( r, p, AL, P, V, Vgfs ) (MACRO)

	"put polynomial over Galois-field"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	single putpgfs(r,p,AL,P,V,Vgfs) single r,p; list AL; pol P;
					list V,Vgfs;
	a = putpgfs(r,p,AL,P,V,Vgfs);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber einem
	endlichen Koerper GF(q) der Charakteristik p < BASIS, wobei
	AL = (G,AL1) die Arithmetikliste zu GF(q) ist.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	Analog ist Vgfs eine einelementige Variablenliste, die den Namen
	eines primitiven Elementes der Koerpererweiterung GF(q)/(Z/pZ)
	repraesentiert.
	pf ist ein Zeiger auf eine zum Schreiben geoeffnete Datei.
	putpgfs schreibt ein Polynom in r Variablen ueber GF(q) auf
	stdout. Das Polynomende wird mit '#' markiert.
	putpgfs liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			putpi( r, P, V )                (MACRO)

	"put polynomial over integers"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single putpi(r,P,V) single r; pol P; list V;
	a = putpi(r,P,V);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	ganzen Zahlen.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	putpi schreibt ein Polynom in r Variablen ueber den ganzen
	Zahlen auf stdout. Das Polynomende wird mit '#' markiert.
	putpi liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			putpmi( r, m, P, V )            (MACRO)

	"put polynomial over modular integers"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single putpmi(r,m,P,V)  single r; int m; pol P; list V;
	a = putpmi(r,m,P,V);
	m ist eine positive ganze Zahl.
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber Z/mZ.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	putpmi schreibt ein Polynom in r Variablen ueber Z/mZ auf
	stdout. Das Polynomende wird mit '#' markiert.
	putpmi liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			putpms( r, m, P, V )            (MACRO)

	"put polynomial over modular singles"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single putpms(r,m,P,V) single r,m; pol P; list V;
	a = putpms(r,m,P,V);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber Z/mZ.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	putpms schreibt ein Polynom in r Variablen ueber Z/mZ auf
	stdout. Das Polynomende wird mit '#' markiert.
	putpms liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			putpnf( r, F, P, V, Vnf )       (MACRO)

	"put polynomial over number field"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	single putpnf(r,F,P,V,Vnf)  single r; pol F,P; list V,Vnf;
	a = putpnf(r,F,P,V,Vnf);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber einem
	Zahlkoerper K. F ist das zugehoerige irreduzible Polynom in
	einer Variablen ueber Z, das den Zahlkoerper erzeugt,d.h. K
	entsteht durch Adjunktion einer Nullstelle von F. 
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	Analog ist Vnf eine einelementige Variablenliste, die den
	Namen einer Nullstelle von F repraesentiert.
	putpnf schreibt ein Polynom in r Variablen ueber einem Zahl-
	koerper K auf stdout. Die Koeffizienten werden dann als
	Polynome in der Variablen von Vnf ueber Q aufgefasst.
	Das Polynomende wird mit '#' markiert.
	putpnf liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			putppf( r, p, P, V )

	"put polynomial over p-adic field"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	single putppf( r, p, P, V )  single r,p; pol P; list V;
	s = putppf( r, p, P, V );
	Dabei muss gelten:
	      - r ist eine ganze Zahl mit 0 <= r < BASIS.
	      - p ist prim.
	P ist ein Polynom in r Variablen ueber den p-adischen Zahlen. Ist
	r gleich 0, muss V die leere Liste sein; sonst ist V eine Liste
		V = ( V1, ..., Vr ),
	deren Elemente Vi Variablennamen repraesentieren, also hat Vi
	die folgende Form
		Vi = ( ascii( Bu ), ascii( BZ2 ), ..., ascii( BZn ) ),
	falls der Name der i-ten Variablen aus den n alphanumerischen
	Zeichen Bu, BZ2,...,BZn besteht. Ein Variablenname muss immer
	mit einem Buchstaben beginnen. Die Liste Vr repraesentiert den
	Namen der Hauptvariablen.
	putppf schreibt ein Polynom in r Variablen ueber den p-adischen
	Zahlen auf stdout. Das Polynomende wird mit '#' markiert.
	putppf liefert den Ergebniswert
		0       , falls der Programmablauf fehlerfrei war;
		ERROR   , falls Fehler auftraten.



			putpr( r, P, V )                (MACRO)

	"put polynomial over rationals"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single putpr(r,P,V) single r; pol P; list V;
	a = putpr(r,P,V);
	P ist ein Polynom in r (0<=r<BASIS) Variablen ueber den
	rationalen Zahlen.
	Ist r gleich 0, so muss V die leere Liste sein; sonst ist
	V eine Liste V = (V1,...,Vr), wobei die Elemente Vi von V
	die Variablennamen repraesentieren, und zwar in der Form:
	  Vi = ( ascii(Bu) , ascii(BZ2) , ... , ascii(BZn) )
		falls der Name der i-ten Variablen aus den n
		alphanumerischen Zeichen Bu,BZ2,...,BZn besteht.
	Ein Variablenname muss immer mit einem Buchstaben beginnen.
	Die Liste Vr repraesentiert den Namen der Hauptvariablen.
	putpr schreibt ein Polynom in r Variablen ueber den rationalen
	Zahlen auf stdout. Das Polynomende wird mit '#' markiert.
	putpr liefert den Ergebniswert
		0       falls der Programmablauf fehlerfrei war;
		ERROR   falls Fehler auftraten.



			pvext( r, P, V, VN )

	"polynomial variable list extension"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pvext(r,P,V,VN) single r; pol P; list V,VN;
	P1 = pvext(r,P,V,VN);
	P ist ein Polynom in r (0<=r<BASIS) Variablen.
	V ist die P gehoerige Variablenliste.
	VN ist ein Liste von Variablen, die V umfasst.
	P1 = P, aber in der Darstellung bzgl. VN.



			pvinsert( r, P, k )

	"polynomial insertion of new variables" (rekursiv)
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pvinsert(r,P,k) single r; pol P; single k;
	P1 = pvinsert(r,P,k);
	P ist ein Polynom in r (0<=r<BASIS) Variablen X1,...,Xr.
	k ist eine ganze Zahl mit 0<=k<BASIS.
	P1 = P aufgefasst als Polynom ueber den r+k Variablen
	Y1,...,Yk,X1,...,Xr.



			pvmerge( LV, LP, pLP )

	"polynomial variable list merge"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list pvmerge(LV,LP,pPL) list LV,LP; list *pLP;
	V = pvmerge(LV,LP,pLP);
	LP ist eine Liste von Polynomen und LV ist eine Liste, die aus den
	zugehoerigen Variablenlisten besteht.
	V ist die alphabetisch sortierte Vereinigung der in LV angegebenen
	Variablenlisten.
	In pLP werden die Darstellungen der Polynome aus LP bzgl. der
	neuen Variablenliste V abgelegt.



			pvpermut( r, P, PI )

	"polynomial variable permutation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pvpermut(r,P,PI) single r; pol P; list PI;
	P1 = pvpermut(r,P,PI);
	P ist ein Polynom in r (0<=r<BASIS) Variablen X1,...,Xr.
	Fuer r>0 ist PI eine Liste, die aus den r Zahlen 1 bis r
	besteht, d. h.  PI = ( pi(1) ,..., pi(r) )
	mit  1<=pi(i)<=r  fuer 1<=i<=r
	und  pi(i) != pi(j)  fuer 1<=i,j<=r;
	sonst PI die leere Liste.
	P1 = P,  wobei fuer r>0 die Reihenfolge der Variablen X1,...Xr
	permutiert wurde, d. h.
	P1(X(pi(1)),...,X(pi(r))) = P(X1,...,Xr).



			pvred( r, P, V, pV )

	"reduction of polynomial variables"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol pvred(r,P,V) single r; pol P; list V; list *pV;
	P1 = pvred(r,P,V,pV);
	P ist ein Polynom in r (0<=r<BASIS) Variablen und V ist die
	zugehoerige Variablenliste.
	P1 = P, wobei alle Variablen, deren Koeffizient 0 ist, in der
	Darstellung entfernt sind.
	In *pV wird die entsprechend modifizierte Variablenliste abgelegt.



			rfrtodiprfr( r1, r2, F )

        "rational function over the rationals to distributive polynomial 
	 over rational functions over the rationals"
        Quellbibliothek: srclib.pol4
        Include-Datei:   _pol4.h
        pol rfrtodiprfr(r1,r2,F)  single r1,r2; rfunc F;
        P = rfrtodiprfr(r1,r2,F);
        Dabei muss gelten:
              - 0 <= r1 < BASIS.
              - 0 <= r2 < BASIS.
              - F ist eine rationale Funktion in r = r1 + r2 Variablen
                ueber Q.
		Das Nennerpolynom von F ist ein Polynom in r2 Variablen
		ueber Q.
	P ist das F entsprechende distributive Polynom in r1 Variablen
	ueber rationalen Funktionen in r2 Variablen ueber Q.



			sclfupi( P, n )

	"special coefficient list from univariate polynomial over the
	integers"
	Quellbibliothek : srclib.pol2
	Include - Datei : _pol2.h
	list sclfupi(P,n) pol P; single n;
	L = sclfupi(P,n);
	P ist ein Polynom in einer Veraenderlichen ueber den ganzen Zahlen.
	n ist eine positive single, groesser als der Grad von P.
	L ist die zu P gehoerige "special coefficient list" der Laenge n.
	( siehe upifscl ).



			sclfuprfmsp1( P, n )

	"special coefficient list from univariate polynomial over rational
	functions over modular single prime, transcendence degree 1"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	list sclfuprfmsp1(P,n) pol P; single n;
	L = sclfuprfmsp1(P,n);
	P ist ein Polynom in einer Veraenderlichen ueber dem rationalen
	Funktionenkoerper ueber (Z/pZ), wobei p eine single Primzahl ist.
	n ist eine positive single, groesser als der Grad von P.
	L ist die zu P gehoerige "special coefficient list" der Laenge n
	( siehe uprfmsp1fscl ).



			spifact( r, P )

	"squarefree polynomial over integers factorization"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list spifact( r, P )  single r; pol P;
	L = spifact( r, P );
	P ist ein Polynom in r Variablen ueber den ganzen Zahlen,
	das, bzgl. seiner Hauptvariablen, primitiv, quadratfrei und
	positiven Grades ist und positiven Leitkoeffizienten hat.
	L ist eine Liste der voneinander verschiedenen, positiven
	irreduziblen Faktoren von P.
	Tritt ein Fehler auf, so ist L = ERROR.



			udpgf2remsp( G, P1, P2, ilc )

	"univariate dense polynomial over Galois-field with
	characteristic 2 remainder, special version"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol udpgf2rem(G,P1,P2,ilc)  obj G; pol P1, P2; gf2el ilc;
	P3 = udpgf2rem(G,P1,P2,ilc);
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        P1 und P2 sind dense Polynome in einer Veraenderlichen ueber
	GF(2^n) mit Koeffizienten in spezieller Bit-Darstellung.
	P2 ist ungleich 0 und es gilt Grad(P1) > Grad(P2).
	ilc ist das Inverse des Leitkoeffizienten von P2.
	Sollte ilc gleich 0 sein, so wird das Inverse berechnet.
	Vorsicht!! P1 wird veraendert.
	Das Programm ist besonders effizient, falls haeufig
	mit ein und demselben Polynom reduziert werden muss.
	P3 = P1 % P2, dabei ist P3 ein dense Polynom mit 
	Koeffizienten in spezieller Bit-Darstellung.



			udpicontpp( P, pPP )

	"univariate dense polynomial over integers content and primitive
	part"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	int udpicontpp(P,pPP)  pol P,*pPP;
	I = udpicont(P,pPP);
	P ist ein Polynom in dense-Darstellung in einer Variable ueber den
	ganzen Zahlen.
	Fuer P = 0 ist I = 0 und *pPP = 0. Fuer P ungleich 0 gilt:
	I ist der Inhalt von P (stets positiv), *pPP der primitive Anteil
	von P, d.h. 1/I * P.



			udpidif( P1, P2 )

	"univariate dense polynomial over integers difference"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpidif(P1,P2)  pol P1,P2;
	P3 = udpidif(P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber den ganzen Zahlen.
	P3 = P1 - P2.



			udpiiprod( P, A )

	"univariate dense polynomial over integers integer product"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpiiprod(P,A)  pol P; int A;
	P1 = udpiiprod(P,A);
	P ist ein Polynom in dense-Darstellung in einer Variable ueber den
	ganzen Zahlen.
	P1 = A * P.



			udpineg( P )

	"univariate dense polynomial over integers negation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpineg(P)  pol P;
	P1 = udpineg(P);
	P ist ein Polynom in dense-Darstellung in einer Variablen
	ueber den ganzen Zahlen.
	P1 = -P.



			udpiprod( P1, P2 )

	"univariate dense polynomial over integers product"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpiprod(P1,P2)  pol P1,P2;
	P3 = udpiprod(P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber den ganzen Zahlen.
	P3 = P1 * P2.



			udpipsrem( P1, P2 )

	"univariate dense polynomial over integers pseudo remainder"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpipsrem(P1,P2)  pol P1,P2;
	P3 = udpipsrem(P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in einer Variable
	ueber den ganzen Zahlen.
	P2 ist ungleich 0.
	P3 ist der Pseudo-Rest von P1 und P2, d. h.
	P3 = (P1 * k^(Grad(P1)-Grad(P2)+1)) modulo P2, wobei k der
	fuehrende Koeffizient von P2 ist, falls Grad(P1) >= Grad(P2);
	sonst ist P3 = P1.



			udpisum( P1, P2 )

	"univariate dense polynomial over integers sum"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpisum(P1,P2)  pol P1,P2;
	P3 = udpisum(P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber den ganzen Zahlen.
	P3 = P1 + P2.



			udpitoudpmi( P, M )

	"univariate dense polynomial over integers to univariate dense
	 polynomial over modular integers"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpitoudpmi( P,M )  pol P; int M;
	P1 = udpitoudpr( P,M );
	Dabei muss gelten:
	      - P ist dense-Polynom in einer Variablen ueber den ganzen 
		Zahlen.
	      - M ist positive ganze Zahl.
	P1 = P aufgefasst als Polynom ueber Z/M*Z, d.h. die Polynom-
	koeffizienten werden modulo M reduziert.



			udpitoudppf( P, p, d )

	"univariate dense polynomial over integers to univariate dense
	 polynomial over p-adic field"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol udpitoudppf( P, p, d )  pol P; single p,d;
	P1 = udpitoudppf( P, p, d );
	Dabei muss gelten:
	      - P ist Polynom in dense-Darstellung in einer Variablen
		ueber den ganzen Zahlen mit Koeffizienten Ai.
	      - p ist Primzahl.
	Die Koeffizienten von P1 seien ai.
	Dabei sind die ai jeweils Approximationen von Ai aus Qp vom Grad
	d, fuer die bzgl. der additiven p-adischen Bewertung vp gilt:
		vp( Ai - ai ) >= d
	und     ai = 0                            , falls d <= vp( Ai )
	sonst   ai = ai_vp( Ai ) * p^vp( Ai ) + ... + ai_d * p^d,
	wobei   ai_vp( Ai ) != 0          und
		0 <= ai_j <= p - 1
	Fuer ai ergibt sich folgende Form:
		ai = 0                  , falls a = 0 oder alle ai_j = 0
		     ( d, ai_vp( Ai ), ..., ai_d )               , sonst
	ACHTUNG: Ist die Approximation fuer den hoechsten Koeffizienten 0,
	-------  so wird das Polynom im Grad reduziert.



			udpitoudpr( P )

	"univariate polynomial over integers to univariate polynomial
	 over rationals"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpitoudpr( P )  pol P;
	P1 = udpitoudpr( P );
	P ist Polynom in einer Variablen ueber Z in dense-Darstellung. 
	P1 ist das zugehoerige dense-Polynom in einer Variablen ueber Q.



			udpm2togf2el( G, P )

	"univariate dense polynomial over modular 2 to Galois-field
	 with characteristic 2 element"	
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	gf2el udpm2togf2el(G,P)  obj G; pol P;
	a = udpm2togf2el(G,P);
	Voraussetzungen:
	      -  G ist ein irreduzibles, normiertes Polynom in einer 
		Variablen ueber Z/2Z vom Grad n in der speziellen Bit-
	   	Darstellung (vgl. udpm2tosb).
		G kann als ein erzeugendes Polynom fuer Gf(2^n) 
		interpretiert werden.
	      -	P ist ein Polynom in dense-Darstellung in einer 
		Variablen ueber Z/2Z.
	Ergebnis: a ist dann die Darstellung von P als Element 
		  des Koerpers Gf(2^n), und zwar wird das Polynom 
		  zuerst in die spezielle Bit-Notation uebertragen
		  mittels udpm2tosb und dann modulo G reduziert.
		  a ist also ein Polynom in einer Variablen ueber Z/2Z
		  vom Grad < n in spezieller Bit-Notation. 



			udpm2tosb( P )

	"univariate dense polynomial over modular 2 to special
	bit-representation"	
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	obj udpm2tosb(P)  pol P;
	a = udpm2tosb(P);
	P ist ein Polynom in dense-Darstellung in einer Variablen 
	ueber Z/2Z.
	a ist dann die spezielle Bit-Darstellung des Polynoms P, d.h.:
	Ist das Polynom wie folgt gegeben
		P = c(n) x^n + c(n-1) x^(n-1) + ... + c(1) x + c(0)
	mit Koeffizienten aus Z/2Z, d.h.
		c(i) = 0, 1  fuer alle i = 0, ... , n,
	und c(n) ungleich 0, so ist P dargestellt in der Form
		P = ( n c(n) c(n-1) ... c(1) c(0) ).
	Dann ist 
		a = ( n a(k) a(k-1) ... a(1) a(0) )
	eine Liste von positiven singles, wobei n wiederum den Grad
	bezeichnet. Dabei ist k der ganzzahlige Anteil von n / 30 ,
	a(0) = c(0) 2^0 + c(1) 2^1 + ... + c(28) 2^28 + c(29) 2^29,
	a(1) = c(30) 2^0 + c(31) 2^1 + ... + c(58) 2^28 + c(59) 2^29,
	und allgemein fuer alle 0 <= j <= k :
	a(j) = c(30*j) 2^0 + c(30*j+1) 2^1 + ... + c(30*j+29) 2^29. 
	Jedes a(j) ist vom Typ single, d.h. entsprechend der SIMATH-
	Konvention ein 32-Bit Wort, wobei die ersten beiden Bits
	unberuecksichtigt bleiben. Jedes a(j) stellt also jeweils 
	30 Koeffizienten des Polynoms P dar.



			udpmideriv( m, P )

	"univariate dense polynomial over modular integers derivation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmideriv(m,P)  int m; pol P;
	P1 = udpmideriv(m,P);
	m ist eine positive ganze Zahl.
	P ist ein Polynom in einer Variablen ueber Z/mZ.
	P1 = P'.



			udpmidif( m, P1, P2 )

	"univariate dense polynomial over modular integers difference"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmidif(m,P1,P2)  int m; pol P1,P2;
	P3 = udpmidif(m,P1,P2);
	m ist eine positive ganze Zahl.
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber Z/mZ.
	P3 = P1 - P2.



			udpmiegcd( m, P1, P2, pPX, pPY )

	"univariate dense polynomial over modular integers extended
	greatest common divisor"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol udpmiegcd(m,P1,P2,pPX,pPY)  int m; pol P1,P2; pol *pPX,*pPY;
	G = udpmiegcd(m,P1,P2,pPX,pPY);
	m ist eine Primzahl.
	P1 und P2 sind Polynome in einer Variablen ueber Z/mZ in dense-
	Darstellung.
	G ist der groesste gemeinsame Teiler von P1 und P2.
	G ist normiert.
	Fuer pPX und pPY gilt:
		1)  P1 * pPX + P2 *pPY = G;
		2)  ist Grad(P1/G) groesser 0, so ist Grad(pPY)
		    kleiner Grad(P1/G); sonst ist Grad(pPY) gleich 0;
		3)  ist Grad(P2/G) groesser 0, so ist Grad(pPX)
		    kleiner Grad(P2/G); sonst ist Grad(pPX) gleich 0;
		4)  ist P1 gleich 0, so ist pPX gleich 0;
		5)  ist P2 gleich 0, so ist pPY gleich 0.



			udpmigcd( m, P1, P2 )

	"univariate dense polynomial over modular integers greatest
	common divisor"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol udpmigcd(m,P1,P2)  int m; pol P1, P2;
	P3 = udpmigcd(m,P1,P2);
	m ist eine Primzahl.
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber Z/mZ.
	P3 ist der groesste gemeinsame Teiler von P1 und P2.
	P3 ist normiert.



			udpmihegcd( m, P1, P2, pP3 )

	"univariate dense polynomial over modular integers half extended
	greatest common divisor"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol udpmihegcd(m,P1,P2,pPY)  int m; pol P1,P2; pol *pPY;
	G = udpmihegcd(m,P1,P2,pPY);
	m ist eine Primzahl.
	P1 und P2 sind Polynome in einer Variablen ueber Z/mZ in dense-
	Darstellung.
	G ist der groesste gemeinsame Teiler von P1 und P2.
	G ist normiert.
	Fuer pPY gilt:
		1)  es existiert ein Polynom PX derart, dass
		    P1 * PX + P2 *pPY = G;
		2)  ist Grad(P1/G) groesser 0, so ist Grad(pPY)
		    kleiner Grad(P1/G); sonst ist Grad(pPY) gleich 0;
		3)  ist P2 gleich 0, so ist pPY gleich 0.



			udpmijacsym( m, P1, P2 )

	"univariate dense polynomial over modular integers Jacobi-symbol"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single udpmijacsym(m,P1,P2)  int m; pol P1,P2;
	a = udpmijacsym(m,P1,P2);
	m ist eine Primzahl.
	P1 und P2 sind teilerfremde Polynome in dense-Darstellung
	in einer Variablen ueber Z/mZ.
	P2 ist ein normiertes Polynom.
	a ist das Jacobi-Symbol [P1/P2].
	Die Listen fuer P1 und P2 werden veraendert.



			udpmimiprod( m, P, a )

	"univariate dense polynomial over modular integers, modular integer
	product"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmimiprod(m,P,a)  int m; pol P; int a;
	P1 = udpmimiprod(m,P,a);
	m ist eine positive ganze Zahl.
	P ist ein Polynom in einer Variablen in dense-Darstellung
	ueber Z/mZ. a ist ein Element aus Z/mZ.
	P1 = a * P.



			udpmimonic( m, P )

	"univariate dense polynomial over modular integers monic"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmimonic(m,P)  int m; pol P;
	P1 = udpmimonic(m,P);
	m ist eine positive ganze Zahl.
	P ist ein Polynom in einer Variablen in dense-Darstellung
	ueber Z/mZ.
	Der Leitkoeffizient von P ist in Z/mZ invertierbar.
	P1 ist das zu P assoziierte normierte Polynom.
	Fuer P = 0 ist P1 = 0.



			udpmineg( m, P )

	"univariate dense polynomial over modular integers negation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmineg(m,P)  int m; pol P;
	P1 = udpmineg(m,P);
	m ist eine ganze Zahl.
	P ist ein Polynom in dense-Darstellung in einer Variablen
	ueber Z/mZ.
	P1 = -P.



			udpmiprod( m, P1, P2 )

	"univariate dense polynomial over modular integers product"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmiprod(m,P1,P2)  int m; pol P1,P2;
	P3 = udpmiprod(m,P1,P2);
	m ist eine ganze Zahl.
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber Z/mZ.
	P3 = P1 * P2.



			udpmiqrem( m, P1, P2, pP3 )

	"univariate dense polynomial over modular integers quotient
	and remainder"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmiqrem(m,P1,P2,pP3)  int m; pol P1,P2; pol *pP3;
	P4 = udpmiqrem(m,P1,P2,pP3);
	m ist eine Primzahl.
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber Z/mZ. P2 ist ungleich 0.
	P4 = P1 / P2.
	*pP3 = P1 % P2.



			udpmiquot( m, P1, P2 )          (MACRO)

	"univariate dense polynomial over modular integers quotient"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmiquot(m,P1,P2)  int m; pol P1,P2;
	P3 = udpmiquot(m,P1,P2);
	m ist eine Primzahl.
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber Z/mZ. P2 ist ungleich 0.
	P3 = P1 / P2.



			udpmirem( ip, P, P2 )

	"univariate dense polynomial over modular integers remainder"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmirem(ip,P,P2)  int ip; pol P,P2;
	P3 = udpmirem(ip,P,P2);
	ip ist eine Primzahl.
	P und P2 sind Polynome in dense-Darstellung in einer
	Variablen ueber Z / (ip)*Z.
	P und P2 sind ungleich 0, und der Grad von P ist groesser
	gleich dem Grad von P2.
	P3 = P % P2.



			udpmisum( m, P1, P2 )

	"univariate dense polynomial over modular integers sum"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmisum(m,P1,P2)  int m; pol P1,P2;
	P3 = udpmisum(m,P1,P2);
	m ist eine positive ganze Zahl.
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber Z/mZ.
	P3 = P1 + P2.



			udpmsderiv( m, P )

	"univariate dense polynomial over modular singles derivation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmsderiv(m,P) single m; pol P;
	P1 = udpmsderiv(m,P);
	P ist ein Polynom in einer Variablen ueber Z/mZ (0<m<BASIS).
	P1 = P'.



			udpmsdif( m, P1, P2 )

	"univariate dense polynomial over modular singles difference"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmsdif(m,P1,P2) single m; pol P1,P2;
	P3 = udpmsdif(m,P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber Z/mZ mit m aus [1,BASIS-1].
	P3 = P1 - P2;



			udpmsegcd( m, P1, P2, pPX, pPY )

	"univariate dense polynomial over modular singles extended greatest
	common divisor"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol udpmsegcd(m,P1,P2,pPX,pPY)  single m; pol P1,P2; pol *pPX,pPY;
	G = udpmsegcd(m,P1,P2,pPX,pPY);
	P1 und P2 sind Polynome in einer Variablen ueber Z/mZ in dense-
	Darstellung, wobei m eine Primzahl aus [2,BASIS] ist.
	G ist der groesste gemeinsame Teiler von P1 und P2.
	G ist nicht unbedingt normiert.
	Fuer pPX und pPY gilt:
		1)  P1 * pPX + P2 *pPY = G;
		2)  ist Grad(P1/G) groesser 0, so ist Grad(pPY)
		    kleiner Grad(P1/G); sonst ist Grad(pPY) gleich 0;
		3)  ist Grad(P2/G) groesser 0, so ist Grad(pPX)
		    kleiner Grad(P2/G); sonst ist Grad(pPX) gleich 0;
		4)  ist P1 gleich 0, so ist pPX gleich 0;
		5)  ist P2 gleich 0, so ist pPY gleich 0.



			udpmsgcd( m, P1, P2 )

	"univariate dense polynomial over modular singles greatest
	common divisor"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol udpmsgcd(m,P1,P2) single m; pol P1, P2;
	P3 = udpmsgcd(m,P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber Z/mZ (0<m<BASIS) und m ist Primzahl.
	P3 ist der groesste gemeinsame Teiler von P1 und P2.
	P3 ist normiert.



			udpmshegcd( m, P1, P2, pP3 )

	"univariate dense polynomial over modular singles half extended
	greatest common divisor"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol udpmshegcd(m,P1,P2,pPY) single m; pol P1,P2; pol *pPY;
	G = udpmshegcd(m,P1,P2,pPY);
	P1 und P2 sind univariate Polynome ueber Z/mZ in dense-Darstellung,
	wobei m eine Primzahl aus [2,BASIS] ist.
	G ist der groesste gemeinsame Teiler von P1 und P2.
	G ist nicht unbedingt normiert.
	Fuer pPY gilt:
		1)  es existiert ein Polynom PX derart, dass
		    P1 * PX + P2 *pPY = G;
		2)  ist Grad(P1/G) groesser 0, so ist Grad(pPY)
		    kleiner Grad(P1/G); sonst ist Grad(pPY) gleich 0;
		3)  ist P2 gleich 0, so ist pPY gleich 0.



			udpmsjacsym( m, P1, P2 )

	"univariate dense polynomial over modular singles
	 Jacobi-symbol"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single udpmsjacsym(m,P1,P2) single m; pol P1,P2;
	a = udpmsjacsym(m,P1,P2);
	P1 und P2 sind teilerfremde Polynome in dense-Darstellung
	in einer Variablen ueber Z/mZ und m ist eine Primzahl aus
	[3,BASIS[. P2 ist ein normiertes Polynom.
	a ist das Jacobi-Symbol [P1/P2].
	Die Listen fuer P1 und P2 werden veraendert.



			udpmsmonic( m, P )

	"univariate dense polynomial over modular singles monic"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmsmonic(m,P) single m; pol P;
	P1 = udpmsmonic(m,P);
	P ist ein Polynom in einer Variablen in dense-Darstellung
	ueber Z/mZ. Der fuehrende Koeffizient ist eine Einheit.
	P1 ist das zu P assoziierte normierte Polynom.



			udpmsmsprod( m, P, a )

	"univariate dense polynomial over modular singles, modular
	single product"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmsmsprod(m,P,a)  single m; pol P; single a;
	P1 = udpmsmsprod(m,P,a);
	P ist ein Polynom in einer Variablen in dense-Darstellung
	ueber Z/mZ (0<m<BASIS). a ist ein Element aus Z/mZ.
	P1 = a * P.



			udpmsneg( m, P )

	"univariate dense polynomial over modular singles negation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmsneg(m,P) single m; pol P;
	P1 = udpmsneg(m,P);
	P ist ein Polynom in dense-Darstellung in einer Variablen
	ueber Z/mZ mit m aus [1,BASIS-1].
	P1 = -P.



			udpmsprod( m, P1, P2 )

	"univariate dense polynomial over modular singles product"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmsprod(m,P1,P2) single m; pol P1,P2;
	P3 = udpmsprod(m,P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber Z/mZ mit m aus [1,BASIS-1].
	P3 = P1 * P2.



			udpmsqrem( m, P1, P2, pP3 )

	"univariate dense polynomial over modular singles quotient
	and remainder"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmsqrem(m,P1,P2,pP3) single m; pol P1,P2; pol *pP3;
	P4 = udpmsqrem(m,P1,P2,pP3);
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber Z/mZ mit m Primzahl aus [2,BASIS] und P2 ungleich 0.
	P4 = P1 / P2.
	*pP3 = P1 % P2.



			udpmsquot( m, P1, P2 )          (MACRO)

	"univariate dense polynomial over modular singles quotient"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmsquot(m,P1,P2) single m; pol P1,P2;
	P3 = udpmsquot(r,m,P1,P2);
	P1 und P2 sind univariate Polynome ueber Z/mZ (0<m<BASIS)
	in dense-Darstellung und m ist Primzahl; P2 ungleich 0.
	P3 = P1 / P2.



			udpmsrem( m, P1, P2 )

	"univariate dense polynomial over modular singles remainder"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmsrem(m,P1,P2) single m; pol P1,P2;
	P3 = udpmsrem(m,P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in einer
	Variablen ueber Z/mZ, wobei m eine Primzahl aus [2,BASIS]
	ist. P1 und P2 sind ungleich 0 und der Grad von P1 ist
	groesser gleich dem Grad von P2.
	P3 = P1 % P2.
	!! Warnung !!
	Die Liste fuer P1 wird veraendert. Um Nebeneffekte zu vermeiden,
	sollte mit einer Kopie von P1 gearbeitet werden.



			udpmssum( m, P1, P2 )

	"univariate dense polynomial over modular singles sum"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udpmssum(m,P1,P2) single m; pol P1,P2;
	P3 = udpmssum(m,P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber Z/mZ mit m aus [1,BASIS-1].
	P3 = P1 + P2;



			udpmssumjs( m, P, n )

	"univariate dense polynomial over modular singles, summation over
	Jacobi-symbols"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	int udpmssumjs(m,P,n)  single m; pol P; single n;
	A = udpmssumjs(m,P,n);
	P ist ein quadratfreies Polynom in dense-Darstellung aus
	Z/mZ[X] und m ist eine Primzahl aus [3,BASIS].
	n ist eine ganze Zahl aus [0,BASIS).
	A ist die Summe der Jacobi-Symbole [P/P1], wobei ueber alle
	normierten Polynome P1 aus Z/mZ[X] vom Grad n summiert wird,
	deren groesster gemeinsamer Teiler mit P trivial ist.



			udpmstbc( m, P )

	"univariate dense polynomial over modular single trailing
	base coefficient"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single udpmstbc(m,P)  single m; pol P;
	s = udpmstbc( m, P );
	P ist ein Polynom in einer Variablen in dense-Darstellung
	ueber Z/mZ. Falls P gleich 0 ist, ist s gleich 0.
	Sonst ist s dann der freie Koeffizient von P.



			udppfdif( p, P1, P2 )

	"univariate dense polynomial over p-adic field difference"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol udppfdif( p, P1, P2)  single p; pol P1,P2;
	P = udppfdif( p, P1, P2);
	Dabei muss gelten:
	      - p ist Primzahl.
	      - P1 und P2 sind Polynome in dense-Darstellung in einer
		Variablen ueber dem p-adischen Zahlkoerper Qp.
	Dabei sind die Koeffizienten der Polynome jeweils Approximationen
	von Zahlen aus Qp.
	P = P1 - P2. ( p-adisch )



			udppfexp( p, P, n )

	"univariate dense polynomial over p-adic field exponentiation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol udppfexp( p, P, n )  single p,n; pol P;
	P1 = udppfexp( p, P, n );
	Dabei muss gelten:
	      - p ist Primzahl.
	      - n ist nichtnegative ganze Zahl.
	      - P ist Polynom in dense-Darstellung in einer Variablen
		ueber dem p-adischen Zahlkoerper Qp.
	Dabei sind die Koeffizienten des Polynoms jeweils Approximationen
	von Zahlen aus Qp.
	P1 = P^n.  ( p-adisch )



			udppffit( p, P, Pd )

	"univariate dense polynomial over p-adic field fitting"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	single udppffit( p, P, Pd )  single p; pol P,*Pd;
	d = udppffit( p, P, Pd );
	Dabei muss gelten:
	      - p ist Primzahl.
	      - P ist Polynom in dense-Darstellung in einer Variablen
		ueber dem p-adischen Zahlkoerper Qp.
	      - P ist  u n g l e i c h  dem Nullpolynom.
	Die Koeffizienten von P seien ai.
	Dabei sind die ai jeweils Approximationen von Ai aus Qp vom Grad
	di, fuer die bzgl. der additiven p-adischen Bewertung
	vp gilt:
		vp( Ai - ai ) >= di
	und     ai = 0                            , falls di <= vp( Ai )
	sonst   ai = ai_vp( Ai ) * p^vp( Ai ) + ... + ai_di * p^di,
	wobei   ai_vp( Ai ) != 0          und
		0 <= ai_j <= p - 1
	Fuer ai ergibt sich folgende Form:
		ai = 0                  , falls a = 0 oder alle ai_j = 0
		di, ai_vp( Ai ), ..., ai_di )                    , sonst
	Die Koeffizienten ai != 0 werden auf ihre maximal gemeinsame Ge-
	nauigkeit d angepasst, und entsprechend wird P nach *Pd umgeformt.
	d = maximal gemeinsame Genauigkeit.



			udppfneg( p, P )

	"univariate dense polynomial over p-adic field negation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol udppfneg( p, P )  single p; pol P;
	P1 = udppfneg( p, P );
	Dabei muss gelten:
	      - p ist Primzahl.
	      - P ist Polynom in dense-Darstellung in einer Variablen
		ueber dem p-adischen Zahlkoerper Qp.
	Dabei sind die Koeffizienten des Polynoms jeweils Approximationen
	von Zahlen aus Qp.
	P1 = -P  ( p-adisch )



			udppfpfprod( p, P, a )

	"univariate dense polynomial over p-adic field p-adic field
	 element product"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol udppfpfprod( p, P, a )  single p; pol P; pfel a;
	P1 = udppfpfprod( p, P, a );
	Dabei muss gelten:
	      - p ist Primzahl.
	      - P ist Polynom in dense-Darstellung in einer Variablen
		ueber dem p-adischen Zahlkoerper Qp.
	      - a ist Element des p-adischen Zahlkoerpers Qp.
	Dabei sind die Koeffizienten des Polynoms jeweils Approximationen
	von Zahlen aus Qp.
	P1 = a * P.  ( p-adisch )



			udppfpprod( p, P, i )

	"univariate dense polynomial over p-adic field prime power
	 product"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol udppfpprod( p, P, i )  single p,i; pol P;
	P1 = udppfpprod( p, P, i );
	Dabei muss gelten:
	      - p ist Primzahl.
	      - P ist Polynom in dense-Darstellung in einer Variablen
		ueber dem p-adischen Zahlkoerper Qp.
	Dabei sind die Koeffizienten des Polynoms jeweils Approximationen
	von Zahlen aus Qp.
	P1 = p^i * P.   ( p-adisch )



			udppfprod( p, P1, P2 )

	"univariate dense polynomial over p-adic field product"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol udppfprod( p, P1, P2 )  single p; pol P1,P2;
	P = udppfprod( p, P1, P2 );
	Dabei muss gelten:
	      - p ist Primzahl.
	      - P1 und P2 sind Polynome in dense-Darstellung in einer
		Variablen ueber dem p-adischen Zahlkoerper Qp.
	Dabei sind die Koeffizienten der Polynome jeweils Approximationen
	von Zahlen aus Qp.
	P = P1 * P2.



			udppfsum( p, P1, P2 )

	"univariate dense polynomial over p-adic field sum"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol udppfsum( p, P1, P2 )  single p; pol P1,P2;
	P = udppfsum( p, P1, P2 );
	Dabei muss gelten:
	      - p ist Primzahl.
	      - P1 und P2 sind Polynome in dense-Darstellung in einer
		Variablen ueber dem p-adischen Zahlkoerper Qp.
	Dabei sind die Koeffizienten der Polynome jeweils Approximationen
	von Zahlen aus Qp.
	P = P1 + P2.    ( p-adisch )



			udprdif( P1, P2 )

	"univariate dense polynomial over rationals difference"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udprdif(P1,P2)  pol P1,P2;
	P3 = udprdif(P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber den rationalen Zahlen.
	P3 = P1 - P2.



			udprneg( P )

	"univariate dense polynomial over rationals negation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udprneg(P)  pol P;
	P1 = udprneg(P);
	P ist ein Polynom in dense-Darstellung in einer Variablen
	ueber den rationalen Zahlen.
	P1 = -P.



			udprprod( P1, P2 )

	"univariate dense polynomial over rationals product"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udprprod(P1,P2)  pol P1,P2;
	P3 = udprprod(P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber den rationalen Zahlen.
	P3 = P1 * P2.



			udprqrem( P1, P2, pP3 )

	"univariate dense polynomial over rationals quotient and remainder"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udprqrem(P1,P2,pP3)  pol P1,P2,*pP3;
	P4 = udprqrem(P1,P2,pP3);
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber den rationalen Zahlen. P2 ist ungleich 0.
	P4 = P1 / P2.
	*pP3 = P1 % P2.



			udprrprod( P, A )

	"univariate dense polynomial over rationals, rational number
	 product"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udprrprod( P,A )  pol P; rat A;
	P1 = udprrprod( P,A );
	P ist ein Polynom in einer Variable in dense-Darstellung ueber Q.
	P1 = A * P.



			udprsum( P1, P2 )

	"univariate dense polynomial over rationals sum"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol udprsum(P1,P2)  pol P1,P2;
	P3 = udprsum(P1,P2);
	P1 und P2 sind Polynome in dense-Darstellung in einer Variablen
	ueber den rationalen Zahlen.
	P3 = P1 + P2.



			udprtoudppf( P, p, d )

	"univariate dense polynomial over rationals to univariate dense
	 polynomial over p-adic field"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol udprtoudppf( P, p, d )  pol P; single p,d;
	P1 = udprtoudppf( P, p, d );
	Dabei muss gelten:
	      - P ist Polynom in dense-Darstellung in einer Variablen
		ueber den rationalen Zahlen mit Koeffizienten Ai.
	      - p ist Primzahl.
	Die Koeffizienten von P1 seien ai.
	Dabei sind die ai jeweils Approximationen von Ai aus Qp vom Grad
	d, fuer die bzgl. der additiven p-adischen Bewertung vp gilt:
		vp( Ai - ai ) >= d
	und     ai = 0                            , falls d <= vp( Ai )
	sonst   ai = ai_vp( Ai ) * p^vp( Ai ) + ... + ai_d * p^d,
	wobei   ai_vp( Ai ) != 0          und
		0 <= ai_j <= p - 1
	Fuer ai ergibt sich folgende Form:
		ai = 0                  , falls a = 0 oder alle ai_j = 0
		( d, ai_vp( Ai ), ..., ai_d )                    , sonst
	ACHTUNG: Ist die Approximation fuer den hoechsten Koeffizienten 0,
	-------  so wird das Polynom im Grad reduziert.



			udptbc( P )

	"univariate dense polynomial trailing base coefficient"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	obj udptbc(P)  pol P;
	a = udptbc( P );
	P ist ein Polynom in einer Variablen in dense-Darstellung.
	Falls P gleich 0 ist, ist a gleich 0. Sonst ist a dann
	der freie Koeffizient von P.



			upgf22pvprem( G, m, P )

	"univariate polynomial over Galois-field with characteristic 2,
	2^m-th power of variable, polynomial, remainder"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgf22pvprem(G,m,P)  obj G; single m; pol P;
	R = upgf22pvprem(G,m,P);
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        m ist eine positive single.
        P ist ein Polynom positiven Grades in der Veraenderlichen x
	ueber GF(2^n) mit Koeffizienten in spezieller Bit-Darstellung.
	Es wird berechnet R(x) = x^(2^m) mod P(x).



			upgf2bofact( G, P )

	"univariate polynomial over Galois-field with characteristic 2,
	Ben-Or factorization"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgf2bofact( G, P )  obj G; pol P;
	L = upgf2bofact( G, P );
        Dabei muss gelten:
        - G ist ein irreduzibles normiertes Polynom in einer Variablen
          ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
          (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        - P ist ein normiertes Polynom in einer Variablen ueber GF(2^n),
          in der speziellen Bit-Darstellung, ungleich dem Nullpolynom.
	L = ( P_1, .. ,P_r ) ist eine Liste aus irreduziblen Polynomen in
        der speziellen Bit-Darstellung, fuer die gilt: P = P_1 *...* P_r.
        Literatur: M. Ben-Or: Proc.22, IEEE Symp. Foundations Comp. Sci.,
                              p.394-398, 1981.



			upgf2bofacts( G, P )

	"univariate polynomial over Galois-field with characteristic 2
	Ben-Or factorization, special"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgf2bofacts( G, P )  obj G; pol P;
	L = upgf2bofacts( G, P );
        Dabei muss gelten:
        - G ist ein irreduzibles normiertes Polynom in einer Variablen
          ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
          (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        - P ist ein normiertes Polynom in einer Variablen ueber GF(2^n),
          in der speziellen Bit-Darstellung, ungleich dem Nullpolynom.
	L ist die Liste der irreduziblen Faktoren und Exponenten von P,
        d.h. L = ( P_1, e_1, .. ,P_k, e_k ) mit P = P_1^e_1 * .. * P_k^e_k,
             wobei die P_i Polynome in der speziellen Bit-Darstellung sind.
        Literatur: M. Ben-Or: Proc.22, IEEE Symp. Foundations Comp. Sci.,
                              p.394-398, 1981.



			upgf2bqp( G, P )

	"univariate polynomial over Galois-field with characteristic 2
	Berlekamp Q polynomials construction"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgf2bqp( G, P )  obj G; pol P;
	Q = upgf2bqp( G, P );
        Dabei muss gelten:
        - G ist ein irreduzibles normiertes Polynom in einer Variablen
          ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
          (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
	- P ist ein Polynom in einer Variable ueber GF(2^n) vom Grad m>=2 
          in der speziellen Bit-Darstellung.
	Q ist die Liste (Q[0],...,Q[m-1]), wobei Q[i] der Rest bei
	Polynomdivision von x^((p^n)*i) durch P(x) in der speziellen
        Bit-Darstellung (vgl. udpm2tosb) ist.



			upgf2ddfact( G, P )

	"univariate polynomial over Galois-field with characteristic 2
	 distinct degree factorization"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgf2ddfact( G, P )  obj G; pol P;
	L = upgf2ddfact( G, P );
        Dabei muss gelten:
        - G ist ein irreduzibles normiertes Polynom in einer Variablen
          ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
          (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
	- P ein normiertes quadratfreies Polynom in einer Variablen
	  ueber GF(2^n) vom Grad >= 2 in der speziellen Bit-Darstellung.
        Dann ist
	L = ( G1, m1, G2, m2, ..., Gk, mk ). Fuer 1<=i<=k ist dabei mi
	eine positive ganze Zahl, m1 < ... < mk, und Gi das Produkt aller
	irreduziblen normierten Faktoren von P vom Grad mi in der 
        speziellen Bit-Darstellung.



			upgf2eval( G, P, a )

	"polynomial over Galois-field with characteristic 2 evaluation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgf2eval(G, P, a)  obj G; pol P; gf2el a;
	P1 = upgf2eval(G, P, a);
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        P ist ein Polynom in einer Veraenderlichen ueber GF(2^n) mit 
	Koeffizienten in spezieller Bit-Darstellung.
        a ist ein Element aus GF(2^n), das als Polynom in einer
        Variablen ueber Z/2Z vom Grad < n in spezieller Bit-Notation
        dargestellt wird.
	P1 = P(a).



			upgf2gcd( G, P1, P2 )

	"univariate polynomial over Galois-field with characteristic 2
	greatest common divisor"
        Quellbibliothek: srclib.pol3
        Include-Datei:   _pol3.h
        pol upgf2gcd(G, P1, P2)  obj G; pol P1,P2;
        P3 = upgf2gcd(G, P1, P2);
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        P1 und P2 sind Polynome in einer Veraenderlichen ueber GF(2^n)
	mit Koeffizienten in spezieller Bit-Darstellung.
	P3 ist der groesste gemeinsame Teiler von P1 und P2.



			upgf2modexps( G, F, m, P, pM )

	"univariate polynomial over Galois-field with characteristic 2,
	modular exponentiation, special version"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgf2modexps(G,F,m,P,pM)  obj G; pol F,P; single m; matrix *pM;
	R = upgf2modexps(G,F,m,P,pM);
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        F ist ein Polynom in der Veraenderlichen x ueber GF(2^n) mit
	Koeffizienten in spezieller Bit-Darstellung
	(weitere Bedingungen an F siehe unten).
	m ist eine positive single.
        P ist ein Polynom positiven Grades in der Veraenderlichen x
	ueber GF(2^n) mit Koeffizienten in spezieller Bit-Darstellung.
	Sei l der Grad von P.
	Fuer l = 1 bzw. fuer 2^m < l ist *pM ohne Bedeutung.
	Ist F = 0, so ist *pM die leere Liste, und es wird   
			R(x) = x^(2^m)     mod P(x)  
	berechnet.
	Ist F != 0, so muss gelten F(x) = x^(2^m) mod P(x), und
	*pM ist eine lxl Matrix mit Eintraegen aus GF(2^n)
	in spezieller Bit-Darstellung, so dass gilt:
	Sei *pM = ( a_11 a_12 a_13  ....  a_1l
	            a_21 a_22 a_23  ....  a_2l
				. . . . . 
	            a_l1 a_l2 a_l3  ....  a_ll ),
	dann gilt fuer 1 <= i <= l jeweils mit j = (l + 1) - i:
	a_1j * x^(l-1) + ... + a_lj * x^0 = x^(2^4 * (i-1)) mod P(x).
	In diesem Fall wird 
			R(x) = x^((2^m)^2) mod P(x).
	berechnet.



			upgf2mprem( G, a, T, P )

	"univariate polynomial over Galois-field with characteristic 2,
	monomial, polynomial, remainder"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgf2mprem(G, a, T, P)  obj G; gf2el a; int T; pol P;
	R = upgf2mprem(G, a, T, P);
        G ist ein irreduzibles normiertes Polynom in einer Variablen
        ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
        (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        a ist ein Element aus GF(2^n), das als Polynom in einer
        Variablen ueber Z/2Z vom Grad < n in spezieller Bit-Notation
        dargestellt wird. a ist ungleich 0.
	T ist eine positive ganze Zahl.
        P ist ein Polynom positiven Grades in der Veraenderlichen x
	ueber GF(2^n) mit Koeffizienten in spezieller Bit-Darstellug.
        R(x) = (a * x)^T mod P(x).



			upgf2sfact( G, P )

	"univariate polynomial over Galois-field with characteristic 2
	squarefree factorization" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgf2sfact( G, P )  obj G; pol P;
	L = upgf2sfact( G, P );
        Dabei muss gelten:
        - G ist ein irreduzibles normiertes Polynom in einer Variablen
          ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
          (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
	- P ist ein normiertes Polynom positiven Grades in einer Unbe-
          stimmten ueber GF(2^n) in der speziellen Bit-Darstellung. 
        Dann ist
	L eine Liste der Form ( ( e_1 , P_1 ) , ... , ( e_t , P_t ) ) und
	t eine positive single, so dass fuer 1 <= i <= t gilt:
	- 0 < e_1 < e_2 < ... < e_t;
	- P_i ist normierter quadratfreier Faktor von P;
	- die P_i sind paarweise prim;
	- (P_1)^(e_1) * ... * (P_t)^(e_t) = P.



			upgf2sfed( G, H, d )

	"univariate polynomial over Galois-field with characteristic 2,
        separate factor of equal degree"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgf2sfed( G, H, d )  obj G; pol H; single d; 
	L = upgf2sfed( G, H, d );
        Dabei muss gelten:
        - G ist ein irreduzibles normiertes Polynom in einer Variablen
          ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
          (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n).
        - H ist ein normiertes quadratfreies Polynom vom Grad l ueber 
	  GF(2^n) in der speziellen Bit-Darstellung.
        Dann liefert die Funktion upgf2sfed eine Zerlegung von H in der 
	Form:
        H(x) = h_1(x) * ... * h_k(x), wobei die h_i(x) die irreduzibelen 
	Faktoren vom gleichen Grad d  in der speziellen Bit-Darstellung 
	sind, und es gilt: deg( H ) = l = k*d.
        L ist die Liste ( h_1(x) ... h_k(x) ).
        Literatur: M. Ben-Or: Proc.22, IEEE Symp. Foundations Comp. Sci.,
                              p.394-398, 1981.



			upgf2tf( G, F, d, M )

	"polynomial over Galois-field with characteristic 2, trace 
	function, special"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgf2tf( G, F, d, M )  single d; obj G; pol F, M;
	P = upgf2tf( G, F, d, M );
        Dabei muss gelten:
        - G ist ein irreduzibles normiertes Polynom in einer Variablen
          ueber Z/2Z vom Grad n in der speziellen Bit-Darstellung
          (vgl. udpm2tosb) als erzeugendes Polynom fuer GF(2^n);
        - F ist ein Polynom vom Grad m in einer Variablen ueber GF(2^n); 
        - M ist ein Polynom vom Grad l in einer Variablen ueber GF(2^n); 
        - m < l; 
        - F, M haben Koeffizienten in spezieller Bit-Darstellung.
        Dann ist P ein Polynom der Form
        P = Trace(F) = F + F^q + F^q^2 + ... + F^q^d. Alle Produkte,
        die fuer die Berechnung von P gebildet werden, sind reduziert
        modulo ( M * (Z/2Z)[x] ) in spezieller Bit-Darstellung.



			upgfsbfact( p, AL, P, d )

	"univariate polynomial over Galois-field with single characteristic
	Berlekamp factorization"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgfsbfact(p,AL,P,d)  single p,d; list AL; pol P;
	L = upgfsbfact(p,AL,P,d);
	P ist ein normiertes quadratfreies Polynom positiven Grades in
	einer Variable ueber GF(p^n).
	P darf keinen Primpolynomteiler mit Grad kleiner d haben.
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	L ist eine Liste aller normierten irreduziblen Faktoren positiven
	Grades von P.



			upgfsbfls( p, AL, P, B, d )

	"univariate polynomial over Galois-field with single characteristic
	Berlekamp factorization, last step"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgfsbfls(p,AL,P,B,d)  single p,d; list AL; pol P; list B;
	L = upgfsbfls(p,AL,P,B,d);
	P ist ein normiertes quadratfreies Polynom in einer Variable ueber
	GF(p^n), wobei Grad(P) >= 2.
	P darf keinen Primpolynomteiler vom Grade kleiner d haben.
	(Diese letzte Bedingung wird im Testrahmen nicht ueberprueft.)
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	B = (B1,...,Br) mit r > 0 ist eine Liste normierter Polynome in
	einer Variable ueber GF(p^n), die eine Basis fuer den Vektorraum
	aller Polynome C vom Grad < Grad(P) darstellen, fuer die gilt :
	P teilt C^(p^n) - C.
	(Die lineare Unabhaengigkeit der Bi wird im Testrahmen nicht
	ueberprueft.)
	B1 ist 1.
	L ist eine Liste aller normierten irreduziblen Faktoren positiven
	Grades von P.



			upgfsbfzm( p, AL, s, P, G )

	"univariate polynomial over Galois-field with single characteristic
	Berlekamp factorization, Zassenhaus method"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgfsbfzm(p,AL,s,P,G)  single p,s; list AL; pol P,G;
	L = upgfsbfzm(p,AL,s,P,G);
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P ist ein normiertes, quadratfreies Polynom in einer
	Veraenderlichen ueber GF(p^n) mit deg(P) >= 2.
	s ist mindestens so gross wie die Anzahl der irreduziblen
	Faktoren von P, und auf jeden Fall muss gelten 2 <= s <= deg(P).
	G ist ein normiertes Polynom mit 0 < deg(G) < deg(P) und
	(G^(p^n) - G) mod P = 0, d.h. P|(G-s1)*....*(G-sq).
	Dabei gilt q = p^n und GF(p^n)={s1,...,sq}.
	L ist genau die Liste der Elemente aus GF(p^n), fuer die gilt
	gcd( P, G-s) != 1.



			upgfsbofact( p, AL, P )

	"univariate polynomial over Galois-field with single characteristic,
	Ben-Or factorization"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgfsbofact(p, AL, P)  single p; list AL; pol P;
	L = upgfsbofact(p, AL, P);
        Dabei muss gelten:
        - p ist eine Primzahl < BASIS, p ungleich 2,
        - AL = ( G, AL1 ) kann als Arithmetikliste fuer GF(p^n) interpretiert
          werden (siehe gfsalgen), wobei n = llength(AL1) + 1.
        - P ist ein normiertes Polynom in einer Variablen ueber GF(p^n),
          ungleich dem Nullpolynom.
	  L = ( P_1, ... ,P_r ) ist die Liste aller irreduziblen Faktoren
	  von P, also: P = P_1 * ... * P_r.
        Literatur: M. Ben-Or: Proc.22, IEEE Symp. Foundations Comp. Sci.,
                              p.394-398, 1981.



			upgfsbofacts( p, AL, P )

	"univariate polynomial over Galois-field with single characteristic,
	Ben-Or factorization, special"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgfsbofacts(p, AL, P)  single p; list AL; pol P;
	L = upgfsbofacts(p, AL, P);
        Dabei muss gelten:
        - p ist eine Primzahl < BASIS, p ungleich 2,
        - AL = ( G, AL1 ) kann als Arithmetikliste fuer GF(p^n) interpretiert
          werden (siehe gfsalgen), wobei n = llength(AL1) + 1.
        - P ist ein normiertes Polynom in einer Variablen ueber GF(p^n),
          ungleich dem Nullpolynom.
	L ist die Liste der irreduziblen Faktoren und Exponenten von P,
        d.h. L = ( P_1, e_1, .. ,P_k, e_k ) mit P = P_1^e_1 * .. * P_k^e_k.
        Literatur: M. Ben-Or: Proc.22, IEEE Symp. Foundations Comp. Sci.,
                              p.394-398, 1981.



			upgfsbqp( p, AL, P )

	"univariate polynomial over Galois-field with single characteristic
	Berlekamp Q polynomials construction"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgfsbqp(p,AL,P)  single p; list AL; pol P;
	Q = upgfsbqp(p,AL,P);
	P ist ein Polynom in einer Variable ueber GF(p^n) vom Grad m>=2.
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	Q ist die Liste (Q[0],...,Q[m-1]), wobei Q[i] der Rest bei
	Polynomdivision von x^((p^n)*i) durch P(x) ist.



			upgfscfact( p, AL, P )

	"univariate polynomial over Galois-field with single characteristic
	complete factorization"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgfscfact(p,AL,P)  single p; list AL; pol P;
	L = upgfscfact(p,AL,P);
	P ist ein Polynom positiven Grades in einer Variable ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	Dann ist L=(P_1, ... ,P_r) eine Liste aus irreduziblen, bis auf das
	erste normierten Polynomen, fuer die gilt: P = P_1*...*P_r.



			upgfscfacts( p, AL, P )

	"univariate polynomial over Galois-field with single characteristic
	complete factorization special"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgfscfacts(p,AL,P)  single p; list AL; pol P;
	L = upgfscfacts(p,AL,P);
	p ist eine single Primzahl, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.                           
	P ist ein normiertes Polynom positiven Grades in einer Unbestimmten
	ueber GF(p^n).
	L ist eine Liste der Form (P_1, e_1, ... P_r, e_r );
	dabei ist r eine positive single, und fuer 1 <= i <= j <= r gilt:
	- e_i ist eine positive single;
	- P_i ist ein normierter irreduzibler Faktor von A;
	- P_i != P_j, falls i != j;
	- (P_1)^(e_1) * ... * (P_r)^(e_r) = P.



			upgfsddfact( p, AL, P )

	"univariate polynomial over Galois-field with single characteristic
	 distinct degree factorization"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgfsddfact(p,AL,P)  single p; list AL; pol P;
	L = upgfsddfact(p,AL,P);
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P ein normiertes quadratfreies Polynom in einer Variablen
	ueber GF(p^n) vom Grad >= 2.
	L = ( G1, m1, G2, m2, ..., Gk, mk ). Fuer 1<=i<=k ist dabei mi
	eine positive ganze Zahl, m1 < ... < mk, und Gi das Produkt aller
	irreduziblen normierten Faktoren von P vom Grad mi.



			upgfsegcd( p, AL, P1, P2, pP3, pP4 )

	"univariate polynomial over Galois-field with single characteristic
	extended greatest common divisor"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgfsegcd(p,AL,P1,P2,pP3,pP4)  single p; list AL; pol P1,P2;
							  pol *pP3,*pP4;
	P5 = upgfsegcd(p,AL,P1,P2,pP3,pP4);
	p ist eine single Primzahl, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P1 und P2 sind Polynome in einer Variablen ueber GF(p^n).
	P5 ist der groesste gemeinsame Teiler von P1 und P2. *pP3 und *pP4
	sind Polynome in einer Variablen ueber GF(p^n), und es gilt:
	1)  P1 * (*pP3) + P2 * (*pP4) = P5;
	2)  ist Grad(P1/P5) groesser 0, so ist Grad(*pP4)
	    kleiner Grad(P1/P5); sonst ist Grad(*pP4) gleich 0;
	3)  ist Grad(P2/P5) groesser 0, so ist Grad(*pP3)
	    kleiner Grad(P2/P5); sonst ist Grad(*pP3) gleich 0;
	4)  ist P1 bzw. P2 gleich 0, so ist *pP3 bzw. *pP4 gleich 0;



			upgfsgcd( p, AL, P1, P2 )

	"univariate polynomial over Galois-field with single characteristic
	greatest common divisor"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgfsgcd(p,AL,P1,P2)  single p; list AL; pol P1, P2;
	P3 = upgfsgcd(p,AL,P1,P2);
	P1 und P2 sind Polynome in einer Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P3 ist der groesste gemeinsame Teiler von P1 und P2.



			upgfsgsd( p, AL, P )

	"univariate polynomial over Galois-field with single characteristic
	greatest squarefree divisor" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgfsgsd(p,AL,P)  single p; list AL; pol P;
	P1 = upgfsgsd(p,AL,P);
	p ist eine single Primzahl, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P ist ein normiertes Polynom in einer Unbestimmten ueber GF(p^n).
	P1 ist ein quadratfreies Polynom in einer Unbestimmten ueber
	GF(p^n), das P teilt und fuer das eine natuerliche Zahl s
	existiert, so dass P  (P1)^s teilt.



			upgfshegcd( p, AL, P1, P2, pP3 )

	"univariate polynomial over Galois-field with single characteristic
	half extended greatest common divisor"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgfshegcd(p,AL,P1,P2,pP3)  single p; list AL; pol P1,P2,*pP3;
	P4 = upgfshegcd(p,AL,P1,P2,pP3);
	p ist eine single Primzahl, AL=(G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P1 und P2 sind Polynome in einer Variablen ueber GF(p^n).
	P4 ist der groesste gemeinsame Teiler von P1 und P2.
	*pP3 ist ein Polynom in einer Variablen ueber GF(p^n), und es gilt:
	1)  es existiert ein Polynom P derart, dass
	    P1 * P + P2 * (*pP3) = P4;
	2)  ist Grad(P1/P4) groesser 0, so ist Grad(*pP3)
	    kleiner Grad(P1/P4); sonst ist Grad(*pP3) gleich 0;
	3)  ist P2 gleich 0, so ist *pP3 gleich 0.



			upgfsmieprem( p, AL, a, t, P )

	"univariate polynomial over Galois-field, monomial, integer 
	 exponentiation, polynomial, remainder"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgfsmieprem(p,AL,a,t,P)  single p; list AL; gfel a; int t; pol P;
	R = upgfsmieprem(p,AL,a,t,P);
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), wobei 
	n = llength(AL1) + 1.
	P ist ein Polynom in einer Veraenderlichen ueber GF(p^n).
	Der Grad von P ist >= 1.
	a ist ein Element ungleich Null aus GF(p^n).
	t ist positiv.
	R(x) = (a*x)^t mod P(x).                  



			upgfsmprem( p, AL, a, T, P )

	"univariate polynomial over Galois-field, monomial, polynomial,
	remainder"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgfsmprem(p, AL, a, T, P) single p; list AL; gfel a; int T; pol P;
	R = upgfsmprem(p, AL, a, T, P);
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen) und es gilt
	n = llength(AL1) + 1.
	a ist ein Element aus GF(p^n). a ist ungleich 0.
	T ist eine positive ganze Zahl.
	P ist ein Polynom positiven Grades in einer Veraenderlichen
	ueber GF(p^n).
	R(x) = (a*x)^T mod P(x).



			upgfsnif( p, AL, P )

	"univariate polynomial over Galois-field with single characteristic
	number of irreducible factors"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	single upgfsnif(p,AL,P)  single p; list AL; pol P;
	t = upgfsnif(p,AL,P);
	P ist ein normiertes quadratfreies Polynom positiven Grades in
	einer Variable ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	t ist die Anzahl der normierten irreduziblen Faktoren positiven
	Grades von P.



			upgfsrand( p, AL, m )

	"univariate polynomial over Galois-field with single characteristic
         randomize"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgfsrand( p, AL, m )  single p, m; list AL; 
	P = upgfsrand( p, AL, m );
	p ist eine Primzahl < BASIS.
        AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) interpretiert
        werden (siehe gfsalgen), wobei n = llength(AL1) + 1.
	m muss groesser gleich 0 sein.
	P ist ein zufaellig erzeugtes Polynom in einer Variablen ueber 
        GF(p^n) mit 0 <= Grad(P) <= m. P ist nicht das Nullpolynom.



			upgfsrandpd( p, AL, m )

	"univariate polynomial over Galois-field with single characteristic
         randomize, positive degree"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgfsrandpd( p, AL, m )  single p, m; list AL; 
	P = upgfsrandpd( p, AL, m );
	p ist eine Primzahl < BASIS.
        AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) interpretiert
        werden (siehe gfsalgen), wobei n = llength(AL1) + 1.   
        m muss groesser gleich 1 sein.
	P ist ein zufaellig erzeugtes Polynom in einer Variablen ueber 
        GF(p^n) mit 1 <= Grad(P) <= m. P ist nicht das Nullpolynom.



			upgfsrelpfac( p, AL, P, Fak, pA2 )

	"univariate polynomial over Galois-field with single characteristic
	relative prime factorization"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgfsrelpfac(p,AL,P,Fak,pA2) single p; list AL; pol P,Fak,*pA2;   
	A1 = upgfsrelpfac(p,AL,P,Fak,pA2);
	p ist eine single Primzahl, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.                           
	P und Fak sind normierte Polynome positiven Grades in einer
	Unbestimmten ueber GF(p^n), und Fak teilt P.
	A1 und *pA2 sind Polynome in einer Unbestimmten ueber GF(p^n),
	so dass gilt: A1 * (*pA2) = P;
	              ggT ( A1 , Fak ) = 1;
               	      *pA2 | (Fak)^(deg(P)).



			upgfsrf( p, AL, P )

	"univariate polynomial over Galois-field with single characteristic
	root finding" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgfsrf(p,AL,P)  single p; list AL; pol P;
	L = upgfsrf(p,AL,P);
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P ist ein normiertes Polynom ueber GF(p^n) in einer
	Veraenderlichen mit deg(P) >= 1.
	L ist eine Liste aller Nullstellen von P.
!!!!!   Vorsicht : Das Programm ist gedacht fuer Polynome P, die voll-
!!!!!   staendig in Linearfaktoren zerfallen. Ansonsten benoetigt das
!!!!!   Programm unverhaeltnismaessig viel Zeit.
	In diesem Fall rufen Sie besser "upgfscfact(p,AL,P)" auf.



			upgfssfact( p, AL, P )

	"univariate polynomial over Galois-field with single characteristic
	squarefree factorization" (rekursiv)
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgfssfact(p,AL,P)  single p; list AL; pol P;
	L = upgfssfact(p,AL,P);
	p ist eine single Primzahl, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P ist ein normiertes Polynom positiven Grades in einer Unbestimmten
	ueber GF(p^n). 
	L ist eine Liste der Form ( ( e_1 , P_1 ) , ... , ( e_t , P_t ) );
	dabei ist t eine positive single und fuer 1 <= i <= t gilt:
	- 0 < e_1 < e_2 < ... < e_t;
	- P_i ist normierter quadratfreier Faktor von P;
	- die P_i sind paarweise prim;
	- (P_1)^(e_1) * ... * (P_t)^(e_t) = P.



			upgfssfed( p, AL, G, d )

	"univariate polynomial over Galois-field with single characteristic,
        separate factors of equal degree"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upgfssfed( p, AL, G, d )  single p, d; list AL; pol G;
	L = upgfssfed( p, AL, G, d );
	p ist ungerade Primzahl.
	d ist positiv.
        AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) interpretiert
        werden (siehe gfsalgen), wobei n = llength(AL1) + 1.   
        G ist ein normiertes, quadratfreies Polynom in einer Variablen 
	ueber GF(p^n), das nur irreduzible Faktoren vom Grad d hat. 
	L ist die Liste aller irreduziblen Faktoren von G, d.h.:
        L = ( h_1 ... h_k ), P = h_1 * ... * h_k, und h_1, ..., h_k sind
	irreduzibel und vom Grad d.
        Literatur: M. Ben-Or: Proc.22, IEEE Symp. Foundations Comp. Sci.,
                              p.394-398, 1981.



			upgfssfp( p, AL, P )

	"univariate polynomial over Galois-field with single characteristic
	squarefree part"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgfssfp(p,AL,P)  single p; list AL; pol P;
	P1 = upgfssfp(p,AL,P);
	P ist ein normiertes Polynom von positivem Grad in einer
	Variablen ueber GF(p^n).
	p ist eine Primzahl < BASIS, AL = (G,AL1) kann als Arithmetikliste
	fuer GF(p^n) interpretiert werden (siehe gfsalgen), und es gilt
	n = llength(AL1) + 1.
	P1 ist der quadratfreie Anteil von P, d.h.
	P = P1 * P2^2    und    ggt(P1,P1') = 1.



			upgfstf( p, AL, G, d, M )

	"univariate polynomial over Galois-field with single characteristic,
         trace function"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upgfstf( p, AL, P, d, M )  single p, d;  list AL;  pol P, M;
	P1 = upgfstf( p, AL, P, d, M );
	p ist ungerade Primzahl.
	d ist positiv.
        AL = (G,AL1) kann als Arithmetikliste fuer GF(p^n) interpretiert
        werden (siehe gfsalgen), wobei n = llength(AL1) + 1.   
        M ist ein Polynom in einer Variablen ueber GF(p^n), das nur 
	irreduzible Faktoren vom Grad d hat. 
        P ist ein Polynom in einer Variablen ueber GF(p^n) mit 
	Grad(P) < Grad(M).
	(P wird aufgefasst als Element aus GF(p^n)[x] / (M).)
        P1 = Tr(P) = ( P + P^q + P^(q^2) + ... + P^(q^(d-1)) ) mod M,
	wobei q = p^n ist.



			upifact( P )

	"univariate polynomial over integers factorization"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upifact(P)  pol P;
	L = upifact(P);
	P ist ein Polynom in einer Variablen ueber den ganzen Zahlen,
	ungleich Null.
	L = ( c, P1,e1, ..., Pk,ek ) fuer k>=1; c=sign(P)*cont(P);
	Fuer 1<=i<=k sind ei positive ganze Zahlen und Pi paarweise
	verschiedene positive irreduzible Faktoren von P, so dass
	P = c * P1^e1 *...* Pk^ek.
	Tritt ein Fehler auf, so ist L = ERROR.



			upifscl( L )

	"univariate polynomial over the integers from special coefficient
	list"
	Quellbibliothek : srclib.pol2
	Include - Datei : _pol2.h
	pol upifscl(L) list L;
	P = upifscl(L);
	Sei a_n * x^n + ... + a_0 * x^0 ein Polynom ueber den ganzen
	Zahlen.
	Dann ist die Liste (a_0, ..., a_n) eine "special coefficient list",
	die dem Polynom entspricht.
	upifscl wandelt eine "special coefficient list" in ein sparse -
	Polynom in einer Veraenderlichen ueber Z um.



			upihlfa( p, P, L, k )

	"univariate polynomial over the integers, Hensel lemma
	factorization approximation"
	Quellbibliothek : srclib.pol2
	Include - Datei : _pol2.h
	list upihlfa(p,P,L,k) single p; pol P; list L; single k;
	L1 = upihlfa(p,P,L,k);
	p ist eine single Primzahl.
	P ist ein Polynom in einer Veraenderlichen mit Koeffizienten aus Z
	und Grad(P) > 1, der Leitkoeffizient wird nicht von p geteilt.
	L=(P_1, ... , P_r) ist eine Liste von paarweise teilerfremden
	Polynomen positiven Grades in einer Veraenderlichen ueber Z/pZ.
	P = P_1 * ... * P_r mod p.
	Fuer 2 <= i <= r ist P_i normiert.
	k ist eine ganze Zahl > 1, so dass die kleinste Zweierpotenz
	groesser gleich k noch eine single ist.
	Dann ist L1 = (f_1, ... ,f_r) eine Liste von Polynomen in einer
	Veraenderlichen ueber Z mit positiven Graden.
	Fuer 1 <= i <= r ist f_i kongruent P_i mod p.
	P = f_1 * ... * f_r mod M mit M = p^k.
	Die Faktorisierung gilt sogar fuer p^t, wobei t die kleinste
	Zweierpotenz groesser gleich k ist.
	Die Koeffizienten von f_i liegen in [0,p^t-1].



			upihlfaip( p, P, L, k )

	"univariate polynomial over integers, Hensel lemma factorization
	approximation with respect to integer prime"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upihlfaip(p,P,L,k)  int p; pol P; list L; single k;
	L1 = upihlfaip(p,P,L,k);
	p ist eine Primzahl.
	P ist ein Polynom in einer Veraenderlichen mit Koeffizienten aus
	Z und Grad(P) > 1, der Leitkoeffizient wird nicht von p geteilt.
	L=(P_1, ... , P_r) ist eine Liste von paarweise teilerfremden
	Polynomen positiven Grades in einer Veraenderlichen ueber Z/pZ.
	P = P_1 * ... * P_r mod p.
	Fuer 2 <= i <= r ist P_i normiert.
	k ist eine ganze Zahl > 1, so dass die kleinste Zweierpotenz
	groesser gleich k noch eine single ist.
	Dann ist L1 = (f_1, ... ,f_r) eine Liste von Polynomen in einer
	Veraenderlichen ueber Z mit positiven Graden.
	Fuer 1 <= i <= r ist f_i kongruent P_i mod p.
	P = f_1 * ... * f_r mod M mit M = p^k.
	Die Faktorisierung gilt sogar fuer p^t, wobei t die kleinste
	Zweierpotenz groesser gleich k ist.
	Die Koeffizienten von f_i liegen in [0,p^t-1].



			upihli( p, P, L )

	"univariate polynomial over integers, Hensel lemma initialization"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upihli(p,P,L) single p; pol P; list L;
	L1 = upihli(p,P,L);
	P ist ein Polynom in einer Veraenderlichen ueber Z/pZ, p prim, und
	Grad(P) > 1.
	L=(f_1, ... , f_r) ist eine Liste von paarweise teilerfremden
	Polynomen in einer Veraenderlichen mit positiven Graden ueber Z/pZ.
	P = f_1 * ... * f_r.
	Dann ist L1 = (A_1, ... , A_r) eine Liste von Polynomen in einer
	Veraenderlichen ueber Z/pZ.
	Fuer 1 <= i <= r ist deg(A_i) < deg(f_i) und mit F_i = P / f_i
	gilt ( F_i * A_i ) + ... + ( F_r * A_r) = 1.



			upihliip( P, F, L )

	"univariate polynomial over integers, Hensel lemma initialization
	with respect to integer prime"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upihliip(P,F,L)  int P; pol F; list L;
	L1 = upihliip(P,F,L);
	P ist eine Primzahl.
	F ist ein Polynom in einer Veraenderlichen ueber Z / P*Z und
	Grad(P) > 1.
	L = (f_1, ... ,f_r) ist eine Liste von paarweise teilerfremden
	Polynomen in einer Veraenderlichen mit positiven Graden ueber
	Z / P*Z und es  F = f_1 * ... * f_r.
	L1 = (A_1, ... , A_r) ist eine Liste von Polynomen in einer
	Veraenderlichen ueber Z / P*Z.
	Fuer 1 <= i <= r ist deg(A_i) < deg(f_i) und mit F_i = F / f_i
	gilt ( F_i * A_i ) + ... + ( F_r * A_r) = 1.



			upihlqs( p, p_k, p_l, P, L1, L2, A )

	"univariate polynomial over integers, Hensel lemma quadratic step"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upihlqs(p,p_k,p_l,P,L1,L2,A)  single p; int p_k,p_l;
					   pol P; list L1,L2; pol A;
	L = upihlqs(p,p_k,p_l,P,L1,L2,A);
	p ist eine Primzahl < BASIS.
	p_k = p^k und p_l = p^l mit nicht negativen Exponenten k und l,
	fuer die gilt: 2*l < k.
	P ist ein normiertes Polynom in einer Veraenderlichen
	ueber den ganzen Zahlen mit Grad(P) > 1.
	L1 ist eine Liste (f_1,...,f_r) von normierten Polynomen in einer
	Veraenderlichen ueber Z mit Koeffizienten in [0,p^k-1].
	P = f_1 * ... * f_r mod p^k.
	L2 ist eine Liste (A_1,...,A_r) von Polynomen in einer Veraender-
	lichen ueber Z und fuer 1 <= i <= r gilt deg(A_i) < deg(f_i).
	Mit F_i = P / f_i gilt die Resultantengleichung
	A_1 * F_1 + ... + A_r * F_r = p^l mod p^k.
	A = f_1 * ... * f_r.
	L = ( L3, L4, A2 ).
	L3 ist eine Liste (g_1,...,g_r) von normierten Polynomen in einer
	Veraenderlichen ueber Z mit Koeffizienten in [0,p^t-1].
	P = g_1 * ... * g_r mod p^t. Dabei ist t = 2 * ( k - l)  >  k.
	L4 ist eine Liste (B_1,...,B_r) von Polynomen in einer Veraender-
	lichen ueber Z und fuer 1 <= i <= r gilt deg(B_i) < deg(g_i).
	Mit G_i = P / g_i gilt die Resultantengleichung
	B_1 * G_1 + ... + B_r * G_r = p^l mod p^t.
	A2 = g_1 * ... * g_r.



			upihlqsip( P, p_k, p_l, F, L1, L2, A )

	"univariate polynomial over integers, Hensel lemma quadratic step
	with respect to integer prime"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upihlqsip(P,p_k,p_l,F,L1,L2,A)  int P,p_k,p_l; pol F;
					     list L1,L2; pol A;
	L = upihlqsip(P,p_k,p_l,F,L1,L2,A);
	P ist eine Primzahl.
	p_k = P^k und p_l = P^l mit nicht negativen Exponenten k und l,
	fuer die gilt: 2*l < k.
	F ist ein normiertes Polynom in einer Veraenderlichen
	ueber den ganzen Zahlen mit Grad(F) > 1.
	L1 ist eine Liste (f_1,...,f_r) von normierten Polynomen in einer
	Veraenderlichen ueber Z mit Koeffizienten in [0,P^k-1].
	F = f_1 * ... * f_r mod P^k.
	L2 ist eine Liste (A_1,...,A_r) von Polynomen in einer Veraender-
	lichen ueber Z und fuer 1 <= i <= r gilt deg(A_i) < deg(f_i).
	Mit F_i = F / f_i gilt die Resultantengleichung
	A_1 * F_1 + ... + A_r * F_r = P^l mod P^k.
	A = f_1 * ... * f_r.
	L = ( L3, L4, A2 ).
	L3 ist eine Liste (g_1,...,g_r) von normierten Polynomen in einer
	Veraenderlichen ueber Z mit Koeffizienten in [0,P^t-1].
	F = g_1 * ... * g_r mod P^t. Dabei ist t = 2 * ( k - l)  >  k.
	L4 ist eine Liste (B_1,...,B_r) von Polynomen in einer Veraender-
	lichen ueber Z und fuer 1 <= i <= r gilt deg(B_i) < deg(g_i).
	Mit G_i = F / g_i gilt die Resultantengleichung
	B_1 * G_1 + ... + B_r * G_r = P^l mod P^t.
	A2 = g_1 * ... * g_r.



			upinfeval( P, F, a )

	"univariate polynomial over integers number field element 
	 evaluation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	nfel upinfeval(P,F,a)  pol P,F; nfel a;
	a1 = upinfeval(P,F,a);
	Es muss gelten : P ist Polynom in einer Variable ueber den
		ganzen Zahlen.
		F ist ein irreduzibles Polynom vom Grad >= 1 in einer 
		Variable ueber den ganzen Zahlen, und zwar in dense-
		Darstellung.
		a ist ein Element aus dem durch F gegebenen Zahlkoerper.
	a1 = P(a)  (Element aus dem durch F gegebenen Zahlkoerper, genauso
	            dargestellt wie a)



			upinfseval( P, F, a )

	"univariate polynomial over integers number field element,
	sparse representation, evaluation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	nfel upinfseval(P,F,a)  pol P,F; nfel a;
	a1 = upinfseval(P,F,a);
	Es muss gelten : P ist Polynom in einer Variable ueber den ganzen
		Zahlen.
		F ist ein irreduzibles Polynom vom Grad >= 1 in einer
		Variable ueber den rationalen Zahlen.
		a ist ein Element aus dem durch F gegebenen Zahlkoerper,
		das als Polynom vom Grad < Grad(F) in einer Variable ueber
		den rationalen Zahlen dargestellt ist (sparse-Darstellung).
	a1 = P(a)  (Element aus dem durch F gegebenen Zahlkoerper, genauso
	dargestellt wie a)



			upireddiscc( P, pc )

	"univariate polynomial over the integers reduced discriminant
	and content of resultant equation"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	int upireddiscc(P,pc) pol P; int *pc;
	a = upireddiscc(P,pc);
	P ist ein Polynom in einer Variablen ueber den ganzen Zahlen
	mit einem Grad groesser gleich 2.
	a ist die reduzierte Diskriminante von P, also ein Element aus Z.
	pc ist der Inhalt der Resultantengleichung von P.
	pc ist also gerade gleich dem Quotienten aus der klassischen und
	der reduzierten Diskriminante von P.



			upiresulc( P1, P2, pB )

	"univariate polynomial over the integers resultant and cofactor of
	resultant equation"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	int upiresulc(P1,P2,pB) pol P1,P2; pol *pB;
	a = upiresulc(P1,P2,pB);
	P1 und P2 sind Polynome in einer Variablen ueber den ganzen Zahlen
	mit positiven Graden.
	a ist die Resultante von P1 und P2 und als solche aus Z.
	*pB ist ein Polynom in einer Variablen ueber Z, so dass ein
	Polynom	A in einer Variablen ueber Z existiert, fuer das die
	Resultantengleichung P1 * A + P2 * (*pB) = a erfuellt ist.
	Die Resultante a wird mit Hilfe des Collins-Algorithmus berechnet.
	(vgl. G.E. Collins, The Calculation of Multivariate Polynomial
	Resultants, Journal ACM, No. 4,18 (Oct. 1971), 515-532.)



			upm2imgen( n )

	"univariate polynomial over modular 2, irreducible and 
	monic, generator"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upm2imgen(n)  single n;
	P = upm2imgen(n);
	Voraussetzung: n >= 1.
	Ergebnis:
	. P ist ein zufaellig erzeugtes, irreduzibles, normiertes Polynom
	vom Grad n in einer Variable ueber Z/2Z.
	Bemerkung: zuerst wird getestet, ob es ein irreduzibles Trinom
	in einer Variablen vom Grad n ueber Z/2Z gibt, also ein Polynom 
	der Form:  x^n + x^k + 1 ( 1 <= k <= n/2 ).
	Gibt es kein irreduzibles Trinom, wird upmsimgen aufgerufen.
	(vgl. auch upm2imtgen)



			upm2imtgen( n )

	"univariate polynomial over modular 2, irreducible and 
	monic trinomial, generator"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upm2imtgen(n)  single n;
	P = upm2imtgen(n);
	Voraussetzungen : n >= 1.
	Ergebnis: 
	. existiert ein irreduzibles Trinom vom Grad n in einer Variablen
	  ueber Z/2Z, also x^n + x^k + 1 ( 1 <= k <= n/2 ), 
	  so ist P = x^n + x^k + 1.
	. sonst ist P = 0.
	Folgende Kriterien gelten:
	a) n = 3 * l (l = 0, 1, 2, ...) => x^n + x^(n/2) + 1 irreduzibel
	b) n und k gerade => x^n + x^k + 1 ist ein Quadrat, also reduzibel
	c) x^n + x^k + 1 irreduzibel <=> x^n + x^(n-k) + 1 irreduzibel
	   (deshalb wird gefordert: 1 <= k <= n/2)
	d) Ist  n = 1 (mod 3) und k = 2 (mod 3) 
	   oder n = 2 (mod 3) und k = 1 (mod 3) ,
	   so ist x^2 + x + 1 Teiler von x^n + x^k + 1 .
	   (also ist das Trinom dann reduzibel)
	e) In 50% aller 2 <= n <= 1000 gibt es ein irreduzibles Trinom.
	   Eine Tabelle fuer die moeglichen Trinome ist in Zierler/Brillhart.
	Literatur:
	. Zierler/Brillhart, "On Primitive Trinomials (Mod 2)",
	  Information And Control 13, 1968, S. 541-554.
	. J.H. v.Lint, "Introduction to Coding Theory", NY, Springer 1982.



			upmiaddval( p, P1, P )

	"univariate polynomial over modular integer prime additive
	valuation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single upmiaddval( p, P1, P )  int p; pol P1,P;
	w = upmiaddval( p, P1, P );
	p ist eine Primzahl.
	P1 und P sind Polynome in einer Veraenderlichen ueber (Z/pZ),
	P1 hat positiven Grad und P ist ungleich dem Nullpolynom.
	w ist eine nicht negative single, fuer die ein Polynom P2 in
	einer Veraenderlichen ueber (Z/pZ) existiert, das nicht von
	P1 geteilt wird und fuer das gilt: P = (P1)^w * P2.



			upmibfact( ip, P, d )

	"univariate polynomial over modular integers factorization,
	Berlekamp algorithm"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmibfact(ip,P,d)  int ip; pol A; single d;
	L = upmibfact(ip,P,d);
	ip ist eine Primzahl.
	P ist ein normiertes quadratfreies Polynom positiven Grades in
	einer Variable ueber Z / (ip)*Z.
	A darf keinen irreduziblen Faktor mit Grad < d haben.
	L ist eine Liste aller normierten irreduziblen Faktoren positiven
	Grades von A.



			upmibfls( ip, P, B, d )

	"univariate polynomial over modular integers Berlekamp
	factorization, last step"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmibfls(ip,P,B,d)  int ip; pol P; list B; single d;
	L = upmibfls(ip,P,B,d);
	ip ist eine Primzahl.
	P ist ein normiertes quadratfreies Polynom in einer Variable
	ueber Z / (ip)*Z, wobei Grad(P) groesser als 1 ist.
	B = (B_1,...,B_r) ist ein eine Liste positiver Laenge, wobei
	jeweils B_i ein normiertes Polynome in einer Variable ueber
	Z / (ip)*Z ist. Speziell B_1 ist gleich 1. Die B_i's bilden
	eine Basis des Vektorraums aller Polynome C mit Graden kleiner
	als Grad(P), fuer die gilt: P teilt C^(ip) - C.
	d ist eine positive single, so dass P keinen irreduziblen
	Faktor mit Grad kleiner d hat.
	L ist eine Liste aller normierten irreduziblen Faktoren positiven
	Grades von P.



			upmibfzm( ip, s, P, G )

	"univariate polynomial over modular integers, Berlekamp
	factorization, Zassenhaus method"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmibfzm(ip,s,P,G)  int ip; single s; pol P,G;
	L = upmibfzm(ip,s,P,G);
	ip ist eine Primzahl.
	P ist ein normiertes, quadratfreies Polynom in einer
	Veraenderlichen ueber Z / (ip)*Z mit Grad groesser 1.
	s ist mindestens so gross wie die Anzahl der irreduziblen
	Faktoren von P und auf jeden Fall muss gelten 2 <= s <= deg(P).
	G ist ein normiertes Polynom mit 0 < deg(G) < deg(P) und
	(G^(ip) - G) mod P = 0, d.h. P | (G-s_1)*....*(G-s_ip),
	wobei Z / (ip)*Z = { s_1, ..., s_ip }.
	L ist genau die Liste der Elemente aus Z / (ip)*Z, fuer die gilt
	gcd( P, G - s ) != 1.



			upmibofact( ip, P )

	"univariate polynomial over modular integers Ben-Or factorization"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmibofact(ip, P)  int ip; pol P;
	L = upmibofact(ip, P);
        Dabei muss gelten:
        - ip ist eine Primzahl,
        - P ist ein normiertes Polynom in einer Variablen  ueber Z/(ip)*Z; 
          ungleich dem Nullpolynom.
	  L = ( P_1, .. ,P_r ) ist eine Liste aus irreduziblen Polynomen,
          fuer die gilt: P = P_1 *...* P_r.
        Literatur: M. Ben-Or: Proc.22, IEEE Symp. Foundations Comp. Sci.,
                              p.394-398, 1981.



			upmibofacts( ip, P )

	"univariate polynomial over modular integers Ben-Or factorization,
        special"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmibofacts(ip, P)  int ip; pol P;
	L = upmibofacts(ip, P);
        Dabei muss gelten:
        - ip ist eine Primzahl,
        - P ist ein normiertes Polynom in einer Variablen ueber Z/(ip)*Z,
          ungleich dem Nullpolynom.
	L ist die Liste der irreduziblen Faktoren und Exponenten von P,
        d.h. L = ( P_1, e_1, .. ,P_k, e_k ) mit P = P_1^e_1 * .. * P_k^e_k.
        Literatur: M. Ben-Or: Proc.22, IEEE Symp. Foundations Comp. Sci.,
                              p.394-398, 1981.



			upmibqp( ip, P )

	"univariate polynomial over modular integers, Berlekamp Q
	polynomials construction"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmibqp(ip,P)  int ip; pol P;
	Q = upmibqp(ip,P);
	ip ist eine Primzahl.
	P ist ein Polynom in der Variablen x ueber Z / (ip)*Z vom
	Grad n>=2.
	Q ist die Liste (Q_0, ..., Q_(n-1) ), wobei Q_i der Rest bei
	Polynomdivision von x^(p*i) durch P(x) ist, also ein Polynom
	in der Variablen x ueber Z / (ip)*Z.



			upmicfact( ip, P )

	"univariate polynomial over modular integers complete
	factorization"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmicfact(ip,P)  int ip; pol P;
	L = upmicfact(ip,P).
	ip ist eine Primzahl.
	P ist ein normiertes Polynom positiven Grades in einer Variablen
	ueber Z / (ip)*Z.
	L ist eine Liste aller normierten irreduziblen Faktoren von P.



			upmicfacts( P, F )

	"univariate polynomial over modular integers, complete
	factorization special"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmicfacts(P,F)  int P; pol F;
	L = upmicfacts(P,F);
	P ist eine Primzahl.
	F ist ein normiertes Polynom positiven Grades in einer
	Variablen ueber Z / P*Z.
	L ist eine Liste der Form (P_1, e_1, ... P_r, e_r );
	dabei ist r eine positive single und fuer 1 <= i <= j <= r gilt:
	- e_i ist eine positive single;
	- P_i ist ein normierter irreduzibler Faktor von F;
	- P_i != P_j, falls i != j;
	- (P_1)^(e_1) * ... * (P_r)^(e_r) = F.



			upmiddfact( ip, P )

	"univariate polynomial over modular integers distinct degree
	factorization"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmiddfact(ip,P)  int ip; pol P;
	L = upmiddfact(ip,P);
	ip ist eine Primzahl.
	P ist ein normiertes quadratfreies Polynom in einer Variablen
	ueber Z / (ip)*Z vom Grad >= 2.
	L ist eine Liste ( G1, m1, G2, m2, ..., Gk, mk ), wobei mi fuer
	1 <= i <= k jeweils eine positive ganze Zahl ist und Gi das
	Produkt aller irreduziblen normierten Faktoren von P mit Grad mi.
	Es gilt m1 < ... < mk.



			upmiegcd( P, P1, P2, pP3, pP4 )

	"univariate polynomial over modular integers extended greatest
	common divisor"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmiegcd(P,P1,P2,pP3,pP4)  int P; pol P1,P2; pol *pP3,*pP4;
	P5 = upmiegcd(P,P1,P2,pP3,pP4);
	P ist eine Primzahl.
	P1 und P2 sind Polynome in einer Variablen ueber Z / P*Z.
	P5 ist der groesste gemeinsame Teiler von P1 und P2.
	Fuer pP3 und pP4 gilt:
	1)  P1 * pP3 + P2 *pP4 = P5;
	2)  ist Grad(P1/P5) groesser 0, so ist Grad(*pP4)
	    kleiner Grad(P1/P5); sonst ist Grad(*pP4) gleich 0;
	3)  ist Grad(P2/P5) groesser 0, so ist Grad(*pP3)
	    kleiner Grad(P2/P5); sonst ist Grad(*pP3) gleich 0;
	4)  ist P1 gleich 0, so ist *pP3 gleich 0;
	5)  ist P2 gleich 0, so ist *pP4 gleich 0.



			upmigcd( ip, P1, P2 )

	"univariate polynomial over modular integers greatest common
	divisor"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmigcd(ip,P1,P2)  int ip; pol P1, P2;
	P3 = upmigcd(ip,P1,P2);
	ip ist eine Primzahl.
	P1 und P2 sind Polynome in einer Variablen ueber Z / (ip)*Z.
	P3 ist der groesste gemeinsame Teiler von P1 und P2.



			upmigsd( ip, P )

	"univariate polynomial over modular integers greatest squarefree
	divisor" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmigsd(ip,P)  int ip; pol P;
	S = upmigsd(ip,P);
	ip ist eine Primzahl.
	P ist ein Polynom in einer Variablen ueber Z / (ip)*Z.
	S ist ein quadratfreies Polynom in einer Variablen Z / (ip)*Z,
	das P teilt und fuer das gilt  P |  S^(deg(P)).



			upmihegcd( P, P1, P2, pP3 )

	"univariate polynomial over modular integers half extended
	greatest common divisor"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmihegcd(P,P1,P2,pP3)  int P; pol P1,P2; pol *pP3;
	P4 = upmihegcd(P,P1,P2,pP3);
	P ist eine Primzahl.
	P1 und P2 sind Polynome in einer Variablen ueber Z / P*Z.
	P4 ist der groesste gemeinsame Teiler von P1 und P2.
	Fuer pP3 gilt:
	1)  es existiert ein Polynom P derart, dass
	    ( P1 * P ) + ( P2 *pP3 )  =  P4;
	2)  ist Grad(P1/P4) groesser 0, so ist Grad(*pP3)
	    kleiner Grad(P1/P4); sonst ist Grad(*pP3) gleich 0;
	3)  ist P2 gleich 0, so ist *pP3 gleich 0.



			upmijacsym( m, P1, P2 )

	"univariate polynomial over modular integers Jacobi-symbol"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single upmijacsym(m,P1,P2)  int m; pol P1,P2;
	a = upmijacsym(m,P1,P2);
	m ist eine Primzahl.
	P1 und P2 sind teilerfremde Polynome ungleich 0 in einer
	Variablen ueber Z/mZ.
	P2 ist ein normiertes Polynom.
	a ist das Jacobi-Symbol [P1/P2].



			upmimpexp( ip, K, E, P )

	"univariate polynomial over modular integers modular polynomial
	exponentiation"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmimpexp(ip,K,E,P)  int ip; pol K; int E; pol P;
	R = upmimpexp(ip,K,E,P);
	ip ist eine Primzahl.
	K und P sind Polynome positiven Grades aus ( Z / (ip)*Z ) [x],
	wobei x eine Veraenderliche ueber Z / (ip)*Z ist.
	E ist eine positive ganze Zahl.
	R(x) =  K(x) ^ E mod P(x).



			upmimprem( ip, K, E, P )

	"univariate polynomial over modular integers, monomial, polynomial,
	remainder"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol upmimprem(ip, K, E, P)  int ip,K,E; pol P;
	R = upmimprem(ip, K, E, P);
	ip ist eine Primzahl.
	K ist ein Element aus Z / (ip)*Z. K ist ungleich 0.
	E ist eine positive ganze Zahl.
	P ist ein Polynom positiven Grades in der Veraenderlichen x
	ueber Z / (ip)*Z.
	R(x) = ( K * x )^E mod P(x).



			upminif( m, P )

	"univariate polynomial over modular integers, number of irreducible
	factors"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single upminif(m,P)  int m; pol P;
	n = upminif(m,P);
	m ist eine Primzahl.
	P ist ein normiertes, quadratfreies Polynom ueber Z/mZ
	in einer Veraenderlichen.
	n ist die Anzahl der irreduziblen Faktoren von P.



			upmirand( ip, m )

	"univariate polynomial over modular integers randomize"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol upmirand(ip, m)  int ip, single m;
	P = upmirand(ip, m);
	ip ist eine Primzahl,
        m muss groesser gleich 0 sein,
	P ist ein zufaellig erzeugtes Polynom in einer Variablen ueber 
        Z/(ip)*Z mit 0 <= Grad(P) <= m, P ist nicht das Nullpolynom.



			upmirelpfact( P, F, Fak, pA2 )

	"univariate polynomial over modular integers relative prime
	factorization"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmirelpfact(P,F,Fak,pA2)  int P; pol F,Fak; pol *pA2;
	A1 = upmirelpfact(P,F,Fak,pA2);
	P ist eine Primzahl.
	F ist ein Polynom in einer Veraenderlichen ueber Z / P*Z.
	Fak ist ein Teiler von F und als solcher ein Polynom in einer
	Veraenderlichen ueber Z / P*Z.
	A1 und *pA2 sind Polynome in einer Veraenderlichen ueber Z / P*Z,
	so dass gilt:   A1  *  (*pA2) = F;   ggT ( A1, Fak ) = 1  und
	*pA2 | (Fak)^(deg(F)).



			upmirem( M, P1, P2 )

	"univariate polynomial over modular integers remainder"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol upmirem(M,P1,P2)  int M; pol P1,P2;
	P3 = upmirem(ip,P1,P2);
	M ist eine positive ganze Zahl.
	P1 und P2 sind Polynome in einer Variablen ueber Z / M*Z.
	Der fuehrende Koeffizient von P2 ist eine Einheit in Z / M*Z.
	P3 = P1 % P2.



			upmires( m, P1, P2 )

	"univariate polynomial over modular integers resultant"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	int upmires(m,P1,P2)  int m; pol P1,P2;
	a = upmires(m,P1,P2);
	m ist eine Primzahl.
	P1 und P2 sind Polynome in einer Variablen ueber Z/mZ
	vom Grad groesser gleich 1.
	a ist die Resultante von P1 und P2.



			upmiresulc( m, P1, P2, pC )

	"univariate polynomial over modular integers resultant and cofactor
	of resultant equation"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	int upmiresulc(m,P1,P2,pC)  int m; pol P1,P2; pol *pC;
	a = upmiresulc(m,P1,P2,pC);
	P1 und P2 sind Polynome in einer Variablen ueber Z/mZ
	mit positiven Graden, wobei m eine Primzahl ist.
	a ist die Resultante von P1 und P2 und als solche aus Z/mZ.
	*pC ist ein Polynom in einer Variablen ueber Z/mZ, so dass ein
	Polynom A in einer Variablen ueber Z/mZ existiert, fuer das
	die Resultantengleichung P1 * A + P2 * (*pC) = a erfuellt ist.



			upmirf( ip, P )

	"univariate polynomial over modular integers, root finding"
	(rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmirf(ip,P)  int ip; pol P;
	L = upmirf(ip,P);
	ip ist eine Primzahl.
	P ist ein normiertes Polynom ueber Z / (ip)*Z in einer
	Veraenderlichen positivem Grad.
	L ist eine Liste aller Nullstellen von P.



			upmirfspec( ip, P )

	"univariate polynomial over modular integers, root finding,
	special" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmirfspec(ip,P)  int ip; pol P;
	L = upmirfspec(ip,P);
	ip ist eine Primzahl.
	P ist ein normiertes Polynom ueber Z / (ip)*Z in einer
	Veraenderlichen von positivem Grad.
	L ist eine Liste aller Nullstellen von P.
!!!!!   Vorsicht! Das Programm ist gedacht fuer Polynome P, die voll-
!!!!!   staendig in Linearfaktoren zerfallen. Ansonsten benoetigt das
!!!!!   Programm unverhaeltnismaessig viel Zeit.
	In diesem Fall rufen Sie besser "upmicfact(ip,P)" oder
	"upmirf(ip,P)" auf.



			upmisfact( ip, P )

	"univariate polynomial over modular integers squarefree
	factorization" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmisfact(ip,P)  int ip; pol P;
	L = upmisfact(ip,P);                              
	ip ist eine Primzahl.
	P ist ein normiertes Polynom positiven Grades in einer Variablen
	ueber Z / (ip)*Z.
	L ist eine Liste L = ( (e_1, P_1), ..., (e_n, P_n) ). Dabei ist
	fuer 1 <= i <= n jeweils e_i eine natuerliche Zahl und P_i ein
	quadratfreier, normierter Faktor von P. Die P_i sind paaweise prim,
	und es gilt e_1 < ... < e_n, sowie P = P_1^e_1 * ... * P_n^e_n.



			upmisfed( ip, G, d )

	"univariate polynomial over modular integers separate factor of 
	equal degree"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmisfed(ip, G, d)  int ip; single d; pol G;
	L = upmisfed(ip, G, d);
	ip ist eine Primzahl, ip != 2;
        G ist ein normiertes quadratfreies Polynom vom Grad l ueber Z/(ip)*Z.
        Dann liefert die Funktion upmisfed eine Zerlegung von G in der Form:
        G(x) = h_1(x) * ... * h_k(x), wobei die h_i(x) alle irreduzibel vom
        gleichen Grad d sind, und es gilt: deg( G ) = l = k*d.
        L ist die Liste ( h_1(x) ... h_k(x) ).
        Literatur: M. Ben-Or: Proc.22, IEEE Symp. Foundations Comp. Sci.,
                              p.394-398, 1981.



			upmisfp( m, P )

	"univariate polynomial over modular integers squarefree part"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmisfp(m,P)  int m; pol P;
	P1 = upmisfp(m,P);
	m ist eine Primzahl.
	P ist ein normiertes Polynom von positivem Grad in einer
	Variablen ueber Z/mZ.
	P1 ist der quadratfreie Anteil von P, d.h.
	P = P1 * P2^2    und    ggt(P1,P1') = 1.



			upmitfsp( ip, G, d, M )

	"univariate polynomial over modular integers, trace function, 
	special"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmitfsp(ip, G, d, M)  int ip; single d; pol G, M;
	P = upmitfsp(ip, G, d, M);
	ip ist eine Primzahl, p != 2.
        Dabei muss gelten:
        G ist ein Polynom vom Grad m in einer Variablen ueber Z/(ip)*Z,
        M ist ein Polynom vom Grad l in einer Variablen ueber Z/(ip)*Z. 
        m < l.
        Dann liefert die Funktion upmitfsp ein Polynom der Form:
        P = Tr(G) = G + G^(ip) + G^(ip)^2 + ... + G^(ip)^d. Alle Produkte,
        die fuer die Berechnung von P gebildet werden, sind reduziert
        modulo M(x).



			upmitransf( M, P, r, P1 )

	"univariate polynomial over modular integers transformation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol upmitransf(M,P,r,P1)  int M; pol P; single r; pol P1;
	P2 = upmitransf(M,P,r,P1);
	M ist eine positive ganze Zahl.
	P ist ein Polynom ueber Z / M*Z in einer Variablen.
	P1 ist ein Polynom ueber Z / M*Z in r (1<=r<BASIS) Variablen.
	P2 ist ein Polynom in r Variablen ueber Z / M*Z, so dass gilt
	P2 = P(P1) (d.h. die Variable von P wird durch P1 ersetzt).



			upmitransf2( M, P, r, P1 )

	"univariate polynomial over modular integers transformation
	version2"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol upmitransf2(M,P,r,P1)  int M; pol P; single r; pol P1;
	P2 = upmitransf2(M,P,r,P1);
	M ist eine positive ganze Zahl.
	P ist ein Polynom ueber Z / M*Z in einer Variablen.
	P1 ist ein Polynom ueber Z / M*Z in r (1<=r<BASIS) Variablen.
	P2 ist ein Polynom in r Variablen ueber Z / M*Z, so dass gilt
	P2 = P(P1) (d.h. die Variable von P wird durch P1 ersetzt).
	upmitransf2 benutzt im Gegensatz zu upmitransf das Horner Schema,
	allerdings ohne Laufzeitverbesserung fuer ueberschaubare Beispiele.



			upmsaddval( p, P1, P )

	"univariate polynomial over modular singles additive valuation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single upmsaddval( p, P1, P )  single p; pol P1,P;
	w = upmsaddval( p, P1, P );
	p ist eine Primzahl.
	P und P1 sind Polynome in einer Veraenderlichen ueber (Z/pZ),
	P1 hat positiven Grad, und P ist ungleich dem Nullpolynom.
	w ist eine nicht negative single, fuer die ein Polynom P2 in
	einer Veraenderlichen ueber (Z/pZ) existiert, das nicht von
	P1 geteilt wird, und fuer das gilt: P = (P1)^w * P2.



			upmsbfact( p, A, d )

	"univariate polynomial over modular singles factorization,
	Berlekamp algorithm"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmsbfact(p,A,d)  single p,d; pol A;
	L = upmsbfact(p,A,d);
	A ist ein normiertes quadratfreies Polynom positiven Grades in
	einer Variable ueber Z/pZ, wobei p eine Primzahl ist.
	A darf keinen irreduziblen Faktor mit Grad < d haben.
	L ist eine Liste aller normierten irreduziblen Faktoren positiven
	Grades von A.



			upmsbfls( m, P, B, d )

	"univariate polynomial over modular singles Berlekamp
	factorization, last step"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmsbfls(m,P,B,d)  single m,d; pol P; list B;
	L = upmsbfls(m,P,B,d);
	P ist ein normiertes quadratfreies Polynom in einer Variable ueber
	Z/mZ, wobei Grad(P) >= 2 und m Primzahl.
	B = (B1,...,Br) mit r > 0 ist eine Liste normierter Polynome in
	einer Variable ueber Z/mZ, die eine Basis fuer den Vektorraum
	aller Polynome C vom Grad < Grad(P) darstellen, fuer die gilt :
	P teilt C^m - C.
	B1 ist 1. d ist positiv.
	P darf keinen irreduziblen Faktor von einem Grad < d haben.
	(Diese letzte Bedingung wird im Testrahmen nicht ueberprueft.)
	L ist eine Liste aller normierten irreduziblen Faktoren positiven
	Grades von P.



			upmsbfzm( m, s, P, G )

	"univariate polynomial over modular singles,
	Berlekamp factorization, Zassenhaus method"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmsbfzm(m,s,P,G) single m,s; pol P,G;
	L = upmsbfzm(m,s,P,G);
	m ist eine Primzahl < BASIS.
	P ist ein normiertes, quadratfreies Polynom in einer
	Veraenderlichen ueber Z/mZ mit deg(P) >= 2.
	s ist mindestens so gross wie die Anzahl der irreduziblen
	Faktoren von P und auf jeden Fall muss gelten 2 <= s <= deg(P).
	G ist ein normiertes Polynom mit 0 < deg(G) < deg(P) und
	(G^m - G) mod P = 0, d.h. P|(G-s1)*....*(G-sm) wobei
	Z/mZ={s1,...,sm}.
	L ist genau die Liste der Elemente aus Z/mZ, fuer die gilt
	gcd( P, G-s) != 1;



			upmsbqp( p, A )

	"univariate polynomial over modular singles, Berlekamp Q
	polynomials construction"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmsbqp(p,A)  single p; pol A;
	Q = upmsbqp(p,A);
	p ist eine Primzahl. A ist ein Polynom in einer Variable ueber
	Z/pZ vom Grad n>=2.
	Q ist die Liste (Q[0],...,Q[n-1]), wobei Q[i] der Rest bei Poly-
	nomdivision von x^(p*i) durch A(x) ist.



			upmscfact( p, A )

	"univariate polynomial over modular singles complete factorization"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmscfact(p,A)  single p;  pol A;
	L = upmscfact(p,A);
	p ist Primzahl, A ist ein normiertes Polynom positiven Grades
	in einer Variable ueber Z/pZ.
	L ist eine Liste aller normierten irreduziblen Faktoren von A.



			upmscfacts( p, A )

	"univariate polynomial over modular single prime, complete
	factorization special"
	Quellbibliothek: srclib.pol2
	Include - Datei: _pol2.h
	list upmscfacts(p,A)  single p;  pol A;
	L = upmscfacts(p,A);
	A ist ein normiertes Polynom positiven Grades in einer
	Variablen ueber Z/pZ, wobei p eine single Primzahl ist.
	L ist eine Liste der Form (P_1, e_1, ... P_r, e_r );
	dabei ist r eine positive single und fuer 1 <= i <= j <= r gilt:
	- e_i ist eine positive single;
	- P_i ist ein normierter irreduzibler Faktor von A;
	- P_i != P_j, falls i != j;
	- (P_1)^(e_1) * ... * (P_r)^(e_r) = A.



			upmsddfact( p, F )

	"univariate polynomial distinct degree factorization"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmsddfact(p,F)  single p; pol F;
	L = upmsddfact(p,F);
	p ist eine Primzahl, F ein normiertes quadratfreies Polynom in
	einer Variablen ueber Z/pZ vom Grad >= 2.
	L = ( G1, m1, G2, m2, ..., Gk, mk ). Fuer 1<=i<=k ist dabei mi
	eine positive ganze Zahl, m1 < ... < mk, und Gi das Produkt aller
	irreduziblen normierten Faktoren von F vom Grad mi.



			upmsegcd( m, P1, P2, pP3, pP4 )

	"univariate polynomial over modular singles extended greatest
	common divisor"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmsegcd(m,P1,P2,pP3,pP4) single m; pol P1,P2; pol *pP3,pP4;
	P5 = upmsegcd(m,P1,P2,pP3,pP4);
	P1 und P2 sind Polynome in einer Variablen ueber Z/mZ, wobei
	m eine Primzahl aus [2,BASIS] ist.
	P5 ist der groesste gemeinsame Teiler von P1 und P2.
	Fuer pP3 und pP4 gilt:
		1)  P1 * pP3 + P2 *pP4 = P5;
		2)  ist Grad(P1/P5) groesser 0, so ist Grad(pP4)
		    kleiner Grad(P1/P5); sonst ist Grad(pP4) gleich 0;
		3)  ist Grad(P2/P5) groesser 0, so ist Grad(pP3)
		    kleiner Grad(P2/P5); sonst ist Grad(pP3) gleich 0;
		4)  ist P1 gleich 0, so ist pP3 gleich 0;
		5)  ist P2 gleich 0, so ist pP4 gleich 0.



			upmsgcd( m, P1, P2 )

	"univariate polynomial over modular singles greatest
	common divisor"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmsgcd(m,P1,P2) single m; pol P1, P2;
	P3 = upmsgcd(m,P1,P2);
	P1 und P2 sind Polynome in einer Variablen ueber Z/mZ
	(0<m<BASIS) und m ist Primzahl.
	P3 ist der groesste gemeinsame Teiler von P1 und P2.



			upmsgsd( m, P )

	"univariate polynomial over modular singles greatest squarefree
	divisor" (rekursiv)
	Quell-Bibliothek: srclib.pol2
	Include-Datei   : _pol2.h
	pol upmsgsd(m,P) single m; pol P;
	S = upmsgsd(m,P);
	m ist eine positive single.
	P ist ein Polynom in einer Veraenderlichen ueber Z/mZ.
	S ist ein quadratfreies Polynom in einer Veraenderlichen ueber
	Z/mZ, das P teilt und fuer das eine natuerliche Zahl s existiert,
	so dass P teilt (S)^s.



			upmshegcd( m, P1, P2, pP3 )

	"univariate polynomial over modular singles half extended
	greatest common divisor"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmshegcd(m,P1,P2,pP3) single m; pol P1,P2; pol *pP3;
	P4 = upmshegcd(m,P1,P2,pP3);
	P1 und P2 sind Polynome in einer Variablen ueber Z/mZ, wobei
	m eine Primzahl aus [2,BASIS] ist.
	P4 ist der groesste gemeinsame Teiler von P1 und P2.
	Fuer pP3 gilt:
		1)  es existiert ein Polynom P derart, dass
		    P1 * P + P2 *pP3 = P4;
		2)  ist Grad(P1/P4) groesser 0, so ist Grad(pP3)
		    kleiner Grad(P1/P4); sonst ist Grad(pP3) gleich 0;
		3)  ist P2 gleich 0, so ist pP3 gleich 0.



			upmsimgen( p, n )

	"univariate polynomial over modular singles, irreducible and monic,
	generator"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmsimgen(p, n)  single p,n;
	P = upmsimgen(p, n);
	Es muss gelten : p ist Primzahl, n >= 1.
	P ist ein zufaellig erzeugtes, irreduzibles, normiertes Polynom
	vom Grad n in einer Variable ueber Z/pZ.
   !!!	Bemerkung: 
	a) es gibt zudem Programme, die irreduzible Polynome 
	spezieller Form suchen, und zwar upmsimtgen und upm2imtgen.
	b) Fuer p = 2 sollte man upm2imgen oder upm2imtgen benutzen.



			upmsimtgen( p, n )

	"univariate polynomial over modular singles, irreducible and 
	 monic trinomial, generator"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmsimtgen(p, n)  single p, n;
	P = upmsimtgen(p, n);
	Voraussetzungen: 
	. p ist eine Primzahl.
	. n >= 1.
	Ergebnis: 
	. Existiert ein irreduzibles Trinom vom Grad n in einer Variablen 
	  ueber Z/pZ, also x^n + x^k + 1 (1 <= k <= n/2), 
	  so ist P = x^n + x^k + 1.
	  (Im Falle p = 3 wird ein Trinom der Form x^n + x^k + 2 gesucht.)
	. Sonst ist P = 0.
	Kriterien:
	a) x^n + x^k + 1 irreduzibel <=> x^n + x^(n-k) + 1 irreduzibel
	   (Deshalb wird gefordert: 1 <= k <= n/2.)
	b) Fuer p = 3 besitzt x^n + x^k + 1 die Nullstelle 1. Deshalb wird 
	   in diesem Fall nach einem Trinom der Form x^n + x^k + 2 gesucht.
	Es wurden folgende Kriterien verwendet, da sie vermutlich richtig 
	sind:
	c) n und k gerade => x^n + x^k + 1 ist reduzibel
	d) Ist  n = 1 (mod 3) und k = 2 (mod 3) 
	   oder n = 2 (mod 3) und k = 1 (mod 3) ,
	   so ist x^2 + x + 1 Teiler von x^n + x^k + 1.
	   (Also ist das Trinom dann reduzibel. Dabei kann x^2 + x + 1 auch
	   modulo p in 2 Linearfaktoren zerfallen)
	Bemerkungen: 
	. Diese Prozedur ist probabilistisch.
	. Fuer p = 2 sollte man besser upm2imtgen oder upm2imgen verwenden.
	. Um ganz sichher ein irreduzibles Polynom vom Grad n in einer 
	  Variablen ueber Z/pZ zu erhalten, sollte man upmsimgen benutzen.
	. Die Bedingungen b), c) sind nur experimentell richtig.
	  (Sie sind evtl. in der Literatur zu finden.



			upmsjacsym( m, P1, P2 )

	"univariate polynomial over modular singles Jacobi-symbol"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single upmsjacsym(m,P1,P2) single m; pol P1,P2;
	a = upmsjacsym(m,P1,P2);
	P1 und P2 sind teilerfremde Polynome ungleich 0 in einer
	Variablen ueber Z/mZ und m ist eine Primzahl aus [3,BASIS[.
	P2 ist ein normiertes Polynom.
	a ist das Jacobi-Symbol [P1/P2].



			upmsmprem( m, k, T, P )

	"univariate polynomial over modular singles, monomial, polynomial,
	remainder"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol upmsmprem(m, k, T, P)  single m,k; int T; pol P;
	R = upmsmprem(m, k, T, P);
	m ist eine Primzahl < BASIS.
	k ist ein Element aus Z/mZ. k ist ungleich 0.
	T ist eine positive ganze Zahl.
	P ist ein Polynom positiven Grades in einer Veraenderlichen
	ueber Z/mZ.
	R(x) = (k*x)^T mod P(x).



			upmsnif( m, P )

	"univariate polynomial over modular singles,
	number of irreducible factors"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single upmsnif(m,P) single m; pol P;
	n = upmsnif(m,P);
	m ist eine Primzahl < BASIS. P ist ein normiertes,
	quadratfreies Polynom ueber Z/mZ in einer Veraenderlichen.
	n ist die Anzahl der irreduziblen Faktoren von P.



			upmsrelpfact( p, P, Fak, pA2 )

	"univariate polynomial over modular singles relative prime
	factorization"
	Quellbibliothek : srclib.pol2
	Include - Datei : _pol2.h
	pol upmsrelpfact(p,P,Fak,pA2) single p; pol P,Fak; pol *pA2;
	A1 = upmsrelpfact(p,P,Fak,pA2);
	P ist ein Polynom in einer Veraenderlichen ueber Z/pZ,
	wobei p eine single Primzahl ist.
	Fak ist ein Polynom in einer Veraenderlichen ueber Z/pZ und
	teilt P.
	A1 und *pA2 sind Polynome in einer Veraenderlichen ueber Z/pZ,
	so dass gilt: A1 * (*pA2) = P;
		      ggT ( A1 , Fak ) = 1;
		      *pA2 | (Fak)^(deg(P)).



			upmsrem( m, P1, P2 )

	"univariate polynomial over modular singles remainder"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol upmsrem(m,P1,P2) single m; pol P1,P2;
	P3 = upmsrem(m,P1,P2);
	P1 und P2 sind Polynome in einer Variablen ueber Z/mZ mit m
	Primzahl aus [2,BASIS].
	P3 = P1 % P2.



			upmsres( m, P1, P2 )

	"univariate polynomial over modular singles resultant"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single upmsres(m,P1,P2) single m; pol P1,P2;
	a = upmsres(m,P1,P2);
	P1 und P2 sind Polynome in einer Variablen ueber Z/mZ
	vom Grad groesser gleich 1, wobei m eine Primzahl aus
	[2,BASIS] ist.
	a ist die Resultante von P1 und P2.



			upmsresulc( m, P1, P2, pC )

	"univariate polynomial over modular singles resultant and cofactor
	of resultant equation"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	single upmsresulc(m,P1,P2,pC) single m; pol P1,P2; pol *pC;
	a = upmsresulc(m,P1,P2,pC);
	P1 und P2 sind Polynome in einer Variablen ueber Z/mZ
	mit positiven Graden, wobei m eine single Primzahl ist.
	a ist die Resultante von P1 und P2 und als solche aus Z/mZ.
	*pC ist ein Polynom in einer Variablen ueber Z/mZ, so dass ein
	Polynom A in einer Variablen ueber Z/mZ existiert, fuer das
	die Resultantengleichung P1 * A + P2 * (*pC) = a erfuellt ist.



			upmsrf( m, P )

	"univariate polynomial over modular singles, root finding"
	(rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmsrf(m,P)      single m; pol P;
	L = upmsrf(m,P);
	m ist eine Primzahl < BASIS.
	P ist ein normiertes Polynom ueber Z/mZ in einer
	Veraenderlichen mit deg(P) >= 1.
	L ist eine Liste aller Nullstellen von P.
!!!!!   Vorsicht : das Programm ist gedacht fuer Polynome P, die voll-
!!!!!   staendig in Linearfaktoren zerfallen. Ansonsten benoetigt das
!!!!!   Programm unverhaeltnismaessig viel Zeit.
	In diesem Fall rufen Sie besser "upmscfact(m,P)" auf.



			upmssfact( m, P )

	"univariate polynomial over modular singles squarefree
	factorization" (rekursiv)
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list upmssfact(m,P) single m; pol P;
	L = upmssfact(m,P);
	P ist ein normiertes Polynom von positivem Grad in einer
	Variablen ueber Z/mZ mit m Primzahl aus [2,BASIS].
	L ist eine Liste
	    L = ( ( e1 , P1 ) , ... , ( en , Pn ) )
	mit
	    e1 < e2 < ... < en;
	    Pi (1<=i<=n) quadratfreier, normierter Faktor von P;
	    Pi paarweise prim;
	    P = P1^e1 * ... * Pn^en.



			upmssfp( m, P )

	"univariate polynomial over modular singles squarefree part"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmssfp(m,P) single m; pol P;
	P1 = upmssfp(m,P);
	P ist ein normiertes Polynom von positivem Grad in einer
	Variablen ueber Z/mZ mit m Primzahl aus [2,BASIS].
	P1 ist der quadratfreie Anteil von P, d. h.
	P = P1 * P2^2    und    ggt(P1,P1') = 1.



			upmssrpp( m, P )

	"univariate polynomial over modular singles square root
	principal part"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmssrpp(m,P)  single m; pol P;
	P1 = upmssrpp(m,P);
	P ist ein Polynom aus Z/mZ[X], dessen Grad gerade und dessen
	fuehrender Koeffizient ein Quadrat in Z/mZ ist; dabei ist m
	eine Primzahl aus [3,BASIS].
	P1 ist der Hauptteil der Potenzreihenentwicklung von P^(1/2)
	in X^(-1).



			upmssrpser( m, P, i )

	"univariate polynomial over modular singles square root 
	power series"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	pol upmssrpser(m, P, i)  single m, i; pol P;
	P1 = upmssrpser(m, P, i);
	Voraussetzungen:
	- m ist eine Primzahl aus [3,BASIS].	
	- P ist ein Polynom aus Z/mZ[X], dessen Grad gerade und dessen
	  fuehrender Koeffizient ein Quadrat in Z/mZ ist;
	- i ist eine positive ganze Zahl
	Ergebnis:
	- P1 ist der Anfang Potenzreihenentwicklung in X^(-1) von P^(1/2) 
	  bis zur Potenz X^(-i).



			upmstransf( m, P, r, P1 )

	"univariate polynomial over modular singles transformation"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	pol upmstransf(m,P,r,P1)    single m,r; pol P,P1;
	L = upmstransf(m,P,r,P1);
	m ist eine positive ganze Zahl < BASIS.
	P ist ein Polynom ueber Z/mZ in einer Veraenderlichen.
	P1 ist ein Polynom ueber Z/mZ in r (1<=r<BASIS) Variablen.
	L ist ein Polynom in r Veraenderlichen ueber Z/mZ, so dass gilt
	L = P(P1) (d.h. die Variable von P wird durch P1 ersetzt).



			upnfeval( F, P, A )

	"univariate polynomial over a number field evaluation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	nfel upnfeval(F,P,A)  pol F,P; nfel A;
	B = upnfeval(F,P,A);
	F ist ein irreduzibles Polynom ueber Z in einer Variablen vom
	Grad r >= 1 in dense-Darstellung.
	Sei z eine Nullstelle von F, dann hat der zugrundeliegende
	Zahlkoerper die Form Q(z) = Q[z].
	A ist ein Element dieses Zahlkoerpers und ist in der Form
	A = ( HNA, s, as, ..., a0 ) bzw. A = 0.
	( s, as, ..., a0 ) ist ein Polynom in einer Veraenderlichen
	ueber Z in dense-Darstellung ( s < r ).      
	HNA ist eine positive ganze Zahl und ggT( HNA, as, ..., a0 ) = 1.
	Es gilt: A = (as/HNA) * z^s + ... + (a1/HNA) * z + (a0/HNA).
	P ist ein Polynom in einer Veraenderlichen ueber diesem
	Zahlkoerper in sparse-Darstellung.
	B = P(A) in analoger Darstellung zu der von A.



			upnfgcd( F, P1, P2 )

	"univariate polynomial over number field greatest common divisor"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upnfgcd(F,P1,P2) pol F, P1, P2;
	P3 = upgnfcd(F,P1,P2);
	P1 und P2 sind univariate Polynome ueber einem Zahlkoerper K.
	F ist das zugehoerige Minimalpolynom in einer Variablen ueber
	Z vom Grad n >= 1 in dense-Darstellung, d.h. K entsteht durch
	Adjunktion einer Nullstelle von F.
	P3 ist der groesste gemeinsame Teiler von P1 und P2.
!!!!    Beachte : P3 ist dann ein normiertes Polynom.



			upnfgcdcf( F, P1, P2, pQ1, pQ2 )

	"univariate polynomial over number field greatest common divisor
	and cofactors"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	pol upnfgcdcf(F,P1,P2,pQ1,pQ2) pol F, P1, P2;
				       pol *pQ1, *pQ2;
	P3 = upnfgcdcf(F,P1,P2,pQ1,pQ2);
	P1 und P2 sind univariate Polynome ueber einem Zahlkoerper K.
	F ist das zugehoerige Minimalpolynom in einer Variablen
	ueber Z vom Grad n >= 1 in dense-Darstellung, d.h. K
	entsteht durch Adjunktion einer Nullstelle von F.
	P3 ist der groesste gemeinsame Teiler von P1 und P2.
!!!     Beachte : P3 ist ein normiertes Polynom.
	*pQ1 = P1 / P3, *pQ2 = P2 / P3,  falls P3 ungleich 0 ist;
	*pQ1 = 0 = *pQ2, sonst.



			upnfsfact( F, P )

	"univariate polynomial over number field squarefree factorization"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list upnfsfact(F,P)  pol F,P;
	L = upnfsfact(F,P);
	P ist ein primitives Polynom positiven Grades in einer Variablen 
	ueber einem Zahlkoerper K. Dabei ist F das zugehoerige Minimal-
	polynom in einer Variablen ueber Z vom Grad n >= 1 in dense-Dar-
	stellung, d.h. K entsteht durch Adjunktion einer Nullstelle von F.
	L ist eine Liste
	    L = ( ( e1 , P1 ) , ... , ( en , Pn ) )
	mit natuerlichen Zahlen ei, wobei
	    1 <= e1 < e2 < ... < en;
	    Pi (1<=i<=n) normierter, quadratfreier Faktor von P.
	Dann ist	
		P = P1^e1 * ... * Pn^en
	die quadratfreie Faktorisierung von P.



			upprmsp1disc( p, F )

	"univariate polynomial over polynomial ring over modular
	single prime, transcendence degree 1, discriminant"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol upprmsp1disc(p,F) single p; pol F;
	P = upprmsp1disc(p,F);
	Sei x eine Unbestimmte ueber Z/pZ, wobei p eine single Primzahl
	ist.
	F ist ein Polynom in einer Unbestimmten ueber (Z/pZ) [x] -
	dem Polynomring in x ueber Z/pZ.
	P ist die Diskriminante von F und als solche aus (Z/pZ) [x].



			upprmsp1hfa( p, F, P, L, k )

	"univariate polynomial over polynomial ring over modular single
	prime, transcendence degree 1, Hensel factorization approximation"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	list upprmsp1hfa(p,F,P,L,k) single p; pol F,P; list L; single k;
	L1 = upprmsp1hfa(p,F,P,L,k);
	Sei x eine Unbestimmte ueber Z/pZ, wobei p eine single Primzahl
	ist.
	F ist ein Polynom positiven Grades in einer Unbestimmten ueber
	(Z/pZ) [x] - dem Polynomring in x ueber Z/pZ.
	P ist ein normiertes, irreduzibles Polynom aus (Z/pZ) [x].
	Der Leitkoeffizient von F wird nicht von P geteilt.
	L = ( f_1, ... f_r) ist eine Liste von paarweise teilerfremden
	Polynomen in einer Unbestimmten ueber (Z/pZ) [x].
	Es gilt F = f_1 * ... * f_r mod (P).                          
	Die Koeffizienten von f_i sind aus (Z/pZ) [x] und haben Grade,
	die kleiner sind als der Grad P. Fuer 2 <= i <= r ist f_i normiert.
	k ist eine ganze Zahl > 1, so dass das Produkt aus dem Grad von P
	und der kleinsten Zweierpotenz groesser gleich k eine single ist.
	L1 = (F_1, ... ,F_r) ist eine Liste von Polynomen in einer
	Unbestimmten ueber (Z/pZ) [x] mit positiven Graden.
	Fuer 1 <= i <= r ist f_i kongruent F_i mod (P) und es gilt
	F = F_1 * ... * F_r mod (P)^k.
	Die Faktorisierung gilt sogar fuer (P)^t, wobei t die kleinste
	Zweierpotenz groesser gleich k ist.
	Die Koeffizienten von F_i haben Grade kleiner als ( t * Grad(P) ).



			upprmsp1hli( p, F, P, L )

	"univariate polynomial over polynomial ring over modular single
	prime, transcendence degree 1, Hensel lemma initialization"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	list upprmsp1hli(p,F,P,L) single p; pol F, P; list L;
	L1 = upprmsp1hli(p,F,P,L);
	Sei x eine Unbestimmte ueber Z/pZ, wobei p eine single Primzahl
	ist.
	F ist ein normiertes Polynom vom Grade > 1 in einer Unbestimmten
	ueber (Z/pZ) [x] - dem Polynomring in x ueber Z/pZ.
	P ist ein normiertes, irreduzibles Polynom aus (Z/pZ) [x].
	L = (f_1, ... f_r) ist eine Liste von paarweise teilerfremden
	normierten Polynomen in einer Unbestimmten ueber (Z/pZ) [x].
	Es gilt F = f_1 * ... * f_r mod (P).       
	L1 = ( A_1, ... A_r ) ist eine Liste von Polynomen in einer
	Unbestimmten ueber (Z/pZ) [x].
	Fuer 1 <= i <= r ist deg(A_i) < deg(f_i)  und die Koeffizienten
	der f_i haben Grade < deg(P).      
	Fuer 1 <= i <= r sei F_i := ( f_1 * ... * f_r ) / f_i, dann gilt
	( F_1 * A_1 ) + ... + ( F_r * A_r ) = 1 mod (P).



			upprmsp1hqs( p, F, T, L1, L2, A )

	"univariate polynomial over polynomial ring over modular single
	prime, transcendence degree 1, Hensel quadratic step"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	list upprmsp1hqs(p,F,T,L1,L2,A) single p; pol F, A; list T, L1, L2;
	L = upprmsp1hqs(p,F,T,L1,L2,A);
	Sei x eine Unbestimmte ueber Z/pZ, wobei p eine single Primzahl
	ist.
	F ist ein normiertes Polynom positiven Grades in einer Unbestimmten
	ueber (Z/pZ) [x] - dem Polynomring in x ueber Z/pZ.
	T = ( P, k, l, Pk, Pl) ist eine Liste, bestehend aus einem
	normierten, irreduziblen Polynom P aus (Z/pZ) [x], zwei ganzen
	Zahlen k und l,	fuer die gilt l >= 0 und k - 2*l > 0,
	sowie den Polynompotenzen Pk = (P)^k und Pl = (P)^l.
	L1 = ( f1, f2, ... , fr ) ist eine Liste normierter Polynome in
	einer Unbestimmten ueber (Z/pZ) [x] mit Koeffizienten vom
	Grade < k * deg(P). Es gilt f1 * ... * fr = F mod ( (P)^k ).
	L2 = ( A1, A2, ... , Ar ) ist eine Liste bestehend aus Polynomen
	in einer Veraenderlichen ueber (Z/pZ) [x], so dass fuer 1 <= i <= r
        deg(Ai) < deg(fi) gilt.
	Es ist A = f_1 * ... * f_r und fuer 1 <= i <= r sei F_i := A / fi,
	dann gilt ( F_1 * A_1 ) + ... + ( F_r * A_r ) = (P)^l mod (P)^k .
	L = ( L3, L4, A2 ).
	L3 bzw. L4 sind Listen analog zu L1 bzw. L2, die Aussagen gelten
	jedoch fuer 2 * (k-l) anstelle von k ( beachte k + (k - 2*l) > k ).
	A2 ist gleich dem Produkt der Polynome in Liste L3.



			upprmsp1redd( p, F )

	"univariate polynomial over polynomial ring over modular
	single prime, transcendence degree 1, reduced discriminant"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol upprmsp1redd(p,F) single p; pol F;
	P = upprmsp1redd(p,F);
	Sei x eine Unbestimmte ueber Z/pZ, wobei p eine single Primzahl
	ist.
	F ist ein Polynom in einer Unbestimmten ueber (Z/pZ) [x] -
	dem Polynomring in x ueber Z/pZ.
	P ist die reduzierte Diskriminante von F und als solche ein
	Element aus (Z/pZ) [x] und ein Teiler der Diskriminante von F.



			upprmsp1ress( p, P1, P2 )

	"univariate polynomial over polynomial ring over modular
	single prime, transcendence degree 1, resultant, Sylvester 
	algorithm"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol upprmsp1ress(p,P1,P2) single p; pol P1,P2;
	P3 = upprmsp1ress(p,P1,P2);
	Sei x eine Unbestimmte ueber Z/pZ, wobei p eine single Primzahl
	ist.
	P1 und P2 sind Polynome in einer Unbestimmten ueber (Z/pZ) [x] -
	dem Polynomring in x ueber Z/pZ.
	P3 ist die Resultante von P1 und P2 und als solche aus (Z/pZ) [x].



			uprfact( P )

	"univariate polynomial over rationals factorization"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list uprfact(P)  pol P;
	L = uprfact(P);
	P ist ein Polynom ungleich Null in einer Variable ueber den
	rationalen Zahlen.
	Sei N der Hauptnenner der Koeffizienten von P, also Q = N * P ein
	Polynom ueber den ganzen Zahlen und c = sign(P)*cont(P) / N eine
	rationale Zahl.
	L = (c,P1,e1,...,Pk,ek) mit k>=0.
	k = 0, falls P Grad 0 hat. Andernfalls gilt :
	e1,...,ek sind positive ganze Zahlen und P1,...,Pk die paarweise
	verschiedenen positiven irreduziblen Faktoren von Q, also Polynome
	ueber den ganzen Zahlen.
	Es gilt also : P = c * P1^e1 * ... * Pk^ek.
	Falls uprfact fehlerhaft verlaeuft, ist L = ERROR.



			uprfcdpr( PC )

	"univariate polynomial over the rationals from common denominator
	polynomial over the rationals"
	Quellbibliothek : srclib.pol2
	Include - Datei : _pol2.h
	pol uprfcdpr(PC) pol PC;
	P = uprfcdpr(PC);
	P = PC als sparse - Polynom in einer Veraenderlichen ueber Q
	( siehe cdprfcl ).



			uprfmsp1egcd( p, P1, P2, pF1, pF2 )

	"univariate polynomial over rational functions over modular
	single prime, transcendence degree 1, extended greatest
	common divisor"
	Quellbibliothek: srclib.pol4
	Include - Datei: _pol4.h
	pol uprfmsp1egcd(p,P1,P2,pF1,pF2) single p; pol P1,P2,*pF1,*pF2;
	F = uprfmsp1egcd(p,P1,P2,pF1,pF2);
	P1 und P2 sind Polynome in einer Variablen ueber dem rationalen
	Funktionenkoerper ueber (Z/pZ), wobei p eine single Primzahl ist.
	F, *pF1 und *pF2 sind jeweils Polynome in einer Variablen ueber
	dem rationalen Funktionenkoerper ueber (Z/pZ).
	F ist der normierte groesste gemeinsame Teiler von P1 und P2.
	Weiterhin gilt:
	1)  (*pF1) * P1 + (*pF2) * P2 = F;
	2)  ist Grad(P1/F) groesser 0, so ist Grad(*pF2)
	    kleiner Grad(P1/F); sonst ist Grad(*pF2) gleich 0;
	3)  ist Grad(P2/F) groesser 0, so ist Grad(*pF1)
	    kleiner Grad(P2/F); sonst ist Grad(*pF1) gleich 0;
	4)  ist P1 gleich 0, so ist *pF1 gleich 0.
	5)  ist P2 gleich 0, so ist *pF2 gleich 0.



			uprfmsp1fcdp( p, P )

	"univariate polynomial over rational functions over modular single
	prime, transcendence degree 1, from common denominator polynomial
	over rational functions over modular single prime, transcendence
	degree 1"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol uprfmsp1fcdp(p,P) single p; pol P;
	PC = uprfmsp1fcdp(p,P);
	P ist ein CD - Polynom in einer Veraenderlichen ueber dem 
	rationalen Funktionenkoerper ueber (Z/pZ), wobei p eine single
	Primzahl ist ( siehe cdprfmsp1fcl ).
	PC = P als sparse - Polynom.



			uprfmsp1fscl( L )

	"univariate polynomial over rational functions over modular single
	prime, transcendence degree 1, from special coefficient list"
	Quellbibliothek: srclib.pol4
	Include-Datei:   _pol4.h
	pol uprfmsp1fscl(L) list L;
	P = uprfmsp1fscl(L);
	Sei x eine Unbestimmte ueber Z/pZ, wobei p eine single Primzahl
	ist.
	Sei a_n * y^n + ... + a_0 * y^0 ein Polynom in y ueber (Z/pZ) (x)
	- dem rationalen Funktionenkoerper in x ueber (Z/pZ).
	Dann ist die Liste (a_0, ..., a_n) eine "special coefficient list",
	die obigem Polynom entspricht.
	uprfmsp1fscl wandelt eine "special coefficient list" in ein 
	sparse - Polynom in einer Veraenderlichen ueber (Z/pZ) (x) um.



			uprnfeval( P, F, a )

	"univariate polynomial over rationals number field element
	 evaluation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	nfel uprnfeval(P,F,a)  pol P,F; nfel a;
	a1 = uprnfeval(P,F,a);
	Es muss gelten : P ist Polynom in einer Variable ueber den
		rationalen Zahlen.
		F ist ein irreduzibles Polynom vom Grad >= 1 in einer
		Variable ueber den ganzen Zahlen, und zwar in dense-
		Darstellung.
		a ist ein Element aus dem durch F gegebenen Zahlkoerper.
	a1 = P(a)  (Element aus dem durch F gegebenen Zahlkoerper, genauso
	            dargestellt wie a)



			uprnfseval( P, F, a )

	"univariate polynomial over rationals number field element,
	sparse representation, evaluation"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	nfel uprnfseval(P,F,a)  pol P,F; nfel a;
	a1 = uprnfseval(P,F,a);
	Es muss gelten : P ist Polynom in einer Variable ueber den
		rationalen Zahlen.
		F ist ein irreduzibles Polynom vom Grad >= 1 in einer
		Variable ueber den rationalen Zahlen.
		a ist ein Element aus dem durch F gegebenen Zahlkoerper,
		das als Polynom vom Grad < Grad(F) in einer Variable ueber
		den rationalen Zahlen dargestellt ist (sparse-Darstellung).
	a1 = P(a)  (Element aus dem durch F gegebenen Zahlkoerper, genauso
	dargestellt wie a)



			uspiapf( p, P, k )

	"univariate separable polynomial over the integers, approximation
	of p-adic factorization"
	Quellbibliothek: srclib.pol3
	Include-Datei:   _pol3.h
	list uspiapf(p,P,k)  single p; pol P; single k;
	L1 = uspiapf(p,P,k);
	p ist eine single Primzahl.
	P ist ein normiertes, separables Polynom in einer Veraenderlichen
	mit Koeffizienten aus Z und Grad(P) > 1.
	k ist eine ganze Zahl > 1, so dass die kleinste Zweierpotenz
	groesser gleich 2*k noch eine single ist.
	p^k teilt nicht die reduzierte Diskriminante von P ( siehe
	upireddiscc ).
	Dann ist L1 = (f_1, ... ,f_r) eine Liste von Polynomen in einer
	Veraenderlichen ueber Z mit positiven Graden.
	P = f_1 * ... * f_r mod M mit M = p^(2*k).
	Sei P = P_1 * ... * P_s die Faktorisierung von P ueber den
	p-adischen ganzen Zahlen, dann ist r = s und bei geeigneter
	Numerierung ist P_i kongruent zu f_i modulo p^(2*k) fuer 1<=i<=r.
	Die Koeffizienten von f_i liegen in [0,p^(2*k)-1].



			uspifact( P )

	"univariate squarefree polynomial over integers factorization"
	Quellbibliothek: srclib.pol2
	Include-Datei:   _pol2.h
	list uspifact( P )  pol P;
	L = uspifact( P );
	P ist ein primitives quadratfreies Polynom in einer Variablen
	ueber den ganzen Zahlen mit positivem Grad und positivem Leit-
	koeffizienten.
	L ist eine Liste der positiven irreduziblen Faktoren von P.
	Tritt ein Fehler auf, so ist L = ERROR.



			vlsort( V, pPI )

	"variable list sort"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	list vlsort(V,pPI) list VL; list pPI;
	V1 = vlsort(V,pPI);
	V ist ein Liste von Variablen.
	V1 ist die alphanumerisch sortierte Variablenliste.
	*pPI repraesentiert die Permutation, die V in V1 ueberfuehrt.



			vncomp( Vn1, Vn2 )

	"variable name comparison"
	Quellbibliothek: srclib.pol1
	Include-Datei:   _pol1.h
	single vncomp(Vn1,Vn2) list Vn1,Vn2;
	n = vncomp(Vn1,Vn2);
	Vn1 und Vn2 sind Listen, die Variablennamen repraesentieren.
	n =  0, falls Vn1 gleich Vn2;
	     1, falls Vn1 in alphanumerischer Ordnung vor Vn2 kommt;
	    -1, falls Vn2 in alphanumerischer Ordnung vor Vn1 kommt.
	Dabei geht vncomp davon aus, dass folgendes gilt:
	    'Ziffer' < 'Grossbuchstabe' < 'Kleinbuchstabe'.



