			ecgf2btco( G, a1, a2, a3, a4, a6, r, s, t, u )

	"elliptic curve over Galois-field with characteristic 2, birational
	 transformation of coefficients"
	Quellbibliothek: srclib.ec2
	Include-Datei:	 _ec2.h
	list ecgf2btco(G, a1, a2, a3, a4, a6, r, s, t, u)
		obj G;  gf2el a1, a2, a3, a4, a6, r, s, t, u;
	L = ecgf2btco(G, a1, a2, a3, a4, a6, r, s, t, u);
	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).
		- a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als
		  Polynome in einer Variablen ueber Z/2Z vom Grad < n in
		  spezieller Bit-Notation dargestellt werden.
		- r, s, t, u sind Elemente aus GF(2^n), die als Polynome
		  in einer Variablen ueber Z/2Z vom Grad < n in spezieller
		  Bit-Notation dargestellt werden. u ist ungleich 0.
	ecgf2btco berechnet zu der durch a1, a2, a3, a4, a6 in
	Weierstrass-Normalform gegebenen elliptischen Kurve die durch
	r, s, t, u gegebene birationale elliptische Kurve mit den
	Koeffizienten a1', a2', a3', a4', a6' in Weierstrass-Normalform
	gemaess
		x = u^2*x' + r,
		y = u^3*y' + u^2*s*x' + t.
	ecgf2btco liefert eine Liste mit den Koeffizienten der neuen Kurve:
	L = (a1', a2', a3', a4', a6'). a1', a2', a3', a4' und a6' sind
	Elemente aus GF(2^n) in spezieller Bit-Darstellung.
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.49.



			ecgf2cdivp( G, a6, m )

        "elliptic curve over Galois-field with characteristic 2,
	construction of division polynomials"
	Quellbibliothek: srclib.ec3
        Include-Datei:   _ec3.h
        list ecgf2cdivp(G, a6, m)  obj G; gf2el a6; single m;
        L = ecgf2cdivp(G, a6, m);
        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).
        a6 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, a6 ist ungleich Null.
	Sei E die elliptische Kurve ueber GF(2^n), die durch die Gleichung
		E: y^2 + x*y = x^3 + a6
	gegeben ist. (Siehe auch ecgf2npmspv1.)
	m ist eine positive single groesser als 3.
	L ist die Liste der Teilungspolynome, d.h. insbesondere eine Liste
	von Polynomen in einer Veraenderlichen ueber GF(2^n) mit
	Koeffizienten in spezieller Bit-Darstellung.
	Das erste Teilungspolynom in L hat Index 0 und das letzte den
	Index m.  (Siehe "Constructing Elliptic Curve Cryptosystems in 
	Characteristic 2" in Advances in Cryptology - Proceedings of
	Crypto '90, Lect. Not. in Comp. Sci., 537 (1991), pp 161-162,
	von Neal Koblitz, erschienen im Springer Verlag.)



			ecgf2cssa( G, a6, s, pl, ts )

	"elliptic curve over Galois field with characteristic 2, combined
	 Schoof- Shanks- algorithm"
	Quellbibliothek: srclib.ec3
	Include-Datei:   _ec3.h
	int ecgf2cssa(G, a6, s, pl, ts)
		obj G; gf2el a6; int s; single pl, ts;
	N = ecgf2cssa(G, a6, s, pl, ts);
	    G ist ein irreduzibles normiertes Polynom in einer
	Veraenderlichen ueber Z/2Z vom Grad n, in der speziellen
	Bit-Darstellung (vgl. udpm2tosb) als definierendes Polynom fuer
	den endlichen Koerper GF(2^n) der Charakteristik 2.
	    a6 ist ein Element dieses endlichen Koerpers GF(2^n), das
	als Polynom in einer Veraenderlichen vom Grad < n ueber Z/2Z
	dargestellt wird. a6 definiert eine elliptische Kurve der Form
		E: y^2 + xy = x^3 + a6
	ueber dem durch G definierten endlichen Koerper GF(2^n).
	    ecgf2cssa berechnet die Ordnung n der rationalen
	Punktgruppe von E ueber GF(2^n), d.h. N = #E(GF(2^n)) mit Hilfe
	eines kombinierten Schoof-Shanks-Verfahrens.
	    s >= 1 ist eine natuerliche Zahl, die die zu erwartende
	Kongruenz im Schoof-Teil des Algorithmus bestimmt, genauer
	liefert der Schoof-Teil eine natuerliche Zahl a, so dass gilt
		N = #E(GF(2^n)) = a mod m,
	wobei m >= s ist. (Der Schoof-Teil bestimmt also die
	Punktanzahl "mindestens modulo s".)
	    pl ist eine einfach genaue ganze Zahl. Ist pl == 0, so erfolgt
	waehrend der Laufzeit keine Ausgabe auf stdout. Ist pl != 0, so
	erhaelt man waehrend der Laufzeit auf stdout einige einfache
	Ausgaben ueber den gegenwaertigen Stand der Berechnungen.
	    ts ist eine positive ganze Zahl, die die Groesse der
	benutzten Tabelle kontrolliert. Wird ts auf 0 gesetzt, so wird
	die Feldgroesse unter der Annahme, dass genuegend Speicherplatz
	vorhanden ist, vom Programm so bestimmt, dass die Laufzeit
	minimiert wird. Ist ts != 0, so wird die Groesse der
	benoetigten Tabelle mit ts/100 multipliziert. Werte kleiner als
	100 verkleinern also die Tabelle, Werte groesser als 100
	vergroessern die Tabelle und sollten nicht benutzt werden, da
	dann sowohl der Speicherplatzbedarf als auch die Laufzeit
	ansteigen. ts = 100 hat dieselbe Wirkung wie ts = 0. (Eine
	Verkleinerung der Tabelle bedutet eine Verkleinerung der Anzahl
	der Babysteps und fuehrt daher zu einer Vergroesserung der
	Anzahl der Giantsteps.)
	Hinweis: Der berechnete Speicherplatzbedarf liegt in der
	Groessenordnung von
			     sqrt(sqrt(2^n))
			     ------------- *  1/128 KB,
			   	 sqrt(m)
	wobei n der Grad des Koerpes und m der vom Schoof-Teil
	bestimmte Modul der Kongruenz ist. m ist nicht vor Ausfuerhrung
	des Programmes bekannt, so dass a priori keine sicheren Aussagen
	ueber den Speicherplatzbedarf gemacht werden koennen.
	Vorsicht: Die auftretenden Tabellen koennen durchaus die
	Groessenordnung von mehreren Megabytes erreichen.
	    ecgf2cssa liefert NULL, falls die benoetigte Tabelle nicht
	angelegt werden konnte. ecgf2cssa liefert eine negative ganze
	Zahl, falls zur Bestimmung der Ordnung der noch nicht
	implementierte zweite Teil des Shanks-Algorithmus erforderlich
	ist. Falls ecgf2cssa eine positive ganze Zahl N liefert, so
	gilt
		N = #E(Z/pZ).



			ecgf2disc( G, a1, a2, a3, a4, a6 )

	"elliptic curve over Galois-field with characteristic 2, 
	 discriminant"
	Quellbibliothek: srclib.ec2
	Include-Datei:	 _ec2.h
	gf2el ecgf2disc(G, a1, a2, a3, a4, a6)
		obj G;  gf2el a1, a2, a3, a4, a6;
	D = ecgf2disc(G, a1, a2, a3, a4, a6);
	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).
		- a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als
		  Polynome in einer Variablen ueber Z/2Z vom Grad < n in
		  spezieller Bit-Notation dargestellt werden.
	ecgf2disc berechnet die Diskriminante D der durch die Koeffizienten
	a1, ... , a6 in Weierstrass-Normalform gegebenen kubischen Kurve
	ueber GF(2^n).
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.46.



			ecgf2fmoplam( G, a1, a2, a3, a4, a6, P, L, N )

	"elliptic curve over Galois-field with characteristic 2, finding
	a multiple of the order of a point with the Pollard Lambda method"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	int ecgf2fmoplam(G, a1, a2, a3, a4, a6, P, L, N)
		obj G; gf2el a1, a2, a3, a4, a6; list P, L; int N;
	M = ecgf2fmoplam(G, a1, a2, a3, a4, a6, P, L, N);
	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).
	a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als Polynome
	in einer Variablen ueber Z/2Z vom Grad < n in spezieller
	Bit-Notation dargestellt werden. Sei E die elliptische Kurve
	ueber GF(2^n) mit den Koeffizienten a1, a2, a3, a4 und a6 in
	Weierstrass Normalform.
	P = (x, y, z) ist ein projektiver Punkt auf E, d.h. insbesondere
	sind x, y und z Elemente aus GF(2^n) in spezieller Bit-Notation.
	L ist entweder eine Liste von positiven ganzen Zahlen oder
	eine nicht negative single, die zwischen 3 und 30 liegen sollte.
	Bei Eingabe L==0 wird fuer L (gemaess angegebener Quelle) die
	Liste (1, 2, 2^2, ..., 2^19 ) genommen.
	N ist eine nicht negative ganze Zahl, die bei Eingabe von N==0
	standardmaessig gleich sqrt(2*sqrt(2^n)) gesetzt wird. Sie sollte
	im allgemeinen groessenordnungsmaessig diesem Wert entsprechen.
	ecgf2fmoplam berechnet mit Hilfe eines Verfahrens, das auf der
	Pollard'schen Lambda-Methode basiert (siehe A.K. Lenstra und 
	H.W. Lenstra: Algorithms in number theory, Technical Report of
	The University of Chicago, May 1987),
	eine Zahl M, fuer die gilt M * P = O, wobei O das neutrale
	Element der rationalen Punktgruppe E(GF(2^n)) bezeichnet.
	Das Verfahren fuehrt unter Umstaenden nicht zum Erfolg und
	liefert in diesem Fall -1 zurueck.



			ecgf2fp( G, a1, a2, a3, a4, a6 )

	"elliptic curve over Galois-field with characteristic 2, find
	 point"
	Quellbibliothek: srclib.ec3
	Include-Datei:   _ec3.h
	list ecgf2fp(G, a1, a2, a3, a4, a6)
		obj G;  gf2el a1, a2, a3, a4, a6;
	P = ecgf2fp(G, a1, a2, a3, a4, a6);
	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).
                - a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als
                  Polynome in einer Variablen ueber Z/2Z vom Grad < n in
		  spezieller Bit-Notation dargestellt werden.
	ecgf2fp liefert einen Punkt P auf der durch a1, a2, a3, a4 und
	a6 in Weierstrass-Normalform gegebenen elliptischen Kurve ueber
	GF(2^n) in projektiver Darstellung, d.h. P ist eine dreielementige
	Liste P = (x, y, 1) von Elementen aus GF(2^n) in spezieller
	Bit-Darstellung. P ist nicht der Fernpunkt, d.h. P != (0, 1, 0).



			ecgf2jinv( G, a1, a2, a3, a4, a6 )

	"elliptic curve over Galois-field with characteristic 2, 
	 j-invariant"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	gf2el ecgf2jinv(G, a1, a2, a3, a4, a6)
		obj G;  gf2el a1, a2, a3, a4, a6;
	j = ecgf2jinv(G, a1, a2, a3, a4, a6);
	Dabei muss gelten:
		- G ist ein irreduzibles normiertes Polynom in einer
		  Variablen ueber Z/2Z vom Grad n in der speziellen
		  Bit-Notation (vgl. udpm2tosb) als erzeugendes
		  Polynom fuer GF(2^n)
                - a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als
                  Polynome in einer Variablen ueber Z/2Z vom Grad < n in
		  spezieller Bit-Notation dargestellt werden.
	ecgf2jinv berechnet die j-Invariante j der durch die Koeffizienten
	a1, a2, a3, a4, a6 in Weierstras-Normalform gegebenen elliptischen
	Kurve ueber GF(2^n).
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.46.



			ecgf2lp( G, a1, a2, a3, a4, a6, P1, P2 )

	"elliptic curve over Galois-field with characteristic 2, line 
	 through points"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecgf2lp(G, a1, a2, a3, a4, a6, P1, P2)
		obj G;  gf2el a1, a2, a3, a4, a6;  list P1, P2;
	L = ecgf2lp(G, a1, a2, a3, a4, a6, 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).
                - a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als
                  Polynome in einer Variablen ueber Z/2Z vom Grad < n in
		  spezieller Bit-Notation dargestellt werden.
                - P1 und P2 sind 3-elementige Listen von Elementen aus 
		  GF(2^n) in spezieller Bit-Notation als projektive Dar-
		  stellungen von Punkten auf einer elliptischen Kurve E.
	P1 und P2 sind 3-elementige Listen als projektive Darstellungen von
	Punkten auf der durch a1, a2, a3, a4, a6 gegebenen elliptischen
	Kurve. ecgf2lp berechnet die Steigung l und den y-Achsenabschnitt n
	der Geraden G durch P1 und P2 bzw. der Tangente an P1 fuer P1 = P2.
		G: y = l*x + n.
	ecgf2lp liefert falls moeglich eine 2-elementige Liste aus Steigung
	und y-Achsenabschnitt:
		L = (l, n).
	ecgf2lp liefert die Liste
		( 0 ), falls P1 = -P2,
		( 1 ), falls P1 der Punkt im Unendlichen ist,
		( 2 ), falls P2 der Punkt im Unendlichen ist.
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.58.



			ecgf2mopto( G, a1, a2, a3, a4, a6, P, N )

        "elliptic curve over Galois-field with characteristic 2, multiple
	of the order of a point to exact order of the point"
        Quellbibliothek: srclib.ec2
        Include-Datei:   _ec2.h
        int ecgf2mopto(G, a1, a2, a3, a4, a6, P, N)
                obj G; gf2el a1, a2, a3, a4, a6; list P; int N;
        M = ecgf2mopto(G, a1, a2, a3, a4, a6, P, N);
        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).
        a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als Polynome
        in einer Variablen ueber Z/2Z vom Grad < n in spezieller
        Bit-Notation dargestellt werden. Sei E die elliptische Kurve
        ueber GF(2^n) mit den Koeffizienten a1, a2, a3, a4 und a6 in
        Weierstrass Normalform.
        P = (x, y, z) ist ein projektiver Punkt auf E, d.h. insbesondere
        sind x, y und z Elemente aus GF(2^n) in spezieller Bit-Notation.
	N ist ein Vielfaches der Punktordnung von P, d.h. es gilt 
	N * P = 0, wobei 0 das neutrale Element der rationalen Punktgruppe
	E(GF(2^n)) bezeichnet.  ecgf2mopto berechnet die Ordnung M von P.



			ecgf2msha1( G, a1, a2, a3, a4, a6, P, a, m, pl, ts )

	"elliptic curve over Galois-field with characteristic 2, modified
	Shanks' algorithm, first part"
	Quellbibliothek: srclib.ec3
	include-Datei:   _ec3.h
	list ecgf2msha1(G, a1, a2, a3, a4, a6, P, a, m, pl, ts)
		obj G; gf2el a1, a2, a3, a4, a6; list P; int a, m; 
		single pl, ts;
	L = ecgf2msha1(G, a1, a2, a3, a4, a6, P, a, m, pl, ts);
	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).
		- a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als
		  Polynome in einer Variablen ueber Z/2Z vom Grad < n
		  in spezieller Bit-Notation dargestellt werden.
		- P = ( x  y  z ) ist ein projektiver Punkt auf der
		  durch a1, a2, a3, a4, a6 gegebenen elliptischen Kurve
		  ueber GF(2^n), d.h. insbesondere, dass die
		  Koordinaten x, y, z des Punktes Elemente aus GF(2^n)
		  sind.
		- a und m sind ganze Zahlen,
		- pl und ts sind einfach genau.
	a1, a2, a3, a4, a6 sind Koeffizienten einer elliptischen Kurve
	E ueber dem durch G definierten endlichen Koerper der
	Charakteristik 2 vom Grad n. P = (x, y, z) ist ein Punkt auf
	dieser elliptischen Kurve E in projektiver Darstellung.
	ecgf2msha1 berechnet mit Hilfe eines modifizierten
	Babystep-Giantstep-Algorithmus die Ordnung ord des Punktes P in
	der Punktgruppe der elliptischen Kurve E und ein Vielfaches
	res der Ordnung von P. res liegt im Hasse-Intervall (und ist
	damit ein moeglicher Wert fuer die Ordnung der Punktgruppe).
	a und m sind ganze Zahlen, so dass fuer die Ordnung der
	Punktgruppe der Kurve gilt
		#E(GF(2^n)) = a mod m.
	(Mit Hilfe dieser Kongruenz werden Speicherplatz und Laufzeit
	des ueblichen Babystep-Giantstep-Algorithmus verringert.)
	Ist der Paramenter pl == 0, so erfolgt keine Ausgabe auf
	stdout. Ist pl != 0, so erhaelt man waehrend der Laufzeit auf
	stdout einige einfache Ausgaben ueber den gegenwaertigen Stand
	der Berechnungen.
	ts ist eine positive ganze Zahl, die die Groesse der benutzten
	Tabelle kontrolliert.  Wird ts auf 0 gesetzt, so wird die
	Feldgroesse unter der Annahme, dass genuegend Speicherplatz
	vorhanden ist, vom Programm so bestimmt, dass die Laufzeit
	minimiert wird. Ist ts != 0, so wird die Groesse der
	benoetigten Tabelle mit ts/100 multipliziert. Werte kleiner als
	100 verkleinern also die Tabelle, Werte groesser als 100
	vergroessern die Tabelle und sollten nicht benutzt werden, da
	dann sowohl der Speicherplatzbedarf, als auch die Laufzeit
	ansteigen. ts = 100 hat dieselbe Wirkung, wie ts = 0.
	(Eine Verkleinerung der Tabelle bedeutet eine Verkleinerung der
	Anzahl der Babysteps und fuehrt daher zu einer Vergroesserung
	der Anzahl der Giantsteps.)
	Hinweis: Der berechnete Speicherplatzbedarf liegt in der
	Groessenordnung von
			     sqrt(sqrt(2^n))
			     ------------- *  1/128 KB,
			   	 sqrt(m)
	wobei n der Grad des Koerpes ist.
	Vorsicht: Die auftretenden Tabellen koennen durchaus die
	Groessenordnung von mehreren Megabytes erreichen.
	ecgf2msha1 liefert (sofern genuegend Speicherplatz fuer die
	Tabelle vorhanden war) stets eine aus drei Eintraegen
	bestehende Liste L = (status ord res).
		Ist status < 0, so war die Ordnung des Startpunktes zu
	gering.
		Ist status > 0, so enthaelt ord die Ordnung des
	Startpunktes P, und res enthaelt ein Vielfaches von ord im
	Hasse-Intervall, so dass res = a mod m.
	ecgf2msha1 liefert NULL, falls die Tabelle nicht angelegt
	werden konnte.



			ecgf2mul( G, a1, a2, a3, a4, a6, k, P1 )

	"elliptic curve Galois-field with characteristic 2, 
	 multiplication-map"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecgf2mul(G, a1, a2, a3, a4, a6, k, P1)
		obj G;  gf2el a1, a2, a3, a4, a6;  int k;  list P1;
	Pk = ecgf2mul(p, a1, a2, a3, a4, a6, k, P1);
	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).
                - a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als
		  Polynome in einer Variablen ueber Z/2Z vom Grad < n in
		  spezieller Bit-Notation dargestellt werden.
		- k ist eine natuerliche Zahl.
                - P ist eine 3-elementige Liste von Elementen aus GF(2^n) 
		  in spezieller Bit-Notation als projektive Darstellung 
		  eines Punktes auf einer elliptischen Kurve E.
	Fuer einen in projektiver Darstellung als 3-elementige Liste
	gegebenen Punkt P1 = (x1, y1, z1) auf der durch a1, a2, a3, a4, a6
	in Weierstrass-Normalform gegebenen elliptischen Kurve E berechnet
	ecgf2mul das Vielfache
		Pk = k*P1 = (xk, yk, zk)
	und gibt dieses als 3-elementige Liste von Elementen aus GF(2^n)
	zurueck.



			ecgf2neg( G, a1, a2, a3, a4, a6, P )

	"elliptic curve over Galois-field with characteristic 2,
	 negative point"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecgf2neg(G, a1, a2, a3, a4, a6, P)
		obj G;  gf2el a1, a2, a3, a4, a6;  list P;
	L = ecgf2neg(G, a1, a2, a3, a4, a6, 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).
                - a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als
                  Polynome in einer Variablen ueber Z/2Z vom Grad < n in
		  spezieller Bit-Notation dargestellt werden.
                - P ist eine 3-elementige Liste von Elementen aus GF(2^n)
		  in spezieller Bit-Notation als projektive Darstellung 
		  eines Punktes auf einer elliptischen Kurve E.
	Fuer einen in projektiver Darstellung als 3-elementige Liste
	gegebenen Punkt P auf der durch a1, a2, a3, a4, a6 in
	Weierstrass-Normalform gegebenen elliptischen Kurve E berechnet
	ecgf2neg das Negative des Punktes P in projektiver Darstellung 
	und gibt dieses als 3-elementige Liste von Elementen aus GF(2^n) 
	zurueck.
	Literatur: J. H. Silverman,
		The arithmetic of elliptic curves, p.58.



			ecgf2npca( G, a6 )

	"elliptic curve over Galois-field with characteristic 2, counting
	 algorithm"
	Quellbibliothek: srclib.ec3
	Include-Datei:   _ec3.h
	int ecgf2npca(G, a6)  obj G; gf2el a6;
	N = ecgf2npca(G, a6);
	    G ist ein irreduzibles normiertes Polynom in einer
	Veraenderlichen ueber Z/2Z vom Grad n, in der speziellen
	Bit-Darstellung (vgl. udpm2tosb) als definierendes Polynom fuer
	den endlichen Koerper GF(2^n) der Charakteristik 2. n muss
	kleiner oder gleich 29 sein. (Fuer groessere Erweiterungsgrade
	kann man ecgf2cssa benutzen.)
	    a6 ist ein Element dieses endlichen Koerpers GF(2^n), das
	als Polynom in einer Veraenderlichen vom Grad < n ueber Z/2Z
	dargestellt wird. a6 definiert eine elliptische Kurve der Form
		E: y^2 + xy = x^3 + a6
	ueber dem durch G definierten endlichen Koerper GF(2^n).
	    ecgf2csca berechnet die Ordnung n der rationalen
	Punktgruppe von E ueber GF(2^n), d.h. N = #E(GF(2^n)), mit Hilfe
	eines einfachen Abzaehlverfahrens.



			ecgf2npfe( Gm, a1, a2, a3, a4, a6, Nm, GmtoGn )

	"elliptic curve over Galois field with characteristic 2, number
	 of points after field extension"
	Quellbibliothek: srclib.ec3
	Include-Datei:   _ec3.h
	list ecgf2npfe(Gm, a1, a2, a3, a4, a6, Nm, GmtoGn)
		obj Gm; gf2el a1, a2, a3, a4, a6; int Nm; list GmtoGn;
	L = ecgf2npfe(Gm, a1, a2, a3, a4, a6, Nm, GmtoGn, n);
	    Gm ist ein irreduzibles, normiertes Polynom in einer
	Veraenderlichen ueber Z/2Z vom Grad m in der speziellen
	Bit-Darstellung (vgl. udpm2tosb) als erzeugendes Polynom fuer
	den Grundkoerper GF(2^m).
	    a1, a2, a3, a4, a6 sind Elemente aus (dem durch Gm
	definierten Koerpers) GF(2^m), die als Polynome in einer
	Variablen ueber Z/2Z vom Grad < m in spezieller Bit-Notation
	dargestellt werden. a1, a2, a3, a4, a6 sind Koeffizienten einer
	elliptischen Kurve ueber GF(2^m).
	    Nm ist eine natuerliche Zahl, Nm ist die Anzahl der
	rationalen Punkte der durch a1, a2, a3, a4, a6 ueber GF(2^m) in
	Weierstrass-Normalform gegebenen elliptischen Kurve.
	    GmtoGn ist eine zweielementige Liste, die die Einbettung
	eines endlichen Koerpers der Charakteristik 2 mit 2^m Elementen
	(gegeben durch Gm) in einen Erweiterungskoerper mit 2^n (m|n)
	Elementen (gegeben durch Gn) beschreibt. GmtoGn wird mit Hilfe
	des Programmes gf2ies erzeugt. (GmtoGn = ( Gn, re ) ist eine
	zweielementige 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.)
	    ecgf2npfe liefert eine Liste L der Form
		L = (Gn, a1s, a2s, a3s, a4s, a6s, Nn)
	mit
		obj Gn; gf2el a1s, a2s, a3s, a4s, a6s; int Nn
	    ecgf2fpe berechnet die Anzahl Nn der rationalen Punkte der
	gleichen elliptischen Kurve ueber dem durch Gn gegebenen
	Erweiterungskoerper. a1s, a2s, a3s, a4s und a6s sind
	Einbettungen von a1, a2, a3, a4 und a6 in diesen
	Erweiterungskoerper, der dann durch Gn definiert ist.



			ecgf2npmi( G, a6, S, v, pM )

        "elliptic curve over Galois-field with characteristic 2, number of
        points modulo an integer determined with the Schoof algorithm"
        Quellbibliothek: srclib.ec3
        Include-Datei:   _ec3.h
        int ecgf2npmi(G,a6,S,v,pM)  obj G; gf2el a6; int S, *pM; single v;
        M = ecgf2npmi(G,a6,S,v,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).
        a6 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
        und ungleich Null ist.
        Sei E die elliptische Kurve ueber GF(2^n), die durch die Gleichung
                      y^2 + x*y = x^3 + a6
        gegeben ist.
	S ist eine positive ganze Zahl.
	v ist gleich 1 oder 2.
	Je nach Wert von v wird ecgf2npmspv1 oder ecgf2npmspv2 aufgerufen.
	Dann ist *pM eine positive ganze Zahl groesser gleich S.
	Sei N = # E(GF(2^n)), d.h. N sei die Maechtigkeit der rationalen
	Punktgruppe von E. Dann ist M = N modulo *pM.
	Benutzt wird der Schoof Algorithmus.



			ecgf2npmp2( G, a6, c, L )

        "elliptic curve over Galois-field with characteristic 2,
	number of points modulo a power of 2"
        Quellbibliothek: srclib.ec3
        Include-Datei:   _ec3.h
        single ecgf2npmp2(G,a6,c,L) obj G; gf2el a6; single c; list L;
	m = ecgf2npmp2(G,a6,c,L);
        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).
        a6 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
        und ungleich Null ist.
        Sei E die elliptische Kurve ueber GF(2^n), die durch die Gleichung
                      y^2 + x*y = x^3 + a6
        gegeben ist. (Siehe auch ecgf2npmspv1.)
	c ist eine single mit 2<c<20 sowie c < n. c sollte nicht groesser
	als 6 sein, sonst laeuft das Programm unverhaeltnismaessig lange.
        L ist die Liste der Teilungspolynome, d.h. insbesondere eine Liste
        von Polynomen in einer Veraenderlichen ueber GF(2^n) mit
	Koeffizienten in spezieller Bit-Darstellung.
	Das erste Teilungspolynom in L hat Index 0 und das letzte einen
	Index, der groesser als 2^(c-1) - 3 ist.
        Sei N = # E(GF(2^n)), d.h. N sei die Maechtigkeit der rationalen
        Punktgruppe von E. Dann ist m = N modulo 2^c.



			ecgf2npmspv1( G, a6, p, L )

        "elliptic curve over Galois-field with characteristic 2, number of
	points modulo a single prime determined with the Schoof algorithm,
	version 1"
        Quellbibliothek: srclib.ec3
        Include-Datei:   _ec3.h
        single ecgf2npmspv1(G,a6,p,L) obj G; gf2el a6; single p; list L;
	m = ecgf2npmspv1(G,a6,p,L);
        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).
        a6 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
	und ungleich Null ist.
        Sei E die elliptische Kurve ueber GF(2^n), die durch die Gleichung
                      y^2 + x*y = x^3 + a6
        gegeben ist.
	p ist eine single Primzahl groesser als 2.
        L ist die Liste der Teilungspolynome, d.h. insbesondere eine Liste
        von Polynomen in einer Veraenderlichen ueber GF(2^n) mit
	Koeffizienten in spezieller Bit-Darstellung.
	Das erste Teilungspolynom in L hat Index 0 und das letzte einen
	Index, der groesser als p ist.
        (Siehe "Constructing Elliptic Curve Cryptosystems in
        Characteristic 2" in Advances in Cryptology - Proceedings of
        Crypto '90, Lect. Not. in Comp. Sci., 537 (1991), pp 161-162,
        von Neal Koblitz, erschienen im Springer Verlag.)
	Sei N = # E(GF(2^n)), d.h. N sei die Maechtigkeit der rationalen
	Punktgruppe von E. 
	Dann ist m = N modulo p, falls diese Kongruenz mit dem ersten Teil
	des Schoof Algorithmus berechnet werden kann, 
	m = -1 sonst.
	c sei ein fixiertes Element mit Spur 1 aus GF(2^n).
	Zu jeder nicht supersingulaeren elliptischen Kurve E1 ueber 
	GF(2^n), d.h. fuer jede elliptische Kurve mit j-Invariante ungleich 
	Null, gibt es ein A6 aus GF(2^n) \ {0}, so dass E1 isomorph ist zu 
	der elliptischen Kurve E2 gegeben durch
                      y^2 + x*y = x^3 + A6
	oder zur elliptischen Kurve E3 gegeben durch
                      y^2 + x*y = x^3 + c * x^2 + A6.
	Es gilt # E2 (GF(2^n)) + # E3 (GF(2^n))  =  2*(2^n) + 2. Damit
	reduziert sich die Bestimmung von #E fuer nicht supersingulaere
	Kurven auf Kurven des Typs y^2 + x*y = x^3 + a6.



			ecgf2npmspv2( G, a6, p, L )

        "elliptic curve over Galois-field with characteristic 2, number of
	points modulo a single prime determined with the Schoof algorithm,
	version 2"
        Quellbibliothek: srclib.ec3
        Include-Datei:   _ec3.h
        single ecgf2npmspv2(G,a6,p,L) obj G; gf2el a6; single p; list L;
	m = ecgf2npmspv2(G,a6,p,L);
        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).
        a6 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
	und ungleich Null ist.
        Sei E die elliptische Kurve ueber GF(2^n), die durch die Gleichung
                      y^2 + x*y = x^3 + a6
        gegeben ist.
	p ist eine single Primzahl groesser als 2.
        L ist die Liste der Teilungspolynome, d.h. insbesondere eine Liste
        von Polynomen in einer Veraenderlichen ueber GF(2^n) mit
	Koeffizienten in spezieller Bit-Darstellung.
	Das erste Teilungspolynom in L hat Index 0 und das letzte einen
	Index, der groesser als p ist.
        (Siehe "Constructing Elliptic Curve Cryptosystems in
        Characteristic 2" in Advances in Cryptology - Proceedings of
        Crypto '90, Lect. Not. in Comp. Sci., 537 (1991), pp 161-162,
        von Neal Koblitz, erschienen im Springer Verlag.)
	Sei N = # E(GF(2^n)), d.h. N sei die Maechtigkeit der rationalen
	Punktgruppe von E. Dann ist m = N modulo p.
	Benutzt wird der Schoof Algorithmus.
	c sei ein fixiertes Element mit Spur 1 aus GF(2^n).
	Zu jeder nicht supersingulaeren elliptischen Kurve E1 ueber 
	GF(2^n), d.h. fuer jede elliptische Kurve mit j-Invariante ungleich 
	Null, gibt es ein A6 aus GF(2^n) \ {0}, so dass E1 isomorph ist zu 
	der elliptischen Kurve E2 gegeben durch
                      y^2 + x*y = x^3 + A6
	oder zur elliptischen Kurve E3 gegeben durch
                      y^2 + x*y = x^3 + c * x^2 + A6.
	Es gilt # E2 (GF(2^n)) + # E3 (GF(2^n))  =  2*(2^n) + 2. Damit
	reduziert sich die Bestimmung von #E fuer nicht supersingulaere
	Kurven auf Kurven des Typs y^2 + x*y = x^3 + a6.



			ecgf2sfmuls( p, a6, x1, y1, n )

	"elliptic curve over Galois-field with characteristic 2,
	special form, multiplication-map, special version"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
        void ecmpsnfmuls(G, a4, a6, x1, y1, n)
		obj G; gfel a6, *x1, *y1; int n;
        ecgf2sfmuls(G, a4, a6, x1, y1, n);
	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 sei 
	eine elliptische Kurve ueber dem durch G definierten endlichen
	Koerper GF(2^n) definiert durch eine Gleichung der Form
		y^2 + x*y = x^3 + a6.
	(*x1, *y1) ist ein Punkt auf der elliptischen Kurve E in
	affiner Darstellung. (*x1, *y1) darf nicht der Nullpunkt der
	Kurve sein. ecgf2sfmuls berechnet das Vielfache n * (*x1, *y1)
	des Punktes (*x1, *y1) und legt das Ergebnis wieder unter
	(*x1, *y1) ab. ecgf2sfmuls legt in (*x1, *y1) jeweils die leere
	Liste ab falls n * (*x1, *y1) der Nullpunkt der Kurve ist.
	Vorsicht: Der Punkt (*x1, *y1) wird veraendert.



			ecgf2sfsums( G, a6, x1, y1, x2, y2 )

	"elliptic curve over Galois-field with characteristic 2,
	special form, sum of points, special version"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	void ecgf2sfsums(G, a6, x1, y1, x2, y2)
		obj G; gf2el a6, *x1, *y1, *x2, *y2;
	ecgf2sfsums(p, a6, x1, y1, x2, y2);
	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 sei 
	eine elliptische Kurve ueber dem durch G definierten endlichen
	Koerper GF(2^n) definiert durch eine Gleichung der Form
		y^2 + x*y = x^3 + a6.
	(*x1, *y1) und (*x2, *y2) sind Punkte auf der elliptischen
	Kurve E ueber GF(2^n) in affiner Darstellung. (*x1, *y1) und
	(*x2, *y2) duerfen nicht der Nullpunkt der Kurve sein.
	ecgf2sfsums berechnet die Summe der Punkte (*x1, *y1) und
	(*x2, *y2) und legt das Ergebnis wieder unter (*x2, *y2) ab.
	ecgf2sfmuls legt in (*x2, *y2) jeweils die leere Liste ab,
	falls (*x1, *y1) + (*x2, *y2) der Nullpunkt ist.
	Vorsicht: Nur der Punkt (*x1, *y1) bleibt unveraendert, der
	Punkt (*x2, *y2) wird veraendert. Ein Aufruf der Form
		ecgf2sfsums(G, a6, x1, y1, x1, y1)
	hat unerwartete Seiteneffekte und liefert i.a. ein falsches
	Ergebnis.



			ecgf2srpp( G, P )

	"elliptic curve over Galois-field with characteristic 2, standard
	 representation of projective point"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecgf2srpp(G, P)  obj G; list P;
	Q = ecgf2srpp(G, P);
	Dabei muss gelten:
		- G ist ein irreduzibles normierte 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 eine 3-elementige Liste von Elementen aus GF(2^n) 
		  in spezieller Bit-Notation als projektive Darstellung 
		  eines Punktes auf einer elliptischen Kurve E.
	ecgf2srpp berechnet fuer den projektiven Punkt P = (x, y, z)
	eine Darstellung Q' = (x', y', z') von Elementen aus GF(2^n),
	so dass gilt:
		x' = x/z, y' = y/z, z' = 1, falls z != 0;
		x' = 0,   y' = 1,   z' = 0, falls z == 0.



			ecgf2sum( G, a1, a2, a3, a4, a6, P1, P2 )

	"elliptic curve over Galois-field with characteristic 2, sum of 
	 points"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecgf2sum(G, a1, a2, a3, a4, a6, P1, P2)
		obj G;  gf2el a1, a2, a3, a4, a6;  list P1, P2;
	P3 = ecgf2sum(G, a1, a2, a3, a4, a6, 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).
                - a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als
                  Polynome in einer Variablen ueber Z/2Z vom Grad < n in
		  spezieller Bit-Notation dargestellt werden.
                - P1 und P2 sind 3-elementige Listen von Elementen aus 
		  GF(2^n) in spezieller Bit-Notation als projektive Dar-
		  stellungen von Punkten auf einer elliptischen Kurve E.
	P1 = (x1, y1, z1) und P2 = (x2, y2, z2) sind 3-elementige Listen 
	als projektive Darstellungen von Punkten auf der durch a1, ... , a6 
	in Weierstrass-Normalform gegebenen elliptischen Kurve. ecgf2sum
	berechnet die Summe P3 der beiden Punkte P1 und P2 und gibt diese 
	als 3-elementige Liste von rationalen Zahlen zurueck: 
	P3 = (x3, y3, z3).
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.59.



			ecgf2tavb6( G, a1, a2, a3, a4, a6 )

	"elliptic curve over Galois-field with characteristic 2, Tate's 
	 values b2, b4, b6"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecgf2tavb6(G, a1, a2, a3, a4, a6)
		obj G;  gf2el a1, a2, a3, a4, a6;
	L = ecgf2tavb6(G, a1, a2, a3, a4, a6);
	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).
		- a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als
		  Polynome in einer Variablen ueber Z/2Z vom Grad < n in
		  spezieller Bit-Notation dargestellt werden.
	ecgf2tavb6 berechnet die Tateschen Groessen b2, b4 und b6 fuer die
	durch die Koeffizienten a1, ... , a6 in Weierstrass-Normalform
	gegebene kubische Kurve und gibt diese als Liste L = (b2, b4, b6) 
	von Elementen aus GF(2^n) in spezieller Bit-Notation zurueck.
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.46.



			ecgf2tavb8( G, a1, a2, a3, a4, a6 )

	"elliptic curve over Galois-field with characteristic 2, Tate's 
	 values b2, b4, b6, b8"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecgf2tavb8(G, a1, a2, a3, a4, a6)
		obj G; gf2el a1, a2, a3, a4, a6;
	L = ecgf2tavb8(G, a1, a2, a3, a4, a6);
	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).
		- a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als
		  Polynome in einer Variablen ueber Z/2Z vom Grad < n in
		  spezieller Bit-Notation dargestellt werden.
	ecgf2tavb8 berechnet die Tateschen Groessen b2, b4, b6 und b8 fuer
	die durch die Koeffizienten a1, ... , a6 in Weierstrass-Normalform
	gegebene kubische Kurve und gibt diese als Liste L = (b2,b4,b6,b8)
	von Elementen aus GF(2^n) in spezieller	Bit-Notation zurueck.
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.46.



			ecgf2tavc6( G, a1, a2, a3, a4, a6 )

	"elliptic curve over Galois-field with characteristic 2, Tate's
	 values c4, c6"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecgf2tavc6(G, a1, a2, a3, a4, a6)
		obj G;  gf2el a1, a2, a3, a4, a6;
	L = ecgf2tavc6(G, a1, a2, a3, a4, a6);
	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).
		- a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als
		  Polynome in einer Variablen ueber Z/2Z vom Grad < n in
		  spezieller Bit-Notation dargestellt werden.
	ecgf2tavc6 berechnet die Tateschen Groessen c4 und c6 fuer die 
	durch die Koeffizienten a1, ... , a6 in Weierstrass-Normalform 
	gegebene kubische Kurve und gibt diese als Liste L = (b2, b4, b6) 
	von Elementen aus GF(2^n) in spezieller Bit-Notation zurueck.
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.46.



			ecimina1( E )

	"elliptic curve with integer coefficients, minimal model, a1"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecimina1(E)  list E;
	a1 = ecimina1(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der 
	elliptischen Kurve E/Q (siehe ecrinit).
	ecimina1 liefert den Koeffizienten a1 des minimalen Modells
	(von eingeschraenktem Typ) der elliptischen Kurve E/Q. Falls
	der Koeffizient a1 noch nicht in E vorhanden ist, wird er
	berechnet und in E abgelegt.
	E wird veraendert.



			ecimina2( E )

	"elliptic curve with integer coefficients, minimal model, a2"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecimina2(E)  list E;
	a2 = ecimina2(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe ecrinit).  
	ecimina2 liefert den Koeffizienten a2 des minimalen Modells
	(von eingeschraenktem Typ) der elliptischen Kurve E/Q. Falls
	der Koeffizient a2 noch nicht in E vorhanden ist, wird er mit
	Hilfe von ecimina1 berechnet und dort abgelegt.
	E wird veraendert.



			ecimina3( E )

	"elliptic curve with integer coefficients, minimal model, a3"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecimina3(E)  list E;
	a3 = ecimina3(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecimina3 liefert den Koeffizienten a3 des minimalen Modells
	(von eingeschraenktem Typ) der elliptischen Kurve E/Q. Falls
	der Koeffizient a3 noch nicht in E vorhanden ist, wird a3 mit
	Hilfe von 'ecimina1' berechnet und dort abgelegt.
	E wird veraendert.



			ecimina4( E )

	"elliptic curve with integer coefficients, minimal model, a4"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecimina4(E)  list E;
	a4 = ecimina4(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrint').  
	ecimina4 liefert den Koeffizienten a4 des minimalen Modells
	(von eingeschraenktem Typ) der elliptischen Kurve E/Q. Falls
	der Koeffizient a4 noch nicht in E vorhanden ist, wird er mit
	Hilfe von 'ecimina1' berechnet und dort abgelegt.
	E wird veraendert.



			ecimina6( E )

	"elliptic curve with integer coefficients, minimal model, a6"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecimina6(E)  list E;
	a6 = ecimina6(E); 
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecimina6 liefert den Koeffizienten a6 des minimalen Modells
	(von eingeschraenktem Typ) der elliptischen Kurve E/Q. Falls
	der Koeffizient a6 noch nicht in E vorhanden ist, wird er mit
	Hilfe von 'ecimina1' berechnet und dort abgelegt.
	E wird veraendert.



			eciminb2( E )

	"elliptic curve with integer coefficients, minimal model, b2"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int eciminb2(E)  list E;
	b2 = eciminb2(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q (siehe ecrinit).
	eciminb2 liefert den Tate'schen Koeffizienten b2 des minimalen
	Modells von eingeschraenktem Typ der elliptischen Kurve E/Q.
	Falls der Wert b2 des minimalen Modells noch nicht in der Liste
	E vorhanden ist, wird er (zusammen mit b4, b6 und b8) berechnet
	und dort abgelegt.
	E wird veraendert.



			eciminb4( E )

	"elliptic curve with integer coefficients, minimal model, b4"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int eciminb4(E)  list E;
	b4 = eciminb4(E);
	eciminb4 liefert den Tate'schen Koeffizienten b4 des minimalen
	Modells von eingeschraenktem Typ der elliptischen Kurve E/Q
	(siehe 'ecrinit').
	Falls der Wert b4 des minimalen Modells noch nicht in der Liste
	E vorhanden ist, wird er (zusammen mit b2, b6 und b8) berechnet
	und dort abgelegt.
	E wird veraendert.



			eciminb6( E )

	"elliptic curve with integer coefficients, minimal model, b6"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int eciminb6(E)  list E;
	b6 = eciminb6(E);
	eciminb6 liefert den Tate'schen Koeffizienten b6 des minimalen
	Modells von eingeschraenktem Typ der elliptischen Kurve E/Q
	(siehe 'ecrinit').
	Falls der Wert b6 des minimalen Modells noch nicht in der Liste
	E vorhanden ist, wird er (zusammen mit b2, b4 und b8) berechnet
	und dort abgelegt.
	E wird veraendert.



			eciminb8( E )

	"elliptic curve with integer coefficients, minimal model, b8"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int eciminb8(E)  list E;
	b8 = eciminb8(E);
	eciminb8 liefert den Tate'schen Koeffizienten b8 des minimalen
	Modells von eingeschraenktem Typ der elliptischen Kurve E/Q
	(siehe 'ecrinit').
	Falls der Wert b8 des minimalen Modells noch nicht in der Liste
	E vorhanden ist, wird er (zusammen mit b2, b4 und b6) berechnet
	und dort abgelegt.
	E wird veraendert.



			eciminbrtmp( E, p, n )

	"elliptic curve with integer coefficients, minimal model,
	bad reduction type modulo prime"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list eciminbrtmp(E, p, n)  list E; int p; single n;
	L = eciminbrtmp(E, p, n)
	Dabei muss gelten:
            - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	      Kurve E/Q (siehe 'ecrinit'),
            - p eine Primzahl groesser als 3,
            - p^n ist die hoechste p-Potenz, die in der Diskriminante 
	      des minimalen Modells der elliptischen Kurve E/Q aufgeht.
	Rueckgabe:
	    - bei fehlerhaftem Lauf die einelementige Liste ( -1 )
            - bei erfolgreichem Lauf die dreielementige Liste 
	          ( exp  rtyp  cp )  single exp, rtyp, cp;
	      mit dem Exponenten 'exp' des (lokalen) Fuehrers, 
              dem Reduktionstyp 'rtyp' gemaess der Tabelle in der
	      Dokumentation zu 'ecimintatealg' und dem c_p-Wert 
	      cp = #[E(Q)/E_0(Q)] (s.a. 'ecimintatealg').



			eciminbtac( E )

	"elliptic curve with integer coefficients, minimal model,
        birational transformation to actual ( rational ) model"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list eciminbtac(E)  list E;
	BTmr = eciminbtac(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q (siehe ecrinit). 
	eciminbtac liefert die 4-elemenetige Liste 
	       BTmr = ( r  s  t  u )  rat r, s, t, u;
	mit der birationalen Transformation ( r  s  t  u ) vom
	minimalen Modell von eingeschraenktem Typ zum rationalen
	(tatsaechlichen) Modell von E/Q. Falls die birationale
	Transformation BTmr noch nicht in E vorhanden ist, wird sie
	berechnet und dort abgelegt.
	E wird veraendert.



			eciminbtco( E, BT )

	"elliptic curve with integer coefficients, minimal model,
	birational transformation of coefficients"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list eciminbtco(E, BT)  list E, BT;
	L = eciminbtco(E, BT);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit') und
	BT = ( r  s  t  u ) rat r, s, t, u, mit u != 0.
	Das minimale Modell von E/Q wird durch BT birational transformiert.
	eciminbtco liefert eine durch 'ecrinit' erzeugte Liste L (siehe
	Dokumentation von 'ecrinit') mit den Daten des transformierten
	Modells.
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.49.



			eciminbtsnf( E )

	"elliptic curve with integer coefficients, minimal model,
        birational transformation to short normal form"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list eciminbtsnf(E)  list E;
	BTms = eciminbtsnf(E);
	Dabei ist E seine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	eciminbtsnf liefert die 4-elemenetige Liste 
	       BTms = ( r  s  t  u )  rat r, s, t, u;
	mit der birationalen Transformation ( r, s, t, u ) vom
	minimalen Modell zum Modell in kurzer WNF von E/Q. Falls die
	birationale Transformatin BTms noch nicht in E vorhanden ist,
	so wird sie berechnet und dort abgelegt.
	E wird veraendert.



			eciminc4( E )

	"elliptic curve with integer coefficients, minimal model, c4"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int eciminc4(E)  list E;
	c4 = eciminc4(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q (siehe ecrinit).
	eciminc4 liefert den Tateschen Koeffizienten c4 des minimalen
	Modells (von eingeschraenktem Typ) der elliptischen Kurve E/Q.
	Falls der Wert c4 des minimalen Modells noch nicht in der Liste
	E vorhanden ist, wird er berechnet und dort abgelegt.
	E wird veraendert.



			eciminc6( E )

	"elliptic curve with integer coefficients, minimal model, c6"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int eciminc6(E)  list E;
	c6 = eciminc6(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	eciminc6 liefert den Tateschen Koeffizienten c6 des minimalen
	Modells (von eingeschraenktem Typ) der elliptischen Kurve E/Q.
	Falls der Wert c6 des minimalen Modells noch nicht in der Liste
	E vorhanden ist, wird er berechnet und dort abgelegt.
	E wird veraendert.



			ecimindif( E, P, Q )

        "elliptic curve with integer coefficients, minimal model,
	difference of points"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecimindif(E, P, Q)  list E, P, Q;
        S = ecimindif(E, P, Q);
	Dabei muss gelten:
	  - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe 'ecrinit').
	  - P = ( xP  yP  zP )  int xP, yP, zP;  und 
	    Q = ( xQ  yQ  zQ )  int xQ, yQ, zQ;  
	    sind zwei Punkte auf dem minimalen Modell (von eingeschraenktem 
	    Typ) von E/Q.
	Rueckgabe: S = P + (-Q) = P - Q.



			ecimindisc( E )

	"elliptic curve with integer coefficients, minimal model, 
	discriminant"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecimindisc(E)  list E;
	D = ecimindisc(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q. (siehe ecrinit).
	ecimindisc liefert die Diskriminante D des minimalen Modells
	von eingeschraenktem Typ der elliptischen Kurve E/Q.
	Falls die Diskriminante D des minimalen Modells noch nicht in
	der Liste E vorhanden ist, wird sie berechnet und dort
	abgelegt.
	E wird veraendert.



			ecimindiv( E, P, n )

	"elliptic curve with integer coefficients, minimal model,
	division of a point by an integer"
        Quellbibliothek: srclib.ec2
        Include-Datei:   _ec2.h
        list ecimindiv(E, P, h, n) list E, P;  floating h; single n;
        Q = ecimindiv(E, P, h, n);
	ecimindiv versucht den Punkt P durch n zu dividieren, 
	d.h. einen Punkt Q auf E zu finden mit P = n * Q.
	Dabei muss gelten:
	 - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	   Kurve E/Q (s. 'ecrinit').
	 - P = ( x  y  z ) int x, y, z; ist ein Punkt auf dem
	   durch die Liste E gegebenen minimalen Modell von E/Q
	 - h > 0 ist die Neron-Tate-Hoehe von P
	 - n != 0.
	Rueckgabe: Q = ( xQ  yQ  zQ ), falls P = n * Q ist,
                   Q = ( 0 ), falls P nicht durch n teilbar ist
		   ERROR sonst.



			ecimindivby2( E, P, h, PL, H )

	"elliptic curve with integer coefficients, minimal model,
	division by 2 of a point"
        list ecimindivby2(E, P, h, PL, H)  list E, P, *PL;  floating h, *H;
        L = ecimindivby2( E, P, h, &PL, &H );
	Dabei muss gelten:
	 - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	   Kurve E/Q (siehe ecrinit).
	 - P = ( x  y  z )  int x, y, z; ist ein Punkt auf dem
	   durch die Liste E gegebenen minimalen Modell von E/Q.
	 - h > 0 ist die Neron-Tate-Hoehe von P.
	 - *PL ist eine Liste von Paaren ( P1  h1   P2  h2 ... Pn  hn )
	   mit Pi = ( xi  yi  zi )  int xi, yi, zi; floating hi;
	   (1 <= i <= n). Es gilt h1 < h2 < ... < hn.
	 - *H >= 0.
	ecimindivby2 versucht den Punkt P (modulo Torsion) durch 2 zu 
	dividieren, d.h. einen Punkt Q in der Punktliste PL zu finden mit 
	P + T = 2 * Q = Q + Q, T Torsionspunkt.
	Rueckgabe: Q = ( xQ  yQ  zQ ), falls P + T = 2 * Q = Q + Q ist,
		       T Torsionspunkt auf E/Q.
                   Q = ( 0 ), falls P + T nicht durch 2 teilbar ist
		       (fuer alle Torsionspunkte T auf E/Q).



			ecimindivs( E, P, h, ug, PL, n )

	"elliptic curve with integer coefficients, minimal model,
	division of a point by an integer, special version"
        Quellbibliothek: srclib.ec2 
	Include-Datei:   _ec2.h
	list ecimindivs(E, P, h, ug, PL, n)  
		list E, P, *PL;  floating h, *ug; single n;
        Q = ecimindivs(E, P, h, ug, PL, n);
	ecimindivs versucht den Punkt P (modulo Torsion) durch n zu 
	dividieren, d.h. einen Punkt Q auf E zu finden mit
	P + T = n * Q, T Torsionspunkt.
	Dabei muss gelten:
	 - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	   Kurve E/Q (s. 'ecrinit').
	 - P = ( x  y  z ) int x, y, z; ist ein Punkt auf dem
	   durch die Liste E gegebenen minimalen Modell von E/Q
	 - h > 0 ist die Neron-Tate-Hoehe von P
	 - ug ist ein Zeiger auf ein floating Zahl, *ug >= 0. 
	 - PL ist ein Zeiger auf eine Liste. *PL enthaelt alle bisher
	   gefundenen Punkte mit Weil-Hoehe <= *ug (siehe 'ecisnfpbwh'). 
	 - n != 0.
	Rueckgabe: Q = ( xQ  yQ  zQ ), falls P = n * Q ist,
                   Q = ( 0 ), falls P + T nicht durch n teilbar ist
		   ERROR sonst.



			ecimindouble( E, P )

        "elliptic curve with integer coefficients, minimal model,
	double of a point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecimindouble(E, P)  list E, P;
        D = ecimindouble(E, P);
	Dabei muss gelten:
	 - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	   Kurve E/Q (siehe 'ecrinit').
	 - P = ( xP  yP  zP ) int xP, yP, zP; ist ein Punkt auf dem
	   minimalen Modell (von eingeschraenktem Typ) von E/Q.
        ecimindouble berechnet die Punktsumme
		D = 2 * P = P + P 
	auf dem minimalen Modell der elliptischen Kurve E/Q.
	Rueckgabe: D = ( xD  yD  zD ) int xD, yD, zD;



			ecimindwhnth( E )

	"elliptic curve with integer coefficients, minimal model,
	difference between Weil height and Neron-Tate height"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	floating ecimindwhnth(E)  list E;
	d = ecimindwhnth(E);
        ecimindwhnth liefert eine obere Grenze d fuer die Differenz 
	zwischen der Weil-Hoehe d( P ) und der Neron-Tate-Hoehe h(P)
	auf der durch die Liste E gegebenen elliptischen Kurve E/Q, 
	d.h. fuer einen beliebigen Punkt P auf dem minimalen Modell
	von E/Q gilt | h(P) - d(P) | < d.
        Falls die Grenze d noch nicht in der Liste E vorhanden ist,
	so wird sie berechnet und dort abgelegt.
	E wird veraendert.
	Literatur: J.H. Silverman, "The Difference between the Weil
	   Height and the Canonical Height on Elliptic Curves",
	   Math. Comp. Vol 55, No. 192, pp 723-743, 1990.



			eciminfdisc( E )

	"elliptic curve with integer coefficients, minimal model,
	factorization of discriminant"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list eciminfdisc(E)  list E;
	F = eciminfdisc(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	eciminfdisc liefert eine Liste 
	      F = ( p_1  e_1  p_2  e_2 ...  p_n  e_n ) 
	      int p_1, p_2, ..., p_n; single e_1, e_2, ..., e_n;
	mit der vollstaendigen (Prim-) Faktorisierung des Betrags der
	Diskriminanten D des minimalen Modells der elliptischen Kurve E/Q.
		   ----      (e_i)
	       D =  ||  (p_i)
	          1<=i<=n
	Falls dir Liste F noch nicht in der Liste E vorhanden ist, wird
	sie berechnet und dort abgelegt.
	E wird veraendert.



			ecimingentor( E )

        "elliptic curve with integer coefficients, minimal model,
	generators of torsion group"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecimingentor(E)  list E;
	L = ecimingentor(E);
	Dabei ist E eine Liste mit allen wichtigen daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	ecimingentor liefert eine Liste
	  ( P ) mit einem Erzeuger P = ( xP  yP  zP ) int xP, yP, zP;
		der Torsionsgruppe, falls diese zyklisch ist,
	oder eine Liste
	  ( P  Q ) mit zwei Erzeugern P = ( xP  yP  zP ) int xP, yP, zP;
		Q = ( xQ  yQ  zQ ) int xQ, yQ, zQ; der Torsionsgruppe,
		falls diese bizyklisch ist,
	Falls ein Erzeugendensystem der Torsionsgruppe des minimalen
	Modells (von eingeschraenktem Typ) von E/Q noch nicht in E 
	vorhanden ist, wird es (mit Hilfe der Funktion 'ecisnfgentor') 
	berechnet und dort abgelegt.
	E wird veraendert.



			eciminlhaav( E, P )

	"elliptic curve with integer coefficients, minimal model,
	local height at the archimedean absolute value"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	floating eciminlhaav(E, P)  list E, P;
	lambda = eciminlhaav(E, P);
	Dabei gilt:
	 - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	   Kurve E/Q (siehe 'ecrinit').
	 - P = ( x  y  z ) int x, y, z; ist ein Punkt auf dem minimalen 
	   Modell (von eingeschraenktem Typ) der elliptischen Kurve E/Q:
                    /  /  x       y  \
                   /  | ----- , ----- | , falls z != 0,
             P =  {    \ z^2     z^3 /   
		   \
                    \  O = ( 0 : 1 : 0 ), falls z == 0.
	eciminlhaav berechnet die lokale Neron-Tate-Hoehe von P bzgl. 
	der archimedischen Bewertung von Q (also bzgl. des gewoehnlichen
	Absolutbetrags) mit einem Fehler der Groessenordnung 
	O( 4^{-NTH_EPS} ), (default: NTH_EPS = 20, siehe '_ec1.h').
	E wird veraendert.
	Literatur: J.H. Silverman: Math. of Comp., 51, 1988, p.339-350.



			eciminlhnaav( E, P )

	"elliptic curve with integer coefficients, minimal model,
	local heights at all non archimedean absolute values"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	floating ecminlhnaav(E, P)  list P, Q;
	lambda = ecminlhnaav( E, P, L );
	Dabei muss gelten:
	- E ist eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	- P = ( x  y  z ) int x, y, z; 
	  ist ein Punkt auf dem durch die Liste E in gegebenen 
	  minimalen Modell (von eingeschraenktem Typ) der elliptischen 
	  Kurve E/Q.
	Literatur: J.H. Silverman: Math. of Comp., 51, 1988, p.351-358.



			eciminmrtmp( E, p )

	"elliptic curve with integer coefficients, minimal model, 
	multiplicative reduction type modulo prime"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single eciminmrtmp(E, p)  list E; int p;
	n = eciminmrtmp(E, p);
	Dabei muss gelten:
	  - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe 'ecrinit').
	  - p ist eine Primzahl, bzgl. der E/Q multiplikative
	    Reduktion (einen Knoten in singulaeren Punkt) hat.
	Rueckgabe:
	   bei fehlerhaftem Verlauf ERROR, 
	   sonst:  1, falls die multiplikative Reduktion bei p
	              zerfallend ist,
	          -1, falls die multiplikative Reduktion bei p
	              nicht-zerfallend ist.
        Literatur: J. H. Silverman: The Arithmetic of Elliptic 
		                    Curves (Springer)



			eciminmul( E, P, n )

	"elliptic curve with integer coefficients, minimal model,
	multiplication-map"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list eciminmul(E, P, n)  list E, P; single n;
	Q = eciminmul(E, P, n)
	Dabei muss gelten:
	  - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe 'ecrinit').
	  - P = ( x  y  z ) int x, y, z; ist ein Punkt auf dem durch E
	    gegebenen minimalen Modell (von eingeschraenktem Typ von E/Q.
        eciminmul berechnet das n-fache n * P = P + ... + P (n-mal)
	des Punkts P auf dem minimalen Modell von E/Q.



			eciminmwgbase( E )

	"elliptic curve with integer coefficients, minimal model,
	Mordell-Weil-group, base"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list eciminmwgbase(E)  list E;
	B = eciminmwgbase( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q (siehe 'ecrinit').
        eciminmwgbase bestimmt eine Basis 
	  B = ( P1  h1  P2  h2  ...  Pr  hr ); list P1, P2, ..., Pr; 
					       floating h1, h2, ..., hr; 
	der Mordell-Weil-Gruppe des minimalen Modells von E/Q mit
	den Basispunkten
	  Pi = ( xi  yi  zi ) int xi, yi, zi; ( 1 <= i <= r ),
        und deren jeweiliger Neron-Tate-Hoehe hi. 
	Dabei ist r der Rang von E/Q.
	Rueckgabe: bei korrektem Lauf: Liste B
	           sonst: -1.



			eciminneg( E, P )

        "elliptic curve with integer coefficients, minimal model,
	negative point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list eciminneg(E, P)  list E, P;
        N = eciminneg(E, P);
	Dabei muss gelten:
	  - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe ecrinit).
	  - P = ( x  y  z )  int x, y, z; ist ein Punkt auf dem minimalen 
	    Modell (von eingeschraenktem Typ) der elliptischen Kurve E/Q.
	eciminneg berechnet den Punkt N = -P,
	d.h. P + N = O = ( 0 : 1 : 0 ). 
        Rueckgabe: 
	     ( 0  1  0 ), falls P = ( 0  1  0 ),
             ( x  y'  z ) mit y' = -( y + a1 * x * z + a3 * z^3 ), sonst.



			eciminnetahe( E, P )

        "elliptic curve with integer coefficients, minimal model,
	Neron-Tate height"
        Quellbibliothek: srclib.ec1
        Include-Datei:   _ec1.h
	floating eciminnetahe(E, P)  list E, P;
	lambda = eciminnetahe(E, P);
	Dabei muss gelten:
            - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	      Kurve E/Q (siehe 'ecrinit').
            - P = ( x  y  z ), int x, y, z;  
	      stellt einen Punkt auf dem minimalen Modell (von
	      eingeschraenktem Typ) von E/Q dar.
        eciminnetahe berechnet die Neron-Tate Hoehe von P auf NTH_EPS
	(s. <_ec1.h> und 'eciminntheps') Dezimalstellen genau.
        Literatur: J.H. Silverman: Math. of Comp., 51, 1988, p.339-358.



			eciminnetapa( E, P, Q )

	"elliptic curve with integer coefficients, minimal model,
	Neron-Tate pairing"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	floating eciminnetapa(E, P, Q)  list E, P, Q;
	f = eciminnetapa(E, P, Q);
	Dabei muss gelten:
	  - E ist eine Liste mit llen wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe 'ecrinit').
	  - P = ( xP  yP  zP )  int xP, yP, zP;
	    Q = ( xQ  yQ  zQ )  int xQ, yQ, zQ;
            sind Punkte auf dem minimalen Modell (von eingeschraenktem Typ) 
	    von E/Q.
        eciminnetapa berechnet das Neron-Tate Pairing 
	    f = [ h( P + Q ) - h( P ) - h( Q ) ] / 2
	      = [ h( P + Q ) + h( P - Q ) ] / 4
	der Punkte P und Q auf NTH_EPS Dezimalstellen genau. 
	Dabei ist h( ) die Neron-Tate Hoehe (siehe 'eciminnetahe').



			eciminntheps( E, d )

	"elliptic curve with integer coefficients, minimal model, 
	set NTH_EPS"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	floating eciminntheps(E, d)  list E; single d;
	NTH_EPS_alt = eciminntheps(E, d);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe ecrinit).
	eciminntheps berechnet die Anzahl der Iterationen, die
	'eciminlhaav' braucht, um die lokale Neron-Tate-Hoehe eines
	Punkts bzgl. der archimedischen Bewertung von Q mit einem
	Fehler der Groessenordnung O( 4^[-d] ) zu approximieren.
	Es wird das bisherige NTH_EPS zurueckgegeben.
	E wird veraendert.
	Literatur: J.H. Silverman: Math. of Comp., 51, 1988, p.339-350.



			eciminpcompmt( E, P1, P2 )

	"elliptic curve with integer coefficients, minimal model,
	point comparison modulo torsion"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
        single eciminpcompmt(E, P1, P2)  list E, P1, P2;
        s = eciminpcompmt(E, P1, P2);
	Dabei muss gelten: 
	 - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	   Kurve E/Q (siehe 'ecrinit').
	 - P1 = ( x1  y1  z1 ) int x1, y1, z1;
           P2 = ( x2  y2  z2 ) int x2, y2, z2;
           sind zwei normierte Punkte auf dem durch die Liste E gegebenen 
	   minimlalen Modell (siehe Dokumentation zu 'ecrpnorm').
	Rueckgabe:
	    1, falls P1 = P2 ist,  i.e. x1 == x2, y1 == y2, z1 == z2,
	   -1, falls P1 = -P2 ist, i.e. x1 == x2, y1 != y2, z1 == z2,
	    2, falls P1 = +/-P2 + T (Torsionspunkt != O) ist, i.e. 
	       P1 != +/- P2 und h( P1 ) == h( P2 ), h Neron-Tate-Hoehe.
            0, sonst.
        Es gilt also: s != 0  <==>  h( P1 ) != h( P2 ).



			eciminplinsp( P, h, PL )

	"elliptic curve with integer coefficients, minimal model,
	point list, insert point"
        Quellbibliothek: srclib.ec1
        Include-Datei:   _ec1.h
        eciminplinsp(P, h, PL)  list P, *PL; floating h;
        n = eciminplinsp(P, h, PL);
	Es muss gelten: P = ( x  y  z )  int x, y, z; floating h;
	PL ist ein Zeiger auf eine Liste
	    	( P1  h1  P2  h2  ...  Pn  hn )
	mit list Pi = ( xi  yi  zi )  int xi, yi, zi; floating hi;
	Es gilt h1 <= h2 <= ... <= hn.
	Das Paar ( P  h ) wird derart in die Liste *PL eingefuegt, dass
	   h1 <= h2 <= ... <= hi <= h <= h(i+1) <= ... <= hn  gilt. 
        *PL wird veraendert zu
	   ( P1  h1  ...  Pi  hi  P  h  P(i+1)  h(i+1)  ...  Pn  hn ).
	Rueckgabe: n = 0.



			eciminplunion( E, L1, L2, modus )

        "elliptic curve with integer coefficients, minimal model,
	point list union"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
        list eciminplunion(E, L1, L2, modus)  list E, L1, L2; single modus;    
        L = eciminplunion( E, L2, L1, modus );
	Dabei muss gelten:
	 - E ist eine Liste mit allen wichtigen Daten der
	   elliptischen Kurve E/Q (siehe ecrinit).
	 - L1 und L2 sind zwei Punktlisten (vgl. eciminplinsp).
	   L1 muss nach aufsteigenden Neron-Tate-Hoehen geordnet sein.
        eciminplunion bildet die Vereinigung L der beiden Listen L1 
	und L2, wobei L wieder nach aufsteigenden Neron-Tate-Hoehen 
	geordnet ist. 
	Falls modus = 0, so ist L = L1 U L2. 
	Falls modus != 0, so enthaelt L nur Punkte, deren
	Neron-Tate-Hoehe ungleich 0 und ungleich der Neron-Tate-Hohe
	aller anderen Punkte der Liste L ist.



			eciminredtype( E )

	"elliptic curve with integer coefficients, minimal model, 
	reduction type"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list eciminredtype(E)  list E;
	Ntr = eciminredtype(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	eciminredtype liefert 
	  - bei korrektem Lauf eine Liste Ntr = ( p1  t1 ... pn  tn ),
	    wobei die pi alle Primzahlen sind, bzgl. derer E/Q
	    schlechte Reduktion hat, und die ti den zugehoerigen
	    Reduktionstyp nach Neron bzw. Kodaira gemaess der
	    Tabelle in 'ecitatealg' angeben.
          - ERROR sonst,
        Falls die Liste Ntr noch nicht in der Liste E vorhanden ist, so 
	sie wird mit Hilfe von 'ecrcond' berechnet und dort abgelegt.
	E wird veraendert.



			eciminreg( E, LP, n, modus )

	"elliptic curve with integer coefficients, minimal model, 
	 regulator"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	floating eciminreg(E, LP, n, modus)  list E, LP;  single n, modus;
	H = eciminreg(E, LP, n, modus);
	Dabei muss gelten:
	  - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe ecrinit).
	  - Falls modus != 0, so ist 
	       LP = ( P1  h1  ...  Pn  hn )  list P1, ..., Pn; 
					 floating h1, ..., hn;
	    eine Liste von n Punkten Pi = ( xi  yi  zi )  int xi, yi, zi;
	    mit den zugehoerigen Neron-Tate-Hoehen hi auf E/Q.
	    Falls modus == 0, so ist 
	       LP = ( P1  h1  ...  Pn  hn )  list P1, ..., Pn; 
            mit Pi wie oben.
	  - LP = ( P1  P2  ...  Pn )  list P1, P2, ..., Pn; ist eine 
	    Liste von n Punkten Pi = ( xi  yi  zi )  int xi, yi, zi;
	    auf E/Q.
          - n > 0.
        eciminreg bestimmt den Regulator 
		H = | Det( ( h( Pi, Pj ) )i,j=1,...,n ) |
	der Punkte P1, ..., Pn auf NTH_EPS (siehe _ec1.h oder eciminntheps)
	Dezimalstellen genau.
	Dabei ist h( , ) die Neron-Tate Paarung (siehe eciminnetapa).
	Rueckgabe: bei korrektem Lauf: Regulator H >= 0
	           sonst: -1.



			eciminsum( E, P, Q )

        "elliptic curve with integer coefficients, minimal model,
	sum of points"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list eciminsum(E, P, Q)  list E, P, Q;
        S = eciminsum(E, P, Q);
	Dabei muss gelten:
	  - E ist eine Liste mit llen wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe 'ecrinit').
	  - P = ( xP  yP  zP )  int xP, yP, zP;  und 
	    Q = ( xQ  yQ  zQ )  int xQ, yQ, zQ;  
	    sind zwei Punkte auf dem minimalene Modell (von eingeschraenktem 
	    Typ) von E/Q.
	Rueckgabe: S = P + Q.



			ecimintatealg( E, p, n )

	"elliptic curve with integer coefficients, minimal model,
	Tate's algorithm"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecimintatealg(E, p, n)  list E; single n;
	L = ecimintatealg(E, p, n);
	Dabei muss gelten:
          - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe 'ecrinit').
          - p ist eine Primzahl,
          - p^n ist die hoechste p-Potenz, die in der Diskriminante des
	    minimalen Modells der elliptischen Kurve E/Q aufgeht.
	ecimintatealg berechnet nach dem Tateschen Algorithmus 
	  - den Reduktionstyp der Kurve E modulo p,
	  - den Exponenten des Fuehrers von E bei p,
	  - den c_p-Wert von E modulo p
	fuer alle Primzahlen p, die die Diskriminante des minimalen 
	Modells teilen
	ecimintatealg liefert:
          - bei fehlerhaftem Lauf eine einelementige Liste mit
            dem Eintrag -1;
          - bei korrektem Lauf eine dreielementige Liste
              ( exp  rtyp  c_p ) single exp, rtyp, c_p;
            mit
              * dem Exponenten exp des Fuehrers
	      * dem Reduktionstyp rtyp gemaess der folgenden Tabelle
                      | rtyp   | Kodaira | Neron  |  c_p-Wert   | 
                      |--------|---------|--------|-------------|
                      | -n < 0 |    In   |   Bn   | 1, 2 oder n |
                      |--------|---------|--------|-------------|
                      |    1   |    II   |   C1   |      1      |
                      |--------|---------|--------|-------------|
                      |    2   |   III   |   C2   |      2      |
                      |--------|---------|--------|-------------|
                      |    3   |    IV   |   C3   |   1 oder 3  |
                      |--------|---------|--------|-------------|
                      |    5   |    I0*  |   C4   |   2 oder 4  |
                      |--------|---------|--------|-------------|
                      | 10 + v |    In*  |  C5,v  |   2 oder 4  |
                      |--------|---------|--------|-------------|
                      |    6   |    IV*  |   C6   |   1 oder 3  |
                      |--------|---------|--------|-------------|
                      |    7   |   III*  |   C7   |      2      |
                      |--------|---------|--------|-------------|
                      |    8   |    II*  |   C8   |      1      |
                      -------------------------------------------
              * dem Wert c_p = #E(Q)/E0(Q), wobei 
	           E0( Q ) = { P in E( Q ) | P = ( 0 : 1 : 0 ) mod p },
	                      /          | P wird unter der Reduktion \
	                   = < P in E(Q) | modulo p auf den unendlich  >
		              \          | fernen Punkt abgebildet.   /
	Literatur: Tate, J.T.: Algorithm for finding the type of a
			       singular fiber in an elliptic pencil.
		   Modular functions in one variable IV. Antwerp 1972.
		   Lect. Notes Math. 476 ( 1975 ), 33 - 52.



			ecimintorgr( E )

        "elliptic curve with integer coefficients, minimal model,
	torsion group"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecimintorgr(E)  list E;
	L = ecimintorgr(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe Dokumentation von 'ecrinit').
	ecimintorgr liefert eine Liste
	    ( T_1  ...  T_t ) list T_1, ...,T_t;
        mit allen Torsionspunkten
	    T_i = ( x_i  y_i  z_i ) int x_i, y_i, z_i;    (1 <= i <= t) 
        des minimalen Modells von eingeschraenktem Typ fuer E/Q. 
	Falls die Torsionsgruppe des minimalen Modells noch nicht
	in E vorhanden ist, wird sie berechnet und dort abgelegt.
	E wird veraendert.



			ecimintosnf( E )

	"elliptic curve with integer coefficients, minimal model
	to short normal form"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecimintosnf(E)  list E;
	L = ecimintosnf(E);
        Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe Dokumentation zu 'ecrinit').
	ecimintosnf liefert eine 3-elementige Liste 
	        L = ( a4s  a6s  BTms ) int a4s, a6s; list BTms;
	mit den Koeffizienten a4s und a6s eines Modells fuer E/Q 
	in kurzer Weierstrassnormalform und der birationalen 
	Transformation 
		 BTms = ( r  s  t  u )  rat r, s, t, u;,
	die das minimale Modell (von beschraenktem Typ) in kurze WNF 
	ueberfuehrt.
        E wird veraendert.



			ecipnorm( P )

	"elliptic curve with integer coefficients, point normalization"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecipnorm(P); list P;
	Q = ecipnorm(P); 
	Es muss gelten: P ist ein Punkt auf einer elliptischen Kurve 
	E/Q mit   g a n z e n   Koeffizienten a1, a2, a3, a4, a6.
	ecipnorm normiert den Punkt P = ( x  y  z ) int x, y, z;
	nach folgenden Regeln:
	  1. z >= 0
	  2. gcd(x, z) = gcd(y, z) = 1.
	Diese Darstellung existiert wegen der Ganzheit der Koeffizienten
	der elliptischen Kurve und ist eindeutig.
	Rueckgabe: Liste ( x  y  z ).



			ecisnfa4( E )

	"elliptic curve with integer coefficients, short normal form, a4"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecisnfa4(E)  list E;
	a4 = ecisnfa4(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
        ecisnfa4 liefert den Koeffizienten a4 des Modells in kurzer WNF
        der elliptischen Kurve E/Q. Falls der Koeffizient a4 des
        Modells in kurzer WNF noch nicht in E vorhanden ist, wird er
        berechnet und dort abgelegt.
	E wird veraendert.



			ecisnfa6( E )

	"elliptic curve with integer coefficients, short normal form, a6"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecisnfa6(E)  list E;
	a6 = ecisnfa6(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecisnfa6 liefert den Koeffizienten a6 des Modells in kurzer WNF
	der elliptischen Kurve E/Q. Falls der Koeffizient a6 des
	Modells in kurzer WNF noch nicht in E vorhanden ist, wird er
	berechnet und dort abgelegt.
	E wird veraendert.



			ecisnfb2( E )

	"elliptic curve with integer coefficients, short normal form, b2"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecisnfb2(E)  list E;
	b2 = ecisnfb2(E);
	ecisnfb2 liefert den Tateschen Koeffizienten b2 des Modells in
	kWNF der elliptischen Kurve E/Q (siehe 'ecrinit').
	Falls der Wert b2 des Modells in kWNF noch nicht in der Liste E
	vorhanden ist, wird er berechnet und dort abgelegt.
	E wird veraendert.



			ecisnfb4( E )

	"elliptic curve with integer coefficients, short normal form, b4"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecisnfb4( E ) list E;
	b4 = ecisnfb4( E );
        ecisnfb4 liefert den Tateschen Koeffizienten b4 des Modells in
        kWNF der elliptischen Kurve E/Q (siehe 'ecrinit').
        Falls der Wert b4 des Modells in kWNF noch nicht in der Liste E
        vorhanden ist, wird er berechnet und dort abgelegt.
	E wird veraendert.



			ecisnfb6( E )

	"elliptic curve with integer coefficients, short normal form, b6"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecisnfb6(E)  list E;
	b6 = ecisnfb6(E);
	ecisnfb6 liefert den Tateschen Koeffizienten b6 des Modells in
	kWNF der elliptischen Kurve E/Q (siehe 'ecrinit').
	Falls der Wert b6 des Modells in kWNF noch nicht in der Liste E
	vorhanden ist, wird er berechnet und dort abgelegt.
	E wird veraendert.



			ecisnfb8( E )

	"elliptic curve with integer coefficients, short normal form, b8"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecisnfb8(E)  list E;
	b8 = ecisnfb8(E);
	ecisnfb8 liefert den Tateschen Koeffizienten b8 des Modells in
	kWNF der elliptischen Kurve E/Q (siehe 'ecrinit').
	Falls der Wert b8 des Modells in kWNF noch nicht in der Liste E
	vorhanden ist, wird er berechnet und dort abgelegt.
	E wird veraendert.



			ecisnfbtac( E )

	"elliptic curve with integer coefficients, short normal form,
        birational transformation to actual ( rational ) model"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecisnfa4(E)  list E;
	BTsr = ecisnfbtac(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe ecrinit).
	ecisnfbtac liefert die 4-elemenetige Liste 
	       BTsr = ( r  s  t  u )  rat r, s, t, u;
	mit der birationalen Transformation ( r, s, t, u ) vom Modell
	in kurzer WNF zum rationalen (tatsaechlichen) Modell von E/Q.  
	Falls die birationale Transformation BTsr noch nicht in E vor-
	handen ist, so wird sie berechnet und dort abgelegt.
	E wird veraendert.



			ecisnfbtco( E, BT )

	"elliptic curve with integer coefficients, short normal form,
	birational transformation of coefficients"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecisnfbtco(E, BT)  list LC, BT;
	L = ecisnfbtco(E, BT);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit') und
	BT = ( r  s  t  u )  rat r, s, t, u; mit u != 0.
	Das Modell in kurzer WNF von E/Q wird durch BT birational
	transformiert.
	ecisnfbtco liefert eine durch 'ecrinit' erzeugte Liste L
	(siehe Dokumentation von 'ecrinit') mit den Daten des
	transformierten Modells.



			ecisnfbtmin( E )

	"elliptic curve with integer coefficients, short normal form,
        birational transformation to minimal model"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecisnfa4(E)  list E;
	BTsm = ecisnfbtmin(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	ecisnfbtmin liefert die 4-elemenetige Liste 
	       BTsm = ( r  s  t  u )  rat r, s, t, u;
	mit der birationalen Transformation ( r, s, t, u ) vom Modell
	in kurzer WNF zum minimalen Modell (von eingeschraenktem Typ)
	fuer E/Q. Falls die birationale Transformatin BTsm noch nicht
	in E vorhanden ist, wird sie berechnet und dort abgelegt.
	E wird veraendert.



			ecisnfc4( E )

	"elliptic curve with integer coefficients, 
	 short normal form, c4"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecisnfc4(E)  list E;
	c4 = ecisnfc4(E);
        ecisnfc4 liefert den Tateschen Koeffizienten c4 des Modells in
        kWNF der elliptischen Kurve E/Q (siehe 'ecrinit').
        Falls der Wert c4 des Modells in kWNF noch nicht in der Liste E
        vorhanden ist, wird er berechnet und dort abgelegt.
	E wird veraendert.



			ecisnfc6( E )

	"elliptic curve with integer coefficients, short normal form, c6"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecisnfc6(E)  list E;
	c6 = ecisnfc6(E);
        ecisnfc6 liefert den Tateschen Koeffizienten c6 des Modells in
        kWNF der elliptischen Kurve E/Q (siehe 'ecrinit').
        Falls der Wert c6 des Modells in kWNF noch nicht in der Liste E
        vorhanden ist, wird er berechnet und dort abgelegt.
	E wird veraendert.



			ecisnfdif( E, P, Q )

        "elliptic curve with integer coefficients, minimal model,
	difference of points"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecisnfdif(E, P, Q)  list E, P, Q;
        S = ecisnfdif(E, P, Q);
	Dabei muss gelten:
	  - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe 'ecrinit').
	  - P = ( xP  yP  zP )  int xP, yP, zP;  und 
	    Q = ( xQ  yQ  zQ )  int xQ, yQ, zQ;  
	    sind zwei Punkte auf dem durch die List E gegebenen 
	    Modell in kurzer WNF von E/Q.
	Rueckgabe: S = P + (-Q) = P - Q.



			ecisnfdisc( E )

	"elliptic curve with integer coefficients, short normal form, 
	discriminant"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecisnfdisc(E)  list E;
	D = ecisnfdisc(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe ecrinit).
	ecisnfdisc liefert die Diskriminante des Modells in kurzer WNF
	der elliptischen Kurve E/Q.
	Falls die Diskriminante des Modells in kurzer WNF noch nicht in
	der Liste E vorhanden ist, so wird sie dort berechnet und dort
	abgelegt.
	E wird veraendert.



			ecisnfdouble( E, P )

        "elliptic curve with integer coefficients, short normal form,
	double of point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecisnfdouble(E, P)  list E, P;
        D = ecisnfdouble(E, P);
	Dabei gilt
	 - E ist eine Liste mit allen wichtigen Daten der elliptischen
	   Kurve E/Q (siehe 'ecrinit').
	 - P = ( x  y  z ) int x, y, z;
	   ist ein Punkt auf dem Modell in kWNF von E/Q.
        ecisnfdouble berechnet dei Punktsumme 
			    D = 2 * P = P + P 
        auf dem Modell in kWNF der elliptischen Kurve E/Q, die durch die 
	Koeffizienten in E gegeben ist.
	Rueckgabe: D = ( xD  yD  zD ) int xD, yD, zD;



			ecisnfdwhnth( E )

	"elliptic curve with integer coefficients, short normal form,
	difference between Weil height and Neron-Tate height"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	floating ecisnfdwhnth(E)  list E;
	d = ecisnfdwhnth(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q (siehe ecrinit).
        ecisnfdwhnth liefert eine obere Grenze d fuer die Differenz 
	zwischen der Weil-Hoehe d(P) und der Neron-Tate-Hoehe h(P)
	auf der durch die Liste E gegebenen elliptischen Kurve E/Q, 
	d.h. fuer einen beliebigen Punkt P auf dem minimalen Modell
	von E/Q gilt | h(P) - d(P) | < d.
        Falls die Grenze d noch nicht in der Liste E vorhanden ist,
	so wird sie berechnet und dort abgelegt.
	E wird veraendert.
	Literatur: J.H. Silverman, "The Difference between the Weil
	   Height and the Canonical Height on Elliptic Curves",
	   Math. Comp. Vol 55, No. 192, pp 723-743, 1990.



			ecisnfelogp( E, P, n )

	"elliptic curve with integer coefficients, short normal form,
	 elliptic logarithm of point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	floating ecisnfelogp( E, P, n )  list E, P; single n;
	l = ecisnfelogp(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der 
	elliptischen Kurve E/Q (siehe ecrinit). 
	P = ( x  y  z ) int x, y, z;  ist ein Punkt auf der kWNF von E.
        P ist der unendliche Fernpunkt, falls z = 0 ist, 
        P = ( x/z^2, y/z^3 ) sonst.
	n muss positiv sein.
	ecisnfelogp berechnet den elliptischen Logarithmus von P
	mit einem Fehler kleiner als 2^(-n).
	Literatur: D. Zagier: Large integral points on elliptic curves,
	    Math. Comp. Vol. 48, No. 177, January 1987, pp. 425-436.



			ecisnffdisc( E )

	"elliptic curve with integer coefficients, short normal form, 
	factorization of discriminant"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecisnffdisc(E)  list E;
	F = ecisnffdisc(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe ecrinit).
	ecisnffdisc liefert eine Liste 
	      F = ( p1  e1  p2  e2 ...  pn  en )
	      int p1, p2, ..., pn; single e1, e2, ..., en;
	mit der vollstaendigen Faktorisierung der Diskriminanten D 
	des Modells in kurzer WNF der elliptischen Kurve E/Q, also
		   ----      (e_i)
	       D =  ||  (p_i)
	          1<=i<=n
	Falls die Liste F noch nicht in der Liste E vorhanden ist, wird
	sie berechnet und dort abgelegt.
	E wird veraendert.



			ecisnfgentor( E )

        "elliptic curve with integer coefficients, short normal form, 
	 generators of the torsion group"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecisnfgentor(E)  list E;
	L = ecisnfgentor(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	ecisnfgentor liefert eine Liste 
	   ( P )  list P;       falls die Torsionsgruppe zyklisch ist,
		    oder
	   ( P  Q )  list P, Q; falls die Torsionsgruppe bizyklisch ist,
	mit einem Erzeugendensystem der Torsionsgruppe des Modells in 
	kurzer WNF von E/Q. 
	Es ist P = ( x  y  z )  int x, y, z; 
	(Q analog).
	Falls noch kein Erzeugendensystem der Torsionsgruppe des Modells 
	in kurzer WNF von E/Q in E vorhanden ist, so wird es (zusammen 
	mit dem Gruppentyp) berechnet und dort abgelegt.
	E wird veraendert.



			ecisnfmul( E, P, n )

	"elliptic curve with integer coefficients, short normal form, 
	multiplication-map"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecisnfmul(E, P, n)  list E, P;  single n;
	R = ecisnfmul(E, P, n)
	Dabei muss gelten:
	  - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe 'ecrinit').
	  - P = (x  y  z ) int x, y, z; ist ein Punkt auf dem durch E 
	    gegebenen Modell in kurzer WNF von E/Q.
        ecisnfmul berechnet das n-fache n * P = P + ... + P (n-mal)
	des Punkts P auf dem Modell in kurzer WNF von E/Q.



			ecisnfmwgbase( E )

	"elliptic curve with integer coefficients, short normal form,
	Mordell-Weil-group, base"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecisnfmwgbase(E) list E;
	B = ecisnfmwgbase(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q (siehe 'ecrinit').
        ecisnfmwgbase bestimmt eine Basis
  	  B = ( P1  h1  P2  h2  ...  Pr  hr ); list P1, P2, ..., Pr; 
					       floating h1, h2, ..., hr; 
	der Mordell-Weil-Gruppe des Modells von E/Q in kWNF mit
	den Basispunkten
	  	Pi = ( xi  yi  zi ) int xi, yi, zi; ( 1 <= i <= r ),
        und deren jeweiliger Neron-Tate-Hoehe hi. 
	Dabei ist r der Rang von E/Q.
	Rueckgabe: bei korrektem Lauf: Liste B
	           sonst: -1.



			ecisnfneg( E, P )

        "elliptic curve with integer coefficients, short normal form, 
	negative of point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecisnfneg(E, P)  list E, P;
        N = ecisnfneg(E, P);
	Dabei muss gelten:
	  - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe 'ecrinit').
	  - P = ( x  y  z )  int x, y, z; ist ein Punkt auf dem durch 
	    die Liste E gegebenen Modell in kurzer WNF von E/Q,
	ecisnfneg berechnet den Punkt N = -P,
	d.h. P + N = O = ( 0 : 1 : 0 ). 
        Rueckgabe: 
	     ( 0  1  0 ), falls P = ( 0  1  0 ),
             ( x  y'  z ) mit y' = -y, sonst.



			ecisnfpbwh( E, PL, lb, ub, modus, hmin, BL )

        "elliptic curve with integer coefficients, short normal form,
	points of bounded Weil height"
        Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
        ecisnfpbwh( E, PL, lb, ub, modus, hmin, BL )
	     	list E, *PL, *BL; floating *lb, ub, hmin; single modus;
	n = ecisnfpbwh( E, PL, lb, ub, modus );
	Dabei muss gelten:
	 - E ist eine Liste mit allen wichtigen Daten der elliptischen
	   Kurve E/Q (siehe ecrinit).
	 - *PL ist die Liste der bisher gefundenen Punkte auf E/Q, d.h.
	   PL ist entweder ein Zeiger auf die leere Liste
		      oder ein Zeiger auf eine Liste 
              ( P1  h1  P2  h2  ...  Pn  hn )  list Pi; floating hi;
	   wobei Pi ein Punkt auf (dem minimalen Modell von) E/Q und 
	   hi = h(Pi) dessen Neron-Tate-Hoehe ist. Falls nichtleer, 
	   so ist *PL geordnet, d.h. h1 <= h2 <= ... <= hn.
         - *lb ist die untere Grenze des Siebintervalls.
         - ub ist die obere Grenze des Siebintervalls.
	 - hmin > 0 ist eine untere Abschaetzung fuer h( P ), P kein
	   Torsionspunkt.
	ecisnfpbwh berechnet eine Liste aller Punkte auf der kWNF, 
	deren Weil-Hoehe von unten durch *lb und von oben durch ub 
	beschraenkt ist. Die gefundenen Punkte werden zusammen mit 
	ihrer Neron-Tate-Hoehe in *PL (nach der Hoehe geordnet) 
	abgelegt: *PL = ( P1  h1  P2  h2  ...   Pk  hk ) 
           list Pi; floating hi; [Pi = ( xi  yi  zi )  int xi, yi, zi;]
           mit hi = h( Pi ) und h1 <= h2 <= ... <= hk.
	Falls modus < 0, so werden alle Punkte P (modulo Negation) 
	   mit *lb <= d(P) <= ub zusammen mit ihrer Neron-Tate-Hoehe
	   in die Punktliste *PL aufgenommen, d.h. es gibt nur
	   einen Punkt P = ( xP, yP ) in *PL mit x-Koordinate xP.
	Falls modus >= 0, so werden keine Torsionspunkte in *PL
	   aufgenommen. Alle anderen Punkte werden modulo Torsion und
	   Negation betrachtet, d.h. falls P in *PL ist, so werden 
	   weder -P noch Kombinationen P + T und -P + T (T Torsions-
	   punkt auf E/Q) aufgenommen. Es gibt also keine 2 Punkte 
	   in *PL, die dieselbe Neron-Tate-Hoehe haben.
           Falls modus = 0, wird die Berechnung (vorzeitig) beendet, 
	      wenn r linear unabhaengige Punkte gefunden wurden.
	      Dabei ist r der Rang von E/Q. Diese r linear unabhaenigen 
	      Punkte werden in *BL zusammen mit ihrer Neron-Tate-Hoehe
	      abgelegt. hmin dient dabei als untere Grenze fuer den
	      Regulator.
           Falls modus = 1, wird die Berechnung (vorzeitig) beendet, 
	      wenn der erste Nichttorsionspunkt gefunden wurde. 
           Falls modus = 2, wird die Berechnung beendet, falls die
	      Obergrenze ub erreicht ist.
        Rueckgabe: ERROR, falls beim Allokieren ein Fehler auftritt,
	               0, falls *lb >= ub (Siebintervall ist leer),
		       1, falls das gesamte Intervall durchsucht wurde,
		       2, falls die Berechnung vorzeitig (und fehler-
			  frei) beendet wurde (modus = 0 oder 1).



			ecisnfsum( E, P, Q )

        "elliptic curve with integer coefficients, short normal form,
	sum of points"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecisnfsum(E, P, Q)  list E, P, Q;
        S = ecisnfsum(E, P, Q);
	Dabei muss gelten:
	  - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe 'ecrinit').
	  - P = ( xP  yP  zP )  int xP, yP, zP;  und 
	    Q = ( xQ  yQ  zQ )  int xQ, yQ, zQ;  
	    sind zwei Punkte auf dem durch die Liste E gegebenen
	    Modell in kurzer WNF von E/Q.
	Rueckgabe: S = P + Q.



			ecisnftorgr( E )

        "elliptic curve with integer coefficients, short normal form, 
	torsion group"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecisnfnftor(E)  list E;
	L = ecisnfnftor(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe ecrinit).
	ecisnftorgr liefert die Torsionsgruppe (d.h. alle Torsionspunkte)
	des durch E gegebenen Modells in kurzer WNF von E/Q.
	Falls die Torsionsgruppe des Modells in kWNF noch nicht in
	E vorhanden ist, so wird sie mit Hilfe des Satzes von 
	Nagell-Lutz-Cassels berechnet und dort abgelegt.
	Rueckgabe: Liste L = ( T1  T2  ...  Tn )  list T1, T2, ..., Tn;
                   mit Ti = ( xi  yi  zi )  int xi, yi, zi; (1 <= i <= n)
	E wird veraendert.



			ecitatealg( a1, a2, a3, a4, a6, p, n )

	"elliptic curve with integer coefficients Tate's algorithm"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecitatealg( a1, a2, a3, a4, a6, p, n )
		int a1, a2, a3, a4, a6, p;  single n;
	L = ecitatealg( a1, a2, a3, a4, a6, p, n );
	Dabei muss gelten:
		- a1, a2, a3, a4, a6 sind ganzzahlige Koeffizienten
		  einer elliptischen Kurve E ueber Q,
		- p ist eine Primzahl,
		- p^n ist die hoechste p-Potenz, die in der
		  Diskriminante der elliptischen Kurve E aufgeht.
	ecitatealg berechnet nach dem Tateschen Algorithmus 
	        - den Reduktionstyp der Kurve E modulo p,
	        - den Exponenten des Fuehrers von E bei p,
	        - den c_p-Wert von E modulo p.
	ecitatealg liefert:
		- bei fehlerhaftem Lauf eine einelementige Liste mit
		  dem Eintrag -1;
		- eine Liste ( a1'  a2'  a3'  a4'  a6' ) von ganzen
		  Zahlen als Koeffizienten einer neuen, zu E biratio-
		  nal isomorphen, bei p minimalen elliptischen Kurve
		  E', falls die gegebene Kurve E nicht minimal bei p war;
		- bei korrektem Lauf eine dreielementige Liste
		  ( exp  rtyp  c_p ) von natuerlichen Zahlen mit
		  * dem Exponenten exp des Fuehrers
		  * dem Reduktionstyp rtyp gemaess der folgenden Tabelle
                      | rtyp   | Kodaira | Neron  |  c_p-Wert   | 
                      |--------|---------|--------|-------------|
                      | -n < 0 |    In   |   Bn   | 1, 2 oder n |
                      |--------|---------|--------|-------------|
                      |    1   |    II   |   C1   |      1      |
                      |--------|---------|--------|-------------|
                      |    2   |   III   |   C2   |      2      |
                      |--------|---------|--------|-------------|
                      |    3   |    IV   |   C3   |   1 oder 3  |
                      |--------|---------|--------|-------------|
                      |    5   |    I0*  |   C4   |   2 oder 4  |
                      |--------|---------|--------|-------------|
                      | 10 + v |    In*  |  C5,v  |   2 oder 4  |
                      |--------|---------|--------|-------------|
                      |    6   |    IV*  |   C6   |   1 oder 3  |
                      |--------|---------|--------|-------------|
                      |    7   |   III*  |   C7   |      2      |
                      |--------|---------|--------|-------------|
                      |    8   |    II*  |   C8   |      1      |
                      |--------|---------|--------|-------------|
	          * dem Wert c_p = #E(Q)/E0(Q), wobei 
	             E0(Q) = { P in E(Q) | P = [0:1:0] mod p },
	                      /          | P wird unter der Reduktion \
	                   = < P in E(Q) | modulo p auf den unendlich  >
		              \          | fernen Punkt abgebildet.   /
	Literatur: Tate, J.T.: Algorithm for finding the type of a
			       singular fiber in an elliptic pencil.
		   Modular functions in one variable IV. Antwerp 1972.
		   Lect. Notes Math. 476 ( 1975 ), 33 - 52.



			ecitavalb( a1, a2, a3, a4, a6 )

	"elliptic curve with integer coefficients,
	Tate's values b2, b4, b6, b8"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
        list ecitavalb(a1, a2, a3, a4, a6)  int a1, a2, a3, a4, a6;
	L = ecitavalb(a1, a2, a3, a4, a6);
	ecitavalb berechnet die Tateschen Groessen b2, b4, b6 und b8 
	der durch die ganzzahligen Koeffizienten a1, a2, a3, a4, a6 
	gegebenen elliptischen Kurve E/Q.
	ecitavalb liefert die 4-elementige Liste 
	    	( b2  b4  b6  b8 )  int b2, b4, b6, b8;
	Literatur: J.H. Silverman: 
		   The arithmetic of elliptic curves, p.46.



			ecitavalc( a1, a2, a3, a4, a6 )

	"elliptic curve with integer coefficients, minimal model,
	Tate's values c4, c6"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
        list ecitavalc(a1, a2, a3, a4, a6)  int a1, a2, a3, a4, a6;
	L = ecitavalc(a1, a2, a3, a4, a6);
	ecitavalc berechnet die Tateschen Groessen c4 und c6 der durch
	die ganzzahligen Koeffizienten a1, a2, a3, a4, a6 gegebenen
	elliptischen Kurve E/Q.
	ecitavalc liefert die Liste 
		( c4  c6 ) int c4, c6;
	Literatur: J.H. Silverman: 
		   The arithmetic of elliptic curves, p.46.



			ecmipsnfnpsv( p, a4, a6 )

	"elliptic curve over modular integer primes short normal form
	number of points special version"
	Quellbibliothek: srclib.ec2
	Include-Datei:	 _ec2.h
	int ecmipsnfnpsv (p,a4,a6)  int p,a4,a6;
	n = ecmipsnfnpsv (p,a4,a6);
	Dabei muss gelten:
		1. p sollte Primzahl sein.
		2. ggt (p,6) = 1
		3. Es ist entweder a4 oder a6 gleich 0.
	a4 und a6 seien die Koeffizienten einer in kurzer Weierstrass-
	Normalform gegebenen elliptischen Kurve E ueber Z/pZ. Berechnet
	wird die Anzahl n = #E(Z/pZ) der rationalen Punkte auf E.
	(Bedingung 3. bedeutet: E ist nichtsingulaer und hat
	j-Invariante 0 oder 1728.)	
!!!	Fuer spezielle Anwendungen ist n = -1, falls erkannt wird, dass
	p nicht prim ist.
	Wird dies nicht erkannt, so ist sehr wahrscheinlich n != #E(Z/pZ).



			ecmpbtco( p, a1, a2, a3, a4, a6, r, s, t, u )

	"elliptic curve over modular primes, birational transformation
	 of coefficients"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmpbtco(p, a1, a2, a3, a4, a6, r, s, t, u)
		int p, a1, a2, a3, a4, a6, r, s, t, u;
	L = ecmpbtco(p, a1, a2, a3, a4, a6, r, s, t, u);
	Dabei muss gelten:
		- p ist eine Primzahl,
		- a1, a2, a3, a4, a6 sind Elemente aus Z/pZ,
		- r, s, t, u sind Elemente aus Z/pZ und u ist ungleich 0.
	ecmpbtco berechnet zu der durch a1, a2, a3, a4, a6 in
	Weierstrass-Normalform gegebenen elliptischen Kurve die durch
	r, s, t, u gegebene birationale elliptische Kurve mit den
	Koeffizienten a1', a2', a3', a4', a6' in Weierstrass-Normalform
	gemaess
		x = u^2*x' + r,
		y = u^3*y' + u^2*s*x' + t.
	ecmpbtco liefert eine Liste mit den Koeffizienten der neuen Kurve:
	L = (a1', a2', a3', a4', a6').
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.49.



			ecmpdisc( p, a1, a2, a3, a4, a6 )

	"elliptic curve over modular primes, discriminant"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecmpdisc(p, a1, a2, a3, a4, a6)  int p, a1, a2, a3, a4, a6;
	D = ecmpdisc(p, a1, a2, a3, a4, a6);
	Dabei muss gelten:
		- p ist eine Primzahl,
		- a1, a2, a3, a4, a6 sind Elemente aus Z/pZ.
	ecmpdisc berechnet die Diskriminante D der durch die
	Koeffizienten a1, a2, a3, a4, a6 in Weierstrass-Normalform
	gegebenen kubischen Kurve.
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.46.



			ecmpfp( p, a1, a2, a3, a4, a6 )

	"elliptic curve over modular primes, find point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmpfp(p, a1, a2, a3, a4, a6)  int p, a1, a2, a3, a4, a6;
	P = ecmpfp(p, a1, a2, a3, a4, a6);
	Dabei muss gelten:
		- p ist eine Primzahl,
		- a1, a2, a3, a4 und a6 sind Elemente aus Z/pZ.
	ecmpfp liefert einen Punkt P auf der durch a1, a2, a3, a4 und
	a6 in Weierstrass-Normalform gegebenen elliptischen Kurve ueber
	Z/pZ in projektiver Darstellung, d.h. P ist eine dreielementige
	Liste P = (x, y, 1) von Elementen aus Z/pZ. P ist nicht der
	Fernpunkt, d.h.  P != (0, 1, 0).



			ecmpjinv( p, a1, a2, a3, a4, a6 )

	"elliptic curve over modular primes, j-invariant"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecmpjinv(p, a1, a2, a3, a4, a6)  int p, a1, a2, a3, a4, a6;
	j = ecmpjinv(p, a1, a2, a3, a4, a6);
	Dabei muss gelten:
		- p ist eine Primzahl,
		- a1, a2, a3, a4, a6 sind Elemente aus Z/pZ.
	ecmpjinv berechnet die j-Invariante j der durch die
	Koeffizienten a1, a2, a3, a4, a6 in Weierstras-Normalform
	gegebenen elliptischen Kurve.
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.46.



			ecmplp( p, a1, a2, a3, a4, a6, P1, P2 )

	"elliptic curve over modular primes, line through points"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmplp(p, a1, a2, a3, a4, a6, P1, P2)
		int p, a1, a2, a3, a4, a6;  list P1, P2;
	L = ecmplp(p, a1, a2, a3, a4, a6, P1, P2);
	Dabei muss gelten:
	      - p ist eine Primzahl.
	      - a1, a2, a3, a4, a6 sind Elemente aus Z/pZ.
	      - P1 und P2 sind 3-elementige Listen von Elementen aus Z/pZ.
	P1 und P2 sind 3-elementige Listen als projektive Darstellungen
	von Punkten auf der durch a1, a2, a3, a4, a6 gegebenen
	elliptischen Kurve. ecmplp berechnet die Steigung l und den
	y-Achsenabschnitt n der Geraden G durch P1 und P2 bzw. der
	Tangente an P1, falls P1 = P2.
		G: y = l*x + n.
	ecmplp liefert falls moeglich eine 2-elementige Liste aus
	Steigung und y-Achsenabschnitt:
		L = (l, n).
	ecmplp liefert die Liste
		( 0 ), falls P1 = -P2,
		( 1 ), falls P1 der Punkt im Unendlichen ist,
		( 2 ), falls P2 der Punkt im Unendlichen ist.
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.58.



			ecmpmul( p, a1, a2, a3, a4, a6, n, P1 )

	"elliptic curve over modular primes multiplication-map"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmpmul(p, a1, a2, a3, a4, a6, n, P1)
		int p, a1, a2, a3, a4, a6, n;  list P1;
	Pn = ecmpmul(p, a1, a2, a3, a4, a6, n, P1);
	Dabei muss gelten:
		- p ist eine Primzahl,
		- a1, a2, a3, a4, a6 sind Elemente aus Z/pZ,
		- n ist eine natuerliche Zahl,
		- P1 ist eine 3-elementige Liste von Elementen aus Z/pZ.
	Fuer einen in projektiver Darstellung als 3-elementige Liste
	gegebenen Punkt P1 = (x1, y1, z1) auf der durch a1, a2, a3, a4, a6
	in Weierstrass-Normalform gegebenen elliptischen Kurve E
	berechnet ecmpmul das Vielfache
		Pn = n*P1 = (xn, yn, zn)
	und gibt dieses als 3-elementige Liste von Elementen aus Z/pZ
	zurueck.



			ecmpneg( p, a1, a2, a3, a4, a6, P )

	"elliptic curve over modular primes negative point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmpneg(p, a1, a2, a3, a4, a6, P)
		int p, a1, a2, a3, a4, a6;  list P;
	L = ecmpneg(p, a1, a2, a3, a4, a6, P);
	Dabei muss gelten:
		- p ist eine Primzahl,
		- a1, a2, a3, a4, a6 sind Elemente aus Z/pZ,
		- P ist eine 3-elementige Liste von Elementen aus Z/pZ.
	Fuer einen in projektiver Darstellung als 3-elementige Liste
	gegebenen Punkt P auf der durch a1, a2, a3, a4, a6 in
	Weierstrass-Normalform gegebenen elliptischen Kurve E berechnet
	ecmpneg das Negative des Punktes P in projektiver Darstellung
	und gibt dieses als 3-elementige Liste zurueck.
	Literatur: J. H. Silverman,
		The arithmetic of elliptic curves, p.58.



			ecmpsnfcdivp( P, a4, a6, n )

	"elliptic curve over modular primes, short normal form,
	construction of division polynomials"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecmpsnfcdivp(P,a4,a6,n)  int P, a4, a6; single n;
	L = ecmpsnfcdivp(P,a4,a6,n);
	P ist eine Primzahl groesser als 3.
	a4 und a6 seien die Koeffizienten einer in kurzer Weierstrass-
	Normalform gegebenen elliptischen Kurve E ueber Z / P*Z.
	n ist eine positive single groesser 4.
	L ist die Liste der reduzierten Teilungspolynome, d.h. insbesondere
	sind es Polynome in einer Veraenderlichen ueber Z / P*Z.
	Fuer geraden Index erhaelt man das urspruengliche Teilungspolynom
	durch Multiplikation des reduzierten Teilungspolynoms mit der
	zweiten Veraenderlichen.
	Das erste Teilungspolynom in L hat Index 0 und das letzte den
	Index n.
	( Siehe Polynome f_n in Math. Comp., vol.44, IV 1985, pp 483-494 ).



			ecmpsnfcssa( p, a4, a6, s, pl, ts )

	"elliptic curve over modular primes, short normal form,
	 combined Schoof- Shanks- algorithm"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	int ecmpsnfcssa(p, a4, a6, s, pl, ts)
		int p, a4, a6, s; single pl, ts;
	n = ecmpsbfcssa(p, a4, a6, s, pl, ts);
	p ist eine Primzahl, und a4 und a6 sind die Koeffizienten einer
	in kurzer Weierstrass-Normalform gegebenen elliptischen Kurve E
	ueber Z/pZ. ecmpsnfcssa berechnet die Ordnung n der rationalen
	Punktgruppe von E ueber Z/pZ, d.h. n = #E(Z/pZ). (Fuer 
	Primzahlen kleiner als 30000 sollte man den einfachen 
	Abzaehl-Algorithmus ecmspsnfnp benutzen.)
	s >= 1 ist eine natuerliche Zahl. Sei
		{2, 3, 5, ... , p_(k-1), p_k}
	die aufsteigend sortierte Liste der ersten k Primzahlen, und
	sei k und damit auch m eindeutig bestimmt durch die Beziehung
		2*3* ... *p_(k-1) < s <= 2*3* ... *p_(k-1)*p_k = m.
	Mit Hilfe des Schoof-Algorithmus wird zunaechst eine Kongruenz
	der Form #E(Z/pZ) = a mod m berechnet, die dazu benutzt wird,
	den Speicher- und Zeitaufwand des Shanks-Algorithmus zu
	minimieren. (Siehe auch ecmpsnfmsha1.)
	Ist der Parameter pl == 0, so erfolgt keine Ausgabe auf
	stdout. Ist pl != 0, so erhaelt man waehrend der Laufzeit
	auf stdout einige einfache Ausgaben ueber den gegenwaertigen 
	Stand der Berechnungen.
	ts ist eine positive ganze Zahl, die die im Shanks-Teil des
	Algorithmus benutzte Tabellenlaenge kontrolliert. Wird ts
	auf 0 gesetzt, so wird die Feldgroesse unter der Annahme, dass
	genuegend Speicherplatz vorhanden ist, vom Programm so
	bestimmt, dass die Laufzeit minimiert wird. Ist ts != 0, so
	wird die Groesse der benoetigten Tabelle mit ts/100
	multipliziert. Werte kleiner als 100 verkleinern also die
	Tabelle, Werte groesser als 100 vergroessern die Tabelle und
	sollten nicht benutzt werden, da dann sowohl der
	Speicherplatzbedarf als auch die Laufzeit ansteigen. ts = 100
	hat dieselbe Wirkung, wie ts = 0.
	Hinweis: Der berechnete Speicheplatzbedarf liegt in der
	Groessenordnung von
			     sqrt(sqrt(p))    1
			     ------------- * --- KB.
			   	sqrt(m)	     128
	Vorsicht: Die auftretenden Tabellen koennen durchaus die
	Groessenordnung von mehreren Megabytes erreichen.
	ecmpsnfcssa liefert NULL, falls die benoetigte Tabelle nicht
	angelegt werden konnte. ecmpsnfcssa liefert eine negative ganze
	Zahl, falls zur Bestimmung der Ordnung der noch nicht
	implementierte zweite Teil des Shanks-Algorithmus erforderlich ist.
	Falls ecmpsnfcssa eine positive ganze Zahl n liefert, so gilt
		n = #E(Z/pZ).



			ecmpsnfdisc( p, a4, a6 )

	"elliptic curve over modular primes, short normal form,
	 discriminant"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecmpsnfdisc(p, a4, a6)  int a4, a6;
	D = ecmpsnfdisc(p, a4, a6);
	Dabei muss gelten:
		- p ist eine Primzahl,
		- a4 und a6 sind Elemente aus Z/pZ.
	ecmpsnfdisc berechnet die Diskriminante D der durch a4 und a6
	in kurzer Weierstrass-Normalform gegebenen kubischen Kurve.
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.50.



			ecmpsnffmopl( p, a4, a6, P, L, N )

	"elliptic curve over modular primes, short normal form, finding
	a multiple of the order of a point with the Pollard Lambda method"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	int ecmpsnffmopl(p, a4, a6, P, L, N)  int p, a4, a6, N; list P, L;
	M = ecmpsnffmopl(p, a4, a6, P, L, N);
	p ist eine Primzahl groesser als 37.
	a4 und a6 sind Koeffizienten einer in kurzer Weierstrass-Normalform
	gegebenen elliptischen Kurve E ueber Z/pZ.
	P = (x, y, z) ist ein projektiver Punkt auf E,
	d.h. insbesondere sind x, y und z Elemente aus Z/pZ.
	L ist entweder eine Liste von positiven ganzen Zahlen oder
	eine nicht negative single, die zwischen 3 und 30 liegen sollte.
	Bei Eingabe L==0 wird fuer L (gemaess angegebener Quelle) die
	Liste (1, 2, 2^2, ..., 2^19 ) genommen.
	N ist eine nicht negative ganze Zahl, die bei Eingabe von N==0
	standardmaessig gleich sqrt(2*sqrt(p)) gesetzt wird. Sie sollte
	im allgemeinen groessenordnungsmaessig diesem Wert entsprechen.
	ecmpsnffmopl berechnet mit Hilfe eines Verfahrens, das auf der
	Pollard'schen Lambda-Methode basiert (siehe A.K. Lenstra und 
	H.W. Lenstra: Algorithms in number theory, Technical Report of
	The University of Chicago, May 1987),
	eine Zahl M, fuer die gilt M * P = O, wobei O das neutrale
	Element der rationalen Punktgruppe E(Z/pZ) bezeichnet.
	Das Verfahren fuehrt unter Umstaenden nicht zum Erfolg und
	liefert in diesem Fall -1 zurueck.



			ecmpsnffmopr( p, a4, a6, P, k )

	"elliptic curve over modular primes, short normal form, finding
	a multiple of the order of a point with the Pollard Rho method"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	int ecmpsnffmopr(p, a4, a6, P, k) int p, a4, a6; list P; single k;
	M = ecmpsnffmopr(p, a4, a6, P, k);
	p ist eine Primzahl groesser als 37.
	a4 und a6 sind Koeffizienten einer in kurzer Weierstrass-Normalform
	gegebenen elliptischen Kurve E ueber Z/pZ.
	P = (x, y, z) ist ein projektiver Punkt auf E,
	d.h. insbesondere sind x, y und z Elemente aus Z/pZ.
	k ist eine positive single, die zwischen 3 und 30 liegen sollte.
	(Zu naeheren Erlaeuterungen k betreffend siehe angegebene Quelle.)
	ecmpsnffmopr berechnet mit Hilfe eines Verfahrens, das auf der
	Pollard'schen rho-Methode basiert (siehe A.K. Lenstra und 
	H.W. Lenstra: Algorithms in number theory, Technical Report of
	The University of Chicago, May 1987),
	eine Zahl M, fuer die gilt M * P = O, wobei O das neutrale
	Element der rationalen Punktgruppe E(Z/pZ) bezeichnet.
	Die Laufzeit des Verfahrens liegt erwartungsgemaess bei
	3 * sqrt(p) * D_add, wobei mit D_add die durchschnittliche Dauer
	bezeichnet sei, die zur Addition zweier Punkte aus E(Z/pZ)
	benoetigt wird. Damit liegt die zu erwartende Laufzeit sowohl weit
	ueber der Laufzeit von ecmpsnffmopl als auch ueber der von
	ecmpsnfcssa (man beachte, dass insbesondere die Gruppenordnung von
	E(Z/pZ) ein Vielfaches der Punktordnung eines beliebigen Punktes
	aus E(Z/pZ) ist.)
	Zur Bestimmung der genauen Punktordnung siehe auch ecmpsnfmopto.



			ecmpsnffp( p, a4, a6 )

	"elliptic curve over modular primes, short normal form,
	 find point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmpsnffp(p, a4, a6)  int p, a4, a6;
	P = ecmpsnffp(p, a4, a6);
	Dabei muss gelten:
		- p ist eine Primzahl;
		- a4 und a6 sind Elemente aus Z/pZ.
	ecmpsnffp liefert einen Punkt P auf der durch a4 und a6 in
	kurzer Weierstrass-Normalform gegebenen elliptischen Kurve
	ueber Z/pZ in projektiver Darstellung, d.h. P ist eine
	dreielementige Liste P = (x, y, 1) von Elementen aus Z/pZ.
	P ist nicht der Fernpunkt, d.h.  P != (0, 1, 0).



			ecmpsnfjinv( p, a4, a6 )

	"elliptic curve over modular primes, short normal form,
	  j-invariant"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecmpsnfjinv(p, a4, a6)  int p, a4, a6;
	j = ecmpsnfjinv(p, a4, a6)
	Dabei muss gelten:
		- p ist eine Primzahl,
		- a4 und a6 sind Elemente aus Z/pZ.
	ecmpsnfjinv berechnet die j-Invariante j der durch a4 und a6
	in kurzer Weierstrass-Normalform gegebenen elliptischen Kurve.
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.50.



			ecmpsnflp( p, a4, a6, P1, P2 )

	"elliptic curve over modular primes, short normal form,
	 line through points"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmpsnflp(p, a4, a6, P1, P2)  int p, a4, a6;  list P1, P2;
	L = ecmpsnflp(p, a4, a6, P1, P2);
	Dabei muss gelten:
		- p ist eine Primzahl,
		- a4 und a6 sind Elemente aus Z/pZ,
		- P1 und P2 sind 3-elementige Listen von Elementen
		  aus Z/pZ.
	P1 und P2 sind 3-elementige Listen als projektive Darstellungen
	von Punkten auf der durch a4 und a6 in kurzer Weierstrass-
	Normalform gegebenen elliptischen Kurve E. ecmpsnflp berechnet
	die Steigung l und den y-Achsenabschnitt n der Geraden G durch
	P1 und P2 bzw. der Tangente an P1, falls P1 = P2.
		G: y = l*x + n.
	ecmpsnflp liefert falls moeglich eine 2-elementige Liste aus
	Steigung und y-Achsenabschnitt:
		L = (l, n).
	ecmpsnflp liefert (0), falls P1 = -P2,
		          (1), falls P1 der Punkt im Unendlichen ist,
			  (2), falls P2 der Punkt im Unendlichen ist.
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.58.



			ecmpsnfmopto( p, a4, a6, P, mul )

        "elliptic curve over modular primes, short normal form, multiple
	of the order of a point to exact order of the point"
        Quellbibliothek: srclib.ec2
        Include-Datei:   _ec2.h
	int ecmpsnfmopto(p, a4, a6, P, mul)  int p, a4, a6, mul; list P;
        ord = ecmpsnfmopto(p, a4, a6, P, mul);
        p ist eine Primzahl groesser als 37.
	a4 und a6 sind Koeffizienten einer in kurzer Weierstrass-Normalform
        gegebenen elliptischen Kurve E ueber Z/pZ.
        P = (x, y, z) ist ein projektiver Punkt auf E,
        d.h. insbesondere sind x, y und z Elemente aus Z/pZ.
	mul ist ein Vielfaches der Punktordnung von P,
	d.h. es gilt mul*P = 0, wobei 0 das neutrale Element
	der rationalen Punktgruppe E(Z/pZ) bezeichnet.
	ecmpsnfmopto berechnet die genaue Ordnung ord von P.



			ecmpsnfmsha1( p, a4, a6, P, a, m, pl, ts )

	"elliptic curve over modular primes, short normal form,
	 modified Shanks' algorithm, first part"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecmpsnfmsha1(p, a4, a6, P, a, m, pl, ts)
		int p, a4, a6; list P; int a, m; single pl, ts;
	L = ecmpsnfmsha1(p, a4, a6, P, a, m, pl, ts);
	p > 37 ist eine Primzahl, und a4 und a6 sind die Koeffizienten
	einer in kurzer Weierstrass-Normalform gegebenen elliptischen
	Kurve E ueber Z/pZ. P = (x, y, z) ist ein projektiver Punkt auf
	E, d.h. insbesondere, dass x, y und z Elemente aus Z/pZ sind.
	ecmpsnfmsha1 berechnet mit Hilfe eines modifizierten
	Babystep-Giantstep-Algorithmus die Ordnung ord des Punktes P
	und ein Vielfaches res der Ordnung von P im Hasse-Intervall von p.
	a und m sind ganze Zahlen, so dass fuer die Ordnung #E(Z/pZ)
	von E ueber Z/pZ gilt
		#E(Z/pZ) = a mod m.
	(a und m werden i.a. mit dem Schoof-Algorithmus berechnet.)
	(Fuer Primzahlen kleiner als 30000 ist der Abzaehl-Algorithmus
	ecmspsnfnp schneller als der Babystep-Giantstep-Algorithmus.)
	Ist der Parameter pl == 0, so erfolgt keine Ausgabe auf
	stdout. Ist pl != 0, so erhaelt man waehrend der Laufzeit
	auf stdout einfache Ausgaben ueber den gegenwaertigen Stand der
	Berechnungen.
	ts ist eine positive ganze Zahl, die die benutzte
	Tabellenlaenge kontrolliert. Wird ts auf 0 gesetzt, so wird die
	Feldgroesse unter der Annahme, dass genuegend Speicherplatz
	vorhanden ist, vom Programm so bestimmt, dass die Laufzeit
	minimiert wird. Ist ts != 0, so wird die Groesse der
	benoetigten Tabelle mit ts/100 multipliziert. Werte kleiner als
	100 verkleinern also die Tabelle, Werte groesser als 100
	vergroessern die Tabelle und sollten nicht benutzt werden, da
	dann sowohl der Speicherplatzbedarf, als auch die Laufzeit
	ansteigen. ts = 100 hat dieselbe Wirkung, wie ts = 0.
	Hinweis: Der berechnete Speicheplatzbedarf liegt in der
	Groessenordnung von
			     sqrt(sqrt(p))    1
			     ------------- * --- KB.
			   	sqrt(m)	     128
	Vorsicht: Die auftretenden Tabellen koennen durchaus die
	Groessenordnung von mehreren Megabytes erreichen.
	ecmpsnfmsha1 liefert NULL, falls die benoetigte Tabelle nicht
	angelegt werden konnte. Ansonsten liefert ecmpsnfmsha1 eine
	dreielementige Liste der Form ( status  res  ord ) von ganzen
	Zahlen. Ist status < 0, so war die Ordnung des Startpunktes P
	nicht hinreichend gross fuer die Berechnungen. Ist status > 0,
	so enthaelt ord die Ordnung des Startpunktes P, und res enthaelt
	ein Vielfaches von ord im Hasse-Intervall, so dass res = a mod m.



			ecmpsnfmul( p, a4, a6, n, P1 )

	"elliptic curve over modular primes, short normal form,
	 multiplication-map"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmpsnfmul(p, a4, a6, n, P1)
		int p, a4, a6;  single n;  list P1;
	Pn = ecmpsnfmul(p, a4, a6, n, P1);
	Dabei muss gelten:
		- p ist eine Primzahl,
		- a4, a6 sind Elemente aus Z/pZ,
		- n ist eine natuerliche Zahl,
		- P1 ist eine 3-elementige Liste von Elementen
		  aus Z/pZ.
	Fuer einen in projektiver Darstellung als 3-elementige Liste
	gegebenen Punkt P1 = (x1, y1, z1) auf der durch a4 und a6 in
	kurzer Weierstrass-Normalform gegebenen elliptischen Kurve E
	berechnet ecmpsnfmul das Vielfache Pn = n*P1 = (xn, yn, zn)
	und gibt dieses als 3-elementige Liste von rationalen Zahlen
	zurueck.



			ecmpsnfmuls( p, a4, a6, x1, y1, n )

        "elliptic curve over modular primes, short normal form,
	 multiplication-map, special version"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
        void ecmpsnfsums(p, a4, a6, x1, y1, n)  int p, a4, a6, *x1, *y1, n;
        ecmpsnfmuls(p, a4, a6, x1, y1, n);
	a4 und a6 sind die Koeffizienten einer in kurzer
	Weierstrass-Normalform gegebenen elliptischen Kurve E ueber Z/pZ.
	(*x1, *y1) ist ein affiner Punkt auf E. (*x1, *y1) darf nicht der
	Nullpunkt der Kurve sein. ecmpsnfmuls berechnet das Vielfache
	n * (*x1, *y1) des Punktes (*x1, *y1) und legt das Ergebnis wieder
	unter (*x1, *y1) ab. ecmpsnfmuls legt in (*x1, *y1) die Werte
	(-1, -1) ab, falls n * (*x1, *y1) der Nullpunkt der Kurve ist.
	Vorsicht: Der Punkt (*x1, *y1) wird veraendert.



			ecmpsnfneg( p, a4, a6, P )

	"elliptic curve over modular primes, short normal form,
	 negative point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmpsnfneg(p, a4, a6, P)  int p, a4, a6;  list P;
	L = ecmpsnfneg(p, a4, a6, P);
	Dabei muss gelten:
		- p ist eine Primzahl,
		- a4, a6 sind Elemente aus Z/pZ,
		- P ist eine 3-elementige Liste von Elementen
		  aus Z/pZ.
	Fuer einen in projektiver Darstellung als 3-elementige Liste
	gegebenen Punkt P auf der durch a4 ung a6 in kurzer
	Weierstrass-Normalform gegebenen elliptischen Kurve E berechnet
	ecmpsnfneg das Negative des Punktes P in projektiver
	Darstellung und gibt dieses als 3-elementige Liste zurueck.



			ecmpsnfnpm2( P, a4, a6 )

	"elliptic curve over modular primes, short normal form, number of
	points modulo 2"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single ecmpsnfnpm2(P,a4,a6)  int P, a4, a6;
	m = ecmpsnfnpm2(P,a4,a6);
	P ist eine Primzahl groesser als 3.
	a4 und a6 seien die Koeffizienten einer in kurzer Weierstrass-
	Normalform gegebenen elliptischen Kurve E ueber Z / P*Z.
	Sei n = # E(Z / P*Z), d.h. n sei die Maechtigkeit der rationalen
	Punktgruppe von E. Dann ist m = n modulo 2.



			ecmpsnfnpmi( P, a4, a6, S, pM )

	"elliptic curve over modular primes, short normal form, number of
	points modulo an integer determined with the Schoof algorithm"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	int ecmpsnfnpmi(P,a4,a6,S,pM)  int P, a4, a6, S, *pM;
	M = ecmpsnfnpmi(P,a4,a6,S,pM);
	P ist eine Primzahl groesser als 3.
	a4 und a6 seien die Koeffizienten einer in kurzer Weierstrass-
	Normalform gegebenen elliptischen Kurve E ueber Z / P*Z.
	S ist eine positive ganze Zahl.
	Es sei { p_1, p_2, ..., p_i, ..., p_j, ... } die Menge der
	Primzahlen mit p_i < p_j fuer i < j.
	Dann sei *pM = p_1 * ... * p_r die Zahl mit minimalem Index r,
	fuer die gilt *pM >= S.
	Sei N = # E(Z / P*Z), d.h. N sei die Maechtigkeit der rationalen
	Punktgruppe von E. Dann ist M = N modulo *pM.
	Benutzt wird der Schoof Algorithmus.



			ecmpsnfnpmsp( P, a4, a6, p, L )

	"elliptic curve over modular primes, short normal form, number of
	points modulo a single prime determined with the Schoof algorithm"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single ecmpsnfnpmsp(P,a4,a6,p,L)  int P, a4, a6; single p; list L;
	m = ecmpsnfnpmsp(P,a4,a6,p,L);
	P ist eine Primzahl groesser als 3.
	a4 und a6 seien die Koeffizienten einer in kurzer Weierstrass-
	Normalform gegebenen elliptischen Kurve E ueber Z / P*Z.
	p ist eine single Primzahl kleiner als P.
	L ist die Liste der reduzierten Teilungspolynome
	( siehe	ecmpsnfcdivp ).
	Das erste Teilungspolynom in L hat Index 0 und das letzte einen
	Index, der groesser als p ist ( siehe Polynome f_n in Math. Comp.,
	vol. 44, April 1985, pp 483-494 bzw. Dissertation von H.G. Folz ).
	Sei N = # E(Z / P*Z), d.h. N sei die Maechtigkeit der rationalen
	Punktgruppe von E. Dann ist m = N modulo p.
	Benutzt wird der Schoof Algorithmus.



			ecmpsnfsum( p, a4, a6, P1, P2 )

	"elliptic curve over modular primes, short normal form,
	 sum of points"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmpsnfsum(p, a4, a6, P1, P2)  int p, a4, a6;  list P1, P2;
	P3 = ecmpsnfsum(p, a4, a6, P1, P2);
	Dabei muss gelten:
		- p ist eine Primzahl,
		- a4, a6 sind Elemente aus Z/pZ,
		- P1 und P2 sind 3-elementige Listen von Elementen
		  aus Z/pZ.
	P1 = (x1, y1, z1) und P2 = (x2, y2, z2) sind 3-elementige
	Listen als projektive Darstellungen von Punkten auf der durch
	a4 und a6 in kurzer Weierstrass-Normalform gegebenen
	elliptischen Kurve. ecmpsnfsum berechnet die Summe P3 der
	beiden Punkte P1 und P2 und gibt diese als 3-elementige Liste
	von Elementen aus Z/pZ zurueck: P3 = (x3, y3, z3).
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.59.



			ecmpsnfsums( p, a4, a6, x1, y1, x2, y2 )

        "elliptic curve over modular primes, short normal form, sum of
	 points, special version"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
        void ecmpsnfsums(p, a4, a6, x1, y1, x2, y2)
                int p, a4, a6, *x1, *y1, *x2, *y2;
        ecmpsnfsums(p, a4, a6, x1, y1, x2, y2);
	a4 und a6 sind die Koeffizienten einer in kurzer
	Weierstrass-Normalform gegebenen elliptischen Kurve E ueber
	Z/pZ. (*x1, *y1) und (*x2, *y2) sind affine Punkte auf E.
	(*x1, *y1) und (*x2, *y2) duerfen nicht der Nullpunkt der Kurve 
	sein. ecmpsnfsums berechnet die Summe der Punkte
	(*x1, *y1) und (*x2, *y2) und legt das Ergebnis wieder
	unter (*x2, *y2) ab. ecmpsnfsums legt in (*x2, *y2) die Werte
	(-1, -1) ab, falls (*x1, *y1) + (*x2, *y2) der Nullpunkt ist.
	Vorsicht: Nur der Punkt (*x1, *y1) bleibt unveraendert, der
	Punkt (*x2, *y2) wird veraendert. Ein Aufruf der Form
		ecmpsnfsums(p, a4, a6, x1, y1, x1, y1)
	hat unerwartete Seiteneffekte und liefert i.a. ein
	fehlerhaftes Ergebnis.



			ecmpsrpp( p, P )

	"elliptic curve over modular primes, standard representation
	 of projective point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmpsrpp(p, P)  int p; list P;
	Q = ecmpsrpp(p, P);
	Dabei muss gelten:
		- p ist eine Primzahl,
		- P ist eine 3-elementige Liste von Elementen
		  aus Z/pZ.
	ecmpsrpp berechnet fuer den projektiven Punkt P = (x, y, z)
	eine Darstellung Q' = (x', y', z'), so dass gilt:
		0 <= x' <= p - 1; 0 <= y' <= p - 1, z' = 1, falls z != 0,
		Q' = (0, 1, 0),                             falls z == 0.



			ecmpsum( p, a1, a2, a3, a4, a6, P1, P2 )

	"elliptic curve over modular primes, sum of points"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmpsum(p, a1, a2, a3, a4, a6, P1, P2)
		int p, a1, a2, a3, a4, a6;  list P1, P2;
	P3 = ecmpsum(p, a1, a2, a3, a4, a6, P1, P2);
	Dabei muss gelten:
		- p ist eine Primzahl,
		- a1, a2, a3, a4, a6 sind Elemente aus Z/pZ,
		- P1 und P2 sind 3-elementige Listen von Elementen
		  aus Z/pZ
	P1 = (x1, y1, z1) und P2 = (x2, y2, z2) sind 3-elementige
	Listen als projektive Darstellungen von Punkten auf der durch
	a1, ... , a6 in Weierstrass-Normalform gegebenen elliptischen
	Kurve. ecmpsum berechnet die Summe P3 der beiden Punkte P1 und
	P2 und gibt diese als 3-elementige Liste von rationalen Zahlen
	zurueck: P3 = (x3, y3, z3).
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.59.



			ecmptavb6( p, a1, a2, a3, a4, a6 )

	"elliptic curve over modular primes Tate's values b2, b4, b6"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmptavb6(p, a1, a2, a3, a4, a6)  int p, a1, a2, a3, a4, a6;
	L = ecmptavb6(p, a1, a2, a3, a4, a6);
	Dabei muss gelten:
		- p ist eine Primzahl.
		- a1, a2, a3, a4, a6 sind Elemente aus Z/pZ.
	ecmptavb6 berechnet die Tateschen Groessen b2, b4 und b6 fuer
	die durch die Koeffizienten a1, ... , a6 in
	Weierstrass-Normalform gegebene kubische Kurve und gibt diese
	als Liste L = (b2, b4, b6) zurueck.
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.46.



			ecmptavb8( p, a1, a2, a3, a4, a6 )

	"elliptic curve over modular primes Tate's values b2, b4, b6, b8"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmptavb8(p, a1, a2, a3, a4, a6)  int p, a1, a2, a3, a4, a6;
	L = ecmptavb8(p, a1, a2, a3, a4, a6);
	Dabei muss gelten:
		- p ist eine Primzahl.
		- a1, a2, a3, a4, a6 Elemente aus Z/pZ.
	ecmptavb8 berechnet die Tateschen Groessen b2, b4, b6 und b8
	fuer die durch die Koeffizienten a1, ... , a6 in
	Weierstrass-Normalform gegebene elliptische Kurve und gibt
	diese als Liste L = (b2, b4, b6, b8) zurueck.
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.46.



			ecmptavc6( p, a1, a2, a3, a4, a6 )

	"elliptic curve over modular primes Tate's values c4, c6"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmptavc6(p, a1, a2, a3, a4, a6)  int p, a1, a2, a3, a4, a6;
	L = ecmptavc6(p, a1, a2, a3, a4, a6);
	Dabei muss gelten:
		- p ist eine Primzahl.
		- a1, a2, a3, a4, a6 sind Elemente aus Z/pZ.
	ecmptavc6 berechnet die Tateschen Groessen c4 und c6 fuer die
	durch die Koeffizienten a1, ... , a6 in Weierstrass-Normalform
	gegebene kubische Kurve und gibt diese als Liste L = (c4, c6)
	zurueck.
	Literatur: D. Husemoeller: Elliptic curves, p.68.



			ecmptosnf( p, a1, a2, a3, a4, a6 )

	"elliptic curve over modular primes to short normal form"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecmptosnf(p, a1, a2, a3, a4, a6)  int p, a1, a2, a3, a4, a6;
	L = ecmptosnf(p, a1, a2, a3, a4, a6);
	Dabei muss gelten:
		- p ist eine Primzahl groesser oder gleich 5.
		- a1, a2, a3, a4, a6 sind Elemente aus Z/pZ.
	ecmptosnf berechnet zu der durch a1, ... , a6 in Weierstrass-
	Normalform gegebenen elliptischen Kurve E eine birational
	isomorphe Kurve E' in kurzer Weierstrass-Normalform mit den
	Koeffizienten a und b gemaess folgender Transformationen:
		x = u^2*x' + r,
		y = u^3*y' + u^2*s*x' + t,
		z = z'.
	ecmptosnf liefert eine Liste, die ihrerseits aus 2 Listen besteht:
		L = ((a, b), (r, s, t, u)).
	Literatur: J. H. Silverman:
		The arithmetic of elliptic curves, p.48.



			ecmspnp( p, a1, a2, a3, a4, a6 )

	"elliptic curve over modular single prime, number of points"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single ecmspnp(p, a1, a2, a3, a4, a6)  single p, a1, a2, a3, a4, a6;
	n = ecmspnp(p, a1, a2, a3, a4, a6);
	Dabei muss gelten:
          - p ist eine Primzahl kleiner als 2^15 = 32768.
	  - 0 <= a1, a2, a3, a4, a6 < p sind die Koeffizienten 
	    einer elliptischen Kurve E/(Z/pZ).
	ecmspnp berechnet die Anzahl n = #E( Z/pZ ) der rationalen
	Punkte auf E/(Z/pZ) mit dem Abzaehlverfahren.
	ecmspnp sollte nur fuer p = 2 oder 3 benutzt werden, 
	da fuer p > 3 immer ein Modell in kurzer WNF existiert
	und 'ecmspsnfnp' wesentlich schneller ist als 'ecmspnp'.
	Rueckgabe: n.



			ecmspsnfnp( p, a4, a6 )

	"elliptic curve over modular single primes, short normal form,
	number of points"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single ecmspsnfnp(p, a4, a6)  single p, a4, a6;
	n = ecmspsnfnp(p, a4, a6);
	Dabei muss gelten:
          - p ist eine Primzahl mit 4 < p < 2^29 = 536870912.
	  - 0 <= a4, a6 < p sind die Koeffizienten einer elliptischen 
	    Kurve E/(Z/pZ) in kurzer Weierstrass-Normalform.
	ecmspsnfnp berechnet die Anzahl n = #E(Z/pZ) der rationalen
	Punkte auf E/(Z/pZ) mit dem Charaktersummenverfahren.
	Im Fehlerfall ist n = ERROR.



			ecmspsnfsha( p, a4, a6 )        (MACRO)

	"elliptic curve over modular single primes, short normal form,
	 Shanks' algorithm"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single ecmspsnfsha(p, a4, a6)  single p, a4, a6;
	n = ecmspsnfsha(p, a4, a6);
	Dabei muss gelten:
		- p ist eine einfach genaue Primzahl groesser oder
		  gleich 37,
		- a4 und a6 sind Elemente aus Z/pZ.
	a4 und a6 seien die Koeffizienten einer in kurzer
	Weierstrass-Normalform gegebenen elliptischen Kurve E ueber
	Z/pZ. Dann berechnet ecmspsnfsha die Anzahl n = #E(Z/pZ) der
	Z/pZ-rationalen Punkte auf E nach dem Shanks-Algorithmus.
	ecmspsnfsha liefert einen negativen Wert, falls die Berechnung
	nicht erfolgreich durchgefuehrt werden konnte.



			ecnfbtco( F, a1, a2, a3, a4, a6, r, s, t, u )

	"elliptic curve over number field birational transformation of
	 coefficients"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecnfbtco( F, a1, a2, a3, a4, a6, r, s, t, u )  pol F;
		nfel a1, a2, a3, a4, a6, r, s, t, u;
	L = ecnfbtco( F, a1, a2, a3, a4, a6, r, s, t, u );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a1, a2, a3, a4, a6 sind Elemente dieses Koerpers K.
		- r, s, t, u sind Elemente aus K und u ist ungleich 0.
	ecnfbtco berechnet zu der durch a1, a2, a3, a4, a6 in
	Weierstrass-Normalform gegebenen elliptischen Kurve die durch
	r, s, t, u gegebene birationale elliptische Kurve mit den
	Koeffizienten a1', a2', a3', a4', a6' in Weierstrass-Normalform
	gemaess x = u^2*x' + r,
		y = u^3*y' + u^2*s*x' + t.
	ecnfbtco liefert eine Liste mit den Koeffizienten der neuen Kurve:
	L = ( a1', a2', a3', a4', a6' );
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.49.



			ecnfdisc( F, a1, a2, a3, a4, a6 )

	"elliptic curve over number field discriminant"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	nfel ecnfdisc( F, a1, a2, a3, a4, a6 )  pol F; nfel a1,a2,a3,a4,a6;
	D = ecnfdisc( F, a1, a2, a3, a4, a6 );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a1, a2, a3, a4, a6 sind Elemente dieses Koerpers K.
	ecnfdisc berechnet die Diskriminante D der durch die
	Koeffizienten a1, ... , a6 in Weierstrass-Normalform
	gegebenen kubischen Kurve.
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.46.



			ecnfjinv( F, a1, a2, a3, a4, a6 )

	"elliptic curve over number field j-invariant"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	nfel ecnfjinv( F, a1, a2, a3, a4, a6 )  pol F; nfel a1,a2,a3,a4,a6;
	j = ecnfjinv( F, a1, a2, a3, a4, a6 );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a1, a2, a3, a4, a6 sind Elemente dieses Koerpers K.
	ecnfjinv berechnet die j-Invariante j der durch die
	Koeffizienten a1, ... , a6 in Weierstrass-Normalform
	gegebenen elliptischen Kurve.
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.46.



			ecnflp( F, a1, a2, a3, a4, a6, P1, P2 )

	"elliptic curve over number field line through points"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecnflp( F, a1, a2, a3, a4, a6, P1, P2 )  pol F;
		nfel a1, a2, a3, a4, a6; list P1, P2;
	L = ecnflp( F, a1, a2, a3, a4, a6, P1, P2 );
	Dabei muss gelten:
		- F ist irreduzibles univariates Polynom in
		  dense-Darstelling, das einen Zahlkoerper K erzeugt.
		- a1, a2, a3, a4, a6 sind Elemente dieses Koerpers K.
		- P1 und P2 sind 3-elementige Listen von Elementen des
		  Koerpers K.
	P1 und P2 sind 3-elementige Listen als projektive Darstellungen
	von Punkten auf der durch a1,...,a6 gegebenen elliptischen Kurve.
	ecnflp berechnet die Steigung l und den y-Achsenabschnitt n
	der Geraden G durch P1 und P2 bzw. der Tangente an P1, falls P1=P2.
		G: y = l*x + n.
	ecnflp liefert falls moeglich eine 2-elementige Liste aus Steigung
	und y-Achsenabschnitt: L = ( l, n ).
	ecnflp liefert ( 0 ), falls P1 = -P2,
		       ( 1 ), falls P1 der Punkt im Unendlichen ist und
		       ( 2 ), falls P2 der Punkt im Unendlichen ist.
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.58.



			ecnfmul( F, a1, a2, a3, a4, a6, n, P1 )

	"elliptic curve over number field multiplication-map"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecnfmul( F, a1, a2, a3, a4, a6, P1 )  pol F;
		nfel a1, a2, a3, a4, a6; single n, list P1;
	Pn = ecnfmul( F, a1, a2, a3, a4, a6, n, P1 );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a1, a2, a3, a4, a6 sind Elemente dieses Koerpers K.
		- n ist eine natuerliche Zahl.
		- P1 ist eine 3-elementige Liste von Elementen
		  des Koerpers K.
	Fuer einen in projektiver Darstellung als 3-elementige Liste
	gegenenen Punkt P1 = ( x1, y1, z1 ) auf der durch a1, ..., a6
	in Weierstrass-Normalform gegebenen elliptischen Kurve E berechnet
	ecnfmul das Vielfache Pn = n*P1 = ( xn, yn, zn ) und gibt dieses
	als 3-elementige Liste von Elementen aus K zurueck.



			ecnfneg( F, a1, a2, a3, a4, a6, P )

	"elliptic curve over number field negative point"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecnfneg( F, a1, a2, a3, a4, a6, P )  pol F;
		nfel a1, a2, a3, a4, a6; list P;
	L = ecnfneg( F, a1, a2, a3, a4, a6, P );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a1, a2, a3, a4, a6 sind Elemente dieses Koerpers K.
		- P ist eine 3-elementige Liste von Elementen
		  des Koerpers K.
	Fuer einen in projektiver Darstellung als 3-elementige Liste
	gegebenen Punkt P auf der durch a1, ... , a6 in Weierstrass-
	Normalform gegebenen elliptischen Kurve E berechnet ecnfneg
	das negative des Punktes P in projektiver Darstellung und gibt
	dieses als 3-elementige Liste zurueck.
	Literatur: J.H. Silverman, The arithmetic of elliptic curves, p.58.



			ecnfsnfdisc( F, a, b )

	"elliptic curve over number field, short normal form, discriminant"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	nfel ecnfsnfdisc( F, a, b )  pol F; nfel a, b;
	D = ecnfsnfdisc( F, a, b );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a, b sind Elemente dieses Koerpers K.
	ecnfsnfdisc berechnet die Diskriminante D der durch a und b in
	kurzer Weierstrass-Normalform gegebenen kubischen Kurve.
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.50.



			ecnfsnfjinv( F, a, b )

	"elliptic curve over number field, short normal form, j-invariant"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	nfel ecnfsnfjinv( F, a, b )  pol F; nfel a, b;
	j = ecnfsnfjinv( F, a, b );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a, b sind Elemente dieses Koerpers K.
	ecnfsnfjinv berechnet die j-Invariante j der durch a und b in
	kurzer Weierstrass-Normalform gegebenen elliptischen Kurve.
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.50.



			ecnfsnflp( F, a, b, P1, P2 )

	"elliptic curve over number field short normal form line through
	 points"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list( F, a, b, P1, P2 )  pol F; nfel a, b; list P1, P2;
	L = ecnfsnflp( F, a, b, P1, P2 );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a, b sind Elemente dieses Koerpers K.
		- P1 und P2 sind 3-elementige Listen von Elementen
		  des Koerpers K.
	P1 und P2 sind 3-elementige Listen als projektive Darstellungen
	von Punkten auf der durch a und b in kurzer Weierstrass-
	Normalform gegebenen elliptischen Kurve E.
	ecnfsnflp berechnet die Steigung l und den y-Achsenabschnitt n
	der Geraden G durch P1 und P2 bzw. der Tangente an P1, falls P1=P2.
		G: y = l*x + n.
	ecnfsnflp liefert falls moeglich eine 2-elementige Liste aus
	Steigung und y-Achsenabschnitt: L = ( l, n ).
	ecnfsnflp liefert ( 0 ), falls P1 = -P2,
			  ( 1 ), falls P1 der Punkt im Unendlichen ist und
			  ( 2 ), falls P2 der Punkt im Unendlichen ist.
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.58.



			ecnfsnfmul( F, a, b, n, P1 )

	"elliptic curve over number field short normal form
	 multiplication-map"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecnfsnfmul(F,a,b,n,P1)  pol F; nfel a,b; single n; list P1;
	P3 = ecnfsnfmul( F, a, b, n, P1 );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a, b sind Elemente dieses Koerpers K.
		- n ist eine natuerliche Zahl.
		- P1 ist eine 3-elementige Liste von Elementen
		  des Koerpers K.
	Fuer einen in projektiver Darstellung als 3-elementige Liste
	gegebenen Punkt P1 = ( x1, y1, z1 ) auf der durch a und b in
	kurzer Weierstrass-Normalform gegebenen elliptischen Kurve E
	berechnet ecnfsnfmul das Vielfache Pn = n*P1 = ( xn, yn, zn )
	und gibt dieses als 3-elementige Liste von Elementen aus K zurueck.



			ecnfsnfneg( F, a, b, P )

	"elliptic curve over number field short normal form negative point"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecnfsnfneg( F, a, b, P )  pol F; nfel a, b; list P;
	L = ecnfsnfneg( F, a, b, P );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a, b sind Elemente dieses Koerpers K.
		- P ist eine 3-elementige Liste von Elementen
		  des Koerpers K.
	Fuer einen in projektiver Darstellung als 3-elementige Liste
	gegebenen Punkt P auf der durch a ung b in kurzer Weierstrass-
	Normalform gegebenen elliptischen Kurve E berechnet ecnfsnfneg
	das Negative des Punktes P in projektiver Darstellung und gibt
	dieses als 3-elementige Liste zurueck.
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.58.



			ecnfsnfsum( F, a, b, P1, P2 )

	"elliptic curve over number field short normal form sum of points"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecnfsnfsum( F, a, b, P1, P2 )  pol F; nfel a, b; list P1, P2;
	P3 = ecnfsnfsum( F, a, b, P1, P2 );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a, b sind Elemente dieses Koerpers K.
		- P1 und P2 sind 3-elementige Listen von Elementen
		  des Koerpers K.
	P1 = ( x1,y1,z1 ) und P2 = ( x2,y2,z2 ) sind 3-elementige Listen
	als projektive Darstellungen von Punkten auf der durch a und b in
	kurzer Weierstrass-Normalform gegebenen elliptischen Kurve.
	ecnfsnfsum berechnet die Summe P3 der beiden Punkte P1 und P2  und
	gibt diese als 3-elementige Liste von Elementen aus K zurueck:
	P3 = ( x3, y3, z3 ).
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.59.



			ecnfsrpp( F, P )

	"elliptic curve over number field standard representation of
	 projective point"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecnfsrpp( F, P )  pol F; list P;
	Q = ecnfsrpp( F, P );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense Darstellung, das einen Zahlkoerper K erzeugt.
		- P ist eine 3-elementige Liste von Elementen
		  des Koerpers K.
	ecnfsrpp berechnet fuer den projektiven Punkt P = ( x, y, z )
	eine Darstellung Q = (x', y', z' ), so dass gilt:
		z' = 1,          falls z != 0,
		Q = ( 0, 1, 0 ), falls z == 0.



			ecnfsum( F, a1, a2, a3, a4, a6, P1, P2 )

	"elliptic curve over number field sum of points"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecnfsum( F, a1, a2, a3, a4, a6, P1, P2 )  pol F;
		nfel a1, a2, a3, a4, a6; list P1, P2;
	P3 = ecnfsum( F, a1, a2, a3, a4, a6, P1, P2 );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das ein Zahlkoerper K erzeugt.
		- a1, a2, a3, a4, a6 sind Elemente dieses Koerpers K.
		- P1 und P2 sind 3-elementige Listen von Elementen
		  des Koerpers K.
	P1 = ( x1,y1,z1 ) und P2 = ( x2,y2,z2 ) sind 3-elementige Listen
	als projektive Darstellungen von Punkten auf der durch a1, ... , a6
	in Weierstrass-Normalform gegebenen elliptischen Kurve.
	ecnfsum berechnet die Summe P3 der beiden Punkte P1 und P2 und
	gibt diese als 3-elementige Liste von Elementen aus K zurueck:
	P3 = ( x3, y3, z3 ).
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.59.



			ecnftavb6( F, a1, a2, a3, a4, a6 )

	"elliptic curve over number field Tate's values b2, b4, b6"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecnftavb6( F, a1, a2, a3, a4, a6 ) pol F; nfel a1,a2,a3,a4,a6;
	L = ecnftavb6( F, a1, a2, a3, a4, a6 );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a1, a2, a3, a4, a6 sind Elemente dieses Koerpers K.
	ecnftavb6 berechnet die Tateschen Groessen b2, b4 und b6 fuer die
	durch die Koeffizienten a1, ... , a6 in Weierstrass-Normalform
	gegebene kubische Kurve und gibt diese als Liste
	L = ( b2, b4, b6 ) zurueck.
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.46.



			ecnftavb8( F, a1, a2, a3, a4, a6 )

	"elliptic curve over number field Tate's values b2, b4, b6, b8"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecnftavb8( F, a1, a2, a3, a4, a6 ) pol F; nfel a1,a2,a3,a4,a6;
	L = ecnftavb8( F, a1, a2, a3, a4, a6 );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a1, a2, a3, a4, a6 sind Elemente dieses Koerpers K.
	ecnftavb8 berechnet die Tateschen Groessen b2,b4,b6 und b8 fuer die
	durch die Koeffizienten a1, ... , a6 in Weierstrass-Normalform
	gegebene kubische Kurve und gibt diese als Liste
	L = ( b2, b4, b6, b8 ) zurueck.
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.46.



			ecnftavc6( F, a1, a2, a3, a4, a6 )

	"elliptic curve over number field Tate's values c4, c6"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecnftavc6( F, a1, a2, a3, a4, a6 ) pol F; nfel a1,a2,a3,a4,a6;
	L = ecnftavc6( F, a1, a2, a3, a4, a6 );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a1, a2, a3, a4, a6 sind Elemente dieses Koerpers K.
	ecnftavc6 berechnet die Tateschen Groessen c4 und c6 fuer die
	durch die Koeffizienten a1, ... , a6 in Weierstrass-Normalform
	gegebene elliptische Kurve und gibt diese als Liste
	L = ( c4, c6 ) zurueck.
	Literatur: D. Husemoeller: Elliptic curves, p.68.



			ecnftosnf( F, a1, a2, a3, a4, a6 )

	"elliptic curve over number field to short normal form"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecnftosnf( F, a1, a2, a3, a4, a6 ) pol F; nfel a1,a2,a3,a4,a6;
	L = ecnftosnf( F, a1, a2, a3, a4, a6 );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a1, a2, a3, a4, a6 sind Elemente dieses Koerpers K.
	ecnftosnf berechnet zu der durch a1, ... , a6  in Weierstrass-
	Normalform gegebenen elliptischen Kurve E eine birational
	isomorphe Kurve E' in kurzer Weierstrass-Normalform mit den
	Koeffizienten a und b gemaess folgender Transformationen:
		x = u^2*x' + r,
		y = u^3*y' + u^2*s*x' + t,
		z = z'.
	ecnftosnf liefert eine Liste, die ihrerseits aus 2 Listen besteht:
		L = ( ( a, b ), ( r, s, t, u ) ).
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.48.



			ecqnfacb2( E )

	"elliptic curve over quadratic number field, actual model, 
	 Tate value b2"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	nfel ecqnfacb2( E )  list E;
	b2 = ecqnfacb2( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q(D^(1/2)) (siehe ecqnfinit).
        ecqnfacb2 liefert den Tate'schen Koeffizienten b2 des 
	urspruenglichen (aktuellen) Modells der elliptischen Kurve 
	E/Q(D^(1/2)).
	Falls der Wert b2 des urspruenglichen Modells noch nicht in 
	der Liste E vorhanden ist, wird er (zusammen mit b4, b6 und 
	b8) berechnet und dort abgelegt.
	E wird veraendert.



			ecqnfacb4( E )

	"elliptic curve over quadratic number field, actual model, 
	 Tate value b4"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	nfel ecqnfacb4( E )  list E;
	b4 = ecqnfacb4( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q(D^(1/2)) (siehe ecqnfinit).
        ecqnfacb4 liefert den Tate'schen Koeffizienten b4 des 
	urspruenglichen (aktuellen) Modells der elliptischen Kurve 
	E/Q(D^(1/2)).
	Falls der Wert b4 des urspruenglichen Modells noch nicht in 
	der Liste E vorhanden ist, wird er mittels ecqnfacb2 berechnet
	und dort abgelegt.
	E wird veraendert.



			ecqnfacb6( E )

	"elliptic curve over quadratic number field, actual model, 
	 Tate value b6"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	nfel ecqnfacb6( E )  list E;
	b6 = ecqnfacb6( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q(D^(1/2)) (siehe ecqnfinit).
        ecqnfacb6 liefert den Tate'schen Koeffizienten b6 des 
	urspruenglichen (aktuellen) Modells der elliptischen Kurve 
	E/Q(D^(1/2)).
	Falls der Wert b6 des urspruenglichen Modells noch nicht in 
	der Liste E vorhanden ist, wird er mittels ecqnfacb2 berechnet
	und dort abgelegt.
	E wird veraendert.



			ecqnfacb8( E )

	"elliptic curve over quadratic number field, actual model, 
	 Tate value b8"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	nfel ecqnfacb8( E )  list E;
	b8 = ecqnfacb8( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q(D^(1/2)) (siehe ecqnfinit).
        ecqnfacb8 liefert den Tate'schen Koeffizienten b8 des 
	urspruenglichen (aktuellen) Modells der elliptischen Kurve 
	E/Q(D^(1/2)).
	Falls der Wert b8 des urspruenglichen Modells noch nicht in 
	der Liste E vorhanden ist, wird er mittels ecqnfacb2 berechnet
	und dort abgelegt.
	E wird veraendert.



			ecqnfacc4( E )

	"elliptic curve over quadratic number field, actual model, 
	 Tate value c4"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	nfel ecqnfacc4( E )  list E;
	c4 = ecqnfacc4( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q(D^(1/2)) (siehe ecqnfinit).
        ecqnfacc4 liefert den Tate'schen Koeffizienten c4 des 
	urspruenglichen (aktuellen) Modells der elliptischen Kurve 
	E/Q(D^(1/2)).
	Falls der Wert c4 des urspruenglichen Modells noch nicht in 
	der Liste E vorhanden ist, wird er (zusammen mit c6) berechnet
	und dort abgelegt.
	E wird veraendert.



			ecqnfacc6( E )

	"elliptic curve over quadratic number field, actual model, 
	 Tate value c6"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	nfel ecqnfacc6( E )  list E;
	c6 = ecqnfacc6( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q(D^(1/2)) (siehe ecqnfinit).
        ecqnfacc6 liefert den Tate'schen Koeffizienten c6 des 
	urspruenglichen (aktuellen) Modells der elliptischen Kurve 
	E/Q(D^(1/2)).
	Falls der Wert c6 des urspruenglichen Modells noch nicht in 
	der Liste E vorhanden ist, wird er mittels ecqnfacc4 berechnet
	und dort abgelegt.
	E wird veraendert.



			ecqnfacdisc( E )

	"elliptic curve over quadratic number field, actual model, 
	 discriminant"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	nfel ecqnfacdisc( E )  list E;
	Delta = ecqnfacdisc( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q(D^(1/2)) (siehe ecqnfinit).
        ecqnfacdisc liefert die Diskriminante des urspruenglichen 
	(aktuellen) Modells der elliptischen Kurve E/Q(D^(1/2)).
	Falls die Diskriminante des urspruenglichen Modells noch 
	nicht in der Liste E vorhanden ist, wird sie berechnet und 
	dort abgelegt.
	E wird veraendert.



			ecqnfacfndisc( E )

	"elliptic curve over quadratic number field, actual model, 
	 factorization of the norm of the discriminant"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecqnfacfndisc( E )  list E;
	F = ecqnfacfndisc( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q(D^(1/2)) (siehe ecqnfinit).
	ecqnfacfndisc liefert eine Liste 
	      F = ( p_1  e_1  p_2  e_2 ...  p_n  e_n ) 
	      int p_1, p_2, ..., p_n; single e_1, e_2, ..., e_n;
	mit der vollstaendigen (Prim-) Faktorisierung des Betrags der
	Norm der Diskriminante des urspruenglichen Modells der
	elliptischen Kurve E/Q(D^(1/2)).
	Die Primzahlen p_i sind wie folgt angeordnet: 
	Zuerst werden die Primteiler des Zaehlers p_1 > p_2 > ... > p_r 
	mit positiven Exponenten ei, anschliessend die Primteiler des 
	Nenners p_(r+1) > p_(r+2) > ... > p_n mit negativen Exponenten
	e_j aufgelistet.
	Falls die Liste F noch nicht in der Liste E vorhanden ist, so
	wird sie berechnet und dort abgelegt.
	E wird veraendert.



			ecqnfacndisc( E )

	"elliptic curve over quadratic number field, actual model, 
	 norm of the discriminant"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	rat ecqnfacndisc( E )  list E;
	N = ecqnfacndisc( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q(D^(1/2)) (siehe ecqnfinit).
        ecqnfacndisc liefert die Norm der Diskriminante des 
	urspruenglichen (aktuellen) Modells der elliptischen Kurve 
	E/Q(D^(1/2)).
	Falls die Norm der Diskriminanten des urspruenglichen Modells
	noch nicht in der Liste E vorhanden ist, wird sie berechnet
	und dort abgelegt.
	E wird veraendert.



			ecqnfacpifdi( E )

	"elliptic curve over quadratic number field, actual model, 
	 prime ideal factorization of the discriminant"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecqnfacpifdi( E )  list E;
	F = ecqnfacpifdi( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q(D^(1/2)) (siehe ecqnfinit).
	ecqnfacpifdi liefert eine Liste 
	      F = ( P_1  e_1  P_2  e_2 ...  P_n  e_n ) 
	      list P_1, P_2, ..., P_n; single e_1, e_2, ..., e_n;
	mit der vollstaendigen Primidealfaktorisierung der Diskriminante
	des urspruenglichen Modells der elliptischen Kurve E/Q(D^(1/2)).
	Die Primideale Pi_ sind wie folgt angeordnet: 
	Zuerst werden die Primideale des Zaehlers P_1, P_2, ..., P_r 
	( Norm(P_i) <= Norm(P_i+1) ) mit positiven Exponenten e_i, an-
	schliessend die Primideale des Nenners P_(r+1), P_(r+2),..., P_n
	(gleiche Anordnung wie oben) mit negativen Exponenten e_j 
	aufgelistet. 
	Die Primideale haben folgende Darstellung: 
	P = ( p pi e )  int p; nfel pi; single e;
	wobei p die Primzahl ist, die von P auf K fortgesetzt wird und pi 
	eine zu P gehoerige Ortsuniformisierende. e gibt das Zerlegungs-
	gesetz von p in K an: 
		  / 0, falls p traege   : (p) = P
            e  = <  1, falls p verzweigt: (p) = P^2
                  \ 2, falls p zerlegt  : (p) = P * P'
	Falls die Liste F noch nicht in der Liste E vorhanden ist, so
	wird sie berechnet und dort abgelegt.
	E wird veraendert.



			ecqnfcond( E )

	"elliptic curve over quadratic number field, conductor"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecqnfcond(E)  list E;
	N = ecqnfcond(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der ell. Kurve
	E/K, K = Q(D^(1/2)) quadratischer Zahlkoerper (siehe ecqnfinit).  
        Falls der Fuehrer von E/K noch nicht in der Liste E vorhanden ist,
	so wird er (zusammen mit seiner Faktorisierung in Primideale, den
	c_P-Werten und den Neron- bzw. Kodaira-Typen) berechnet und dort
	abgelegt.
	ecqnfcond liefert 
	  - bei korrektem Lauf den Fuehrer N der elliptischen Kurve E/K;
	    N ist ein Ideal (als Liste dargestellt, siehe qnfidprod);
          - ERROR sonst.
	E wird veraendert.



			ecqnfdmod4( E )                 (MACRO)

	"elliptic curve over quadratic number field, field discriminant
	 modulo 4"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single ecqnfdmod4( E )  list E;
	d = ecqnfdmod4( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q(D^(1/2)) (siehe ecqnfinit).
        ecqnfdmod4 liefert 1, falls D = 1 mod 4 ist, und 0 sonst.



			ecqnfflddisc( E )               (MACRO)

	"elliptic curve over quadratic number field, field discriminant"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	int ecqnfflddisc( E )  list E;
	disc = ecqnfflddisc( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q(D^(1/2)) (siehe ecqnfinit).
        ecqnfflddisc liefert die Diskriminante von Q(D^(1/2)), also
	disc = 4D  fuer D kongruent 2 oder 3 modulo 4,
                D  fuer D kongruent 1 modulo 4.



			ecqnfinit( D, a1, a2, a3, a4, a6 )

	"elliptic curve over quadratic number field, initialization"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecqnfinit( a1, a2, a3, a4, a6 )  nfel a1, a2, a3, a4, a6;
	E = ecqnfinit( a1, a2, a3, a4, a6 )
	Seien K = Q(D^(1/2)) ein quadratischer Zahlkoerper und
	E die durch die Koeffizienten a1, a2, a3, a4, a6 in
	Weierstrass-Normalform gegebene elliptische Kurve ueber K. 
	(zur Darstellung von Zahlkoerperelementen siehe fputnfel)
	ecqnfinit liefert eine aus 5 Listen bestehende Liste 
	     L = ( L1  L2  L3  L4  L5 ).
	ecqnfinit traegt die Werte a1, a2, a3, a4, a6 in die
	Liste L11 ein (s.u.) und initialisiert alle anderen Listen
	Lij als leere Listen. Dabei wird folgendes Konzept verfolgt:
	In L1 stehen die Daten des "aktuellen" (urspruenglichen, tat-
	saechlichen) Modells ('actual curve' oder 'actual model'). 
	Funktionen, die Daten aus der Liste L1 benutzen oder veraen-
	dern, beginnen mit dem Praefix 
		'ecqnfac' 
	fuer
	   	e(lliptic) c(urve over) q(uadratic n(umber) f(ield), 
		a(ctual) c(urve).
	Fuer L2 werden 2 Faelle unterschieden:
	   1. Fall: Ein global minimales Modell existiert in K.
	            Dann stehen in L2 die Daten des global minimalen
		    Modells von eingeschraenktem Typ, d.h. die 
		    Koeffizienten a1, a2, a3, a4, a6 in L2 sind die in 
		    K ganzen Koeffizienten eines global minimalen Modells 
		    fuer E/K mit 
			a1,a3 aus {0,1}, falls 2 verzweigt oder zerlegt
					 in K ist;
			a1,a3 aus {a+b*omega; a,b = 0,1}, falls 2 traege
					 in K ist;
			a2 aus {-1,0,1}, falls 3 verzweigt oder zerlegt
					 in K ist;
			a2 aus {a+b*omega; a,b = -1,0,1}, falls 3 traege
					 in K ist.
		    Dabei ist {1,omega} Ganzheitsbasis von K ueber Q, d.h.
			omega = D^(1/2), falls D = 2,3 (mod 4);
			omega = (1+D^(1/2) / 2, falls D = 1 (mod4).
	   2. Fall: Ein global minimales Modell existiert nicht.
	            Dann stehen in L2 Listen ( P_i  pi_i  z_i  LP_i ) 
		        list P_i, LP_i; nfel pi_i, single z_i;
		    mit einem Primideal P_i (zur Darstellung von Idealen 
		    siehe qnfidprod), das eine Primzahl p auf K fortsetzt 
		    und bzgl. dem E/K schlechte Reduktion hat, pi_i eine 
		    zu P gehoerige Ortsuniformisierende; z_i gibt das Zer-
		    legungsgesetz von p an. LP_i enthaelt dann die Daten 
		    des bzgl. P_i minimalen Modells von eingeschraenktem 
		    Typ (s.o.).
	   Funktionen, die Daten aus der Liste L2 benutzen oder 
	   veraendern, beginnen mit dem Praefix 
		'ecqnfmin' 
	   fuer 
	   	e(lliptic) c(urve over) q(uadratic n(umber) f(ield), 
		min(imal model).
	In L3 stehen die Daten eines Modells in kurzer Weierstrass-
	   Normalform (kWNF). Falls E/K ein global minimales Modell
	   besitzt, so wird folgendes Modell gewaehlt:
	      1. Das minimale Modell ist bereits in kWNF: Dann werden
		 die Koeffizienten a4 und a6 aus L21 gewaehlt (s.u.).
	      2. Das minimale Modell ist nicht in kWNF: Dann wird
		 das Modell   Y^2 = X^3 - 27 * c4 * X - 54 * c6   mit
		 den Koeffizienten c4 und c6 aus L23 gewaehlt (s.u.).
           Falls E/K kein global minimales Modell besitzt, so wird
	   das zur ersten Primzahl P_1 in der Liste L2 lokal minimale
	   Modell statt des global minimalen Modells verwendet, und die
	   Koeffizienten werden analog zu oben bestimmt.
	   Funktionen, die Daten aus der Liste L3 benutzen oder 
	   veraendern, beginnen mit dem Praefix 
		'ecqnfsnf' 
	   fuer 
	   	e(lliptic) c(urve over) q(uadratic n(umber) f(ield), 
	    	s(hort) n(ormal) f(orm).
	In L4 stehen alle Invarianten der Kurve, die nicht vom 
	   jeweiligen Modell der Kurve abhaengen.
	   Funktionen, die Daten aus der Liste L4 benutzen oder
	   veraendern, beginnen mit dem Praefix 
		'ecqnfinv' 
	   fuer 
	   	e(lliptic) c(urve over) q(uadratic n(umber) f(ield), 
		inv(ariants of the curve).
	In L5 stehen Daten des quadratischen Zahlkoerpers, ueber dem
	   E definiert ist (s.u.).
        Die Liste L1 hat die Form ( L11  L12  L13  L14  L15  L16  L17 )
           mit L11 = ( a1a  a2a  a3a  a4a a6a )  nfel a1a,a2a,a3a,a4a,a6a;
               L12 = ( b2a  b4a  b6a  b8a )  nfel b2a, b4a, b6a, b8a;
               L13 = ( c4a  c6a )  nfel c4a, c6a;
               L14 = ( Da  FDa  NDa   FNDa )  nfel Da; list FDa, FNDa;
	                                      rat NDa;
               L15 = ( TPa  GTa )  list TPa, GTa;
               L16 = ( BTam  BTas )  list BTam, BTas;
                     bzw.
                   = ( ( BTam_1 ... BTam_k )  BTas )  list BTam_i, BTas;
               L17 = Ba  list Ba;
	   Dabei gilt 
	     - a1a, a2a, a3a, a4a, a6a sind die Koeffizieneten
	       der aktuellen Gleichung fuer E/K,
	     - b2a, b4a, b6a, b8a, c4a, c6a sind die Tateschen
	       Groessen der aktuellen Gleichung,
	     - Da ist die Diskriminante der aktuellen Gleichung,
	     - FDa = ( P1  f1  P2  f2 ... )  list Pi; single fi;
	       ist die Faktorisierung von Da in Primideale.
	     - NDa ist die Norm von Da.
	     - FNDa = ( p1  e1  p2  e2 ... )  int pi; single ei;
	       ist die Faktorisierung von NDa.
	     - TPa ist eine Liste mit allen Torsionspunkten des 
	       aktuellen Modells.
	     - GTa ist eine Liste von Erzeugern der Torsionsgruppe 
	       des aktuellen Modells, ( T ) oder ( T1  T2 ).
	     - BTam = ( r_am  s_am  t_am  u_am )  nfel r_am,s_am,t_am,u_am
	       ist die birationale Transformation, die die aktuelle in die 
	       minimale Gleichung ueberfuehrt,
	       bzw. BTam_i = ( r_am_i ... u_am_i )  ...
	       ist die birationale Transformation, die die aktuelle in die 
	       bzgl. P_i minimale Gleichung ueberfuehrt.
	     - BTrs = ( r_rs  s_rs  t_rs  u_rs )  nfel r_rs,s_rs,t_rs,u_rs
	       ist die birationale Transformation, die die aktuelle in die 
	       kurze Gleichung ueberfuehrt.
	     - Br = ( Pr_1  Pr_2  ...  Pr_r )  list Pr_1, Pr_2, ..., Pr_r; 
	       ist eine Basis der Mordell-Weil-Gruppe des urspruenglichen 
	       Modells von E/K, wobei r der Rang der Kurve ist. 
	Die Liste L2 hat folgende Form:
	  - Falls ein global minimales Modell existiert:
	      ( L21  L22  L23  L24  L25  L26  L27 )
	      mit L21 = (a1m a2m a3m a4m a6m)  nfel a1m, a2m, a3m, a4m,a6m;
                  L22 = (b2m b4m b6m b8m)  nfel b2m, b4m, b6m, b8m;
                  L23 = (c4m c6m)  nfel c4m, c6m;
                  L24 = (Dm FDm)  nfel Dm; list FDm;
                  L25 = (TPm GTm)  list TPm, GTm;
                  L26 = (BTmr BTms)  list BTmr, BTms;
                  L27 = Bm  list Bm; 
	  - Falls kein global minimales Modell existiert:
	       ( (P_1  LP_1) ... (P_k  LP_k) ) mit 
               LP_i = ( LP_i1  LP_i2  LP_i3  LP_i4  LP_i5  LP_i6  LP_i7 )
	       und LP_i1 = (aP_i1 aP_i2 aP_i3 aP_i4 aP_i6)  
		       nfel aP_i1, aP_i2, aP_i3, aP_i4, aP_i6;
               (LP_i2, ..., LP_i7 analog zu L22, ..., L27).
          Dabei enthalten die Listen L2n bzw. LP_in (1 <= n <= 7) die
	  den Listen L1n entsprechenden Daten des global bzw. bzgl. P_i 
	  lokal minimalen Modells von E/K mit den birationalen Transfor-
	  mationen vom (jeweiligen) minimalen zum aktuellen bzw. kurzen 
	  Modell.
        Die Liste L3 hat die Form ( L31  L32  L33  L34  L35  L36  L37 )
	   mit L31 = ( a4s a6s )  nfel a4s, a6s;
	       L32 = ( b2s  b4s  b6s  b8s )  nfel b2s, b4s, b6s, b8s;
               L33 = ( c4s  c6s )  nfel c4s, c6s;
               L34 = ( Ds  FDs )  nfel Ds; list FDs;
               L35 = ( TPs  GTs)  list TPs, GTs;
               L36 = ( BTsr BTsm )  list BTsr, BTsm;
               L37 = Bs  list Bs;
        Dabei gilt:
	     - a4s und a6s sind die Koeffizienten eines Modells in
               kurzer Weierstrass-Normalform (kWNF, s.o.).
             - L3i analog zu L1i (2 <= i <= 7) mit kurzem statt aktuellem
	       Modell und den birationalen Transformationen von der kWNF
	       zum aktuellen bzw. zum minimalen Modell.
        Die Liste L4 hat die Form ( L41  L42  L43  L44  L45 )
	   mit L41 = ( j  Fnj )  nfel j, list Fnj;
               L42 = ( N  FN  Nrt  Lcp )  list N, FN, Nrt, Lcp;
               L43 = ( oT  ST )  single oT; list ST;
               L44 = ( C r  Lr  R TS )  single C, r, TS; floating Lr, R;
               L45 = ( w )  floating w;
           Dabei gilt:
	     - j ist die j-Invariante von E/K.
             - Fnj = ( P1 e1 ... Pk ek ) ist die Faktorisierung des
	       Nenners der j-Invariante in Primideale.
             - N = ( NN  No )  int NN; nfel No; ist der Fuehrer von E/K.
	       N ist ein Ideal mit Norm NN und Ortsuniformisierender No.
             - FN = ( P1 f1 ...  Pn fn ) ist die Faktorisierung von N
	       in Primideale.
             - Nrt = ( P1 t1 ...  Pn tn ) gibt alle Primideale, bzgl.  
	       denen E/K schlechte Reduktion hat, zusammen mit dem 
	       Reduktionstyp nach Kodaira an.
             - Lcp = ( c cP1 ...  cPn )  single c, cP1, ..., cPn; 
	       Dabei ist c das Produkt ueber alle cP-Werte mit P|N, 
	       und cP1, ..., cPn sind die zu P1, ..., Pn gehoerigen 
	       cP-Werte.
             - oT ist die Ordnung der Torsionsgruppe von E/K.
	     - ST = ( oT ) oder ( oT/2  2 ) ist eine Liste, die die
               Struktur der Torsionsgruppe von E/K angibt.
               Wichtig: Im nicht-zyklischen Fall muss oT/2 vornestehen,
	       damit sichergestellt ist, dass die erste Zahl in der Liste
	       ST auch der Gruppenexponent e ist, d.h.
                  e * P = ( 0 : 1 : 0) <==> P ist Torsionspunkt auf E/K.
             - C ist das Vorzeichen der Funktionalgleichung der L-Reihe
               von E/K.
             - r ist der Rang der elliptischen Kurve E/K.
             - TS ist die Ordnung der Tate-Shafarevic-Gruppe III.
             - Lr ist der Wert der r-ten Ableitung der L-Reihe
               L(E, s) von E/K bei s = 1 (r = Rang von E/K).
             - R ist der Regulator von E/K.
	     - w ist die reelle Periode omega.
        Die Liste L5 hat die Form ( D  d4 )  int D; single d4;
	     mit der Koerperdiskriminanten D von K und dem Wert
	           / 1, falls D = 1 mod 4, 
	     d4 = <
	           \ 0 sonst.



			ecqnfjinv( E )

	"elliptic curve over quadratic number field, j-invariant"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	nfel ecqnfjinv( E )  list E;
	j = ecqnfjinv( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q(D^(1/2)) (siehe ecqnfinit).
        ecqnfjinv liefert die j-Invariante j = (c4)^3 / Delta
	der elliptischen Kurve E/Q(D^(1/2)).
	Falls j noch nicht in der Liste E vorhanden ist, wird j
	berechnet und dort abgelegt.
	E wird veraendert.



			ecqnftatealg( D, LC, LTV, P, pi, z, n )

	"elliptic curve over quadratic number field, Tate's algorithm"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecqnftatealg( D, LC, LTV, P, pi, z, n )
		int D; list LC, LTV, P; nfel pi; single z, n;
	Dabei muss gelten:
	  - D ist aus Z\{0,1} und quadratfrei.
          - LC = ( a1  a2  a3  a4  a6 )  nfel a1, a2, a3, a4, a6;
	    ist eine Liste mit den Koeffizienten a1, ..., a6 einer
	    elliptischen Kurve E/K, K = Q(D^(1/2)).
	    Es gilt: a_i in O_D (= Ganzheitsring von K).
          - LTV = ( b2  b4  b6  b8  c4 )  nfel b2, b4, b6, b8, c4;
	    ist eine Liste mit den zu LC gehoerigen Tate'schen Werten.
          - P ist ein Primideal in O_D, das die Diskriminante D von 
	    E/K teilt. P ist die Fortsetzung einer Primzahl p auf K.
	  - pi ist eine zu P gehoerige Ortsuniformisierende,
	  - z gibt das Zerlegungsgesetz von p an: z = 0, 1, oder 2,
	    falls p traege, verzweigt bzw. zerlegt ist.
          - n > 0. P^n ist die hoechste P-Potenz, die die 
	    Diskriminante der Kurve E/K teilt.
	ecqnftatealg berechnet nach dem Tateschen Algorithmus 
	  - den Reduktionstyp der Kurve E modulo P,
	  - den Exponenten des Fuehrers von E bei P,
	  - den c_P-Wert von E modulo P.
	ecqnftatealg liefert:
          - bei fehlerhaftem Lauf eine einelementige Liste mit Eintrag 
	    1, 2, ..., 8 oder 9 (entsprechend der Stelle im Algorithmus,
	    an der keine Transformation gefunden werden konnte, so dass
	    E die geforderten Teilbarkeitsbedingungen erfuellt).
          - bei korrektem Lauf: Falls die urspruengliche Gleichung fuer E
	    modulo P minimal war, eine dreielementige Liste
              ( exp  rtyp  c_P )  single exp, rtyp, c_P;
            mit
              * dem Exponenten exp des lokalen Fuehrers
	      * dem Reduktionstyp rtyp gemaess der folgenden Tabelle
                      | rtyp   | Kodaira | Neron  |  c_P-Wert   | 
                      |--------|---------|--------|-------------|
                      | -n < 0 |    In   |   Bn   | 1, 2 oder n |
                      |--------|---------|--------|-------------|
                      |    1   |    II   |   C1   |      1      |
                      |--------|---------|--------|-------------|
                      |    2   |   III   |   C2   |      2      |
                      |--------|---------|--------|-------------|
                      |    3   |    IV   |   C3   |   1 oder 3  |
                      |--------|---------|--------|-------------|
                      |    5   |    I0*  |   C4   |   2 oder 4  |
                      |--------|---------|--------|-------------|
                      | 10 + v |    In*  |  C5,v  |   2 oder 4  |
                      |--------|---------|--------|-------------|
                      |    6   |    IV*  |   C6   |   1 oder 3  |
                      |--------|---------|--------|-------------|
                      |    7   |   III*  |   C7   |      2      |
                      |--------|---------|--------|-------------|
                      |    8   |    II*  |   C8   |      1      |
                      -------------------------------------------
              * dem Wert c_P = #E(K)/E0(K), wobei 
	           E0( K ) = { S in E( K ) | S = ( 0 : 1 : 0 ) mod P },
	                      /          | S wird unter der Reduktion \
	                   = < S in E(K) | modulo P auf den unendlich  >
		              \          | fernen Punkt abgebildet    /
	   Falls die urspruengliche Gleichung fuer E modulo P
	   nicht minimal war, eine fuenfelementige Liste
	      ( a1'  a2'  a3'  a4'  a6' )  nfel a1', ..., a6';
           so dass fuer die Diskriminante D' des Modells bzgl. der ai' 
	   gilt:
	       D' = P^(-12) * D.
	Literatur: Tate, J.T.: Algorithm for finding the type of a
			       singular fiber in an elliptic pencil.
		   Modular functions in one variable IV. Antwerp 1972.
		   Lect. Notes Math. 476 ( 1975 ), 33 - 52.



			ecqnftoeci( D, L )

	"elliptic curve over quadratic number field to elliptic curve 
	 with integral coefficients"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecqnftoeci( D, L )  int D; list L;
	M = ecqnftoeci( D, L );
        D ist aus Z\{0,1} und quadratfrei.
	L = ( a1  a2  a3  a4  a6 )  nfel a1, a2, a3, a4, a6; 
	ist eine Liste mit den Koeffizienten einer elliptischen
	Kurve E ueber dem quadratischen Zahlkoerper Q(D^(1/2)).
	ecqnftoeci liefert eine Liste 
        M = ( a1'  a2'  a3'  a4'  a6' )  nfel a1', a2', a3', a4', a6';
	mit Werten ai' im Ganzheitsring O_D von Q(D^(1/2)), 
	den Koeffizienten einer zu
	     Y^2 + a1 X Y + a3 Y = X^3 + a2 X^3 + a4 X + a6
        birational aequivalenten elliptischen Kurve.



			ecraca1( E )                    (MACRO)

	"elliptic curve over rational numbers, actual curve, a1"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	rat ecraca1(E)  list E;
	a1 = ecraca1(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecraca1 liefert den Koeffizienten a1 des urspruenglichen Modells 
	der elliptischen Kurve E/Q (siehe 'ecrinit').



			ecraca2( E )                    (MACRO)

	"elliptic curve over rational numbers, actual curve, a2"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	rat ecraca2(E)  list E;
	a2 = ecraca2(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecraca2 liefert den Koeffizienten a2 des urspruenglichen Modells
	der elliptischen Kurve E/Q (siehe 'ecrinit').



			ecraca3( E )                    (MACRO)

	"elliptic curve over rational numbers, actual curve, a3"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	rat ecraca3(E)  list E;
	a3 = ecraca3(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecraca3 liefert den Koeffizienten a3 des urspruenglichen Modells
	der elliptischen Kurve E/Q (siehe 'ecrinit').



			ecraca4( E )                    (MACRO)

	"elliptic curve over rational numbers, actual curve, a4"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	rat ecraca4(E)  list E;
	a4 = ecraca4(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecraca4 liefert den Koeffizienten a4 des urspruenglichen Modells
	der elliptischen Kurve E/Q (siehe 'ecrinit').



			ecraca6( E )                    (MACRO)

	"elliptic curve over rational numbers, actual curve, a6"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	rat ecraca6(E)  list E;
	a6 = ecraca6(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit'). 
	ecraca6 liefert den Koeffizienten a6 des urspruenglichen Modells
	der elliptischen Kurve E/Q (siehe 'ecrinit').



			ecracb2( E )

	"elliptic curve over rational numbers, actual curve, b2"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	rat ecracb2(E)  list E;
	b2 = ecracb2(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecracb2 liefert den Tateschen Koeffizienten b2 des aktuellen
	(urspruenglichen) Modells der elliptischen Kurve E/Q.
	Falls der Wert b2 des urspruenglichen Modells noch nicht in der
	Liste E vorhanden ist, so wird er berechnet und dort abgelegt.
	E wird veraendert.



			ecracb4( E )

	"elliptic curve over rational numbers, actual curve, b4"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	rat ecracb4(E)  list E;
	b4 = ecracb4(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecracb4 liefert den Tateschen Koeffizienten b4 des aktuellen
	(urspruenglichen) Modells der elliptischen Kurve E/Q.
	Falls der Wert b4 des urspruenglichen Modells noch nicht in der
	Liste E vorhanden ist, so wird er berechnet und dort abgelegt.
	E wird veraendert.



			ecracb6( E )

	"elliptic curve over rational numbers, actual curve, b6"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	rat ecracb6(E)  list E;
	b6 = ecracb6(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecracb6 liefert den Tateschen Koeffizienten b6 des aktuellen
	(urspruenglichen) Modells der elliptischen Kurve E/Q.
	Falls der Wert b6 des urspruenglichen Modells noch nicht in der
	Liste E vorhanden ist, so wird er berechnet und dort abgelegt.
	E wird veraendert.



			ecracb8( E )

	"elliptic curve over rational numbers, actual curve, b8"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	rat ecracb8(E)  list E;
	b8 = ecracb8(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecracb8 liefert den Tateschen Koeffizienten b8 des aktuellen
	(urspruenglichen) Modells der elliptischen Kurve E/Q.
	Falls der Wert b8 des urspruenglichen Modells noch nicht in der
	Liste E vorhanden ist, so wird er berechnet und dort abgelegt.
	E wird veraendert.



			ecracbtco( E, BT )

	"elliptic curve over rational numbers, birational transformation 
	of coefficients"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecracbtco(E, BT)  list E, BT;
	L = ecracbtco(E, BT);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit') und
	BT = ( r  s  t  u )  rat r, s, t, u; mit u != 0.
	Das aktuelle Modell von E/Q wird durch BT birational transformiert.
	eciminbtco liefert eine durch 'ecrinit' erzeugte Liste L
	(siehe Dokumentation von 'ecrinit') mit den Daren des 
	transformierten Modells.



			ecracbtmin( E )

	"elliptic curve over the rationals, actual curve, birational 
	 transformation to minimal model"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	int ecracbtmin(E)  list E;
	BTrm = ecracbtmin(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe ecrinit).
	ecracbtmin liefert die 4-elemenetige Liste 
	       BTrm = ( r  s  t  u )  rat r, s, t, u;
	mit der birationalen Transformation ( r, s, t, u ) vom
	urspruenglichen Modell zum minimalen Modell von E/Q.  Falls die
	birationale Transformation BTrm noch nicht in E vorhanden ist,
	so wird sie berechnet und dort abgelegt.
	E wird veraendert.



			ecracbtsnf( E )

	"elliptic curve over rational numbers, actual curve, 
	birational transformation to short normal form"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecracbtsnf(E)  list E;
	BTrs = ecracbtsnf(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	ecracbtsnf liefert die 4-elemenetige Liste 
	       BTrs = ( r  s  t  u ) rat r, s, t, u;
	mit der birationalen Transformation ( r, s, t, u ) vom
	urspruenglichen Modell zum Modell in kurzer WNF von E/Q. Falls
	die birationale Transformatin BTrs noch nicht in E vorhanden
	ist, so wird sie berechnet und dort abgelegt.
	E wird veraendert.



			ecracc4( E )

	"elliptic curve over rational numbers, actual curve, c4"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	rat ecracc4(E)  list E;
	c4 = ecracc4(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecracc4 liefert den Tateschen Koeffizienten c4 des aktuellen
	(urspruenglichen) Modells der elliptischen Kurve E/Q.
	Falls der Wert c4 des urspruenglichen Modells noch nicht in der
	Liste E vorhanden ist, so wird er berechnet und dort abgelegt.
	E wird veraendert.



			ecracc6( E )

	"elliptic curve over rational numbers, actual curve, c6"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	rat ecracc6(E)  list E;
	c6 = ecracc6(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecracc6 liefert den Tateschen Koeffizienten c6 des aktuellen
	(urspruenglichen) Modells der elliptischen Kurve E/Q.
	Falls der Wert c6 des urspruenglichen Modells noch nicht in der
	Liste E vorhanden ist, so wird er berechnet und dort abgelegt.
	E wird veraendert.



			ecracdif( E, P, Q )

        "elliptic curve with integer coefficients, actual curve,
	difference of points"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecracdif(E, P, Q)  list E, P, Q;
        S = ecracdif(E, P, Q);
	Dabei muss gelten:
	  - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe 'ecrinit').
	  - P = ( xP  yP  zP )  int xP, yP, zP;  und 
	    Q = ( xQ  yQ  zQ )  int xQ, yQ, zQ;  
	    sind zwei Punkte auf dem aktuellen Modell von E/Q.
	Rueckgabe: S = P + (-Q) = P - Q.



			ecracdisc( E )

	"elliptic curve over rational numbers, actual curve, discriminant"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	rat ecracdisc(E)  list E;
	D = ecracdisc(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecracdisc liefert die Diskriminante des urspruenglichen Modells
	der elliptischen Kurve E/Q.
	Falls die Diskriminante des urspruenglichen Modells noch nicht
	in E vorhanden ist, so wird sie berechnet und dort abgelegt.
	E wird veraendert.



			ecracdouble( E, P )

        "elliptic curve over the rational numbers, minimal model,
	double of point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecracdouble(E, P)  list E, P;
        D = ecracdouble(E, P);
	Dabei muss gelten:
	 - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	   Kurve E/Q (siehe 'ecrinit').
	 - P = ( xP  yP  zP ) int xP, yP, zP; ist ein Punkt auf dem
	   aktuellen Modell von E/Q.
	ecracdouble berechnet die Punktsumme 
		D = 2 * P = P + P 
	auf dem minimalen Modell der elliptischen Kurve E/Q, die durch
	die Koeffizienten in E gegeben ist.
	Rueckgabe: D = ( xD  yD  zD ) rat xD, yD, zD;



			ecracfdisc( E )

	"elliptic curve over rational numbers, actual curve, 
	factorization of discriminant"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecracfdisc(E)  list E;
	F = ecracfdisc(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecracfdisc liefert eine Liste 
	      F = ( p_1  e_1  p_2  e_2 ...  p_n  e_n ) 
	      int p_1, p_2, ..., p_n; single e_1, e_2, ..., e_n;
	mit der vollstaendigen (Prim-) Faktorisierung des Betrags der
	Diskriminanten D des urspruenglichen Modells der elliptischen 
	Kurve E/Q.  Die Primzahlen pi sind wie folgt angeordnet: Zuerst
	werden die Primteiler des Zaehlers p_1 > p_2 > ... > p_r mit
	positiven Exponenten ei, anschliessend die Primteiler des 
	Nenners p_(r+1) > p_(r+2) > ... > p_n mit negativen Exponenten
	e_j aufgelistet:
		  D          = Zaehler( D )    * [1/Nenner( D )]
	     ----      (e_i)   ----      (e_i)   ----      (e_j)
           =  ||  (p_i)      =  ||  (p_i)      *  ||  (p_j)
	    1<=i<=n           1<=i<=r          r+1<=j<=n
	Falls die Liste F noch nicht in der Liste E vorhanden ist, so
	wird sie berechnet und dort abgelegt.
	E wird veraendert.



			ecracgentor( E )

        "elliptic curve over rational numbers, actual curve, 
	generators of torsion group"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecracgentor(E)  list E;
	L = ecracgentor(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	ecracgentor liefert eine Liste
	  ( P ) list P; falls die Torsionsgruppe zyklisch ist,
        oder
	  ( P  Q ) list P, Q; falls die Torsionsgruppe bizyklisch ist,
	mit einem Erzeugendensystem der Torsionsgruppe des 
	urspruenglichen Modells von E/Q. 
	Dabei ist P = ( x  y  z ) int x, y, z; Q analog.
	Falls ein Erzeugendensystem der Torsionsgruppe des urspruenglichen 
	Modells von E/Q noch nicht in E vorhanden ist,  wird es (mit Hilfe 
	der Funktion 'ecisnfgentor') berechnet und dort abgelegt.
	E wird veraendert.



			ecracmul( E, P, n )

	"elliptic curve over the rational numbers, actual curve,
 	multiplication-map"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecracmul(E, P, n)  list E, P; single n;
	N = ecracmul(E, P, n)
	Dabei muss gelten:
	  - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe 'ecrinit').
	  - P = ( x  y  z ) int x, y, z; ist ein Punkt auf dem durch E
	    gegebenen aktuellen Modell von E/Q.
        ecracmul berechnet das n-fache n * P = P + ... + P (n-mal)
	des Punkts P auf dem minimalen Modell von E/Q.



			ecracmwgbase( E )

	"elliptic curve over the rational numbers, actual curve,
	Mordell-Weil-group, base"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecracmwgbase(E)  list E;
	B = ecracmwgbase(E);
	Dabei ist E eine Liste mit allen wichtigen Daten  der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
        ecracmwgbase bestimmt eine Basis
	  B = ( P1  h1  P2  h2  ...  Pr  hr ); list P1, P2, ..., Pr; 
					       floating h1, h2, ..., hr; 
	der Mordell-Weil-Gruppe des aktuellen Modells von E/Q mit
	den Basispunkten
	 	Pi = ( xi  yi  zi ) int xi, yi, zi; ( 1 <= i <= r ),
        und deren jeweiliger Neron-Tate-Hoehe hi.
        Dabei ist r der Rang von E/Q.
	Rueckgabe: bei korrektem Lauf: Liste B
	           sonst: -1.



			ecracneg( E, P )

        "elliptic curve over the rational numbers, actual curve,
	negative point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecracneg(E, P)  list E, P;
        N = ecracneg(E, P);
	Dabei muss gelten:
	  - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	    Kurve E/Q (s. 'ecrinit').
	  - P = ( x  y  z )  int x, y, z; ist ein Punkt auf dem durch die 
	    Liste E gegebenen urspruenglichen Kurve E/Q.
	ecracneg berechnet den Punkt N = -P,
	d.h. P + N = O = ( 0 : 1 : 0 ). 
        Rueckgabe: 
	     ( 0  1  0 ), falls P = ( 0  1  0 ),
             ( x  y'  z ) mit y' = -( y + a1 * x * z + a3 * z^3 ), sonst.



			ecracsum( E, P, Q )

        "elliptic curve over the rational numbers, actual curve,
	sum of points"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecracsum(E, P, Q)  list E, P, Q;
        S = ecracsum(E, P, Q);
	Dabei muss gelten:
	  - E ist eine Liste mit den wichtigen Daten der elliptischen 
	    Kurve E/Q (siehe 'ecrinit').
	  - P = ( xP  yP  zP )  int xP, yP, zP;  und 
	    Q = ( xQ  yQ  zQ )  int xQ, yQ, zQ;  
	    sind zwei Punkte auf dem aktuellen Modell von E/Q.
	Rueckgabe: S = P + Q.



			ecractoecimin( E )

	"elliptic curve over rational numbers, actual curve
	to global minimal model ( Laska's algorithm )"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecractoecimin(E)  list E;
	L = ecractoecimin(E);
	E ist eine Liste mit allen wichtige Daten der elliptischen 
	Kurve ueber Q (siehe 'ecrinit').
	ecractoecimin berechnet zu E ein birational isomorphes, global 
	minimales Modell E' mit den ganzzahligen Koeffizienten
	a1', a2', a3', a4', a6'. E' ist von eingeschraenktem Typ, 
	d.h. a1', a3' = 0 oder 1; a2' = -1, 0, 1.
	Die birationale Isomorphie ist durch r, s, t, u aus R gemaess 
	den folgenden Gleichungen gegeben:
		x = u^2*x' + r;
		y = u^3*y' + u^2*s*x' + t.
	ecractoecimin liefert eine Liste L mit den Koeffizienten der
	neuen elliptischen Kurve E' und der zugehoerigen birationalen 
	Transformation:
		L = ( ( a1'  a2'  a3'  a4'  a6' ) ( r  s  t  u ) ).
	Literatur: Michael Laska, An Algorithm for Finding a Minimal
		Equation for an Elliptic Curve. Mathematics of 
		Computation 38 (1982), 257-260.



			ecractorgr( E )

        "elliptic curve over rational numbers, actual curve, torsion group"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecractorgr(E)  list E;
	L = ecractorgr(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe Dokumentation zu 'ecrinit').
	ecimintorgr liefert eine Liste
	    ( T_1  ...  T_t ) list T_1, ...,T_t;
        mit allen Punkten T_i = ( x_i  y_i  z_i ) int x_i, y_i, z_i;
	(1 <= i <= t) der Torsionsgruppe des aktuellen Modells fuer E/Q. 
	Falls die Torsionsgruppe des aktuellen Modells noch nicht
	in E vorhanden ist, so wird sie berechnet und dort abgelegt.
	E wird veraendert.



			ecracweilhe( E, P )

        "elliptic curve over the rational numbers, Weil height"
        Quellbibliothek: srclib.ec1
        Include-Datei:   _ec1.h
	floating ecracweilhe(E, P)  list E, P;
	lambda = ecracweilhe(E, P);
	Dabei muss gelten:
            - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	      Kurve E/Q (siehe 'ecrinit').
            - P = ( x  y  z ),  int x, y, z;  
	      stellt, falls z = 0 ist, den unendlich fernen Punkt, 
	      sonst den Punkt ( x/z^2, y/z^3 ) auf dem minimalen
	      Modell (von eingeschraenktem Typ) von E/Q dar.
        ecracweilhe berechnet die Weil-Hoehe von P.
        Literatur: J.H. Silverman: Math. of Comp., 51, 1988, p.339-358.



			ecrbtco( LC, BT )

	"elliptic curve over rational numbers, birational transformation 
	of coefficients"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecrbtco(LC, BT)  list LC, BT;
	L = ecrbtco(LC, BT);
	Dabei muss gelten: 
	- LC = ( a1  a2  a3  a4  a6 )  rat a1, a2, a3, a4, a6;
	- BT = ( r  s  t  u )  rat r, s, t, u; mit u != 0;
	ecrbtco berechnet zu der durch a1, a2, a3, a4, a6 in
	Weierstrass-Normalform gegebenen elliptischen Kurve die durch
	r, s, t, u gegebene birationale elliptische Kurve mit den
	Koeffizienten a1', a2', a3', a4', a6' in Weierstrass-Normalform
	gemaess x = u^2*x' + r,
		y = u^3*y' + u^2*s*x' + t.
	ecrbtco liefert eine Liste mit den Koeffizienten der neuen Kurve:
	LC' = ( a1'  a2'  a3'  a4'  a6' ) rat a1', a2', a3', a4', a6';
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.49.



			ecrbtconc( BT1, BT2 )

	"elliptic curve over rational numbers, birational transformation, 
	concatenation of transformations"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
        list ecrbtconc(BT1, BT2)  list BT1, BT2;
	L = ecrbtconc(BT1, BT2);
	Es muss gelten 
	    BT1 = ( r1  s1  t1  u1 )  rat r1, s1, t1, u1;
	und 
	    BT2 = ( r2  s2  t2  u2 )  rat r2, s2, t2, u2;
	ecrbtconc berechnet die birationalen Transformation 
	BT = ( r s t u ), die ausgefuehrt wird, wenn man zuerst BT2 
	und anschliessend BT1 anwendet. BT hat dabei die Gestalt:
	   r = u1^2 * r2                  + r1,
	   s = u1   * s2                  + s1,
	   t = u1^3 * t2 + u1^2 * r2 * s1 + t1,
	   u = u1   * u2.



			ecrbtinv( BT )

	"elliptic curve over rational numbers, birational 
	 transformation, inverse transformation"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
        list ecrbtinv( BT )  list BT;
	L = ecrbtinv( BT );
	BT ist von der Form
		BT = ( r  s  t  u )  rat r, s, t, u;
	mit u != 0.
	ecrbtinv berechnet die zur birationalen Transformation 
	BT inverse Transformation 
		L = ( r'  s'  t'  u' )  rat r', s', t', u';
	d.h. wenn BT eine Kurve E/Q nach E'/Q birational trans-
	formiert, so transformiert L die Kurve E' nach E. 
	Es ist:
	           r             s          rs - t          1
	   r' = - ---,   s' = - ---,   t' = ------,   u' = ---
                  u^2            u            u^3           u



			ecrbtlistp( LP, BT, modus )

	"elliptic curve over rational numbers, birational transformation 
	of list of points"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
        list ecrbtlistp(LP, BT, modus)  list LP, BT; single modus;
	L = ecrbtlistp(LP, BT, modus);
	Es muss gelten:
	  - BT = ( r  s  t  u )  rat r, s, t, u;  mit u != 0.
	  - LP = ( P1  P2  ...  Pn ) list Pi; 
		 mit n >= 0, falls modus = 0.
            oder
	    LP = ( P1  h1  P2  h2 ...  Pn  hn ) list Pi; floating hi;
	                oder 
	    LP = ( P1  P2  ...  Pn ) list Pi; 
		 mit n >= 0, falls modus = 1.
	  - Pi = ( xi  yi  zi )  int xi, yi, zi;
	      stellt einen Punkt ( xi/zi^2, yi/zi^3 ) auf einer 
	      elliptischen Kurve E ueber Q dar.
	  - hi ist die Neron-Tate-Hoehe des Punkts Pi.
        ecrbtlistp transformiert alle Punkte in der Liste LP mittels der 
	birationalen Transformation BT. L ist die Liste der transformierten 
	Punkte.



			ecrbtp( P, BT )

	"elliptic curve over rational numbers, birational transformation 
	of point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecrbtp(P, BT)  list P, BT; 
	L = ecrbtp(P, BT);
	Dabei muss gelten: 
	   - P = ( x  y  z )  int x, y, z;
	   - BT = ( r  s  t  u )  rat r, s, t, u;
	ecrbtp berechnet zu dem Punkt 
	     P = ( X, Y ) = ( x/z^2, y/z^3 )  (falls z != 0)
	den durch die birationale Transformation mit den Parametern 
	r, s, t und u gegebenen Punkt
        Q = ( X', Y' ) = ( x'/z'^2, y'/z'^3 ) gemaess
          X = u^2*X' + r             <==>  X' = (X - r) / u^2 
          Y = u^3*Y' + u^2*s*X' + t  <==>  Y' = (Y - t - u^2*s*X') / u^3.
	ecrbtp liefert die dreielementige Liste Q = ( x'  y'  z' ).
	Q ist 'normiert' (siehe Dokumentation zu 'ecrpnorm').
	Literatur: J.H. Silverman: The arithmetic of elliptic curves, p.49.



			ecrclser( E, A, n )

	"elliptic curve over the rationals, coefficients of L- series"
        Quellbibliothek: srclib.ec2
        Include-Datei:   _ec2.h
	single *ecrclser(E, A, n)  list E; single *A, n;
	A = ecrclser(E, A, n);
	E ist eine Liste mit allen wichtigen Groessen der elliptischen 
	Kurve E / Q (siehe ecrinit).
	A ist ein Zeiger auf die von ecrclser erzeugte Tabelle A
	(array vom Typ single) mit den Koeffizienten a_i der L-Reihe
	zur elliptischen Kurve E/Q. Dabei sind in A[0] die Laenge
	der aktuellen Tabelle (= Anzahl der bereits berechneten 
	Koeffizienten) und in A[i], i > 0, die Koeffizienten a_i 
	abgelegt. n ist die obere Grenze fuer die Anzahl der zu
	berechnenden Koeffizienten.
	Falls n <= A[0] ist, wird A zurueckgegeben 
	     (Koeffizienten a_1, ..., a_n sind bereits berechnet). 
	Falls n > A[0] ist, werden die Koeffizienten
	     a_(A[0]+1), ..., a_n berechnet und in A abgelegt.
	     A[0] wird gleich n gesetzt.
	Bei fehlerhaftem Ablauf wird NULL zurueckgegeben.
	Vor der ersten Berechnung von Koeffizienten muss ecrclser(0)
	aufgerufen werden, um Speicherplatz fuer A[0] zu allokieren 
	und A[0] = 0 zu setzen. 



			ecrcond( E )

	"elliptic curve over rational numbers, conductor"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	int ecrcond(E)  list E;
	N = ecrcond(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	ecrcond liefert 
	  - bei korrektem Lauf den Fuehrer N der elliptischen Kurve E/Q.
          - ERROR sonst,
        Falls der Fuehrer von E/Q noch nicht in der Liste E vorhanden ist,
	so wird er (zusammen mit seiner Faktorisierung, den c_p-Werten 
	und den Neron- bzw. Kodaira-Typen) berechnet und dort abgelegt.
	E wird veraendert.



			ecrcperiod( E )

	"elliptic curve over the rational numbers, complex period"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	complex ecrcperiod( E )  list E;
	w2 = ecrcperiod( E );
	Dabei ist E eine Liste mit allen wichtigen Daten der 
	elliptischen Kurve E/Q (siehe 'ecrinit').
	ecrcperiod berechnet die komplexe Periode w2 von E.
	Literatur: D.R. Grayson: "The Arithogeometric Mean",
	           Arch. Math. 52, pp. 507-512 (1989).



			ecrexptor( E )

        "elliptic curve over rational numbers, exponent of torsion group"
        Quellbibliothek: srclib.ec2
        Include-Datei:   _ec2.h
	single ecrexptor(E)  list E;
	e = ecrexptor(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
        Rueckgabe: e = Exponent der Torsionsgruppe, d.h.
	           /       : n * T = ( 0 : 1 : 0 )   \
	  e = min < n in N :  fuer alle Torsions-     >
		   \       :    punkte T auf E/Q     /
        Falls der Exponent noch nicht in E vorhanden ist, wird er
	mit Hilfe von 'ecisnfgentor' berechnet und dort abgelegt.
	E wird veraendert.
        Literatur: J.H. Silverman: The arithmetic of elliptic curves.



			ecrfcond( E )

	"elliptic curve over rational numbers, factorization of conductor"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	list ecrfcond(E)  list E;
	FN = ecrfcond(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	ecrfcond liefert 
	  - bei korrektem Lauf die Faktorisierung des Fuehrers N der 
	    elliptischen Kurve E/Q.
          - ERROR sonst,
        Falls die Faktorisierung der Fuehrers von E/Q noch nicht in 
	der Liste E vorhanden ist, so sie wird mit Hilfe von 
	'ecrcond' berechnet und dort abgelegt.
	Rueckgabe: bei Erfolg FN, ERROR sonst.
	E wird veraendert.



			ecrfdenjinv( E )

	"elliptic curve over the rationals, factorization of the 
	 denominator of the j-invariant"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecrfdenjinv(E)  list E;
	F = ecrfdenjinv(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe ecrinit).
	ecrfdenjinv liefert eine Liste 
	      F = ( p_1  e_1  ...  p_n  e_n ) 
	      int p_1, ..., p_n; single e_1, ..., e_n;
	mit der vollstaendigen (Prim-) Faktorisierung des Nenners der
	j-Invarianten von E/Q. Die Primzahlen pi sind nach aufsteigender 
	Groesse geordnet. 
	Falls die Faktorisierung der j-Invarianten noch nicht in der
	Liste E vorhanden ist, wird sie berechnet und dort abgelegt.
	E wird veraendert.



			ecrfelser( E, A, z, result )

	"elliptic curve over rational numbers, Fourier expansion
	of the L-series"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single *ecrfelser(E, A, z, result) 
	       list L; double z, *result; single *A;
	A = ecrfelser(E, A, z, result);
	E ist eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe Dokumentation zu 'ecrinit').
	A ist ein Zeiger auf die Tabelle mit den Koeffizienten der
	L-Reihe von E/Q (Array vom Typ single).
	Fuer eine reelle Zahl z berechnet (approximiert) ecrfelser die 
	Summe ueber die Terme
	     a_n * exp(-2 * PI * n * z)
	fuer n = 1 bis unendlich und legt das Ergebnis in der Variablen 
	*result ab. 
	Fuer ein rein imaginaeres z in den komplexen Zahlen entspricht
	dies einer abbrechenden Fourier-Reihe mit den Summanden
	     a_n * exp(2 * PI * i * n * z) .
	Rueckgabe: 
	    bei Erfolg: Zeiger A auf ein Array von singles mit den 
		Koeffizienten a_i der L-Reihe (siehe 'ecrclser'),
            sonst: NULL.
        Literatur: Y.I. Manin, "Cyclotomic fields and modular curves",
		   Russian Math. Surveys 25, no. 6 (1971), pp 7-78.
	Achtung !!!
	Da die Funktion vom Typ single* ist, muss sie in allen 
	Funktionen, in denen sie aufgerufen wird, deklariert werden.



			ecrinit( a1r, a2r, a3r, a4r, a6r )

	"elliptic curve over the rational numbers initialization"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecrinit(a1, a2, a3, a4, a6)  rat a1, a2, a3, a4, a6;
	L = ecrinit(a1, a2, a3, a4, a6);
	Sei E die durch die Koeffizienten a1, a2, a3, a4, a6 in
	Weierstrass-Normalform gegebene elliptische Kurve. 
	ecrinit liefert eine aus 4 Listen bestehende Liste 
	     L = ( L1  L2  L3  L4 ).
	ecrinit traegt die Werte a1r, a2r, a3r, a4r, a6r in die
	Liste L11 ein (s.u.) und initialisiert alle anderen Listen
	Lij als leere Listen. Dabei wird folgendes Konzept verfolgt:
	In L1 stehen die Daten des tatsaechlich eingegebenen Modells 
	   ('actual curve' oder 'actual (rational) model').
	   Funktionen, die Daten aus der Liste L1 benutzen oder 
	   veraendern, beginnen mit dem Praefix 
		'ecrac' 
	   fuer
	   	e(lliptic) c(urve over) r(ational numbers), 
		a(ctual) c(urve).
	In L2 stehen die Daten des minimalen Modells von eingeschraenktem
	   Typ, d.h. die Koeffizienten a1, a2, a3, a4, a6 in L2 sind 
	   die ganzzahligen Koeffizienten eines global minimalen Modells
	   fuer E/Q mit a1, a3 = 0 oder 1, a2 = -1, 0 oder 1.
	   Funktionen, die Daten aus der Liste L2 benutzen oder 
	   veraendern, beginnen mit dem Praefix 
		'ecimin' 
	   fuer 
	   	e(lliptic) c(urve with) i(nteger coefficients,) 
		min(imal model).
	In L3 stehen die Daten eines Modells in kurzer Weierstrass-
	   Normalform (kWNF). Falls das Modell in L2 bereits in kWNF 
	   ist, so werden die Koeffizienten a4 und a6 aus L2 verwendet.
	   Sonst wird E in die Gleichung
	     Y^2 = X^3 - 27 * c4 * X - 54 * c6
	   mit c4, c6 aus L23 transformiert.
	   Funktionen, die Daten aus der Liste L3 benutzen oder 
	   veraendern, beginnen mit dem Praefix 
		'ecisnf' 
	   fuer 
	   	e(lliptic) c(urve with) i(nteger coefficients,) 
	    	s(hort) n(ormal) f(orm).
	In L4 stehen alle Invarianten der Kurve, die nicht vom 
	   jeweiligen Modell der Kurve abhaengen.
	   Funktionen, die Daten aus der Liste L4 benutzen oder
	   veraendern, beginnen mit dem Praefix 
		'ecrinv' 
	   fuer 
	   	el(liptic) c(urve over) r(ational numbers,) 
		inv(ariants of the curve).
        Die Liste L1 hat die Form ( L11  L12  L13  L14  L15  L16  L17 )
           mit L11 = ( a1r  a2r  a3r  a4r a6r )  rat a1r,a2r,a3r,a4r,a6r;   
               L12 = ( b2r  b4r  b6r  b8r )  rat b2r, b4r, b6r, b8r;
               L13 = ( c4r  c6r )  rat c4r, c6r;
               L14 = ( Dr  FDr )  rat Dr; list FDr;
               L15 = ( TPr  GTr )  list TPr, GTr;
               L16 = ( BTrm  BTrs )  list BTrm, BTrs;
               L17 = Br  list Br;
	   Dabei gilt 
	     - a1r, a2r, a3r, a4r, a6r sind die Koeffizienten
	       der aktuellen Gleichung fuer E/Q,
	     - b2r, b4r, b6r, b8r, c4r, c6r sind die Tateschen
	       Groessen der aktuellen Gleichung,
	     - Dr ist die Diskriminante der aktuellen Gleichung,
	     - FDr = ( p1  e1  p2  e2 ... ) ist die Faktorisierung von Dr,
	     - TPr ist eine Liste mit allen Torsionspunkten des 
	       aktuellen Modells,
	     - GTr ist eine Liste von Erzeugern der Torsionsgruppe 
	       des aktuellen Modells, ( T ) oder ( T1  T2 ),
	     - BTrm = ( r_rm  s_rm  t_rm  u_rm )  rat r_rm,s_rm,t_rm,u_rm;
	       ist die birationale Transformation, die die aktuelle in die 
	       minimale Gleichung ueberfuehrt,
	     - BTrs = ( r_rs  s_rs  t_rs  u_rs )  rat r_rs,s_rs,t_rs,u_rs;   
	       ist die birationale Transformation, die die aktuelle in die 
	       kurze Gleichung ueberfuehrt,
	     - Br = ( Pr_1  Pr_2  ...  Pr_r )  list Pr_1, Pr_2, ..., Pr_r; 
	       ist eine Basis der Mordell-Weil-Gruppe des aktuellen Modells 
	       von E/Q, wobei r der Rang der Kurve ist. 
        Die Liste L2 hat die Form ( L21  L22  L23  L24  L25  L26  L27 )
           mit L21 = ( a1m  a2m  a3m  a4m a6m )  int a1m,a2m,a3m,a4m,a6m;
               L22 = ( b2m  b4m  b6m  b8m )  int b2m, b4m, b6m, b8m;
               L23 = ( c4m  c6m )  int c4m, c6m;
               L24 = ( Dm  FDm  dwnm )  int Dm; list FDm; floating dwnm; 
               L25 = ( TPm  GTm )  list TPm, GTm;
               L26 = ( BTmr  BTms )  list BTmr, BTms;
               L27 = Bm  list Bm;
	   Dabei gilt 
	     - a1m, a2m, a3m, a4m, a6m sind die Koeffizienten des
	       minimalen Modells von eingeschraenktem Typ (s.o.).
	     - L2i analog zu L1i (1 <= i <= 7) mit minimalem statt 
	       aktuellem Modell und den birationalen Transformationen 
	       vom minimalen Modell zum aktuellen bzw. zum kurzen.
	     - dwn (in L24) ist die Differenz zwischen Weil-Hoehe und
	       Neron-Tate-Hoehe auf dem minimalen Modell von E/Q.
        Die Liste L3 hat die Form ( L31  L32  L33  L34  L35  L36  L37 )
           mit L31 = ( a4s a6s )  int a4s, a6s;
               L32 = ( b2s  b4s  b6s  b8s )  int b2s, b4s, b6s, b8s;
               L33 = ( c4s  c6s )  int c4s, c6s;
               L34 = ( Ds  FDs  dwns )  int Ds; list FDs; floating dwns;
               L35 = ( TPs  GTs )  list TPs, GTs;
               L36 = ( BTsr  BTsm )  list BTsr, BTsm;
               L37 = Bs  list Bs;
	   Dabei gilt 
	     - a4s und a6s sind die Koeffizienten eines Modells in
	       kurzer Weierstrass-Normalform (kWNF, s.o.).
	     - L3i analog zu L1i (2 <= i <= 7) mit kurzem statt 
	       aktuellem Modell und den birationalen Transformationen 
	       von der kWNF zum aktuellen bzw. zum minimalen Modell.
        Die Liste L4 hat die Form ( L41  L42  L43  L44  L45  L46 )
	   mit L41 = ( j  Fnj )  rat j, list Fnj; 
	       L42 = ( N  FN  Nrt  Lcp )  int N; list FN, Nrt, Lcp;
	       L43 = ( oT  ST )  single oT; list ST;
	       L44 = ( C  r  Lr  R  TS )  single C, r, TS; floating Lr, R;
	       L45 = ( w )  floating w;
	       L46 = ( Nnth  b2'  b4'  b6'  b8' )  
		       single Nnth; int b2', b4', b6', b8';
	   Dabei gilt 
	     - j ist die j-Invariante von E/Q.
	     - Fnj ist die Faktorisierung des Nenners der j-Invariante.
	     - N ist der Fuehrer von E/Q.
	     - FN = ( p1  f1 ...  pn  fn ) ist die Faktorisierung von N.
	     - Nrt = ( p1  t1 ...  pn  tn ) gibt alle Primzahlen,
	       bzgl. derer E/Q schlechte Reduktion hat,
	       zusammen mit dem Reduktionstyp nach Kodaira an.
	     - Lcp = ( c  cp1  ... cpn )  single c, cp1, ..., cpn;
	       Dabei ist c das Produkt ueber alle cp-Werte mit p|N,
	       und cp1, ..., cpn sind die zu p1, ..., pn gehoerigen
	       cp-Werte.
	     - oT ist die Ordnung der Torsionsgruppe von E/Q.
	     - ST = ( oT ) oder ( oT/2  2 ) ist eine Liste, die die 
	       Struktur der Torsionsgruppe von E/Q angibt. 
	       Wichtig: Im nicht-zyklischen Fall muss oT/2 vornestehen, 
	       damit sichergestellt ist, dass die erste Zahl in der
	       Liste ST auch der Gruppenexponent e ist, d.h. 
		 e * P = ( 0 : 1 : 0 ) <==> P ist Torsionspunkt auf E/Q.
	     - C ist das Vorzeichen der Funktionalgleichung der
	       L-Reihe von E/Q.
	     - r ist der Rang der elliptischen Kurve E/Q.
             - TS ist die Ordnung der Tate-Shafarevic-Gruppe III.
	     - Lr ist der Wert der r-ten Ableitung der L-Reihe 
	       L(E, s) von E/Q bei s = 1 (r = Rang von E/Q).
             - R ist der Regulator von E/Q.
             - w ist die reelle Periode omega.
	     - Nnth: Bei der Berechnung der lokalen archimedischen
	       Neron-Tate-Hoehe h_oo(P) muessen die ersten Nnth 
	       Summanden der unendlichen Reihendarstellung berechnet 
	       werden, um eine Approximation von h_oo( P ) mit einem
	       Fehler kleiner als NTH_EPS (default: NTH_EPS = 10^{-20})
	       zu erreichen.
	     - b2', b4', b6', b8' werden ebenfalls bei der Berechnung 
	       der lokalen archimedischen Neron-Tate-Hoehe h_oo( P ) 
	       benoetigt. Es gilt: 
		  b2' = b2m - 12; 
		  b4' = b4m - b2m + 6; 
		  b6' = b6m - 2b4m + b2m - 4;
                  b8' = b8m - 3 b6m + 3 b4m - b2m + 3.



			ecrjinv( E )

	"elliptic curve over rational numbers, j-invariant"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	rat ecrjinv(E)  list E;
	j = ecrjinv(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q (siehe 'ecrinit').
	ecrjinv liefert die j-Invariante j der elliptischen Kurve E/Q.
        Falls die j-Invariante noch nicht in der Liste E vorhanden ist,
	so wird sie berechnet und dort abgelegt.
	E wird veraendert.



			ecrlser( E )

	"elliptic curve over rational numbers, L-series"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	double ecrlser(E)  list E;   
	d = ecrlser(E);
	Dabei ist E eine Liste mit allen wichtigen daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
        ecrlser liefert den Wert der L-Reihe L(E, s) von E/Q an
        der Stelle s = 1.
	Rueckgabe: L(E, 1) bei Erfolg,
		   ERROR     sonst 



			ecrlserfd( E )

	"elliptic curve over rational numbers, L-series, first derivative"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	double ecrlserfd(E)  list E;   
	d = ecrlserfd(E);
	Dabei ist E eine Liste mit allen wichtigen Daten einer elliptischen 
	Kurve E/Q (siehe 'ecrinit').
        ecrlserfd berechnet den Wert der 1. Ableitung der L-Reihe 
	L(E, s) von E/Q an der Stelle s = 1.
	Bei Erfolg ist d = L'(E, 1), sonst ist d = ERROR.



			ecrlserfds( E, A, result )

	"elliptic curve over the rationals, L-series, first derivative, 
	special version"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single *ecrlserfds(E, A, result)  
		list E;  single *A;  double *result;
	A = ecrlserfds(E, A, result);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe ecrinit).
        ecrlserfds berechnet (approximiert) die Summe ueber die Terme
		a_n * exp(-2 * PI * n / sqrt( N )) / n
	fuer n = 1 bis unendlich, wobei N der Fuehrer der Kurve E ist.
	Rueckgabe: 
	    bei Erfolg: Zeiger A auf ein Array von singles mit den 
		Koeffizienten a_i der L-Reihe (siehe ecrclser),
            sonst: NULL.



			ecrlserhd( E, r )

	"elliptic curve over rational numbers, L-series,
	 higher derivative"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	double ecrlserhd(E, r)  list E;   
	d = ecrlserhd(E, r);
	Dabei ist E eine Liste mit allen wichtigen Daten einer 
	elliptischen Kurve E/Q (siehe 'ecrinit').
        ecrlserhd berechnet den Wert der r-ten Ableitung der L-Reihe 
	L(E, s) von E/Q an der Stelle s = 1.
        Rueckgabe: L^(r)(E, 1) bei Erfolg,
		  ERROR         sonst.



			ecrlserhdlc( E, A, s, result )

	"elliptic curve over the rationals, L-series, higher derivative, 
	 large conductor"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single *ecrlserhdlc(E, A, s, result)  
		list E;  single *A, s;  double *result;
	A = ecrlserhdlc(E, A, s, result);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe ecrinit).
	s ist positiv.
        ecrlserhdlc berechnet (approximiert) die s-te Ableitung der L-Reihe 
	von E/Q an der Stelle 1 und legt das Ergebnis in der Variablen 
	*result ab. L^s(E, 1) ist die Summe ueber die Terme
		    2 * Pi * a_n * I_n    mit   I_n = 
	    oo        s-1                    __
	   (    log(y)         -2 Pi n y / \/N
            \  ----------- * e                   dy
             )      y
            1
	fuer n = 1 bis unendlich, wobei N der Fuehrer der Kurve E ist.
	Das Programm funktioniert nur fuer C = (-1)^s, wobei C das Vor-
	zeichen der Funktionalgleichung der L-Reihe von E/Q ist.
	'ecrlserhdlc' sollte nur bei 'grossem' Fuehrer (N > 10^6)
	angewendet werden. Fuer 'kleine' Fuehrer N empfiehlt es sich,
	'ecrlserhdsc' zu verwenden.
	Rueckgabe: 
	    bei Erfolg: Zeiger A auf ein Array von singles mit den 
		Koeffizienten a_i der L-Reihe (siehe ecrclser),
            sonst: NULL.
	Literatur: J.E. Cremona: Algorithms for modular elliptic curves,
		   Cambridge University Press, 1992.



			ecrlserhdsc( E, A, r, result )

	"elliptic curve over rational numbers, L-series, higher derivative, 
	small conductor"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single *ecrlserhdsc(E, A, r, result)  
	    	list E;  single *A, r;  double *result;
	A = ecrlserhdsc(E, A, r, result);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	Der Fuehrer von E/Q sollte nicht groesser als 10^6 sein
	(dann ist 'ecrlserhdlc' schneller).
        ecrlserhdsc berechnet (approximiert) die Summe ueber die Terme
		    2 * Pi * a_n * I_n    mit   I_n = 
	    oo
	   (    /    r                  r      r      \     -2 Pi n y
            \  | log ( y )  + C * ( -1 ) * log ( N y ) | * e          dy
         1/ _)  \                                     /
         /\/N
	fuer n = 1 bis unendlich, wobei N der Fuehrer der Kurve E ist,
	und legt das Ergebnis in der Variablen *result ab.
	Rueckgabe: 
	    bei Erfolg: Zeiger A auf ein Array von singles mit den 
		Koeffizienten a_i der L-Reihe ( siehe 'ecrclser' ),
            sonst: NULL.



			ecrlserrkd( E )

	"elliptic curve over the rationals, L-series, 'rank'-th 
	 derivative"    
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	floating ecrlserrkd(E)  list E;
	l = ecrlserrkd(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
        ecrlserrkd liefert den Wert der r-ten Ableitung (r = Rang E/Q) 
	der L-Reihe L( E, s ) der elliptische Kurve E/Q bei s = 1. 
	Falls der Wert noch nicht in E vorhanden ist, wird er berechnet 
	und dort abgelegt.
	E wird veraendert.



			ecrlsers( E, A, result )

	"elliptic curve over the rationals, L-series, special version"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single *ecrlsers(E, A, result)  list E; single *A; double *result;
	A = ecrlsers(E, A, result);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe ecrinit).
        ecrlsers berechnet (approximiert) die Summe ueber die Terme
		a_n * exp(-2 * PI * n / sqrt(N)) / n
	fuer n = 1 bis unendlich, wobei N der Fuehrer der Kurve E ist.
	Das Ergebnis wird in der Variablen *result abgelegt.
	Rueckgabe: 
	    bei Erfolg: Zeiger A auf ein Array von singles mit den 
		Koeffizienten a_i der L-Reihe (siehe ecrclser),
            sonst: NULL.



			ecrmaninalg( E )

        "elliptic curve over rational numbers, Manin algorithm"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
        single ecrmaninalg(E)  list E;
        n = ecrmaninalg(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe ecrinit).
	ecrmaninalg berechnet mit Hilfe des Manin-Algorithmus unter Annahme 
	der Vermutung von Birch und Swinnerton-Dyer den Rang und eine Basis 
	der elliptischen Kurve E/Q und traegt die Ergebnisse (Rang, Basis, 
	Torsionsgruppe mit Erzeugern und Struktur, Tate-Shafarevic-Gruppe, 
	reelle Periode) in die Liste E ein.
	Waehrend des Funktionslauf werden drei temporaere Dateien
	_NTP_FILE.TMP, _LCOMB_FILE.TMP und _LCOMB_HELP.TMP
	kreiert und anschliessend wieder geloescht.
	Rueckgabe: 
	   - bei erfolgreichem Lauf: 0.
	   - sonst: ERROR.
        E wird veraendert.



			ecrordtor( E )

        "elliptic curve over rational numbers, order of torsion group"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single ecrordtor(E)  list E;
	l = ecrordtor(E);
	Rueckgabe: l = #Etor(Q), Ordnung der Torsionsgruppe von E/Q.
	Falls die Ordnung der Torsionsgruppe von E/Q noch nicht in E 
	vorhanden ist, wird sie (mit Hilfe von 'ecisnftorgr') berechnet 
	und dort abgelegt.
	E wird veraendert.



			ecrordtsg( E )

	"elliptic curve over the rational numbers, order of Tate-
	 Shafarevic group"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single ecrordtsg(E)  list E;
	t = ecrordtsg(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe ecrinit).
        ecrordtsg bestimmt die Ordnung der Tate-Shafarevic-Gruppe.
	Rueckgabe: bei korrektem Lauf: t > 0
	           sonst: -1.



			ecrpcomp( P1, P2 )

	"elliptic curve over rational numbers, point comparison"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
        single ecrpcomp(P1, P2)  list P1, P2;
        s = ecrpcomp(P1, P2);
	Dabei muss gelten: P1 = ( x1  y1  z1 ) int x1, y1, z1 und
	                   P2 = ( x2  y2  z2 ) int x2, y2, z2;
        sind normiert (siehe Dokumentation zu 'ecrpnorm').
	s = 1, falls P1 = P2 ist,  i.e. x1 == x2, y1 == y2, z1 == z2,
	   -1, falls P1 = -P2 ist, i.e. x1 == x2, y1 != y2, z1 == z2,
            0, falls P1 != +/- P2, i.e. x1 != x2    oder    z1 != z2.



			ecrpnorm( P )

	"elliptic curve over rational numbers, point normalization"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecrpnorm(P);  list P;
	Q = ecrpnorm(P); 
	ecrpnorm normiert den Punkt P = ( x  y  z ) int x, y, z;
	nach folgenden Regeln:
	  1. z >= 0
	  2. Falls z = 0: x = 0, y = 1. <==> P = ( 0 : 1 : 0 ) u.f.P.
	     Sonst: z minimal unter der Bedingung x, y, z ganzzahlig
		    und P = ( x/z^2, y/z^3 ).
	Rueckgabe: Liste ( x  y  z ).



			ecrprodcp( E )

	"elliptic curve over the rationals, product over all c_p- values"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	int ecrprodcp(E)  list E;
	c = ecrprodcp(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe ecrinit).
	ecrprodcp liefert 
	  - bei korrektem Lauf das Produkt ueber alle c_p-Werte
	    mit p|N (siehe ecitatealg).
          - ERROR sonst.
        Falls das Produkt ueber alle c_p-Werte noch nicht in der Liste E 
	vorhanden ist, so wird es mit Hilfe von ecrcond berechnet und 
	dort abgelegt.
	E wird veraendert.



			ecrptoproj( P )

	"elliptic curve over rational numbers, point to projective 
	representation"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list  ecrptoproj(P)  list P;
	Q =  ecrptoproj(P);
	ecrptoproj wandelt die affine Dartsellung des Punkts P in 
	die projektieve um.
	Rueckgabe: Liste ( x  y  z ) bei Erfolg,
	           ERROR             sonst.



			ecrrank( E )

	"elliptic curve over the rationals, rank"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single ecrrank(E)  list E;
	r = ecrrank(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe ecrinit).
        ecrrank liefert den Rang r der elliptische Kurve E/Q.
	Falls der Rang r noch nicht in E vorhanden ist, wird er 
	berechnet und dort abgelegt.



			ecrregulator( E )

	"elliptic curve over the rational numbers, regulator"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	floating ecrregulator(E)  list E;
	H = ecrregulator(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
        ecrregulator bestimmt den Regulator auf NTH_EPS Dezimalstellen 
	genau.
	Rueckgabe: bei korrektem Lauf: Regulator H >= 0
	           sonst: -1.



			ecrrl( E )

	"elliptic curve over rational numbers reduction list"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecrrl(E)  list E;
	L = ecrrl(E);
        Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	Seien p1 , ... , pk (aufsteigend geordnet) diejenigen Primzahlen, 
	fuer die E schlechte Reduktion hat. ecrrl liefert eine Liste 
	L = (p1  n1  p2  n2 ... pk  nk) von ganzen Zahlen.
	ES gilt fuer alle i = 1, ... , k:
		ni =  1, falls E bei pi additive Reduktion hat und
		ni = -1, falls E bei pi multiplikative Reduktion hat.



			ecrrperiod( E )

	"elliptic curve over the rational numbers, real period"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	floating ecrrperiod(E)  list E;
	w = ecrrperiod(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der ellip-
	tischen Kurve E/Q (siehe 'ecrinit').
	ecrrperiod berechnet die reelle Periode w = omega von E.
	Literatur: D.R. Grayson: "The Arithogeometric Mean",
	    Arch. Math. 52, pp. 507-512 (1989).



			ecrrt( E, p )

	"elliptic curve over rational numbers reduction type"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single ecrrt(E, p)  list E; int p;
	n = ecrrt(E, p);
        Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	p muss eine Primzahl sein.
	ecrrt berechnet den Reduktionstyp von E bei p und liefert
		0, falls E gute Reduktion bei p hat,
		1, falls E additive Reduktion bei p hat und
	       -1, falls E multiplikative Reduktion bei p hat.



			ecrsign( E )

	"elliptic curve over rational numbers, sign of the functional 
	equation"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single ecrsign(E)  list E;   
	C = ecrsign(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q siehe 'ecrinit')
	ecrsign liefert das Vorzeichen der Funktionalgleichung der
	L-Reihe der elliptischen Kurve E/Q.
	Falls das Vorzeichen noch nicht in E vorhanden ist, wird
	es berechnet und dort abgelegt.
	Rueckgabe: 
	   +1 oder -1, falls das Vorzeichen erfolgreich berechnet
		       werden konnte
	   0         , falls das Vorzeichen nicht berechnet werden
		       konnte, aber kein Fehler vorliegt.
	   ERROR     , falls ein Fehler vorliegt.



			ecrsigns( E, A, C )

	"elliptic curve over the rationals, sign of the functional 
	equation, special version"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single *ecrsigns(E, A, C)  list E;  single *A, *C;
	A = ecrsigns(E, A, C);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe ecrinit).
	Falls das Vorzeichen der Funktionalgleichung von E erfolgreich 
	berechnet werden kann, erhaelt *C diesen Wert, 
	sonst ist *C = 0.
	Rueckgabe: 
	    falls ein Fehler beim Allokieren des Arrays A auftritt: NULL.
            sonst: Zeiger A auf ein Array von singles mit den 
		   Koeffizienten a_i der L-Reihe (siehe ecrclser).



			ecrsnfrroots( a, b )

	"elliptic curve over rational numbers, short normal form,
	 real roots of the right side"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecrsnffrroots( a, b )  rat a, b; 
	L = ecrsnfrroots( a, b );
	ecrsnfrroots berechnet die Liste aller reeller Nullstellen 
	des Polynoms
	    F(x) = x^3 + a x + b.
	Rueckgabe: 
	  - einelementige Liste 
		L = ( e1 )  floating e1;
	    falls F(x) nur eine reelle Nullstelle hat,
	  - dreielementige Liste 
		L = ( e1  e2  e3 )  floating e1, e2, e3;
	    mit e1 <= e2 <= e3, sonst.



			ecrstrtor( E )

        "elliptic curve over rational numbers, structure of torsion group"
        Quellbibliothek: srclib.ec2
        Include-Datei:   _ec2.h
	list ecrstrtor(E)  list E;
	ST = ecrstrtor(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
        ercstrtor liefert eine Liste
	  ( t ) single t; falls die Torsionsgruppe zyklisch ist,
	oder
	  ( t/2  2 ) single t; falls die Torsionsgruppe bizyklisch ist.
        Falls die Struktur der Torsionsgruppe noch nicht in E  vorhanden 
	ist, so wird sie mit Hilfe von 'ecisnfgentor' berechnet und dort 
	abgelegt.
	E wird veraendert.
        Literatur: J.H. Silverman: The arithmetic of elliptic curves.



			ecrtavalb( a1, a2, a3, a4, a6 )

	"elliptic curve over rational numbers, Tate's values 
	 b2, b4, b6, b8"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecrtavalb(a1, a2, a3, a4, a6)  rat a1, a2, a3, a4, a6;
	L = ecrtavalb(a1, a2, a3, a4, a6);
	ecrtavalb berechnet die Tateschen Groessen b2, b4, b6 und b8 
	der durch die rationalen Koeffizienten a1, a2, a3, a4, a6
	gegebenen elliptischen Kurve E/Q.
	ecrtavalb liefert die Liste 
		( b2  b4  b6  b8 )  rat b2, b4, b6, b8.
	Literatur: J.H. Silverman: 
		   The arithmetic of elliptic curves, p.46.



			ecrtavalc( a1, a2, a3, a4, a6 )

	"elliptic curve over the rationals Tate's values c4, c6"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list ecrtavalc(a1, a2, a3, a4, a6)  rat a1, a2, a3, a4, a6;
	L = ecrtavalc(a1, a2, a3, a4, a6);
	ecrtavalc berechnet die Tateschen Koeffizienten c4 und c6
	der durch die rationalen Koeffizienten a1, a2, a3, a4, a6
	gegebenen elliptischen Kurve E/Q.
	ecrtavalc liefert die Liste ( c4  c6 )  rat c4, c6.
	Literatur: J.H. Silverman:
		   The arithmetic of elliptic curves, p.46.



			fgetecr( pf )

	"file get elliptic curve over rational numbers"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list fgetecr(pf)  FILE *pf;
	L = fgetecr(pf);
	fgetecr liest die elliptische Kyrve
	   E:  Y^2  +  a1 XY  +  a3 Y  =  X^3  +  a2 X^2  +  a4 X  +  a6
	mit rationalen Koeffizienten a1, a2, a3, a4, a6 aus der zum
	Lesen geoeffneten Datei *pf ein.
	Rueckgabe: Liste ( a1  a2  a3  a4  a6 )  rat a1, a2, a3, a4, a6;



			fgetecrp( pf )

	"file get point on elliptic curve over rational numbers"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list fgetecrp(pf)  FILE *pf;
	P = fgetecrp(pf);
	fgetecrp liest den Punkt P von der zum Lesen geoeffneten Datei
	*pf ein. Dabei sind die folgenden Eingaben zulaessig:
	 1. ( X Y )  ==> affine Darstellung
	    X, Y vom Typ rat oder int (auch gemischt) zur Darstellung
	    des Punkts ( X, Y ).
	    ( X  Y ) wird konvertiert zu ( x  y  z ) 
	    mit ganzen Zahlen x, y, z und X = x/z^2 und Y = y/z^3.
	 2. ( x  y  z )  ==> SIMATH-spezifische Darstellung  
	    x, y, z vom Typ 'int' zur Dartstellung des 
               - Punkts ( x/z^2, y/z^3 ), falls z != 0 ist
               - unendlich fernen Punkts ( 0 : 1 : 0 ), falls z = 0,
	 3. [ x  y  z ]  ==> projektive Darstellung  
	    x, y, z vom Typ 'int' zur Dartstellung des 
               - Punkts ( x/z, y/z ), falls z != 0 ist
               - unendlich fernen Punkts ( 0 : 1 : 0 ), falls z = 0,
	    [ x  y  z ] wird konvertiert zu ( xz  yz^2  z ) 
	wobei die eingegebenen Zahlen X und Y bzw. x, y und z
	durch Leerzeichen, Return, Komma oder Doppelpunkt voneinander
	getrennt werden duerfen. 
	Die Rueckgabe ( x  y  z )  wird ausserdem normiert (siehe
	Dokumentation zu 'ecrpnorm').
	Rueckgabe: Liste ( x  y  z ) bei Erfolg,
	           ERROR             sonst.



			fputecimin( E, pf )

	"file put elliptic curve with integer coefficients, minimal model"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single fputecimin(E)  list E; 
	s = fputecimin( E );
	Dabei muss gelten:
	 - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	   Kurve E/Q (siehe ecrinit).
	 - *pf ist eine zum Schreiben geoeffnete Datei.
	fputecimin gibt alle in der Liste E abgelegten Daten des
	minimalen Modells der elliptischen Kurve E/Q auf die Datei *pf
	aus.
	Rueckgabe:
	  - bei korrektem Lauf Wert 0,
          - ERROR sonst.



			fputecisnf( E, *pf )

	"file put elliptic curve with integer coefficients, 
	short normal form"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single fputecisnf(E, *pf)  list E; FILE *pf;
	s = fputecisnf(E, *pf);
	Dabei gilt:
	 - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	   Kurve E/Q (siehe ecrinit).
	 - *pf ist eine zum Schreiben geoeffnete Datei.
	fputecisnf gibt alle in der Liste E abgelegten Daten des
	Modells in kurzer WNF der elliptischen Kurve E/Q auf die Datei
	*pf aus.
	Rueckgabe:
	  - bei korrektem Lauf den Wert 0,
          - ERROR sonst.



			fputecr( E, pf )

	"file put elliptic curve"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single fputecr(E, pf)  list E; FILE *pf;
	s = fputecr(E, pf);
	Dabei muss gelten:
	 - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	   Kurve E/Q (siehe Dokumentation zu 'ecrinit').
	 - *pf ist eine zum Schreiben geoeffnete Datei.
	fputecr gibt alle in der Liste E abgelegten Daten der
	elliptischen Kurve E/Q auf die Datei *pf aus.
	Rueckgabe:
	  - bei korrektem Lauf den Wert 0,
          - ERROR sonst.



			fputecrac( E, pf )

	"file put elliptic curve over rational numbers, actual curve"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single fputecrac(E, pf)  list E; FILE *pf;
	s = fputecrac(E, pf);
	Dabei muss gelten:
	 - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	   Kurve E/Q (siehe ecrinit).
	 - *pf ist eine zum Schreiben geoeffnete Datei.  
	fputecrac gibt alle in der Liste E abgelegten Daten des aktuellen 
	Modells der elliptischen Kurve E/Q auf die Datei *pf aus.
	Rueckgabe:
	  - bei korrektem Lauf Wert 0,
          - ERROR sonst.



			fputecrinv( E, pf )

	"file put elliptic curve over the rational numbers, invariants"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single fputecrinv(E, pf)  list E; FILE *pf;
	s = fputecrinv(E, pf);
	Dabei muss gelten:
	 - E ist eine Liste mit allen wichtigen Daten der elliptischen 
           Kurve E/Q (siehe 'ecrinit').
	 - *pf ist eine zum Schreiben geoeffnete Datei.
	fputecrinv gibt alle in der Liste E abgelegten Daten ueber
	Invarianten der elliptischen Kurve E/Q auf die Datei *pf aus.
	Rueckgabe:
	  - bei korrektem Lauf Wert 0,
          - ERROR sonst.



			fputecrlistp( P, modus, pf )

	"file put elliptic curve over the rational numbers, list of points"    
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
        single fputecrlistp(PL, modus, pf) list PL; single modus; FILE *pf;    
	t = fputecrlistp(PL, modus, pf);
	fputecrlistp schreibt die Punktliste PL folgendermassen in die zum 
	Schreiben geoffnete Datei *pf:
	1. Fall: modus = 0
	    Dann muss PL von der Form PL = ( P1  P2  ...  Pn )  
	    mit n >= 0, und Pi = ( xi  yi  zi )  int xi, yi, zi;  
	    sein. Fuer 1 <= i <= n sind die Pi Punkte einer 
	    elliptischen Kurve E/Q.
	2. Fall: modus = 1
	    Dann ist PL von der Form PL = ( P1  h1  P2  h2  ...  Pn  hn )
	    mit n >= 0.  P1, ..., Pn wie oben, hi (vom Typ floating) 
	    ist die Neron-Tate-Hoehe des Punktes Pi (1 <= i <= n).
	3. Fall: modus = -1
	    Dann ist PL von derselben Form wie im 2. Fall, es werden 
	    aber nur die Punkte (ohne die Hoehen) ausgegeben.
	Rueckgabe: 0 bei Erfolg,
		   ERROR sonst.



			fputecrp( P, pf )

	"file put elliptic curve over rational numbers, point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single fputecrp( P, pf )  list P; FILE *pf;
	t = fputecrp( P, pf );
	Es muss gelten:
	    P = ( x  y  z )  int x, y, z;
	fputecrp gibt den Punkt P einer elliptischen Kurve E
	ueber Q in der Form
	    ( x/z^2 , y/z^3 ),  falls z != 0,
	    ( 0 : 1 : 0 ),  sonst,
	auf die Datei *pf aus.
	t = 0 bei Erfolg, ERROR sonst.



			getecr(  )

	"get elliptic curve over rational numbers"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list getecr( )
	L = getecr( );
	getecr liest die elliptische Kyrve
	   E:  Y^2  +  a1 XY  +  a3 Y  =  X^3  +  a2 X^2  +  a4 X  +  a6
        mit rationalen Koeffizienten a1, a2, a3, a4, a6 von stdin ein.
	Rueckgabe: Liste ( a1  a2  a3  a4  a6 )  rat a1, a2, a3, a4, a6;



			getecrp(  )                     (MACRO)

	"get elliptic curve over rational numbers point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	list getecr( ) 
	P = getecr( );
	fgetecrp liest den Punkt P von stdin ein. Zulaessige
	Darstellungen fuer P siehe Dokumentation von 'fgetecrp'.
	Rueckgabe: Liste ( x  y  z ) bei Erfolg,
	           ERROR             sonst.



			isecimintorp( E, P )

      	"is torsion point on elliptic curve with integer coefficients, 
	minimal model"
        Quellbibliothek: srclib.ec2
        Include-Datei:   _ec2.h
	single isecimintorp(E, P)  list E, P;
	s = isecimintorp(E, P);
	Dabei muss gelten:
            - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	      Kurve E/Q (siehe 'ecrinit')
            - P = ( x  y  z ), int x, y, z; ist eine 3-elementige Liste
              ganzer Zahlen, die den Punkt ( x/z^2, y/z^3 ) auf E/Q 
	      darstellen.
        Rueckgabe:
	    1, falls P ein Torsionspunkt auf E/Q ist
	    0  sonst.
        Literatur: J.H. Silverman: The arithmetic of elliptic curves.



			iselecgf2( G, a1, a2, a3, a4, a6, P )

	"is element of an elliptic curve over Galois-field with
	 characteristic 2 ?"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single iselecgf2(G, a1, a2, a3, a4, a6, P)
		obj G;  gf2el a1, a2, a3, a4, a6;  list P;
	n = iselecgf2(G, a1, a2, a3, a4, a6, 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).
                - a1, a2, a3, a4, a6 sind Elemente aus GF(2^n), die als
                  Polynome in einer Variablen ueber Z/2Z vom Grad < n
                  in spezieller Bit-Notation dargestellt werden.
                - P ist eine 3-elementige Liste von Elementen aus GF(2^n)
                  in spezieller Bit-Notation als projektive Darstellung 
		  eines Punktes auf einer elliptischen Kurve E.
	iselecgf2 liefert 1, falls der als 3-elementige Liste in projekti-
	ver Darstellung gegebene Punkt P ein Element der durch a1, ... , a6 
	in Weierstrass-Normalform gegebenen kubischen Kurve E ist. 
	iselecgf2 liefert 0, falls P kein Element von E ist.



			iselecmp( p, a1, a2, a3, a4, a6, P )

	"is element of an elliptic curve over modular primes ?"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single iselecmp(p, a1, a2, a3, a4, a6, P)
		int p, a1, a2, a3, a4, a6;  list P;
	n = iselecmp(p, a1, a2, a3, a4, a6, P);
	Dabei muss gelten:
		- p ist eine Primzahl.
		- a1, a2, a3, a4, a6 sind Elemente aus Z/pZ.
		- P ist eine 3-elementige Liste von Elementen aus Z/pZ.
	iselecmp liefert 1, falls der als 3-elementige Liste in
	projektiver Darstellung gegebene Punkt P ein Element der durch
	a1, ... , a6 in Weierstrass-Normalform gegebenen kubischen
	Kurve E ist. iselecmp liefert 0, falls P kein Element von E
	ist.



			iselecmpsnf( p, a, b, P )

	"is element of an elliptic curve over modular primes,
	 short normal form ?"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single iselecmpsnf(p, a, b, P)  int a, b;  list P;
	n = iselecmpsnf(p, a, b, P);
	Dabei muss gelten:
		- a, b sind Elemente aus Z/pZ,
		- P ist eine 3-elementige Liste von rationalen Zahlen.
	iselecmpsnf liefert 1, falls der als 3-elementige Liste in
	projektiver Darstellung gegebene Punkt P ein Element der durch
	a und b in kurzer Weierstrass-Normalform gegebenen kubischen
	Kurve E ist. iselecmpsnf liefert 0, falls P kein Element von
	E ist.



			iselecnf( F, a1, a2, a3, a4, a6, P )

	"is element of an elliptic curve over number field ?"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single iselecnf( F, a1, a2, a3, a4, a6, P )  pol F;
		nfel a1, a2, a3, a4, a6; list P;
	n = iselecnf( F, a1, a2, a3, a4, a6, P );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a1, a2, a3, a4, a6 sind Elemente dieses Koerpers K.
		- P ist eine 3-elementige Liste von Elementen
		  des Koerers K.
	iselecnf liefert 1, falls der als 3-elementige Liste in projektiver
	Darstellung gegeben Punkt P ein Element der durch a1, ... , a6
	in Weierstrass-Normalform gegebenen kubischen Kurve E ist.
	iselecnf liefert 0, falls P kein Element von E ist.



			iselecnfsnf( F, a, b, P )

	"is element of an elliptic curve over number field, short normal
	 form ?"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single iselecnfsnf( F, a, b, P )  pol F; nfel a, b; list P;
	n = iselecnf( F, a, b, P );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- a, b sind Elemente dieses Koerpers K.
		- P ist eine 3-elementige Liste von Elementen des
		  Koerpers K.
	iselecnfsnf liefert 1, falls der als 3-elementige Liste in projek-
	tiver Darstellung gegebene Punkt P ein Element der durch a und b in
	kurzer Weierstrass-Normalform gegebenen kubischen Kurve E ist.
	iselecnfsnf liefert 0, falls P kein Element von E ist.



			isineciminpl( E, P, h, PL )

	"is in list of points on elliptic curve with integer 
	coefficients, minimal model"
        Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single isineciminpl(E, P, h, PL)  list E, P, PL; floating h;
        s = isineciminpl(E, P, h, PL);
	Dabei muss gelten:
         - E ist eine Liste mit allen wichtigen Daten der elliptischen
	   Kurve E/Q (siehe Dokumentation zu 'ecrinit').
	 - P = ( x  y  z ) int x, y, z; ist ein Punkts auf dem
	   durch die Liste E gegebenen minimalen Modell fuer E/Q.
	 - PL ist eine geordnete Liste 
	       ( P_1  h_1  P_2  h_2  ...  P_n  h_n ) 
	       list P_1, P_2, ..., P_n; floating h_1, h_2, ..., h_n;
           wobei Pi ein Punkt auf dem durch die Liste E gegebenen
	   minimalen Modell fuer E/Q ist und hi = h(Pi) dessen 
	   Neron-Tate-Hoehe ist. Es muss gelten 
		       h1 <= h2 <= ... <= hn.
        isineciminpl ueberprueft, ob der Punkt P in die Liste PL
	aufgenommen werden darf. P darf weder Torsionspunkt noch Summe 
	eines Torsionspunkts - auch ( 0 : 1 : 0 ) - mit einem Punkt aus
	der Liste PL sein, d.h. die Neron-Tate-Hoehe von P darf weder 0
	noch gleich der Hoehe eines anderen Punkts der Liste PL sein.
        Rueckgabe:
            -3, wenn P = O = ( 0 : 1 : 0 ) ist             
	    -2, wenn P ein anderer Torsionspunkt ist     
	    -1, wenn -P in der Liste PL ist
	     0, wenn P kein Torsionspunkt ist und weder P + T noch
	        -P + T fuer alle Torsionspunkte T in der Liste PL sind.
	     1, wenn P in der Liste PL ist
	     2, wenn P + T oder -P + T in der Liste PL sind, d.h. wenn 
		es einen Punkt Q != +/- P mit derselben Neron-Tate-Hoehe
		wie P in der Liste PL gibt. Dabei durchlaeuft T alle 
		von O verschiedenen Torsionspunkte der Kurve.
	     ERROR sonst.



			ispecrpai( P )                  (MACRO)

	"is point of an elliptic curve over the rationals point at 
	 infinity ?"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single ispecrpai(P)  list P;
	n = ispecrpai(P);
	P ist eine dreielementige Liste ( x y z ) mit rationalen
	Eintraegen, die als Punkt auf einer elliptischen Kurve ueber Q
	interpretiert werden kann.
	ispecrpai liefert 1, falls z == 0 ist, und 0 sonst.



			isponecimin( E, P )

	"is point on elliptic curve with integer coefficients, minimal model"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single isponecimin(E, P)  list E, P;
	s = isponecimin(E, P);
	Dabei gilt 
	   - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	     Kurve E/Q (s. 'ecrinit') und 
	   - P = ( x  y  z ) int x, y, z; stellt fuer z!= 0 den Punkt
	     P = ( x/z^2, y/z^3 ) bzw. fuer z = 0 den unendlich fernen 
	     Punkt dar.
	isponecimin liefert 
	  1, falls der Punkt P auf dem minimalen Modell von E/Q
	     liegt
          0  sonst.



			isponecisnf( E, P )

	"is point on elliptic curve with integer coefficients, 
	model in short normal form"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single isponecisnf(E, P)  list E, P;
	s = isponecisnf(E, P);
	Dabei gilt 
	   - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	     Kurve E/Q (siehe 'ecrinit') und 
	   - P = ( x  y  z ) int x, y, z; stellt fuer z!= 0 den Punkt
	     P = ( x/z^2, y/z^3 ) bzw. fuer z = 0 den unendlich
	     fernen Punkt dar.
	isponecisnf liefert 
	  1, falls der Punkt P auf dem Modell in kurzer WNF
	     von E/Q liegt
          0  sonst.



			isponecrac( E, P )

	"is point on elliptic curve over rational numbers, actual model"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single isponecrac(E, P)  list E, P;
	s = isponecrac(E, P);
	Dabei gilt 
	   - E ist eine Liste mit allen wichtigen Daten der elliptischen 
	     Kurve E/Q (siehe 'ecrinit')
	   - P = ( x  y  z ) int x, y, z; stellt fuer z!= 0 den Punkt
	     P = ( x/z^2, y/z^3 ) bzw. fuer z = 0 den unendlich
	     fernen Punkt dar.
	isponecrac liefert 
	  1, falls der Punkt P auf dem urspruenglichen
	     Modell von E/Q liegt
          0  sonst.



			isppecgf2eq( p, P1, P2 )

	"is projective point of an elliptic curve over Galois-field with
	 characteristic 2 equal ?"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single isppecgf2eq(G, P1, P2)  obj G;  list P1, P2;
	n = isppecgf2eq(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 3-elementige Listen von Elementen aus 
		  GF(2^n) in spezieller Bit-Notation als projektive Dar-
		  stellungen von Punkten auf einer elliptischen Kurve E.
	isppecgf2eq vergleicht die in projektiver Darstellung als
	3-elementige Listen gegebenen Punkte P1 und P2.
	isppecgf2eq liefert 1, falls P1 == P2
		        und 0, falls P1 != P2.



			isppecgf2pai( G, P )

	"is projective point of an elliptic curve over Galois-field
	 with characteristic 2 point at infinity ?"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single isppecgf2pai(G, P)  obj G; list P;
	n = isppecgf2pai(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 eine 3-elementige Liste von Elementen aus GF(2^n)
                  in spezieller Bit-Notation als projektive Darstellung 
		  eines Punktes auf einer elliptischen Kurve E.
	isppecgf2pai liefert n = 1, falls P = (x, y, 0), und 0 sonst.



			isppecmpeq( p, P1, P2 )

	"is projective point of an elliptic curve over modular primes
	 equal ?"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single isppecmpeq(p, P1, P2)  int p;  list P1, P2;
	n = isppecmpeq(p, P1, P2);
	Dabei muss gelten:
		- p ist eine Primzahl.
		- P1 und P2 sind 3-elementige Listen von Elementen
		  aus Z/pZ.
	isppecmpeq vergleicht die in projektiver Darstellung als
	3-elementige Listen gegebenen Punkte P1 und P2.
	isppecmpeq liefert 1, falls P1 == P2
		       und 0, falls P1 != P2.



			isppecmppai( p, P )

	"is projective point of an elliptic curve over modular primes
	 point at infinity ?"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single isppecmppai(p, P)  int p;  list P;
	n = isppecmppai(p, P);
	Dabei muss gelten:
		- p ist eine Primzahl.
		- P ist eine 3-elementige Liste als projektive Darstellung
		  eines Punktes auf einer elliptischen Kurve.
	n = 1, falls P = (x, y, 0),
	    0  sonst.



			isppecnfeq( F, P1, P2 )

	"is projective point of an elliptic curve over number field equal?"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single isppecnfeq( F, P1, P2 )  pol F; list P1, P2;
	n = isppecnfeq( F, P1, P2 );
	Dabei muss gelten:
		- F ist ein irreduzibles univariates Polynom in
		  dense-Darstellung, das einen Zahlkoerper K erzeugt.
		- P1 und P2 sind 3-elementige Listen von Elementen
		  des Koerpers K.
	isppecnfeq vergleicht die in projektiver Darstellung als 3-elemen-
	tige Listen gegebenen Punkte P1 und P2.
	isppecnfeq liefert 1, falls P1 == P2
		       und 0, falls P1 != P2.



			isppecnfpai( P )

	"is projective point of an elliptic curve over number field point
	 at infinity ?"
	Quellbibliothek: srclib.ec2
	Include-Datei:   _ec2.h
	single isppecnfpai( P )  list P;
	n = isppecnfpai( P );
	Dabei muss gelten:
		P ist eine 3-elementige Liste als projektive Darstellung
		eines Punktes auf einer elliptischen Kurve.
	n = 1, falls P = ( x, y, 0 ),
	    0 sonst.



			putecimin( E )                  (MACRO)

	"put elliptic curve with integer coefficients, minimal model"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single putecimin(E)  list E; 
	s = putecimin(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	putecimin gibt alle in der Liste E abgelegten Daten des minimalen 
	Modells der elliptischen Kurve E/Q auf stdout aus
	Rueckgabe:
	  - bei korrektem Lauf den Wert 0,
          - ERROR sonst,



			putecisnf( E )                  (MACRO)

	"put elliptic curve with integer coefficients, short normal form"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single putecisnf(E)  list E;
	s = putecisnf(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe 'ecrinit').
	putecisnf gibt alle in der Liste E abgelegten Daten des Modells
	in kurzer WNF der elliptischen Kurve E/Q auf stdout aus.
	Rueckgabe:
	  - bei korrektem Lauf den Wert 0,
          - ERROR sonst,



			putecr( E )                     (MACRO)

	"put elliptic curve over rational numbers"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single putecr(E)  list E;
	s = putecr(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q (siehe Dokumentation zu 'ecrinit').
	putecr gibt alle in der Liste E abgelegten Daten der elliptischen 
	Kurve E/Q auf stdout aus.
	Rueckgabe:
	  - bei korrektem Lauf den Wert 0,
          - ERROR sonst,



			putecrac( E )                   (MACRO)

	"put elliptic curve over rational numbers, actual curve"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single putecrac(E)  list E;
	s = putecrac(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q.
	putecrac gibt alle in der Liste E abgelegten Daten des
	aktuellen Modells der elliptischen Kurve E/Q auf stdout aus.
	Rueckgabe:
	  - bei korrektem Lauf den Wert 0,
          - ERROR sonst,



			putecrinv( E )                  (MACRO)

	"put elliptic curve over the rational numbers, invariants"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single putecrinv(E)  list E; 
	s = putecrinv(E);
	Dabei ist E eine Liste mit allen wichtigen Daten der elliptischen 
	Kurve E/Q.
	putecrinv gibt alle in der Liste E abgelegten Daten ueber
	Invarianten der elliptischen Kurve E/Q auf stdout aus.
	Rueckgabe:
	  - bei korrektem Lauf den Wert 0,
          - ERROR sonst,



			putecrlistp( P, modus )         (MACRO)

	"put elliptic curve over rational numbers, list of points"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
        single putecrlistp( PL, modus )  list PL; single modus; 
	t = putecrlistp( PL, modus );
	t = putecrlistp( PL, modus );
	1. Fall: modus = 0
	    Dann hat PL die Form
		PL = ( P1  P2  ...  Pn )  mit n >= 0,
	    und 
		Pi = ( xi  yi  zi )  int xi, yi, zi;  
	    fuer 1<=i<=n sind projektive Punkte einer elliptischen 
	    Kurve E/Q.
	    Die Punkte P1, ..., Pn werden so wie in putecrp beschrie-
	    ben auf stdout ausgegeben, und zwar jeder Punkt in eine 
	    neue Zeile.
	2. Fall: modus != 0
	    Dann hat PL die Form
		PL = ( ( P1 h1 ) ( P2 h2 ) ... ( Pn hn ) )  mit n>= 0.
	    P1, ..., Pn wie im 1. Fall.
	    hi (vom Typ floating) ist die Neron-Tate-Hoehe des Punktes
	    Pi fuer 1<=i<=n.
	    Die Punkte P1, ..., Pn werden so wie in putecrp beschrie-
	    ben auf stdout ausgegeben, zusaetzlich mit laufender Num-
	    mer i und Neron-Tate-Hoehe hi, und zwar jeder Punkt in 
	    eine neue Zeile.
	t = 0 bei Erfolg, ERROR sonst.



			putecrp( P )                    (MACRO)

	"put elliptic curve over rational numbers, point"
	Quellbibliothek: srclib.ec1
	Include-Datei:   _ec1.h
	single putecrp( P )  list P;
	t = putecrp( P );
	Es muss gelten:
	    P = ( x  y  z )  int x, y, z;
	putecrp gibt den Punkt P einer elliptischen Kurve E
	ueber Q in der Form
	  ( x/z^2 , y/z^3 ),  falls z != 0,
	  ( 0 : 1 : 0 ),  sonst,
	auf stdout aus.
	t = 0 bei Erfolg, ERROR sonst.



