椭圆曲线上的点

基类椭圆曲线点字段，派生自添加组元素，支持椭圆上的点在一般字段上定义的曲线。派生类椭圆曲线Point_number_field和椭圆曲线点_finite_field为该点提供进一步支持关于在数字域（包括有理域）上定义的曲线\（\QQ\）)以及在有限域上。

这个班级椭圆曲线点，它基于方案Morphism_point_projective_ring，当前几乎没有额外的功能。

示例：

下面是一个示例\（\QQ\）:

圣人：E类 = 椭圆曲线(“389a1”)
圣人：P（P） = E类(-1,1); P（P）
(-1 : 1 : 1)
圣人：问 = E类(0,-1); 问
（0:-1:1）
圣人：P（P）+问
(4 : 8 : 1)
圣人：P（P）-问
(1 : 0 : 1)
圣人：三*P（P）-5*问
(328/361 : -2800/6859 : 1)

数字字段上的示例：

圣人：#需要sage.rings.number_field
圣人：K（K）.<我> = 象限域(-1)
圣人：E类 = 椭圆曲线(K（K）, [1,0,0,0,-1])
圣人：P（P） = E类(0,我); P（P）
（0:i:1）
圣人：P（P）.秩序()
+无限
圣人：101*P（P） - 100*P（P） == P（P）
真的

有限域上的示例：

圣人：#需要sage.rings.finite_ring
圣人：K（K）.<一> = GF公司((101,三))
圣人：E类 = 椭圆曲线(K（K）, [1,0,0,0,-1])
圣人：P（P） = E类(40*一^2 + 69*一 + 84 , 58*一^2 + 73*一 + 45)
圣人：P（P）.秩序()
1032210
圣人：E类.基数()
1032210

有限域扩展上的点的算术：

圣人：#需要sage.rings.finite_ring
圣人：k个.<一> = GF公司((5,2))
圣人：E类 = 椭圆曲线(k个,[1,0]); E类
大小为5^2的有限域上y^2=x^3+x定义的椭圆曲线
圣人：P（P） = E类([一,2*一+4])
圣人：5*P（P）
（2*a+3:2*a:1）
圣人：P（P）*5
（2*a+3:2*a:1）
圣人：P（P） + P（P） + P（P） + P（P） + P（P）
（2*a+3:2*a:1）

圣人：F类 = Zmod公司(三)
圣人：E类 = 椭圆曲线(F类, [1,0]);
圣人：P（P） = E类([2,1])
圣人：进口 系统
圣人：n个 = 系统.最大尺寸
圣人：P（P）*(n个+1)-P（P）*n个 == P（P）
真的

算术结束\（\ZZ/N\ZZ\）使用复合材料\（N \）支持。当操作尝试反转不可逆元素ZeroDivision错误并出现模量的因式分解在错误消息中：

圣人：N个 = 1715761513
圣人：E类 = 椭圆曲线(整数(N个), [三,-13])
圣人：P（P） = E类(2,1)
圣人：生命周期管理([2..60])*P（P）
回溯（最近一次调用）：
。。。
ZeroDivisionError:26927的逆运算不存在
（特征=1715761513=26927*63719）

作者：

• William Stein（2005）–初始版本

• Robert Bradshaw等人…。

• John Cremona（2008年2月）–积分计算和团队结构非素数域，Frobenius自同态和序，椭圆对数

• John Cremona（2008年8月）–推出椭圆曲线Point_number_field班

• Tobias Nagel、Michael Mardaus、John Cremona（2008年12月）–\（p\）-上的adic椭圆对数\（\QQ\）

• David Hansen（2009年1月）-新增weil配对函数到椭圆曲线点_finite_field班

• 玛丽亚·莱诺克斯（2011年3月）——新增状态配对和ate_播放函数到椭圆曲线点_finite_field班

班 sage.schemes.elliptic_curves.ell_point。椭圆曲线点(X（X）,v（v）,检查=真的)

基础：方案Morphism_point_projective_ring

椭圆曲线上的一点。

班 sage.schemes.elliptic_curves.ell_point。椭圆曲线点字段(曲线,v（v）,检查=真的)

基础：方案Morphism_point_abelian_variety_field

场上椭圆曲线上的点。该点具有坐标在基本场上。

示例：

圣人：E类 = 椭圆曲线(“37a”)
圣人：E类([0,0])
(0 : 0 : 1)
圣人：E类(0,0)               #括号是可选的
(0 : 0 : 1)
圣人：E类([GF公司(5)(0), 0])     #条目被强制
(0 : 0 : 1)

圣人：E类(0, 0)
(0 : 0 : 1)

圣人：E类(1,0,0)
回溯（最近一次调用）：
。。。
TypeError:坐标[1，0，0]未定义上的点
有理域上由y^2+y=x^3-x定义的椭圆曲线

圣人：E类 = 椭圆曲线([0,0,1,-1,0])
圣人：S公司 = E类(QQ); S公司
上的Abelian点群
有理域上由y^2+y=x^3-x定义的椭圆曲线

圣人：#需要sage.rings.number_field
圣人：x个 = 一夫多妻制(ZZ公司, “x”)
圣人：K（K）.<我> = 数字字段(x个^2 + 1)
圣人：E类 = 椭圆曲线(K（K）, [0,1,0,-160,308])
圣人：P（P） = E类(26, -120)
圣人：问 = E类(2+12*我, -36+48*我)
圣人：P（P）.秩序() == 问.秩序() == 4       #长时间
真的
圣人：2*P（P） == 2*问
False（错误）

圣人：K（K）.<t吨> = 分数字段(多项式环(QQ,“t”))
圣人：E类 = 椭圆曲线([0,0,0,0,t吨^2])
圣人：P（P） = E类(0,t吨)
圣人：P（P）, 2*P（P）, 三*P（P）
（（0:t:1）、（0:-t:1）和（0:1:0））

加法顺序()

返回椭圆曲线上该点的顺序。

如果点为零，则返回1，否则引发未实现错误.

有关数字字段和有限字段上的曲线，请参见下文。

注释

additive_order（）是的同义词订单（）

示例：

圣人：K（K）.<t吨> = 分数字段(多项式环(QQ,“t”))
圣人：E类 = 椭圆曲线([0, 0, 0, -t吨^2, 0])
圣人：P（P） = E类(t吨,0)
圣人：P（P）.秩序()
回溯（最近一次调用）：
。。。
NotImplementedError:未实现点的顺序计算
在一般字段上。
圣人：E类(0).加法顺序()
1
圣人：E类(0).秩序() == 1
真的

ate_播放(问,n个,k个,t吨,q个=无)

返回的ate配对\（n\）-扭转点\（P\）(=自身)和\（问题\）.

也称为\（n\）-th修改了ate配对。\（P\）是\（GF（q）\）-理性，和\（问题\）必须是的元素\（克尔（\pi-p）\），其中\（\pi\）是\（q\）-frobenius地图（因此\（问题\）是\（GF（q^k）\）-理性）。

输入：

• \（P\）(=自身)–程序点\（n\），英寸\（克尔（\pi-1）\），其中\（\pi\）是\（q\）-Frobenius地图（例如。，\（P\）是\（q\）-理性）。

• 问–程序点\（n\）在里面\（克尔（\pi-q）\）

• n个–顺序\（P\）和\（问题\）.

• k个–嵌入程度。

• t吨–弗罗贝尼乌斯的曲线轨迹\（GF（q）\）.

• q个–（默认值：无）基本字段的大小（“大”字段是\（GF（q^k）\）).\（q\）仅当其值为无法推断。

输出：

中的FiniteFieldElement\（GF（q^k）\）–的ate配对\（P\）和\（问题\）.

示例：

嵌入度为6的示例：

圣人：#需要sage.rings.finite_ring
圣人：第页 = 7549; A类 = 0; B类 = 1; n个 = 157; k个 = 6; t吨 = 14
圣人：F类 = GF公司(第页); E类 = 椭圆曲线(F类, [A类, B类])
圣人：R（右）.<x个> = F类[]; K（K）.<一> = GF公司((第页,k个), 模数，模量=x个^k个+2)
圣人：EK公司 = E类.基本扩展（_E）(K（K）)
圣人：P（P） = EK公司(3050, 5371); 问 = EK公司(6908*一^4, 3231*一^三)
圣人：P（P）.ate_播放(问, n个, k个, t吨)
6708*a^5+4230*a^4+4350*a^3+2064*a^2+4022*a+6733
圣人：秒 = 整数(随机范围(1, n个))
圣人：(秒*P（P）).ate_播放(问, n个, k个, t吨) == P（P）.ate_播放(秒*问, n个, k个, t吨)
真的
圣人：P（P）.ate_播放(秒*问, n个, k个, t吨) == P（P）.ate_播放(问, n个, k个, t吨)^秒
真的

另一个嵌入度为7和正迹线的示例：

圣人：#需要sage.rings.finite_ring
圣人：第页 = 2213; A类 = 1; B类 = 49; n个 = 1093; k个 = 7; t吨 = 28
圣人：F类 = GF公司(第页); E类 = 椭圆曲线(F类, [A类, B类])
圣人：R（右）.<x个> = F类[]; K（K）.<一> = GF公司((第页,k个), 模数，模量=x个^k个+2)
圣人：EK公司 = E类.基本扩展（_E）(K（K）)
圣人：P（P） = EK公司(1583, 1734)
圣人：Qx（质量x） = 1729*一^6+1767*一^5+245*一^4+980*一^三+1592*一^2+1883*一+722
圣人：问题 = 1299*一^6+1877*一^5+1030*一^4+1513*一^三+1457*一^2+309*一+1636
圣人：问 = EK公司(Qx（质量x）, 问题)
圣人：P（P）.ate_播放(问, n个, k个, t吨)
1665*a^6+1538*a^5+1979*a^4+239*a^3+2134*a^2+2151*a+654
圣人：秒 = 整数(随机范围(1, n个))
圣人：(秒*P（P）).ate_播放(问, n个, k个, t吨) == P（P）.ate_播放(秒*问, n个, k个, t吨)
真的
圣人：P（P）.ate_播放(秒*问, n个, k个, t吨) == P（P）.ate_播放(问, n个, k个, t吨)^秒
真的

另一个嵌入度为7和负迹线的示例：

圣人：#需要sage.rings.finite_ring
圣人：第页 = 2017; A类 = 1; B类 = 30; n个 = 29; k个 = 7; t吨 = -70
圣人：F类 = GF公司(第页); E类 = 椭圆曲线(F类, [A类, B类])
圣人：R（右）.<x个> = F类[]; K（K）.<一> = GF公司((第页,k个), 模数，模量=x个^k个+2)
圣人：EK公司 = E类.基本扩展（_E）(K（K）)
圣人：P（P） = EK公司(369, 716)
圣人：Qx（质量x） = 1226*一^6+1778*一^5+660*一^4+1791*一^三+1750*一^2+867*一+770
圣人：问题 = 1764*一^6+198*一^5+1206*一^4+406*一^三+1200*一^2+273*一+1712
圣人：问 = EK公司(Qx（质量x）, 问题)
圣人：P（P）.ate_播放(问, n个, k个, t吨)
1794*a^6+1161*a^5+576*a^4+488*a^3+1950*a^2+1905*a+1315
圣人：秒 = 整数(随机范围(1, n个))
圣人：(秒*P（P）).ate_播放(问, n个, k个, t吨) == P（P）.ate_播放(秒*问, n个, k个, t吨)
真的
圣人：P（P）.ate_播放(秒*问, n个, k个, t吨) == P（P）.ate_播放(问, n个, k个, t吨)^秒
真的

使用相同的数据，我们表明ate配对是Tate配对（请参见【HSV2006】第3.1节末尾）：

圣人：#需要sage.rings.finite_ring
圣人：c（c） = (k个*第页^(k个-1)).国防部(n个); T型 = t吨 - 1
圣人：N个 = gcd公司(T型^k个 - 1, 第页^k个 - 1)
圣人：秒 = 整数(N个/n个)
圣人：L（左） = 整数((T型^k个 - 1)/N个)
圣人：M（M） = (L（左）*秒*c（c）.逆模态(n个)).国防部(n个)
圣人：P（P）.ate_播放(问, n个, k个, t吨) == 问.状态配对(P（P）, n个, k个)^M（M）
真的

我们必须传递基本字段大小的示例与Tate配对的协议）。注意，尽管\（第\页）不是\（F\）-理性，（它是\（F\）-理性点）它尽管如此\（克尔（\pi-1）\），合法输入也是如此：

圣人：#需要sage.rings.finite_ring
圣人：q个 = 2^5; F类.<一> = GF公司(q个)
圣人：n个 = 41; k个 = 4; t吨 = -8
圣人：E类 = 椭圆曲线(F类,[0,0,1,1,1])
圣人：P（P） = E类(一^4 + 1, 一^三)
圣人：Fx公司.<b条> = GF公司(q个^k个)
圣人：前任 = 椭圆曲线(Fx公司, [0,0,1,1,1])
圣人：φ = 霍姆(F类, Fx公司)(F类.消息().小寡头().根(Fx公司)[0][0])
圣人：二甲苯 = 前任(φ(P（P）.x个()), φ(P（P）.年()))
圣人：Qx（质量x） = 前任(b条^19+b条^18+b条^16+b条^12+b条^10+b条^9+b条^8+b条^5+b条^三+1,
....:        b条^18+b条^13+b条^10+b条^8+b条^5+b条^4+b条^三+b条)
圣人：Qx（质量x） = 前任(Qx（质量x）[0]^q个, Qx（质量x）[1]^q个) - Qx（质量x）  #确保Qx在ker（pi-q）中
圣人：二甲苯.ate_播放(Qx（质量x）, n个, k个, t吨)
回溯（最近一次调用）：
。。。
ValueError:意外的字段度：将关键字参数q设置为
基本字段的大小（大字段为GF（q^4））。
圣人：二甲苯.ate_播放(Qx（质量x）, n个, k个, t吨, q个)
b^19+b^18+b^17+b^16+b^15+b^14+b^13+b^12
+b^11+b^9+b^8+b^5+b^4+b^2+b+1
圣人：秒 = 整数(随机范围(1, n个))
圣人：(秒*二甲苯).ate_播放(Qx（质量x）, n个, k个, t吨, q个) == 二甲苯.ate_播放(秒*Qx（质量x）, n个, k个, t吨, q个)
真的
圣人：二甲苯.ate_播放(秒*Qx（质量x）, n个, k个, t吨, q个) == 二甲苯.ate_播放(Qx（质量x）, n个, k个, t吨, q个)^秒
真的
圣人：c（c） = (k个*q个^(k个-1)).国防部(n个); T型 = t吨 - 1
圣人：N个 = gcd公司(T型^k个 - 1, q个^k个 - 1)
圣人：秒 = 整数(N个/n个)
圣人：L（左） = 整数((T型^k个 - 1)/N个)
圣人：M（M） = (L（左）*秒*c（c）.逆模态(n个)).国防部(n个)
圣人：二甲苯.ate_播放(Qx（质量x）, n个, k个, t吨, q个) == Qx（质量x）.状态配对(二甲苯, n个, k个, q个)^M（M）
真的

如果\（问题\）不在的内核中\（\pi-p\），其中\（\pi\）是Frobenius自同构：

圣人：#需要sage.rings.finite_ring
圣人：第页 = 29; A类 = 1; B类 = 0; n个 = 5; k个 = 2; t吨 = 10
圣人：F类 = GF公司(第页); R（右）.<x个> = F类[]
圣人：E类 = 椭圆曲线(F类, [A类, B类]);
圣人：K（K）.<一> = GF公司((第页,k个), 模数，模量=x个^k个+2); EK公司 = E类.基本扩展（_E）(K（K）)
圣人：P（P） = EK公司(13, 8); 问 = EK公司(13, 21)
圣人：P（P）.ate_播放(问, n个, k个, t吨)
回溯（最近一次调用）：
。。。
ValueError:点（13:21:1）不在Ker（pi-q）中

如果\（P\）不在内核操作系统中\（\pi-1\）:

圣人：#需要sage.rings.finite_ring
圣人：第页 = 29; A类 = 1; B类 = 0; n个 = 5; k个 = 2; t吨 = 10
圣人：F类 = GF公司(第页); R（右）.<x个> = F类[]
圣人：E类 = 椭圆曲线(F类, [A类, B类]);
圣人：K（K）.<一> = GF公司((第页,k个), 模数，模量=x个^k个+2); EK公司 = E类.基本扩展（_E）(K（K）)
圣人：P（P） = EK公司(14, 10*一); 问 = EK公司(13, 21)
圣人：P（P）.ate_播放(问, n个, k个, t吨)
回溯（最近一次调用）：
。。。
ValueError：该点（14:10*a:1）不在Ker（pi-1）中

注释

首次定义于【HSV2006】，ate配对当基准场上的曲线轨迹非常明显小于预期值。此实现是简单地说，Miller的算法后面跟着一个朴素的指数运算，不要求效率。

作者：

• 玛丽亚·莱诺克斯（2011-03-08）

曲线()

返回该点所在的曲线。

示例：

圣人：E类 = 椭圆曲线(“389a”)
圣人：P（P） = E类([-1,1])
圣人：P（P）.曲线()
有理域上由y^2+y=x^3+x^2-2*x定义的椭圆曲线

除法点(米,多个（_O）=False（错误）)

返回所有点的列表\（问题\）使得\（mQ=P\）哪里\（P\）=自己.

仅包含自定义椭圆曲线上的点包括基础场上方。

输入：

• 米–正整数

• 多个（_O）–bool（默认值：False）；如果返回True根给出所有可能的多项式\（x \）-的坐标\（米\）-的第个根自己.

输出：

（list）–解决方案列表（可能为空）\（问题\）到\（mQ=P\）,哪里\（P\）=自我。

示例：

我们发现椭圆曲线上的五个5-扭转点：

圣人：E类 = 椭圆曲线(“11a”); E类
有理域上由y^2+y=x^3-x^2-10*x-20定义的椭圆曲线
圣人：P（P） = E类(0); P（P）
（0:1:0）
圣人：P（P）.除法点(5)
[(0 : 1 : 0), (5 : -6 : 1), (5 : 5 : 1), (16 : -61 : 1), (16 : 60 : 1)]

请注意，由于[5]*0=0，因此包含了0。

我们创建了一条秩为1的无扭转曲线，并进行了一致性检查：

圣人：E类 = 椭圆曲线(“11a”).方形扭曲(-7)
圣人：问 = E类([44,-270])
圣人：(4*问).除法点(4)
[(44 : -270 : 1)]

我们用一组秩序\(18\):

圣人：#需要sage.rings.finite_ring
圣人：k个.<一> = GF公司((5,2))
圣人：E类 = 椭圆曲线(k个, [1,2+一,三,4*一,2])
圣人：P（P） = E类([三, 三*一+4])
圣人：因素(E类.秩序())
2 * 3^2
圣人：P（P）.秩序()
9

我们发现\(1\)-作为一致性检查的分区点当然，只有一个：

圣人：P（P）.除法点(1)                                                  #需要sage.rings.finite_ring
[（3:3*a+4:1）]

要点\（P\）具有与2互质的阶数，但可被3整除，因此：

圣人：P（P）.除法点(2)                                                  #需要sage.rings.finite_ring
[（2*a+1:3*a+4:1），（3*a+1:a:1）]

我们检查每个2分界点是否如所述工作：

圣人：[2*问 对于 问 在里面 P（P）.除法点(2)]                                   #需要sage.rings.finite_ring
[（3:3*a+4:1），（3:3*a+4:1]

其他一些检查：

圣人：P（P）.除法点(三)                                                  #需要sage.rings.finite_ring
[]
圣人：P（P）.除法点(4)                                                  #需要sage.rings.finite_ring
[（0:3*a+2:1），（1:0:1）]
圣人：P（P）.除法点(5)                                                  #需要sage.rings.finite_ring
[(1 : 1 : 1)]

数字字段上的示例（请参见github问题#3383):

圣人：#需要sage.rings.number_field
圣人：E类 = 椭圆曲线(“19a1”)
圣人：x个 = 一夫多妻制(ZZ公司, “x”)
圣人：K（K）.<t吨> = 数字字段(x个^9 - 三*x个^8 - 4*x个^7 + 16*x个^6 - 三*x个^5
....:                    - 21*x个^4 + 5*x个^三 + 7*x个^2 - 7*x个 + 1)
圣人：EK公司 = E类.基本扩展（_E）(K（K）)
圣人：E类(0).除法点(三)
[(0 : 1 : 0), (5 : -10 : 1), (5 : 9 : 1)]
圣人：EK公司(0).除法点(三)
[(0 : 1 : 0), (5 : 9 : 1), (5 : -10 : 1)]
圣人：E类(0).除法点(9)
[(0 : 1 : 0), (5 : -10 : 1), (5 : 9 : 1)]
圣人：EK公司(0).除法点(9)
[（0:1:0），（5:9:1），（5：-10:1），（-150/121*t^8+414/121*t^7+1481/242*t^6-2382/121*t ^5-103/242*t^4+629/22*t ^3-367/242*t*t^3-2355/484*t^2-753/242*t+1165/484:1），（-150/121*t^8+414/121*t^7+1481/242*t^6-2382/121*t ^5-103/242*t ^4+629/22*t ^3-367/242*t^2-1307/121*t+625/121:-35/484*t ^8+133/242*t ^7-445/242*t/484:1），（-1383/484*t^8+970/121*t^7+3159/242*t^6-5211/121*t^5+37/484*t^4+654/11*t^3-909/484*t ^2-4831/242*t+6791/484:927/121*t ^8-5209/242*t ^7-8187/242*t^6+27975/242*t ^5-1147/242*t^4-1729/11*t ^3+1566/121*t*t^2+12873/242*-10871/242:1），（-1383/484*t^8+970/121*t^7+3159/242*t^6-5211/121*t^5+37/484*t^4+654/11*t^3-909/484*t ^2-4831/242*t+6791/484:-927/121*t ^8+5209/242*t ^7+8187/242*t ^6-27975/242*t ^5+1147/242*t ^4+1729/11*t ^3-1566/121*t ^2-12873/242*电话：+10629/242:1），（-4793/484*t^8+6791/242*t^7+10727/242*t^6-18301/121*t^5+2347/484*t^4+2293/11*t^3-7311/484*t ^2-17239/242*t+26767/484:30847/484*t ^8-21789/121*t ^7-34605/121*t^6+11764/121*t+55428/121*t-176909/484:1），（-4793/484*t^8+6791/242*t^7+10727/242*t^6-18301/121*t^5+2347/484*t^4+2293/11*t^3-7311/484*t ^2-17239/242*t+26767/484:-30847/484*t^8+21789/121*t^7+34605/121*t^6-117164/121*t ^5+10633/484*t ^4+29437/22*t ^3-39725/484*t^3 2-55428/121*电话+176425/484:1）]

has_finite_order()

返回真的如果此点作为该曲线上点组的元素。

对于数字字段和有限字段以外的字段，这是除非self.is_zero（），否则不实现。

示例：

圣人：K（K）.<t吨> = 分数字段(多项式环(QQ,“t”))
圣人：E类 = 椭圆曲线([0, 0, 0, -t吨^2, 0])
圣人：P（P） = E类(0)
圣人：P（P）.has_finite_order()
真的
圣人：P（P） = E类(t吨,0)
圣人：P（P）.has_finite_order()
回溯（最近一次调用）：
。。。
NotImplementedError:未实现点的顺序计算
在一般字段上。
圣人：(2*P（P）).为零()
真的

has _定义_顺序()

如果此点作为元素具有无限的加法阶，则返回True曲线上的一组点。

对于数字字段和有限字段以外的字段，这是除非self.is_zero（），否则不实现。

示例：

圣人：K（K）.<t吨> = 分数字段(多项式环(QQ,“t”))
圣人：E类 = 椭圆曲线([0, 0, 0, -t吨^2, 0])
圣人：P（P） = E类(0)
圣人：P（P）.has _定义_顺序()
False（错误）
圣人：P（P） = E类(t吨,0)
圣人：P（P）.has _定义_顺序()
回溯（最近一次调用）：
。。。
NotImplementedError:未在常规字段上实现点的顺序计算。
圣人：(2*P（P）).为零()
真的

有顺序（_O）(n个)

测试此点是否准确有序\（n\）.

输入：

• n个–整数，或其保理化

算法：

比较缓存顺序（如果可用），否则使用sage.groups.generic.has_order（）.

示例：

圣人：E类 = 椭圆曲线(“26b1”)
圣人：P（P） = E类(1, 0)
圣人：P（P）.有顺序（_O）(7)
真的
圣人：P（P）._订单
7
圣人：P（P）.有顺序（_O）(7)
真的

它还可以与保理化对象：

圣人：E类 = 椭圆曲线(GF公司(419), [1,0])
圣人：P（P） = E类(-33, 8)
圣人：P（P）.有顺序（_O）(因素(21))
真的
圣人：P（P）._订单
21
圣人：P（P）.有顺序（_O）(因素(21))
真的

此方法比计算顺序和比较要快得多：

圣人：#未测试--每次的时间都不同
圣人：第页 = 4 * 触头(素数(三,377)) * 587 - 1
圣人：E类 = 椭圆曲线(GF公司(第页), [1,0])
圣人：%计时P=E.random_point（）；P.set_order（倍数=P+1）每个回路72.4 ms±773µs（7次运行的平均值±标准偏差，每个回路1次）
圣人：%计时P=E.random_point（）；相位顺序（P+1）每个回路32.8 ms±3.12 ms（7次运行的平均值±标准偏差，每个回路10次）
圣人：fac公司 = 因素(第页+1)
圣人：%计时P=E.random_point（）；相位顺序（fac）每个回路30.6 ms±3.48 ms（7次运行的平均值±标准偏差，每个回路10次）

订单一旦确认一次，就会被缓存，并且缓存与共享订单（）:

圣人：#未测试--每次的时间都不同
圣人：P（P）, = E类.氏族()
圣人：特拉特(P（P）, '顺序（_O）')
圣人：%时间相位顺序（P+1）CPU时间：用户83.6 ms，系统：30µs，总计：83.6 ms
挂壁时间：83.8 ms
真的
圣人：%时间相位顺序（P+1）CPU时间：用户31微秒，系统2微秒，总计33微秒
壁厚时间：37.9µs
真的
圣人：%时间P.订单（）CPU时间：用户11µs，系统：0 ns，总计：11µs
壁厚时间：16µs
5326738796327623094747867617954605554069371494832722337612446642054009560026576537626892113026381253624626941643949444792662881241621373288942880288065660
圣人：特拉特(P（P）, '顺序（_O）')
圣人：%时间相位顺序（fac）CPU时间：用户68.6 ms，系统：17µs，总计：68.7 ms
壁时间：68.7毫秒
真的
圣人：%时间相位顺序（fac）CPU时间：用户92µs，系统0 ns，总计92µs
壁厚时间：97.5µs
真的
圣人：%时间P.订单（）CPU时间：用户10µs，系统：1e+03 ns，总计：11µs
壁厚时间：14.5µs
5326738796327623094747867617954605554069371494832722337612446642054009560026576537626892113026381253624626941643949444792662881241621373288942880288065660

被隔离人(米)

如果存在点，则返回True\（问题\）定义相同字段作为自身，以便\（mQ\）==自己。

输入：

• 米–一个正整数。

输出：

（bool）–如果有解决方案，则为True，否则为False。

警告

此函数通常会触发\（米\）-相关椭圆的th除多项式曲线，如果\（米\）虽然它很大将被缓存以供后续调用\（米\）.

示例：

圣人：E类 = 椭圆曲线(“389a”)
圣人：问 = 5*E类(0,0); 问
(-2739/1444 : -77033/54872 : 1)
圣人：问.被隔离人(4)
False（错误）
圣人：问.被隔离人(5)
真的

有限域示例：

圣人：E类 = 椭圆曲线(GF公司(101), [23,34])
圣人：E类.基数().因素()
2 * 53
圣人：设置([T型.秩序() 对于 T型 在里面 E类.点()])
{1, 106, 2, 53}
圣人：伦恩([T型 对于 T型 在里面 E类.点() 如果 T型.被隔离人(2)])
53
圣人：伦恩([T型 对于 T型 在里面 E类.点() 如果 T型.被隔离人(三)])
106

是_初始_顺序()

返回真的如果此点作为该曲线上点组的元素。

对于数字字段和有限字段以外的字段，这是除非self.is_zero（），否则不实现。

示例：

圣人：K（K）.<t吨> = 分数字段(多项式环(QQ,“t”))
圣人：E类 = 椭圆曲线([0, 0, 0, -t吨^2, 0])
圣人：P（P） = E类(0)
圣人：P（P）.has_finite_order()
真的
圣人：P（P） = E类(t吨,0)
圣人：P（P）.has_finite_order()
回溯（最近一次调用）：
。。。
NotImplementedError:未实现点的顺序计算
在一般字段上。
圣人：(2*P（P）).为零()
真的

秩序()

返回椭圆曲线上该点的顺序。

如果点为零，则返回1，否则引发未实现错误.

有关数字字段和有限字段上的曲线，请参见下文。

注释

additive_order（）是的同义词订单（）

示例：

圣人：K（K）.<t吨> = 分数字段(多项式环(QQ,“t”))
圣人：E类 = 椭圆曲线([0, 0, 0, -t吨^2, 0])
圣人：P（P） = E类(t吨,0)
圣人：P（P）.秩序()
回溯（最近一次调用）：
。。。
NotImplementedError:未实现点的顺序计算
在一般字段上。
圣人：E类(0).加法顺序()
1
圣人：E类(0).秩序() == 1
真的

情节(**参数)

把这个点画在椭圆曲线上。

输入：

• **参数–所有参数都直接传递到要点上绘图功能。

示例：

圣人：E类 = 椭圆曲线(“389a”)
圣人：P（P） = E类([-1,1])
圣人：P（P）.情节(点大小=30, rgb颜色=(1,0,0))                                #需要sage.plot
包含1个图形基元的图形对象

方案()

返回该点的方案，即该点所在的曲线。这是同义词曲线（）哪一个可能更多直观。

示例：

圣人：E类 = 椭圆曲线(QQ,[1,1])
圣人：P（P） = E类(0,1)
圣人：P（P）.方案()
有理域上由y^2=x^3+x+1定义的椭圆曲线
圣人：P（P）.方案() == P（P）.曲线()
真的
圣人：x个 = 一夫多妻制(ZZ公司, “x”)
圣人：K（K）.<一> = 数字字段(x个^2 - 三,“a”)                                      #需要sage.rings.number_field
圣人：P（P） = E类.基本扩展（_E）(K（K）)(1, 一)                                            #需要sage.rings.number_field
圣人：P（P）.方案()                                                            #需要sage.rings.number_field
由y^2=x^3+x+1定义的椭圆曲线
定义多项式x^2-3的中的数字字段

设置顺序(价值,倍数,检查=无)

设置该点的缓存顺序（即自我_秩序)到给定的价值.

或者，当倍数如果给定，此方法将首次运行订单来自多个（）从给定的点顺序，然后缓存结果。

当你事先知道这一点的顺序时，可以使用这个，或者订单的倍数，以避免潜在的昂贵订单计算。

输入：

• 价值–正整数

• 倍数–正整数；相互排斥价值

输出：无

示例：

此示例说明了基本用法。

圣人：E类 = 椭圆曲线(GF公司(7), [0, 1])  #该曲线的阶数为12
圣人：G公司 = E类(5, 0)
圣人：G公司.设置顺序(2)
圣人：2*G公司
（0:1:0）
圣人：G公司 = E类(0, 6)
圣人：G公司.设置顺序(倍数=12)
圣人：G公司._订单
三

我们现在给出一个更有趣的例子，NIST-P521曲线。它订单太大，无法用Sage计算，而且需要很长时间使用其他包，因此在这里非常有用。

圣人：#需要sage.rings.finite_ring
圣人：第页 = 2^521 - 1
圣人：上一个屋顶状态 = 证明.算术()
圣人：证明.算术(False（错误）)  #关闭素性检查
圣人：F类 = GF公司(第页)
圣人：A类 = 第页 - 三
圣人：B类 = 1093849038073734274511112390766805569936207598951683748994586394495953116150735016013708737573759623248592132296706313309438452531591012912142327488478985984
圣人：q个 = 6864797660130609714981900799081393217269435300143305409394463459185543183397655394245057746333217197532963996371363321113864768612440380340372808892707005449
圣人：E类 = 椭圆曲线([F类(A类), F类(B类)])
圣人：G公司 = E类.随机点()
圣人：G公司.设置顺序(q个)
圣人：G公司.秩序() * G公司  #这几乎不需要时间。
（0:1:0）
圣人：证明.算术(上一个屋顶状态) #恢复状态

使用.set_order（）用一个多重=参数可以用于计算点的顺序明显地更快而不是打电话订单（）如果点已经知道将来\（米\）-扭转：

圣人：F类.<一> = GF公司((10007, 23))
圣人：E类 = 椭圆曲线(F类, [9,9])
圣人：n个 = E类.秩序()
圣人：米 = 5 * 47 * 139 * 1427 * 2027 * 4831 * 275449 * 29523031
圣人：断言 米.划分(n个)
圣人：P（P） = n个/米 * E类.提升_x(6747+一)
圣人：断言 米 * P（P） == 0
圣人：P（P）.设置顺序(倍数=米)   #计算精确顺序
圣人：因素(米 // P（P）.秩序())    #订单现在已缓存
47 * 139

此功能内部使用的算法是订单来自多个（）.的确，只是打电话订单（）在P（P）将需要保理后的更长时间n个相当昂贵：

圣人：n个 == 米 * 6670822796985115651 * 441770032618665681677 * 9289973478285634606114927
真的

传递价值等于\(0\):

圣人：#需要sage.rings.finite_ring
圣人：E类 = 椭圆曲线(GF公司(7), [0, 1])  #该曲线的阶数为12
圣人：G公司 = E类.随机点()
圣人：G公司.设置顺序(0)
回溯（最近一次调用）：
。。。
ValueError:点订单的值0非法
圣人：G公司.设置顺序(1000)
回溯（最近一次调用）：
。。。
ValueError:值1000非法：超出max Hasse界限

传递不是实际值的值也很可能是错误这一点的顺序。可能性有多大取决于实际订单和实际组结构：

圣人：E类 = 椭圆曲线(GF公司(7), [0, 1])  #该曲线的阶数为12
圣人：G公司 = E类(5, 0)   #G有订单2
圣人：G公司.设置顺序(11)
回溯（最近一次调用）：
。。。
ValueError:值11非法：11*（5:0:1）不是标识

然而，设置顺序可以被愚弄。例如，订单可以设置为实际订单的倍数：

圣人：E类 = 椭圆曲线(GF公司(7), [0, 1])  #该曲线的阶数为12
圣人：G公司 = E类(5, 0)   #G有订单2
圣人：G公司.设置顺序(8)
圣人：G公司.秩序()
8

作者：

• 玛丽亚·莱诺克斯（2011-02-16）

• Lorenz Panny（2022）：添加多重=选项

状态配对(问,n个,k个,q个=无)

返回Tate配对\（n\）-扭转点\（P=自己）和点\（问题\）.

返回的值为\（f_{n，P}（Q）^e）哪里\（f_{n，P}\）是具有的函数除数\（n[P]-n[O].\）这也被称为“改良泰特美术馆”配对”。这是一个定义明确的双线性映射。

输入：

• P=自身–n阶椭圆曲线点

• 问–与P在同一曲线上的椭圆曲线点（可以是任意顺序）

• n个–正整数：P的阶

• k个–正整数：嵌入度

• q个–正整数：基本字段的大小（“大”字段是\（GF（q^k）\）.\（q\）仅当其值为无法推断。）

输出：

安\（n\）基地统一之根self.curve（）.base_field（）

示例：

一个简单的例子，将一个点与自身配对，并将一个点与另一个合理点：

圣人：第页 = 103; A类 = 1; B类 = 18; E类 = 椭圆曲线(GF公司(第页), [A类, B类])
圣人：P（P） = E类(33, 91); n个 = P（P）.秩序(); n个
19
圣人：k个 = GF公司(n个)(第页).乘法顺序(); k个
6
圣人：P（P）.状态配对(P（P）, n个, k个)
1
圣人：问 = E类(87, 51)
圣人：P（P）.状态配对(问, n个, k个)
1
圣人：设置随机种子(35)
圣人：P（P）.状态配对(P（P）, n个, k个)
1

我们现在让\（问题\）是上述同一曲线上的一个点，但定义在配对扩展域，我们还证明了配对：

圣人：#需要sage.rings.finite_ring
圣人：K（K）.<一> = GF公司((第页,k个))
圣人：EK公司 = E类.基本扩展（_E）(K（K）); P（P） = EK公司(P（P）)
圣人：Qx（质量x） = 69*一^5 + 96*一^4 + 22*一^三 + 86*一^2 + 6*一 + 35
圣人：问题 = 34*一^5 + 24*一^4 + 16*一^三 + 41*一^2 + 4*一 + 40
圣人：问 = EK公司(Qx（质量x）, 问题);

乘以辅因子，使Q具有n阶：

圣人：#需要sage.rings.finite_ring
圣人：小时 = 551269674; 问 = 小时*问
圣人：P（P） = EK公司(P（P）); P（P）.状态配对(问, n个, k个)
24*a^5+34*a^4+3*a^3+69*a^2+86*a+45
圣人：秒 = 整数(随机范围(1,n个))
圣人：答案1 = (秒*P（P）).状态配对(问, n个, k个)
圣人：答案2 = P（P）.状态配对(秒*问, n个, k个)
圣人：答案3 = P（P）.状态配对(问, n个, k个)^秒
圣人：答案1 == 答案2 == 答案3
真的
圣人：(答案1 = 1) 和 (答案1^n个 == 1)
真的

下面是一个使用Tate配对计算Weil的示例配对（使用与上述相同的数据）：

圣人：#需要sage.rings.finite_ring
圣人：e（电子） = 整数((第页^k个-1)/n个); e（电子）
62844857712
圣人：P（P）.weil配对(问, n个)^e（电子）
94*a^5+99*a^4+29*a^3+45*a^2+57*a+34
圣人：P（P）.状态配对(问, n个, k个) == P（P）._磨坊主_(问, n个)^e（电子）
真的
圣人：问.状态配对(P（P）, n个, k个) == 问._磨坊主_(P（P）, n个)^e（电子）
真的
圣人：P（P）.状态配对(问, n个, k个)/问.状态配对(P（P）, n个, k个)
94*a^5+99*a^4+29*a^3+45*a^2+57*a+34

我们必须传递基本字段大小的示例与Weil配对达成一致）：

圣人：#需要sage.rings.finite_ring
圣人：F类.<一> = GF公司((2,5))
圣人：E类 = 椭圆曲线(F类, [0,0,1,1,1])
圣人：P（P） = E类(一^4 + 1, 一^三)
圣人：Fx公司.<b条> = GF公司((2,4*5))
圣人：前任 = 椭圆曲线(Fx公司,[0,0,1,1,1])
圣人：φ = 霍姆(F类, Fx公司)(F类.消息().小寡头().根(Fx公司)[0][0])
圣人：二甲苯 = 前任(φ(P（P）.x个()), φ(P（P）.年()))
圣人：Qx（质量x） = 前任(b条^19 + b条^18 + b条^16 + b条^12 + b条^10 + b条^9 + b条^8 + b条^5 + b条^三 + 1,
....:        b条^18 + b条^13 + b条^10 + b条^8 + b条^5 + b条^4 + b条^三 + b条)
圣人：二甲苯.状态配对(Qx（质量x）, n个=41, k个=4)
回溯（最近一次调用）：
。。。
ValueError:意外的字段度：将关键字参数q设置为
基本字段的大小（大字段为GF（q^4））。
圣人：号码 = 二甲苯.状态配对(Qx（质量x）, n个=41, k个=4, q个=32); 号码
b^19+b^14+b^13+b^12+b^6+b^4+b^3
圣人：兽穴 = Qx（质量x）.状态配对(二甲苯, n个=41, k个=4, q个=32); 兽穴
b^19+b^17+b^16+b^15+b^14+b^10+b^6+b^2+1
圣人：e（电子） = 整数((32^4-1)/41); e（电子）
25575
圣人：二甲苯.weil配对(Qx（质量x）, 41)^e（电子） == 号码/兽穴
真的

算法：

• pari：elltatepairing公司计算非约化tate配对和求幂由Sage使用用户输入\（k\）（和可选\（q\）).

作者：

• 玛丽亚·莱诺克斯（2011-03-07）

• Giacomo Pope（2024）：将PARI用于非简化Tate配对

weil配对(问,n个,算法=无)

计算此点与另一点的Weil配对\（问题\）在同一条曲线上。

输入：

• 问–同一曲线上的另一点自己.

• n个–一个整数\（n\）使得\（nP=nQ=（0:1:0）\），其中\（P\）是自己.

• 算法（默认值：无)–选择平价和圣人.PARI通常要快得多，但它只能在有限域上工作。什么时候？无给定，a自动选择合适的算法。

输出：

安\（n\）曲线基本域的单位根。

示例：

圣人：#需要sage.rings.finite_ring
圣人：F类.<一> = GF公司((2,5))
圣人：E类 = 椭圆曲线(F类, [0,0,1,1,1])
圣人：P（P） = E类(一^4 + 1, 一^三)
圣人：Fx公司.<b条> = GF公司((2, 4*5))
圣人：前任 = 椭圆曲线(Fx公司, [0,0,1,1,1])
圣人：φ = 霍姆(F类, Fx公司)(F类.消息().小寡头().根(Fx公司)[0][0])
圣人：二甲苯 = 前任(φ(P（P）.x个()), φ(P（P）.年()))
圣人：O（运行） = 前任(0)
圣人：Qx（质量x） = 前任(b条^19 + b条^18 + b条^16 + b条^12 + b条^10 + b条^9 + b条^8 + b条^5 + b条^三 + 1,
....:        b条^18 + b条^13 + b条^10 + b条^8 + b条^5 + b条^4 + b条^三 + b条)
圣人：二甲苯.weil配对(Qx（质量x）, 41) == b条^19 + b条^15 + b条^9 + b条^8 + b条^6 + b条^4 + b条^三 + b条^2 + 1
真的
圣人：二甲苯.weil配对(17*二甲苯, 41) == Fx公司(1)
真的
圣人：二甲苯.weil配对(O（运行）, 41) == Fx公司(1)
真的

如果任一点未\（n\）-扭转：

圣人：二甲苯.weil配对(O（运行）, 40)                                                #需要sage.rings.finite_ring
回溯（最近一次调用）：
。。。
ValueError:点必须都是n扭转

更大的示例（请参见github问题#4964):

圣人：#需要sage.rings.finite_ring
圣人：P（P）, 问 = 椭圆曲线(GF公司((19,4),“a”), [-1,0]).氏族()
圣人：P（P）.秩序(), 问.秩序()
(360, 360)
圣人：z（z） = P（P）.weil配对(问, 360)
圣人：z（z）.乘法顺序()
360

数字字段上的示例：

圣人：#需要sage.rings.number_field
圣人：E类 = 椭圆曲线(“11a1”).更改（_R）(圆域（CyclotomicField）(5))
圣人：P（P）, 问 = E类.扭转子群().氏族()
圣人：P（P）, 问 = (P（P）.要素(), 问.要素())
圣人：(P（P）.秩序(), 问.秩序())
(5, 5)
圣人：P（P）.weil配对(问, 5)
齐塔人5^2
圣人：问.weil配对(P（P）, 5)
齐塔人5^3

算法：

• 对于算法='pari':pari:ellweilpairing公司.

• 对于algorithm=“阶段”:使用中的命题8实现【2004年10月】。值1为为线性相关的输入点返回。这种情况通过捕获ZeroDivision错误，因为使用了线性相关性的离散对数检验速度太慢对于大型\（n\）.

作者：

• 大卫·汉森（2009-01-25）

• Lorenz Panny（2022）：算法='pari'

x个()

返回\（x \）此点的坐标，作为基础字段的元素。如果这是无穷远处的点ZeroDivision错误已引发。

示例：

圣人：E类 = 椭圆曲线(“389a”)
圣人：P（P） = E类([-1,1])
圣人：P（P）.x个()
-1
圣人：问 = E类(0); 问
（0:1:0）
圣人：问.x个()
回溯（最近一次调用）：
。。。
ZeroDivisionError:有理除零

xy公司()

返回\（x \）和\（年\）此点的坐标，作为2元组。如果这是无穷远处的点ZeroDivision错误已引发。

示例：

圣人：E类 = 椭圆曲线(“389a”)
圣人：P（P） = E类([-1,1])
圣人：P（P）.xy公司()
(-1, 1)
圣人：问 = E类(0); 问
（0:1:0）
圣人：问.xy公司()
回溯（最近一次调用）：
。。。
ZeroDivisionError:有理除零

年()

返回\（年\）此点的坐标，作为基础字段的元素。如果这是无穷远处的点ZeroDivision错误已引发。

示例：

圣人：E类 = 椭圆曲线(“389a”)
圣人：P（P） = E类([-1,1])
圣人：P（P）.年()
1
圣人：问 = E类(0); 问
（0:1:0）
圣人：问.年()
回溯（最近一次调用）：
。。。
ZeroDivisionError:有理除零

班 sage.schemes.elliptic_curves.ell_point。椭圆曲线点_finite_field(曲线,v（v）,检查=真的)

基础：椭圆曲线点字段

有限域上椭圆曲线点的类。

加法顺序()

返回椭圆曲线上该点的顺序。

算法：使用PARI函数pari:ellorder（排列顺序）.

注释

additive_order（）是的同义词订单（）

示例：

圣人：#需要sage.rings.finite_ring
圣人：k个.<一> = GF公司((5,5))
圣人：E类 = 椭圆曲线(k个,[2,4]); E类
尺寸为5^5的有限域上由y^2=x^3+2*x+4定义的椭圆曲线
圣人：P（P） = E类(三*一^4 + 三*一, 2*一 + 1)
圣人：P（P）.秩序()
3227
圣人：问 = E类(0,2)
圣人：问.秩序()
7
圣人：问.加法顺序()
7

圣人：#需要sage.rings.finite_ring
圣人：第页 = 下一个前缀(2^150)
圣人：E类 = 椭圆曲线(GF公司(第页), [1,1])
圣人：P（P） = E类(831623307675610677632782670796608848711856078,
....:      42295786042873366706573292533588638217232964)
圣人：P（P）.秩序()
1427247692705959881058262545272474300628281448
圣人：P（P）.秩序() == E类.基数()
真的

下一个示例有\（j（E）=0）:

圣人：#需要sage.rings.finite_ring
圣人：第页 = 33554501
圣人：F类.<u个> = GF公司((第页,2))
圣人：E类 = 椭圆曲线(F类, [0,1])
圣人：E类.j_变量()
0
圣人：P（P） = E类.随机点()
圣人：P（P）.秩序()  #随机的，随机的
16777251

类似地，当\（j（E）=1728）:

圣人：#需要sage.rings.finite_ring
圣人：第页 = 33554473
圣人：F类.<u个> = GF公司((第页,2))
圣人：E类 = 椭圆曲线(F类, [1,0])
圣人：E类.j_变量()
1728
圣人：P（P） = E类.随机点()
圣人：P（P）.秩序()  #随机的，随机的
46912611635760

离散日志(问)

的旧版本日志（）交换了参数。

注意，此方法使用相反的参数顺序Sage中的所有其他对数方法；看见github问题#37150.

示例：

圣人：E类 = 椭圆曲线(j个=GF公司(101)(5))
圣人：P（P）, = E类.氏族()
圣人：(2*P（P）).日志(P（P）)
2
圣人：(2*P（P）).离散日志(P（P）)
doctest:警告。。。
DeprecationWarning:语法P.discrete_log（Q）。。。请更新您的代码。。。
45
圣人：P（P）.离散日志(2*P（P）)
2

has_finite_order()

返回真的如果该点作为元素具有有限的加法阶曲线上的一组点。

由于基场是有限的，所以答案总是真的.

示例：

圣人：E类 = 椭圆曲线(GF公司(7), [1,三])
圣人：P（P） = E类.点（）[三]
圣人：P（P）.has_finite_order()
真的

日志(基础)

将此点的离散对数返回给给定的基础.换句话说，返回一个整数\（x \）使得\（xP=Q\）哪里\（P\）是基础和\（问题\）就是这一点。

A类值错误如果没有解决方案，则引发。

算法：

要计算实际对数，pari:elllog（错误日志）被调用。

然而，elllog（）不保证在以下情况下终止\（问题\）不是的倍数\（P\），所以我们首先需要检查子组会员资格。具体操作如下：

• 让\（n\）表示顺序\（P\）.首先检查\（nQ\）等于无穷远点（因此\（问题\）划分\（n\）).

• 如果曲线顺序\（\#E\）已缓存，检查是否\（\gcd（n^2，\#E）=n\）如果保持不变，则曲线具有循环\（n\）-扭力，因此所有的点的顺序都是分开的\（n\）必须是的倍数\（P\）我们已经完成了。

• 否则（如果此测试没有结论），请检查配对\（P\）和\（问题\）是微不足道的。

对于异常曲线\（E=p），的padic_elliptic_logarithm（）函数。

输入：

• 基础（点）–同一曲线上的另一点自己.

输出：

（integer）–的离散对数\（问题\）关于\（P\）,它是一个整数\（x \）具有\（0\le x<\mathrm{ord}（P）\）使得\（xP=Q\），如果存在。

作者：

• 约翰·克雷莫纳。适应使用通用功能2008-04-05。

• Lorenz Panny（2022）：切换到PARI。

示例：

圣人：#需要sage.rings.finite_ring
圣人：F类 = GF公司((三,6),“a”)
圣人：一 = F类.消息()
圣人：E类 = 椭圆曲线([0,1,1,一,一])
圣人：E类.基数()
762
圣人：P（P） = E类.氏族（）[0]
圣人：问 = 400*P（P）
圣人：问.日志(P（P）)
400

秩序()

返回椭圆曲线上该点的顺序。

算法：使用PARI函数pari:ellorder（排列顺序）.

注释

additive_order（）是的同义词订单（）

示例：

圣人：#需要sage.rings.finite_ring
圣人：k个.<一> = GF公司((5,5))
圣人：E类 = 椭圆曲线(k个,[2,4]); E类
尺寸为5^5的有限域上由y^2=x^3+2*x+4定义的椭圆曲线
圣人：P（P） = E类(三*一^4 + 三*一, 2*一 + 1)
圣人：P（P）.秩序()
3227
圣人：问 = E类(0,2)
圣人：问.秩序()
7
圣人：问.加法顺序()
7

圣人：#需要sage.rings.finite_ring
圣人：第页 = 下一个前缀(2^150)
圣人：E类 = 椭圆曲线(GF公司(第页), [1,1])
圣人：P（P） = E类(831623307675610677632782670796608848711856078,
....:      42295786042873366706573292533588638217232964)
圣人：P（P）.秩序()
1427247692705959881058262545272474300628281448
圣人：P（P）.秩序() == E类.基数()
真的

下一个示例有\（j（E）=0）:

圣人：#需要sage.rings.finite_ring
圣人：第页 = 33554501
圣人：F类.<u个> = GF公司((第页,2))
圣人：E类 = 椭圆曲线(F类, [0,1])
圣人：E类.j_变量()
0
圣人：P（P） = E类.随机点()
圣人：P（P）.秩序()  #随机的，随机的
16777251

类似地，当\（j（E）=1728）:

圣人：#需要sage.rings.finite_ring
圣人：第页 = 33554473
圣人：F类.<u个> = GF公司((第页,2))
圣人：E类 = 椭圆曲线(F类, [1,0])
圣人：E类.j_变量()
1728
圣人：P（P） = E类.随机点()
圣人：P（P）.秩序()  #随机的，随机的
46912611635760

padic_椭圆_对数(问,第页)

返回的离散对数\（问题\）到基地\（P\）=自己,也就是说，一个整数\（x \）使得\（xP=Q\）仅适用于异常曲线。

算法：

离散对数按[Sma1999]用一个循环来避免标准升力。

输入：

• 问（点）–同一曲线上的另一点自己.

• 第页（整数）–等于曲线顺序的素数。

输出：

（integer）–的离散对数\（问题\）关于\（P\）,它是一个整数\（x \）具有\（0\le x<\mathrm{ord}（P）\）使得\（xP=Q\）.

作者：

• 西尔万·佩利西耶（2022）基于塞缪尔·内维斯（Samuel Neves）代码.

示例：

圣人：#需要sage.rings.finite_ring
圣人：第页 = 235322474717419
圣人：b条 = 8856682
圣人：E类 = 椭圆曲线(GF公司(第页), [0, b条])
圣人：P（P） = E类(200673830421813, 57025307876612)
圣人：问 = E类(40345734829479, 211738132651297)
圣人：x个 = P（P）.padic_椭圆_对数(问, 第页)                                  #需要sage.rings.padics
圣人：x个 * P（P） == 问                                                            #需要sage.rings.padics
真的

班 sage.schemes.elliptic_curves.ell_point。椭圆曲线Point_number_field(曲线,v（v）,检查=真的)

基础：椭圆曲线点字段

数域上椭圆曲线上的点。

大多数功能都派生自父类椭圆曲线点字段。此外，我们还支持阶、高、约化模素数和椭圆对数。

示例：

圣人：E类 = 椭圆曲线(“37a”)
圣人：E类([0,0])
(0 : 0 : 1)
圣人：E类(0,0)               #括号是可选的
(0 : 0 : 1)
圣人：E类([GF公司(5)(0), 0])     #条目被强制
(0 : 0 : 1)

圣人：E类(0, 0)
(0 : 0 : 1)

圣人：E类(1,0,0)
回溯（最近一次调用）：
。。。
TypeError:坐标[1，0，0]未定义上的点
有理域上由y^2+y=x^3-x定义的椭圆曲线

圣人：E类 = 椭圆曲线([0,0,1,-1,0])
圣人：S公司 = E类(QQ); S公司
上的Abelian点群
有理域上由y^2+y=x^3-x定义的椭圆曲线

加法顺序()

返回椭圆曲线上该点的顺序。

如果点具有无限级，则返回+无限。对于定义的曲线\（\QQ\），我们称为PARI；超过其他我们在这里实现函数的数字字段。

注释

additive_order（）是的同义词订单（）

示例：

圣人：E类 = 椭圆曲线([0,0,1,-1,0])
圣人：P（P） = E类([0,0]); P（P）
(0 : 0 : 1)
圣人：P（P）.秩序()
+无限

圣人：E类 = 椭圆曲线([0,1])
圣人：P（P） = E类([-1,0])
圣人：P（P）.秩序()
2
圣人：P（P）.加法顺序()
2

阿基米德_局部_高度(v（v）=无,前c=无,加权=False（错误）)

计算阿基米德点的自身局部高度\（v\）.

输入：

• 自己–数域上椭圆曲线上的点\（K\）.

• v（v）–K或None（默认）的真实或复杂嵌入。如果\（v\）是实嵌入或复杂嵌入，返回局部自身高度\（v\）.如果\（v\）为无，返回总数阿基米德对全球高度的贡献。

• 前c–integer或None（默认）。The precision of the计算。如果无，则精度从\（v\）.

• 加权–布尔值。如果为False（默认），则高度为在\（K\）。如果为True，返回此标准化高度乘以局部度数如果\（v\）是一个单一的地方，或按程度\（K\）如果\（v\）是没有。

输出：

一个实数。正常化是Silverman的两倍纸张[Sil1988年]注意，该局部高度取决于曲线模型。

算法：

请参见[Sil1988年]，第4节。

示例：

示例1、2和3来自[Sil1988年]:

圣人：#需要sage.rings.number_field
圣人：K（K）.<一> = 象限域(-2)
圣人：E类 = 椭圆曲线(K（K）, [0,-1,1,0,0]); E类
数字字段上由y^2+y=x^3+（-1）*x^2定义的椭圆曲线
在a中，定义多项式x^2+2，a=1.414213562373095*我
圣人：P（P） = E类.提升_x(2 + 一); P（P）
（a+2:-2*a-2:1）
圣人：P（P）.阿基米德_局部_高度(K（K）.地点(前c=170)[0]) / 2
0.45754773287523276736211210741423654346576029814695

圣人：#需要sage.rings.number_field
圣人：x个 = 一夫多妻制(ZZ公司, “x”)
圣人：K（K）.<我> = 数字字段(x个^2 + 1)
圣人：E类 = 椭圆曲线(K（K）, [0,0,4,6*我,0]); E类
由y^2+4*y=x^3+6*i*x定义的椭圆曲线
i中定义多项式x^2+1的数字域
圣人：P（P） = E类((0,0))
圣人：P（P）.阿基米德_局部_高度(K（K）.地点（）[0]) / 2
0.510184995162373

圣人：问 = E类.提升_x(-9/4); 问                                                 #需要sage.rings.number_field
（-9/4:27/8*i-4:1）
圣人：问.阿基米德_局部_高度(K（K）.地点（）[0]) / 2                         #需要sage.rings.number_field
0.654445619529600

有理数示例：

圣人：E类 = 椭圆曲线([0, 0, 0, -36, 0])
圣人：P（P） = E类([-三, 9])
圣人：P（P）.阿基米德_局部_高度()
1.98723816350773

扭转点的局部高度可以为非零（与全球高度）：

圣人：#需要sage.rings.number_field
圣人：K（K）.<我> = 象限域(-1)
圣人：E类 = 椭圆曲线([0, 0, 0, K（K）(1), 0])
圣人：P（P） = E类(我, 0)
圣人：P（P）.阿基米德_局部_高度()
0.346573590279973

椭圆_对数(嵌入=无,精度=100,算法=“同等”)

返回此椭圆曲线点的椭圆对数。

将基字段嵌入\（\RR\）或\（\抄送\）（带有任意精度）；否则第一个真实的如果有，则使用嵌入（以指定精度），否则第一个复杂嵌入。

输入：

• 嵌入：将基本字段嵌入\（\RR\）或\（\抄送\）

• 精度：正整数（默认值100）设置计算的精度位数

• 算法：或者“同等”（实际嵌入的默认值）使用PARIpari:ellpointtoz，或“圣人”对于本地人实施。对于复杂的嵌入忽略。

算法：

请参见【1993年版权所有】对于实际嵌入的情况，以及Cremona，J.E.和Thongjunthug，T.2010，针对综合体案例。

作者：

• 迈克尔·马尔道斯（2008-07），

• Tobias Nagel（2008-07）–原始版本【1993年版权所有】.

• 约翰·克雷莫纳（2008-07）——根据eclib代码进行修订。

• John Cremona（2010-03）–复杂嵌入的实现。

示例：

圣人：E类 = 椭圆曲线(“389a”)
圣人：E类.鉴别的() > 0
真的
圣人：P（P） = E类([-1,1])
圣人：P（P）.是_标识_组件 ()
False（错误）
圣人：P（P）.椭圆_对数 (精度=96)
0.4793482501902193161295330101+0.985868850775824102211203849…*I
圣人：问 = E类([三,5])
圣人：问.是_标识_组件()
真的
圣人：问.椭圆_对数 (精度=96)
1.931128271542559442488585220

带有负判别式和扭转点的示例：

圣人：E类 = 椭圆曲线(“11a1”)
圣人：E类.鉴别的() < 0
真的
圣人：P（P） = E类([16,-61])
圣人：P（P）.椭圆_对数(精度=70)
0.25384186085591068434
圣人：E类.周期_晶格().实际周期（_P）(前c=70) / P（P）.椭圆_对数(精度=70)
5.0000000000000000000

一个更大的例子。默认算法使用PARI并使确保结果具有要求的精度：

圣人：E类 = 椭圆曲线([1, 0, 1, -85357462, 303528987048]) #18074克1
圣人：P（P） = E类([4458713781401/835903744, -64466909836503771/24167649046528, 1])
圣人：P（P）.椭圆_对数()  #100位
0.27656204014107061464076203097

原生算法“圣人”过去经常遇到麻烦本例中的精度，但不再：

圣人：P（P）.椭圆_对数(算法=“圣人”)  #100位
0.27656204014107061464076203097

这表明在上报告的错误github问题#4901已修复：

圣人：E类 = 椭圆曲线(“4390c2”)
圣人：P（P） = E类(683762969925/44944,-565388972095220019/9528128)
圣人：P（P）.椭圆_对数()
0.00025638725886520225353198932529
圣人：P（P）.椭圆_对数(精度=64)
0.000256387258865202254
圣人：P（P）.椭圆_对数(精度=65)
0.0002563872588652022535
圣人：P（P）.椭圆_对数(精度=128)
0.00025638725886520225353198932528666427412
圣人：P（P）.椭圆_对数(精度=129)
0.00025638725886520225353198932528666427412
圣人：P（P）.椭圆_对数(精度=256)
0.0002563872588652022535319893252866642741168388008346370015005142128009610936373
圣人：P（P）.椭圆_对数(精度=257)
0.00025638725886520225353198932528666427411683880083463700150051421280096109363730

数字字段示例：

圣人：#需要sage.rings.number_field
圣人：x个 = 一夫多妻制(ZZ公司, “x”)
圣人：K（K）.<一> = 数字字段(x个^三 - 2)
圣人：embs公司 = K（K）.嵌入件(科科斯群岛)
圣人：E类 = 椭圆曲线([0,1,0,一,一])
圣人：Ls（长度） = [E类.周期_晶格(e（电子）) 对于 e（电子） 在里面 embs公司]
圣人：[L（左）.实际标记（_F） 对于 L（左） 在里面 Ls（长度）]
[0, 0, -1]
圣人：P（P） = E类(-1,0)  #订单2
圣人：[L（左）.椭圆_对数(P（P）) 对于 L（左） 在里面 Ls（长度）]
【-1.73964256006716-1.07861534489191*I，
-0.363756518406398-1.50699412135253*I，1.90726488608927]

圣人：#需要sage.rings.number_field
圣人：E类 = 椭圆曲线([-一^2 - 一 - 1, 一^2 + 一])
圣人：Ls（长度） = [E类.周期_晶格(e（电子）) 对于 e（电子） 在里面 embs公司]
圣人：pts（点） = [E类(2*一^2 - 一 - 1 , -2*一^2 - 2*一 + 6 ),
....:       E类(-2/三*一^2 - 1/三 , -4/三*一 - 2/三 ),
....:       E类(5/4*一^2 - 1/2*一 , -一^2 - 1/4*一 + 9/4 ),
....:       E类(2*一^2 + 三*一 + 4 , -7*一^2 - 10*一 - 12 )]
圣人：[[L（左）.椭圆_对数(P（P）) 对于 P（P） 在里面 pts（点）] 对于 L（左） 在里面 Ls（长度）]
[0.250819591818930-0.411963479992219*I，-0.290994550611374-1.37239400324105*I，
-0.693473752205595-2.45028458830342*I，-0.151659609775291-1.48985406505459*I]，
[1.33444787667954-1.50889756650544*I，0.792633734249234-0.548467043256610*I，
0.390154532655013+0.529423541805758*I，0.931968675085317-0.431006981443071*I]，
[1.14758249500109+0.853389664016075*I，2.59823462472518+0.853364016075*I，
1.75372176444709, 0.303069634723001]]

圣人：#需要sage.rings.number_field
圣人：K（K）.<我> = 象限域(-1)
圣人：E类 = 椭圆曲线([0,0,0,9*我-10,21-我])
圣人：刺绣 = K（K）.嵌入件(科科斯群岛)[1]
圣人：L（左） = E类.周期_晶格(刺绣)
圣人：P（P） = E类(2-我, 4+2*我)
圣人：L（左）.椭圆_对数(P（P）, 前c=100)
0.7044837553778220846049649302-0.79246725643650979858266018068*我

has_finite_order()

返回真的如果该点在椭圆曲线上具有有限阶。

示例：

圣人：E类 = 椭圆曲线([0,0,1,-1,0])
圣人：P（P） = E类([0,0]); P（P）
(0 : 0 : 1)
圣人：P（P）.has_finite_order()
False（错误）

圣人：E类 = 椭圆曲线([0,1])
圣人：P（P） = E类([-1,0])
圣人：P（P）.has_finite_order()
真的

具有良好的还原性(P（P）=无)

如果这一点对素数具有良好的约简模，则返回True。

输入：

• P（P）–点曲线base_field的素数，或无（默认）

输出：

（bool）如果是素数\（P\）则返回如果该点在\（P\）; 否则，如果点在所有素数处都有god约简，则返回true该模型判别式的支持。

示例：

圣人：E类 = 椭圆曲线(“990e1”)
圣人：P（P） = E类.消息(0); P（P）
(15 : 51 : 1)
圣人：[E类.具有良好的还原性(第页) 对于 第页 在里面 [2,三,5,7]]
[错误、错误、错误和正确]
圣人：[P（P）.具有良好的还原性(第页) 对于 第页 在里面 [2,三,5,7]]
[真、假、真、真]
圣人：[E类.tamagawa_出口(第页) 对于 第页 在里面 [2,三,5,7]]
[2, 2, 1, 1]
圣人：[(2*P（P）).具有良好的还原性(第页) 对于 第页 在里面 [2,三,5,7]]
[正确，正确，正确]
圣人：P（P）.具有良好的还原性()
False（错误）
圣人：(2*P（P）).具有良好的还原性()
真的
圣人：(三*P（P）).具有良好的还原性()
False（错误）

圣人：#需要sage.rings.number_field
圣人：x个 = 一夫多妻制(ZZ公司, “x”)
圣人：K（K）.<我> = 数字字段(x个^2 + 1)
圣人：E类 = 椭圆曲线(K（K）, [0,1,0,-160,308])
圣人：P（P） = E类(26, -120)
圣人：E类.鉴别的().支持()
[分数理想（i+1），
分数理想（-i-2），
分数理想（2*i+1），
分数理想（3）]
圣人：[E类.tamagawa_出口(第页) 对于 第页 在里面 E类.鉴别的().支持()]
[1，4，4，4]
圣人：P（P）.具有良好的还原性()
False（错误）
圣人：(2*P（P）).具有良好的还原性()
False（错误）
圣人：(4*P（P）).具有良好的还原性()
真的

has _定义_顺序()

如果该点在椭圆曲线上具有无穷阶，则返回True。

示例：

圣人：E类 = 椭圆曲线([0,0,1,-1,0])
圣人：P（P） = E类([0,0]); P（P）
(0 : 0 : 1)
圣人：P（P）.has _定义_顺序()
真的

圣人：E类 = 椭圆曲线([0,1])
圣人：P（P） = E类([-1,0])
圣人：P（P）.has _定义_顺序()
False（错误）

高度(精度=无,归一化的=真的,算法=“同等”)

返回点的Néron-Tate标准高度。

输入：

• 自己–数域上椭圆曲线上的点\（K\）.

• 精度–正整数，或无（默认）。这个结果的位数精度。如果无，则默认实数使用精度。

• 归一化的–布尔值。如果为True（默认），则高度为在\（K\）。如果为False，返回此标准化高度乘以\（K\）.

• 算法–字符串：或“同等”（默认）或“圣人”.如果“同等”基本字段是\（\QQ\），使用PARI库功能；否则使用Sage实现。

输出：

有理数0或非负实数。

文献中使用了两种归一化，一种是这是另一个的两倍。我们使用两者中较大的一个，它适用于BSD猜想。这是与…一致【Cre1997】并且是的两倍【Sil2009】.

请参见维基百科文章Néron-Tate height.

注释

BSD中调节器使用的正确高度公式为非标准高度。

示例：

圣人：E类 = 椭圆曲线(“11a”); E类
有理域上由y^2+y=x^3-x^2-10*x-20定义的椭圆曲线
圣人：P（P） = E类([5,5]); P（P）
(5 : 5 : 1)
圣人：P（P）.高度()
0
圣人：问 = 5*P（P）
圣人：问.高度()
0

圣人：E类 = 椭圆曲线(“37a”); E类
有理域上由y^2+y=x^3-x定义的椭圆曲线
圣人：P（P） = E类([0,0])
圣人：P（P）.高度()
0.0511114082399688
圣人：P（P）.秩序()
+无限
圣人：E类.调节器()
0.0511114082399688...

圣人：定义 天真_高度(P（P）):
....:    返回 日志(相对应力(最大值(防抱死制动系统(P（P）[0].分子()), 防抱死制动系统(P（P）[0].分母()))))
圣人：对于 n个 在里面 [1..10]:
....:    打印(天真_高度(2^n个*P（P）)/4^n个)
0
0.0433216987849966
0.0502949347635656
0.0511006335618645
0.0511007834799612
0.0511013666152466
0.0511034199907743
0.0511106492906471
0.0511114081541082
0.0511114081541180

圣人：E类 = 椭圆曲线(“4602a1”); E类
由y^2+x*y=x^3+x^2-37746035*x-89296920339定义的椭圆曲线
在有理字段上
圣人：x个 = 77985922458974949246858229195945103471590
圣人：年 = 19575260230015313702261379022151675961965157108920263594545223
圣人：d日 = 2254020761884782243
圣人：E类([ x个 / d日^2,  年 / d日^三 ]).高度()
86.7406561381275

圣人：E类 = 椭圆曲线([17, -60, -120, 0, 0]); E类
有理域上由y^2+17*x*y-120*y=x^3-60*x^2定义的椭圆曲线
圣人：E类([30, -90]).高度()
0

圣人：E类 = 椭圆曲线(“389a1”); E类
有理域上由y^2+y=x^3+x^2-2*x定义的椭圆曲线
圣人：P（P）, 问 = E类(-1,1), E类(0,-1)
圣人：P（P）.高度(精度=100)
0.68666708330558658572355210295
圣人：(三*问).高度(精度=100)/问.高度(精度=100)
9.0000000000000000000000000000
圣人：_.起源()
100位精度的实数字段

还实现了数字字段的标准高度：

圣人：R（右）.<x个> = QQ[]
圣人：K（K）.<一> = 数字字段(x个^三 - 2)                                          #需要sage.rings.number_field
圣人：E类 = 椭圆曲线([一, 4]); E类                                          #需要sage.rings.number_field
由y^2=x^3+a*x+4定义的椭圆曲线
定义多项式x^3-2的中的数字字段
圣人：P（P） = E类((0,2))                                                          #需要sage.rings.number_field
圣人：P（P）.高度()                                                            #需要sage.rings.number_field
0.810463096585925
圣人：P（P）.高度(精度=100)                                               #需要sage.rings.number_field
0.81046309658592536863991810577
圣人：P（P）.高度(精度=200)                                               #需要sage.rings.number_field
0.81046309658592536863991810576865158896130286417155832378086
圣人：(2*P（P）).高度() / P（P）.高度()                                           #需要sage.rings.number_field
4
圣人：(100*P（P）).高度() / P（P）.高度()                                         #需要sage.rings.number_field
10000

设置标准化=假将高度乘以度数\（K\）:

圣人：E类 = 椭圆曲线(“37a”)
圣人：P（P） = E类([0,0])
圣人：P（P）.高度()
0.0511114082399688
圣人：P（P）.高度(归一化的=False（错误）)
0.0511114082399688
圣人：K（K）.<z（z）> = 圆域（CyclotomicField）(5)                                            #需要sage.rings.number_field
圣人：EK公司 = E类.更改（_R）(K（K）)                                                 #需要sage.rings.number_field
圣人：PK（主键） = EK公司([0,0])                                                        #需要sage.rings.number_field
圣人：PK（主键）.高度()                                                           #需要sage.rings.number_field
0.0511114082399688
圣人：PK（主键）.高度(归一化的=False（错误）)                                           #需要sage.rings.number_field
0.204445632959875

一些一致性检查：

圣人：E类 = 椭圆曲线(“5077a1”)
圣人：P（P） = E类([-2,三,1])
圣人：P（P）.高度()
1.36857250535393

圣人：EK公司 = E类.更改（_R）(象限域(-三,“a”))                            #需要sage.rings.number_field
圣人：PK（主键） = EK公司([-2,三,1])                                                     #需要sage.rings.number_field
圣人：PK（主键）.高度()                                                           #需要sage.rings.number_field
1.36857250535393

圣人：#需要sage.rings.number_field
圣人：K（K）.<我> = 数字字段(x个^2 + 1)
圣人：E类 = 椭圆曲线(K（K）, [0,0,4,6*我,0])
圣人：问 = E类.提升_x(-9/4); 问
（-9/4:27/8*i-4:1）
圣人：问.高度()
2.69518560017909
圣人：(15*问).高度() / 问.高度()
225

圣人：E类 = 椭圆曲线(“37a”)
圣人：P（P） = E类([0,-1])
圣人：P（P）.高度()
0.0511114082399688
圣人：K（K）.<一> = 象限域(-7)                                            #需要sage.rings.number_field
圣人：预计起飞时间 = E类.方形扭曲(-7)                                            #需要sage.rings.number_field
圣人：问 = E类.同构to(预计起飞时间.更改（_R）(K（K）))(P（P）); 问                         #需要sage.rings.number_field
（0:-7/2*a-1/2:1）
圣人：问.高度()                                                            #需要sage.rings.number_field
0.0511114082399688
圣人：问.高度(精度=100)                                               #需要sage.rings.number_field
0.051111408239968840235886099757

示例表明github问题#5252已修复：

圣人：E类 = 椭圆曲线([1, -1, 1, -2063758701246626370773726978, 32838647793306133075103747085833809114881])
圣人：P（P） = E类([-30987785091199, 258909576181697016447])
圣人：P（P）.高度()
25.8603170675462
圣人：P（P）.高度(精度=100)
25.860317067546190743868840741
圣人：P（P）.高度(精度=250)
25.860317067546190743868840740735110323098872903844416215577171041783572513
圣人：P（P）.高度(精度=500)
25.8603170675461907438688407407351103230988729038444162155771710417835725129551130570889813281792157278507639909972112856019190236125362914195452321720

圣人：P（P）.高度(精度=100) == P（P）.非archimedean_local_height(前c=100)+P（P）.阿基米德_局部_高度(前c=100)
真的

示例表明github问题#8319固定（当曲线不是最小值时，高度正确）：

圣人：E类 = 椭圆曲线([-5580472329446114952805505804593498080000,-157339733785368110382973689903536054787700497223306368000000])
圣人：xP（xP） = 204885147732879546487576840131729064308289385547094673627174585676211859152978311600/23625501907057948132262217188983681204856907657753178415430361
圣人：P（P） = E类.提升_x(xP（xP）)
圣人：P（P）.高度()
157.432598516754
圣人：问 = 2*P（P）
圣人：问.高度() #长时间（4s）
629.730394067016
圣人：问.高度()-4*P（P）.高度() #长时间
0

示例表明github问题#12509已修复（精度问题）：

圣人：#需要sage.rings.number_field
圣人：x个 = 一夫多妻制(QQ)
圣人：K（K）.<一> = 数字字段(x个^2 - x个 - 1)
圣人：v（v） = [0, 一 + 1, 1, 28665*一 - 46382, 2797026*一 - 4525688]
圣人：E类 = 椭圆曲线(v（v）)
圣人：P（P） = E类([72*一 - 509/5,  -682/25*一 - 434/25])
圣人：P（P）.高度()
1.38877711688727
圣人：(2*P（P）).高度()/P（P）.高度()
4
圣人：(2*P（P）).高度(精度=100)/P（P）.高度(精度=100)
4.0000000000000000000000000000
圣人：(2*P（P）).高度(精度=1000)/P（P）.高度(精度=1000)
4.00亿

这表明在上报告的错误github问题#13951已修复：

圣人：E类 = 椭圆曲线([0,17])
圣人：第1页 = E类(2,5)
圣人：第1页.高度()
1.06248137652528
圣人：F类 = E类.更改（_R）(象限域(-三, “a”))                            #需要sage.rings.number_field
圣人：第2页 = F类([2,5])                                                         #需要sage.rings.number_field
圣人：第2页.高度()                                                           #需要sage.rings.number_field
1.06248137652528

是_标识_组件(嵌入=无)

如果此点位于的标识组件上，则返回True它相对于给定（实数或复数）嵌入的曲线。

输入：

• 自己–任意有序字段上曲线上的点（例如。\（\QQ\）)

• 嵌入–的base_field中的嵌入点的曲线\（\RR\）或\（\抄送\）; 如果无（该默认）它使用base_field的第一个嵌入\（\RR\）如果有，否则第一个嵌入\（\抄送\）.

输出：

（bool）–真的如果该点位于曲线。（如果点为零，则结果为True。）

示例：

对于\（K=\QQ\）无需指定嵌入：

圣人：E类 = 椭圆曲线(“5077a1”)
圣人：[E类.提升_x(x个).是_标识_组件() 对于 x个 在里面 srange（范围）(-三,5)]
[假，假，假、假、假，真、真、真]

具有两个实际嵌入的字段上的示例：

圣人：#需要sage.rings.number_field
圣人：L（左）.<一> = 象限域(2)
圣人：E类 = 椭圆曲线(L（左）, [0,1,0,一,一])
圣人：P（P） = E类(-1,0)
圣人：[P（P）.是_标识_组件(e（电子）) 对于 e（电子） 在里面 L（左）.嵌入件(相对应力)]
[错误，正确]

我们可以如下检查：

圣人：#需要sage.rings.number_field
圣人：[e（电子）(E类.鉴别的()) > 0 对于 e（电子） 在里面 L（左）.嵌入件(相对应力)]
[正确，错误]
圣人：e（电子） = L（左）.嵌入件(相对应力)[0]
圣人：E1级 = 椭圆曲线(相对应力, [e（电子）(人工智能) 对于 人工智能 在里面 E类.阿尼夫斯()])
圣人：第1页, 第2页, 电子3 = E1级.二分多项式().根(相对应力,
....:                                                多重性=False（错误）)
圣人：第1页 < 第2页 < 电子3 和 e（电子）(P（P）[0]) < 电子3
真的

非archimedean_local_height(v（v）=无,前c=无,加权=False（错误）,是最小值（_M）=无)

计算非阿基米德地方的自身局部高度\（v\）.

输入：

• 自己–数域上椭圆曲线上的点\（K\）.

• v（v）–一个非阿基米德式的地方\（K\）或“无”（默认）。如果\（v\）是一个非阿基米德的地方，返回局部高度自我在\（v\）.如果\（v\）为无，返回总数非阿基米德对全球高度的贡献。

• 前c–integer或None（默认）。The precision of the计算。如果无，则以符号方式返回高度。

• 加权–布尔值。如果为False（默认），则高度为在\（K\）。如果为True，返回此标准化高度乘以局部度数如果\（v\）是一个单一的地方，或按程度\（K\）如果\（v\）是没有。

输出：

一个实数。正常化是Silverman的两倍纸张[Sil1988年]注意，该局部高度取决于曲线模型。

算法：

请参见[Sil1988年]，第5节。

示例：

示例2和示例3[Sil1988年]:

圣人：#需要sage.rings.number_field
圣人：x个 = 一夫多妻制(ZZ公司, “x”)
圣人：K（K）.<我> = 数字字段(x个^2 + 1)
圣人：E类 = 椭圆曲线(K（K）, [0,0,4,6*我,0]); E类
由y^2+4*y=x^3+6*i*x定义的椭圆曲线
i中定义多项式x^2+1的数字域
圣人：P（P） = E类((0,0))
圣人：P（P）.非archimedean_local_height(K（K）.理想的(我+1))
-1/2*日志（2）
圣人：P（P）.非archimedean_local_height(K（K）.理想的(三))
0
圣人：P（P）.非archimedean_local_height(K（K）.理想的(1-2*我))
0

圣人：#需要sage.rings.number_field
圣人：问 = E类.提升_x(-9/4); 问
（-9/4:27/8*i-4:1）
圣人：问.非archimedean_local_height(K（K）.理想的(1+我))
2*log（2）
圣人：问.非archimedean_local_height(K（K）.理想的(三))
0
圣人：问.非archimedean_local_height(K（K）.理想的(1-2*我))
0
圣人：问.非archimedean_local_height()
2*log（2）

有理数示例：

圣人：E类 = 椭圆曲线([0, 0, 0, -36, 0])
圣人：P（P） = E类([-三, 9])
圣人：P（P）.非archimedean_local_height()
-日志（3）

扭转点的局部高度可以为非零（与全球高度）：

圣人：#需要sage.rings.number_field
圣人：K（K）.<我> = 象限域(-1)
圣人：E类 = 椭圆曲线([0, 0, 0, K（K）(1), 0])
圣人：P（P） = E类(我, 0)
圣人：P（P）.非archimedean_local_height()
-1/2*日志（2）

秩序()

返回椭圆曲线上该点的顺序。

如果点具有无限级，则返回+无限。对于定义的曲线\（\QQ\），我们称为PARI；超过其他我们在这里实现函数的数字字段。

注释

additive_order（）是的同义词订单（）

示例：

圣人：E类 = 椭圆曲线([0,0,1,-1,0])
圣人：P（P） = E类([0,0]); P（P）
(0 : 0 : 1)
圣人：P（P）.秩序()
+无限

圣人：E类 = 椭圆曲线([0,1])
圣人：P（P） = E类([-1,0])
圣人：P（P）.秩序()
2
圣人：P（P）.加法顺序()
2

padic_椭圆_对数(第页,吸附剂=20)

计算\（p\）-这一点的二进椭圆对数。

输入：

第页-整数：质数吸附剂-整数（默认值：20）：首字母\（p\）-adic绝对计算精度

输出：

这个\（p\）-具有精度的adic椭圆自对数吸附剂.

作者：

• 托比亚斯·纳格尔

• 迈克尔·马尔道斯

• 约翰·克雷莫纳

算法：

对于形式群中的点（即在\（p\）)我们拿着日志（）从形式组模块和在以下位置进行评估\（-x/y\）。否则，我们首先乘以该点进入正式小组，并划分结果之后。

托多

请参阅上的评论github问题#4805.目前绝对结果的精度可能小于给定值absprec，错误处理不完善。

示例：

圣人：E类 = 椭圆曲线([0,1,1,-2,0])
圣人：E类(0).padic_椭圆_对数(三)                                      #需要sage.rings.padics
0
圣人：P（P） = E类(0, 0)                                                           #需要sage.rings.padics
圣人：P（P）.padic_椭圆_对数(三)                                         #需要sage.rings.padics
2+2*3+3^3+2*3^7+3^8+3^9+3^11+3^15+2*3^17+3^18+O（3^19）
圣人：P（P）.padic_椭圆_对数(三).举起()                                  #需要sage.rings.padics
660257522
圣人：P（P） = E类(-11/9, 28/27)                                                   #需要sage.rings.padics
圣人：[(2*P（P）).padic_椭圆_对数(第页)/P（P）.padic_椭圆_对数(第页) 对于 第页 在里面 素数_范围(20)]  #很长时间，需要sage.rings.padics
[2+O（2^19），2+O（3^20
圣人：[(三*P（P）).padic_椭圆_对数(第页)/P（P）.padic_椭圆_对数(第页) 对于 第页 在里面 素数_范围(12)]  #很长时间，需要sage.rings.padics
[1+2+O（2^19），3+3^20+O（3^21），3+O（5^19），3+O（7^19），3+O（11^19）]
圣人：[(5*P（P）).padic_椭圆_对数(第页)/P（P）.padic_椭圆_对数(第页) 对于 第页 在里面 素数_范围(12)]  #很长时间，需要sage.rings.padics
[1+2^2+O（2^19），2+3+O（3^20），5+O（5^19），5+O（7^19），5+O（11^19）]

审查期间出现的一个例子github问题#4741:

圣人：E类 = 椭圆曲线(“794a1”)
圣人：P（P） = E类(-1,2)
圣人：P（P）.padic_椭圆_对数(2)  #默认精度=20#需要sage.rings.padics
2^4+2^5+2^6+2^8+2^9+2^13+2^14+2^15+O（2^16）
圣人：P（P）.padic_椭圆_对数(2, 吸附剂=30)                             #需要sage.rings.padics
2^4+2^5+2^6+2^8+2^9+2^13+2^14+2^15+2^22+2^23+2^24+O（2^26）
圣人：P（P）.padic_椭圆_对数(2, 吸附剂=40)                             #需要sage.rings.padics
2^4 + 2^5 + 2^6 + 2^8 + 2^9 + 2^13 + 2^14 + 2^15 + 2^22 + 2^23 + 2^24
+2^28+2^29+2^31+2^34+O（2^35）

减少(第页)

这会发现一个点的减少\（P\）关于椭圆曲线素数模\（p\）.

输入：

• 自己–椭圆曲线上的点。

• 第页–质数

输出：

将点简化为椭圆曲线模上的点\（p\）.

示例：

圣人：E类 = 椭圆曲线([1,2,三,4,0])
圣人：P（P） = E类(0,0)
圣人：P（P）.减少(5)
(0 : 0 : 1)
圣人：问 = E类(98,931)
圣人：问.减少(5)
(3 : 1 : 1)
圣人：问.减少(5).曲线() == E类.减少(5)
真的

圣人：#需要sage.rings.number_field
圣人：x个 = 一夫多妻制(ZZ公司, “x”)
圣人：F类.<一> = 数字字段(x个^2 + 5)
圣人：E类 = 椭圆曲线(F类, [1,2,三,4,0])
圣人：问 = E类(98, 931)
圣人：问.减少(一)
(3 : 1 : 1)
圣人：问.减少(11)
(10 : 7 : 1)

圣人：#需要sage.rings.number_field
圣人：F类.<一> = 数字字段(x个^三 + x个^2 + 1)
圣人：E类 = 椭圆曲线(F类, [一,2])
圣人：P（P） = E类(一, 1)
圣人：P（P）.减少(F类.理想的(5))
（abar:1:1）
圣人：P（P）.减少(F类.理想的(一^2 - 4*一 - 2))
（abar:1:1）