关于射影变种的点#

该模块实现了射影簇上点的模式态射。

作者：

  • David Kohel，William Stein（2006）：初始版本

  • William Stein（2006-02-11）：修复了允许P（0,0,0）作为射影点

  • Volker-Braun（2011-08-08）：重命名类，更多文档，杂项清理

  • Ben Hutz（2012-06）：增加了对投射环的支持

  • Ben Hutz（2013-03）：添加了迭代功能和新的目录结构用于仿射/投影、高度功能

班 sage.方案.项目.项目_点。方案Morphism_point_abelian_variety_field(X（X）,v（v）,检查=真的)[来源]#

基础：添加组元素,方案Morphism_point_projective_field

域上阿贝尔簇的有理点。

示例：

圣人： #需要sage.方案
圣人： E类 = 椭圆曲线([0,0,1,-1,0])
圣人： 起源 = E类(0)
圣人： 起源.领域()
有理场的谱
圣人： 起源.密码子()
有理域上由y^2+y=x^3-x定义的椭圆曲线

>>> 从 sage.all公司 进口 *
>>> #需要sage.方案
>>> E类 = 椭圆曲线([整数(0),整数(0),整数(1),-整数(1),整数(0)])
>>> 起源 = E类(整数(0))
>>> 起源.领域()
有理场的谱
>>> 起源.密码子()
有理域上由y^2+y=x^3-x定义的椭圆曲线
班 sage.方案.项目.项目_点。方案Morphism_point_projective_field(X（X）,v（v）,检查=真的)[来源]#

基础：方案Morphism_point_projective_ring

场上射影空间的有理点。

输入：

  • X（X）–环境射影空间的子模式的homset越过田野\（K\）.

  • v（v）–中的坐标列表或元组\（K\）.

  • 检查–布尔值（默认值：真的). 是否发送给检查输入的一致性。

示例：

圣人： #需要sage.rings.real_mpfr
圣人： P（P） = 投影空间(三, 右后)
圣人： P（P）(2, 三, 4, 5)
(0.400000000000000 : 0.600000000000000 : 0.800000000000000 : 1.00000000000000)

>>> 从 sage.all公司 进口 *
>>> #需要sage.rings.real_mpfr
>>> P（P） = 投影空间(整数(三), 右后)
>>> P（P）(整数(2), 整数(三), 整数(4), 整数(5))
(0.400000000000000 : 0.600000000000000 : 0.800000000000000 : 1.00000000000000)
作为子方案（_S）()[来源]#

返回与此有理点关联的子模式。

示例：

圣人： 第2页.<x个,年,z（z）> = 投影空间(QQ（QQ）,2)
圣人： 第1页 = 第2页.指向([0,0,1]).作为子方案（_S）(); 第1页
有理域上2维射影空间的闭子模式定义为：
x、 年
圣人： 第2页 = 第2页.指向([1,1,1]).作为子方案（_S）(); 第2页
有理域上2维射影空间的闭子模式定义为：
x-z，y-z
圣人： 第1页 + 第2页
有理域上2维射影空间的闭子模式定义为：
x-y，y^2-y*z

>>> 从 sage.all公司 进口 *
>>> 第2页 = 投影空间(QQ（QQ）,整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = 第2页._first_ngens（第一个_基因）(三)
>>> 第1页 = 第2页.指向([整数(0),整数(0),整数(1)]).作为子方案（_S）(); 第1页
有理域上2维射影空间的闭子模式定义为：
x、 年
>>> 第2页 = 第2页.指向([整数(1),整数(1),整数(1)]).作为子方案（_S）(); 第2页
有理域上2维射影空间的闭子模式定义为：
x-z，y-z
>>> 第1页 + 第2页
有理域上2维射影空间的闭子模式定义为：
x-y，y^2-y*z
清除指定项()[来源]#

按分母的最小公倍数进行缩放。

输出：无。

示例：

圣人： R（右）.<吨> = 多项式环(QQ（QQ）)
圣人： P（P）.<x个,年,z（z）> = 投影空间(分数字段(R（右）), 2)
圣人： 问 = P（P）([吨, 三/吨^2, 1])
圣人： 问.清除指定项(); 问
（t^3:3:t^2）

>>> 从 sage.all公司 进口 *
>>> R（右） = 多项式环(QQ（QQ）, 姓名=(“t”,)); (吨,) = R（右）._first_ngens（第一个_基因）(1)
>>> P（P） = 投影空间(分数字段(R（右）), 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）([吨, 整数(三)/吨**整数(2), 整数(1)])
>>> 问.清除指定项(); 问
（时间：3:t^2）

圣人： #需要sage.rings.number_field
圣人： R（右）.<x个> = 多项式环(QQ（QQ）)
圣人： K（K）.<w个> = 数字字段(x个^2 - 三)
圣人： P（P）.<x个,年,z（z）> = 投影空间(K（K）, 2)
圣人： 问 = P（P）([1/w个, 三, 0])
圣人： 问.清除指定项(); 问
（宽：9:0）

>>> 从 sage.all公司 进口 *
>>> #需要sage.rings.number_field
>>> R（右） = 多项式环(QQ（QQ）, 姓名=(“x”,)); (x个,) = R（右）._first_ngens（第一个_基因）(1)
>>> K（K） = 数字字段(x个**整数(2) - 整数(三), 姓名=(“w”,)); (w个,) = K（K）._first_ngens（第一个_基因）(1)
>>> P（P） = 投影空间(K（K）, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）([整数(1)/w个, 整数(三), 整数(0)])
>>> 问.清除指定项(); 问
（宽：9:0）

圣人： P（P）.<x个,年,z（z）> = 投影空间(QQ（QQ）, 2)
圣人： X（X） = P（P）.子模式(x个^2 - 年^2)
圣人： 问 = X（X）([1/2, 1/2, 1])
圣人： 问.清除指定项(); 问
(1 : 1 : 2)

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> X（X） = P（P）.子模式(x个**整数(2) - 年**整数(2))
>>> 问 = X（X）([整数(1)/整数(2), 整数(1)/整数(2), 整数(1)])
>>> 问.清除指定项(); 问
(1 : 1 : 2)

圣人： PS（聚苯乙烯）.<x个,年> = 投影空间(QQ（QQ）, 1)
圣人： 问 = PS（聚苯乙烯）.指向([1, 2/三], False（错误）); 问
(1 : 2/3)
圣人： 问.清除指定项(); 问
(3 : 2)

>>> 从 sage.all公司 进口 *
>>> PS（聚苯乙烯） = 投影空间(QQ（QQ）, 整数(1), 姓名=(“x”, “是”,)); (x个, 年,) = PS（聚苯乙烯）._first_ngens（第一个_基因）(2)
>>> 问 = PS（聚苯乙烯）.指向([整数(1), 整数(2)/整数(三)], False（错误）); 问
(1 : 2/3)
>>> 问.清除指定项(); 问
(3 : 2)
交叉_多重性(X（X）)[来源]#

返回该点的共域的交集多重性，并且X（X）此时。

这使用了投影/仿射子切的intersection_multiple实现。这个点必须是射影子模式的点。

输入：

  • X（X）–与该点的余域在同一环境空间中的子模式。

输出：整数。

示例：

圣人： P（P）.<x个,年,z（z）,w个> = 投影空间(QQ（QQ）, 三)
圣人： X（X） = P（P）.子模式([x个*z（z） - 年^2])
圣人： Y（Y） = P（P）.副血红素([x个^三 - 年*w个^2 + z（z）*w个^2, x个*年 - z（z）*w个])
圣人： 第一季度 = X（X）([1/2, 1/4, 1/8, 1])
圣人： 第一季度.交叉_多重性(Y（Y）)                                       #需要sage.libs.singular
1
圣人： 第2季度 = X（X）([0,0,0,1])
圣人： 第2季度.交叉_多重性(Y（Y）)                                       #需要sage.libs.singular
5
圣人： 第3季度 = X（X）([0,0,1,0])
圣人： 第3季度.交叉_多重性(Y（Y）)                                       #需要sage.libs.singular
6

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(三), 姓名=(“x”, “是”, “z”, “w”,)); (x个, 年, z（z）, w个,) = P（P）._first_ngens（第一个_基因）(4)
>>> X（X） = P（P）.子模式([x个*z（z） - 年**整数(2)])
>>> Y（Y） = P（P）.子模式([x个**整数(三) - 年*w个**整数(2) + z（z）*w个**整数(2), x个*年 - z（z）*w个])
>>> 第一季度 = X（X）([整数(1)/整数(2), 整数(1)/整数(4), 整数(1)/整数(8), 整数(1)])
>>> 第一季度.交叉_多重性(Y（Y）)                                       #需要sage.libs.singular
1
>>> 第2季度 = X（X）([整数(0),整数(0),整数(0),整数(1)])
>>> 第2季度.交叉_多重性(Y（Y）)                                       #需要sage.libs.singular
5
>>> 第3季度 = X（X）([整数(0),整数(0),整数(1),整数(0)])
>>> 第3季度.交叉_多重性(Y（Y）)                                       #需要sage.libs.singular
6

圣人： P（P）.<x个,年,z（z）,w个> = 投影空间(QQ（QQ）, 三)
圣人： X（X） = P（P）.子模式([x个^2 - 年^2])
圣人： 问 = P（P）([1,1,1,0])
圣人： 问.交叉_多重性(X（X）)
回溯（最近一次调用）：
...
TypeError:此点必须是射影子模式上的点

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(三), 姓名=(“x”, “是”, “z”, “w”,)); (x个, 年, z（z）, w个,) = P（P）._first_ngens（第一个_基因）(4)
>>> X（X） = P（P）.子模式([x个**整数(2) - 年**整数(2)])
>>> 问 = P（P）([整数(1),整数(1),整数(1),整数(0)])
>>> 问.交叉_多重性(X（X）)
回溯（最近一次调用）：
...
TypeError:此点必须是射影子模式上的点
多重性()[来源]#

返回该点在其余域上的多重性。

使用子模式多重性实现。此点必须是上的点射影子模式。

OUTPUT：一个整数。

示例：

圣人： P（P）.<x个,年,z（z）,w个,吨> = 投影空间(QQ（QQ）, 4)
圣人： X（X） = P（P）.子模式([年^6 - x个^三*w个^2*吨 + 吨^5*w个, x个^2 - 吨^2])
圣人： 第一季度 = X（X）([1,0,2,1,1])
圣人： 第一季度.多重性()                                                     #需要sage.libs.singular
1
圣人： 第2季度 = X（X）([0,0,-2,1,0])
圣人： 第2季度.多重性()                                                     #需要sage.libs.singular
8

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(4), 姓名=(“x”, “是”, “z”, “w”, “t”,)); (x个, 年, z（z）, w个, 吨,) = P（P）._first_ngens（第一个_基因）(5)
>>> X（X） = P（P）.子模式([年**整数(6) - x个**整数(三)*w个**整数(2)*吨 + 吨**整数(5)*w个, x个**整数(2) - 吨**整数(2)])
>>> 第一季度 = X（X）([整数(1),整数(0),整数(2),整数(1),整数(1)])
>>> 第一季度.多重性()                                                     #需要sage.libs.单数
1
>>> 第2季度 = X（X）([整数(0),整数(0),-整数(2),整数(1),整数(0)])
>>> 第2季度.多重性()                                                     #需要sage.libs.singular
8
normalize_coordinates（规范_坐标）()[来源]#

规范化点，使最后一个非零坐标为\(1\).

输出：无。

示例：

圣人： P（P）.<x个,年,z（z）> = 投影空间(GF公司(5), 2)
圣人： 问 = P（P）.指向([GF公司(5)(1), GF公司(5)(三), GF公司(5)(0)], False（错误）); 问
(1 : 3 : 0)
圣人： 问.normalize_coordinates（规范_坐标）(); 问
(2 : 1 : 0)

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(GF公司(整数(5)), 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）.指向([GF公司(整数(5))(整数(1)), GF公司(整数(5))(整数(三)), GF公司(整数(5))(整数(0))], False（错误）); 问
(1 : 3 : 0)
>>> 问.normalize_coordinates（规范_坐标）(); 问
(2 : 1 : 0)

圣人： P（P）.<x个,年,z（z）> = 投影空间(QQ（QQ）, 2)
圣人： X（X） = P（P）.子模式(x个^2 - 年^2);
圣人： 问 = X（X）.指向([23, 23, 46], False（错误）); 问
(23 : 23 : 46)
圣人： 问.normalize_coordinates（规范_坐标）(); 问
(1/2 : 1/2 : 1)

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> X（X） = P（P）.子模式(x个**整数(2) - 年**整数(2));
>>> 问 = X（X）.指向([整数(23), 整数(23), 整数(46)], False（错误）); 问
(23 : 23 : 46)
>>> 问.normalize_coordinates（规范_坐标）(); 问
(1/2 : 1/2 : 1)
班 sage.方案.项目.项目_点。方案Morphism_point_projective_finite_field(X（X）,v（v）,检查=真的)[来源]#

基础：方案Morphism_point_projective_field

班 sage.方案.项目.项目_点。方案Morphism_point_projective_ring(X（X）,v（v）,检查=真的)[来源]#

基础：方案Morphism_point

环上射影空间的有理点。

输入：

  • X（X）–环上环境射影空间的子模式的homset\（K\）.

  • v（v）–中的坐标列表或元组\（K\）.

  • 检查–布尔值（默认值：真的). 是否检查输入的一致性。

示例：

圣人： P（P） = 投影空间(2, ZZ公司)
圣人： P（P）(2,三,4)
(2 : 3 : 4)

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(整数(2), ZZ公司)
>>> P（P）(整数(2),整数(三),整数(4))
(2 : 3 : 4)
去均质(n个)[来源]#

在\（n\）-第个坐标。

输入：

  • n个–非负整数。

输出：

  • 方案Morphism_point_affine.

示例：

圣人： P（P）.<x个,年,z（z）> = 投影空间(QQ（QQ）, 2)
圣人： X（X） = P（P）.子模式(x个^2 - 年^2)
圣人： 问 = X（X）(23, 23, 46)
圣人： 问.去均质(2)                                                     #需要sage.libs.singular
(1/2, 1/2)

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> X（X） = P（P）.副血红素(x个**整数(2) - 年**整数(2))
>>> 问 = X（X）(整数(23), 整数(23), 整数(46))
>>> 问.脱卤化(整数(2))                                                     #需要sage.libs.singular
(1/2, 1/2)

圣人： #需要sage.libs.pari
圣人： R（右）.<吨> = 多项式环(QQ（QQ）)
圣人： S公司 = R（右）.现状(R（右）.理想的(吨^三))
圣人： P（P）.<x个,年,z（z）> = 投影空间(S公司, 2)
圣人： 问 = P（P）(吨, 1, 1)
圣人： 问.去均质(1)
（待定，1）

>>> 从 sage.all公司 进口 *
>>> #需要sage.libs.pari
>>> R（右） = 多项式环(QQ（QQ）, 姓名=(“t”,)); (吨,) = R（右）._first_ngens（第一个_基因）(1)
>>> S公司 = R（右）.现状(R（右）.理想的(吨**整数(三)))
>>> P（P） = 投影空间(S公司, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）(吨, 整数(1), 整数(1))
>>> 问.去均质(整数(1))
（待定，1）

圣人： P（P）.<x个,年,z（z）> = 投影空间(GF公司(5), 2)
圣人： 问 = P（P）(1, 三, 1)
圣人： 问.去均质(0)
(3, 1)

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(GF公司(整数(5)), 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）(整数(1), 整数(三), 整数(1))
>>> 问.去均质(整数(0))
(3, 1)

圣人： P（P）.<x个,年,z（z）> = 投影空间(GF公司(5), 2)
圣人： 问 = P（P）(1, 三, 0)
圣人： 问.去均质(2)
回溯（最近一次调用）：
...
ValueError:可以。。。t在0坐标下去均匀化

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(GF公司(整数(5)), 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）(整数(1), 整数(三), 整数(0))
>>> 问.去均质(整数(2))
回溯（最近一次调用）：
...
ValueError:可以。。。t在0坐标下去均匀化
全局_高度(前c=无)[来源]#

返回点的绝对对数高度。

输入：

  • 前c–所需的浮点精度（默认值：默认RealField精度）。

输出：

  • 一个实数。

示例：

圣人： P（P）.<x个,年,z（z）> = 投影空间(QQ（QQ）, 2)
圣人： 问 = P（P）.指向([4, 4, 1/30])
圣人： 问.全局_高度()                                                     #需要圣人符号
4.78749174278205

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）.指向([整数(4), 整数(4), 整数(1)/整数(30)])
>>> 问.全局重量()                                                     #需要圣人符号
4.78749174278205

圣人： P（P）.<x个,年,z（z）> = 投影空间(ZZ公司, 2)
圣人： 问 = P（P）([4, 1, 30])
圣人： 问.全局_高度()                                                     #需要圣人符号
3.40119738166216

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(ZZ公司, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）([整数(4), 整数(1), 整数(30)])
>>> 问.全局_高度()                                                     #需要圣人符号
3.40119738166216

圣人： R（右）.<x个> = 多项式环(QQ（QQ）)
圣人： k个.<w个> = 数字字段(x个^2 + 5)                                          #需要sage.rings.number_field
圣人： A类 = 投影空间(k个, 2, “z”)                                        #需要sage.rings.number_field
圣人： A类([三, 5*w个 + 1, 1]).全局_高度(前c=100)                            #需要sage.rings.number_field
2.4181409534757389986565376694

>>> 从 sage.all公司 进口 *
>>> R（右） = 多项式环(QQ（QQ）, 姓名=(“x”,)); (x个,) = R（右）._first_ngens（第一个_基因）(1)
>>> k个 = 数字字段(x个**整数(2) + 整数(5), 姓名=(“w”,)); (w个,) = k个._first_ngens（第一个_基因）(1)#需要sage.rings.number_field
>>> A类 = 投影空间(k个, 整数(2), “z”)                                        #需要sage.rings.number_field
>>> A类([整数(三), 整数(5)*w个 + 整数(1), 整数(1)]).全局_高度(前c=整数(100))                            #需要sage.rings.number_field
2.4181409534757389986565376694

圣人： P（P）.<x个,年,z（z）> = 投影空间(QQbar（QQbar）, 2)                                 #需要sage.rings.number_field
圣人： 问 = P（P）([QQbar（QQbar）(平方英尺(三)), QQbar（QQbar）(平方英尺(-2)), 1])                           #需要sage.rings.number_field sage.symbolic
圣人： 问.全局_高度()                                                     #需要sage.rings.number_field sage.symbolic
0.549306144334055

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQbar（QQbar）, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)#需要sage.rings.number_field
>>> 问 = P（P）([QQbar（QQbar）(平方英尺(整数(三))), QQbar（QQbar）(平方英尺(-整数(2))), 整数(1)])                           #需要sage.rings.number_field sage.symbolic
>>> 问.全局_高度()                                                     #需要sage.rings.number_field sage.symbolic
0.549306144334055

圣人： #需要sage.rings.number_field
圣人： K（K） = 通用CyclotomicField()
圣人： P（P）.<x个,年,z（z）> = 投影空间(K（K）, 2)
圣人： 问 = P（P）.指向([K（K）(4/三), K（K）.消息(7), K（K）.消息(5)])
圣人： 问.全局_高度()
1.38629436111989

>>> 从 sage.all公司 进口 *
>>> #需要sage.rings.number_field
>>> K（K） = 宇宙气旋场()
>>> P（P） = 投影空间(K（K）, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）.指向([K（K）(整数(4)/整数(三)), K（K）.消息(整数(7)), K（K）.消息(整数(5))])
>>> 问.全局_高度()
1.38629436111989
is_preperiodic的(（f）,错误=0.1,退货周期=False（错误）)[来源]#

确定该点相对于地图是否为前周期（f）.

这是为射影空间和子模式实现的。有两个可选关键字参数：错误界限设置标准高度计算中使用的error_bound和退货周期一个布尔值，用于控制如果这一点是周期前的。如果退货周期是真的而这一点不是那么是前期的\((0,0)\)返回该期间的。

算法：

我们知道，一个点是前周期的当且仅当它的规范高度为零。然而，我们只能计算达到数值精度的标准高度。此函数首先计算指向给定误差界的点的标准高度。如果它大于该错误界限，那么它一定不是周期前的。如果它小于误差范围，那么我们预计会提前。在在这种情况下，如果我们确定轨道是有限的，或者点的高度足够大，它一定是在游荡。我们可以确定高度通过计算高度差常数，即高度和点的标准高度（仅取决于贴图，而不取决于点本身）。如果点的高度大于差值界限，则标准高度不能为零，因此该点不能为前周期。

输入：

  • （f）–这一点的密码子的自同态。

千瓦时：

  • 错误–正实数（默认值：0.1）。

  • 退货周期–布尔值（默认值：False（错误）).

输出：

  • 布尔值–真的如果是前期。

  • 如果退货周期是真的，然后(0,0)如果徘徊，以及（m，n）如果是前周期米和期间n个.

示例：

圣人： P（P）.<x个,年> = 投影空间(QQ（QQ）, 1)
圣人： （f） = 动态系统_项目([x个^三 - 三*x个*年^2, 年^三], 领域=P（P）)        #需要sage.方案
圣人： 问 = P（P）(-1, 1)
圣人： 问.is_preperiodic的(（f）)                                                   #需要sage.libs.单数sage.schemes
真的

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(1), 姓名=(“x”, “是”,)); (x个, 年,) = P（P）._first_ngens（第一个_基因）(2)
>>> （f） = 动态系统_项目([x个**整数(三) - 整数(三)*x个*年**整数(2), 年**整数(三)], 领域=P（P）)        #需要sage.方案
>>> 问 = P（P）(-整数(1), 整数(1))
>>> 问.is_preperiodic的(（f）)                                                   #需要sage.libs.单数sage.schemes
真的

圣人： P（P）.<x个,年,z（z）> = 投影空间(QQ（QQ）, 2)
圣人： X（X） = P（P）.子模式(z（z）)
圣人： （f） = 动态系统([x个^2 - 年^2, 年^2, z（z）^2], 领域=X（X）)                  #需要sage.方案
圣人： 第页 = X（X）((-1, 1, 0))
圣人： 第页.is_preperiodic的(（f）, 退货周期=真的)                               #需要sage.libs.单数sage.schemes
(0, 2)

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> X（X） = P（P）.子模式(z（z）)
>>> （f） = 动态系统([x个**整数(2) - 年**整数(2), 年**整数(2), z（z）**整数(2)], 领域=X（X）)                  #需要sage.方案
>>> 第页 = X（X）((-整数(1), 整数(1), 整数(0)))
>>> 第页.is_定期(（f）, 退货周期=真的)                               #需要sage.libs.单数sage.schemes
(0, 2)

圣人： P（P）.<x个,年> = 投影空间(QQ（QQ）,1)
圣人： （f） = 动态系统_项目([x个^2 - 29/16*年^2, 年^2], 领域=P（P）)      #需要sage.方案
圣人： 问 = P（P）(1, 4)
圣人： 问.is_preperiodic的(（f）, 退货周期=真的)                               #需要sage.libs.单数sage.schemes
(1, 3)
圣人： 问 = P（P）(1, 1)
圣人： 问.is_preperiodic的(（f）, 退货周期=真的)                               #需要sage.libs.单数sage.schemes
(0, 0)

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）,整数(1), 姓名=(“x”, “是”,)); (x个, 年,) = P（P）._first_ngens（第一个_基因）(2)
>>> （f） = 动态系统_项目([x个**整数(2) - 整数(29)/整数(16)*年**整数(2), 年**整数(2)], 领域=P（P）)      #需要sage.方案
>>> 问 = P（P）(整数(1), 整数(4))
>>> 问.is_preperiodic的(（f）, 退货周期=真的)                               #需要sage.libs.单数sage.schemes
(1, 3)
>>> 问 = P（P）(整数(1), 整数(1))
>>> 问.is_preperiodic的(（f）, 退货周期=真的)                               #需要sage.libs.单数sage.schemes
(0, 0)

圣人： #需要sage.rings.number_field
圣人： R（右）.<x个> = 多项式环(QQ（QQ）)
圣人： K（K）.<一> = 数字字段(x个^2 + 1)
圣人： P（P）.<x个,年> = 投影空间(K（K）, 1)
圣人： （f） = 动态系统_项目([x个^5 + 5/4*x个*年^4, 年^5], 领域=P（P）)      #需要sage.方案
圣人： 问 = P（P）([-1/2*一 + 1/2, 1])
圣人： 问.is_preperiodic的(（f）)                                                   #需要sage.方案
真的
圣人： 问 = P（P）([一, 1])
圣人： 问.is_preperiodic的(（f）)                                                   #需要sage.方案
False（错误）

>>> 从 sage.all公司 进口 *
>>> #需要sage.rings.number_field
>>> R（右） = 多项式环(QQ（QQ）, 姓名=(“x”,)); (x个,) = R（右）._first_ngens（第一个_基因）(1)
>>> K（K） = 数字字段(x个**整数(2) + 整数(1), 姓名=(“a”,)); (一,) = K（K）._first_ngens（第一个_基因）(1)
>>> P（P） = 投影空间(K（K）, 整数(1), 姓名=(“x”, “是”,)); (x个, 年,) = P（P）._first_ngens（第一个_基因）(2)
>>> （f） = 动态系统_项目([x个**整数(5) + 整数(5)/整数(4)*x个*年**整数(4), 年**整数(5)], 领域=P（P）)      #需要sage.方案
>>> 问 = P（P）([-整数(1)/整数(2)*一 + 整数(1)/整数(2), 整数(1)])
>>> 问.is_preperiodic的(（f）)                                                   #需要sage.方案
真的
>>> 问 = P（P）([一, 整数(1)])
>>> 问.is_定期(（f）)                                                   #需要sage.schemes
False（错误）

圣人： P（P）.<x个,年,z（z）> = 投影空间(QQ（QQ）, 2)
圣人： （f） = 动态系统_项目([                                      #需要sage.方案
....:         -38/45*x个^2 + (2*年 - 7/45*z（z）)*x个 + (-1/2*年^2 - 1/2*年*z（z） + z（z）^2),
....:         -67/90*x个^2 + (2*年 + z（z）*157/90)*x个 - 年*z（z）,
....:         z（z）^2
....:     ], 领域=P（P）)
圣人： 问 = P（P）([1, 三, 1])
圣人： 问.is_preperiodic的(（f）, 退货周期=真的)                               #需要sage.libs.单数sage.schemes
(0, 9)

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> （f） = 动态系统_项目([                                      #需要sage.方案
...         -整数(38)/整数(45)*x个**整数(2) + (整数(2)*年 - 整数(7)/整数(45)*z（z）)*x个 + (-整数(1)/整数(2)*年**整数(2) - 整数(1)/整数(2)*年*z（z） + z（z）**整数(2)),
...         -整数(67)/整数(90)*x个**整数(2) + (整数(2)*年 + z（z）*整数(157)/整数(90))*x个 - 年*z（z）,
...         z（z）**整数(2)
...     ], 领域=P（P）)
>>> 问 = P（P）([整数(1), 整数(三), 整数(1)])
>>> 问.is_preperiodic的(（f）, 退货周期=真的)                               #需要sage.libs.单数sage.schemes
(0, 9)

圣人： P（P）.<x个,年,z（z）,w个> = 投影空间(QQ（QQ）, 三)
圣人： （f） = 动态系统_项目([                                      #需要sage.方案
....:         (-年 - w个)*x个 + (-13/30*年^2 + 13/30*w个*年 + w个^2),
....:         -1/2*x个^2 + (-年 + 三/2*w个)*x个 + (-1/三*年^2 + 4/三*w个*年),
....:         -三/2*z（z）^2 + 5/2*z（z）*w个 + w个^2,
....:         w个^2
....:     ], 领域=P（P）)
圣人： 问 = P（P）([三,0,4/三,1])
圣人： 问.is_preperiodic的(（f）, 退货周期=真的)                               #需要sage.libs.单数sage.schemes
(2, 24)

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(三), 姓名=(“x”, “是”, “z”, “w”,)); (x个, 年, z（z）, w个,) = P（P）._first_ngens（第一个_基因）(4)
>>> （f） = 动态系统_项目([                                      #需要sage.方案
...         (-年 - w个)*x个 + (-整数(13)/整数(30)*年**整数(2) + 整数(13)/整数(30)*w个*年 + w个**整数(2)),
...         -整数(1)/整数(2)*x个**整数(2) + (-年 + 整数(三)/整数(2)*w个)*x个 + (-整数(1)/整数(三)*年**整数(2) + 整数(4)/整数(三)*w个*年),
...         -整数(三)/整数(2)*z（z）**整数(2) + 整数(5)/整数(2)*z（z）*w个 + w个**整数(2),
...         w个**整数(2)
...     ], 领域=P（P）)
>>> 问 = P（P）([整数(三),整数(0),整数(4)/整数(三),整数(1)])
>>> 问.is_preperiodic的(（f）, 退货周期=真的)                               #需要sage.libs.单数sage.schemes
(2, 24)

圣人： #需要sage.rings.number_field sage.schemes sage.symbolic
圣人： 从 sage.misc.verbose软件 进口 设置详细信息
圣人： 设置详细信息(-1)
圣人： P（P）.<x个,年,z（z）> = 投影空间(QQbar（QQbar）, 2)
圣人： （f） = 动态系统_项目([x个^2, QQbar（QQbar）(平方英尺(-1))*年^2, z（z）^2],
....:                                领域=P（P）)
圣人： 问 = P（P）([1, 1, 1])
圣人： 问.is_定期(（f）)
真的

>>> 从 sage.all公司 进口 *
>>> #需要sage.rings.number_field sage.schemes sage.symbolic
>>> 从 sage.misc.verbose软件 进口 设置详细信息
>>> 设置详细信息(-整数(1))
>>> P（P） = 投影空间(QQbar（QQbar）, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> （f） = 动态系统_项目([x个**整数(2), QQ巴(平方英尺(-整数(1)))*年**整数(2), z（z）**整数(2)],
...                                领域=P（P）)
>>> 问 = P（P）([整数(1), 整数(1), 整数(1)])
>>> 问.is_preperiodic的(（f）)
真的

圣人： #需要sage.rings.number_field sage.schemes sage.symbolic
圣人： 设置详细信息(-1)
圣人： P（P）.<x个,年,z（z）> = 投影空间(QQbar（QQbar）, 2)
圣人： （f） = 动态系统_项目([x个^2, 年^2, z（z）^2], 领域=P（P）)
圣人： 问 = P（P）([QQbar（QQbar）(平方英尺(-1)), 1, 1])
圣人： 问.is_preperiodic的(（f）)
真的

>>> 从 sage.all公司 进口 *
>>> #需要sage.rings.number_field sage.schemes sage.symbolic
>>> 设置详细信息(-整数(1))
>>> P（P） = 投影空间(QQbar（QQbar）, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> （f） = 动态系统_项目([x个**整数(2), 年**整数(2), z（z）**整数(2)], 领域=P（P）)
>>> 问 = P（P）([QQbar（QQbar）(平方英尺(-整数(1))), 整数(1), 整数(1)])
>>> 问.is_preperiodic的(（f）)
真的

圣人： P（P）.<x个,年> = 投影空间(QQ（QQ）, 1)
圣人： （f） = 动态系统_项目([16*x个^2 - 29*年^2, 16*年^2], 领域=P（P）)   #需要sage.方案
圣人： 问 = P（P）(-1,4)
圣人： 问.is_preperiodic的(（f）)                                                   #需要sage.libs.单数sage.schemes
真的

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(1), 姓名=(“x”, “是”,)); (x个, 年,) = P（P）._first_ngens（第一个_基因）(2)
>>> （f） = 动态系统_项目([整数(16)*x个**整数(2) - 整数(29)*年**整数(2), 整数(16)*年**整数(2)], 领域=P（P）)   #需要sage.方案
>>> 问 = P（P）(-整数(1),整数(4))
>>> 问.is_preperiodic的(（f）)                                                   #需要sage.libs.单数sage.schemes
真的

圣人： P（P）.<x个,年,z（z）> = 投影空间(GF公司(三), 2)
圣人： F类 = 动态系统([x个^2 - 2*年^2, 年^2, z（z）^2])                          #需要sage.方案
圣人： 问 = P（P）(1, 1, 1)
圣人： 问.is_preperiodic的(F类, 退货周期=真的)                               #需要sage.schemes
(1, 1)

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(GF公司(整数(三)), 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> F类 = 动态系统([x个**整数(2) - 整数(2)*年**整数(2), 年**整数(2), z（z）**整数(2)])                          #需要sage.方案
>>> 问 = P（P）(整数(1), 整数(1), 整数(1))
>>> 问.is_preperiodic的(F类, 退货周期=真的)                               #需要sage.方案
(1, 1)
本地重量(v（v）,前c=无)[来源]#

返回此点坐标的局部高度的最大值。

输入：

  • v（v）–基环的素理想或素理想。

  • 前c–所需的浮点精度（默认值：默认RealField精度）。

输出：

  • 一个实数。

示例：

圣人： P（P）.<x个,年,z（z）> = 投影空间(QQ（QQ）, 2)
圣人： 问 = P（P）.指向([4, 4, 1/150], False（错误）)
圣人： 问.本地高度（_H）(5)                                                     #需要sage.rings.real_mpfr
3.21887582486820

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）.指向([整数(4), 整数(4), 整数(1)/整数(150)], False（错误）)
>>> 问.本地高度（_H）(整数(5))                                                     #需要sage.rings.real_mpfr
3.21887582486820

圣人： P（P）.<x个,年,z（z）> = 投影空间(QQ（QQ）, 2)
圣人： 问 = P（P）([4, 1, 30])
圣人： 问.本地高度（_H）(2)                                                     #需要sage.rings.real_mpfr
0.693147180559945

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）([整数(4), 整数(1), 整数(30)])
>>> 问.本地高度（_H）(整数(2))                                                     #需要sage.rings.real_mpfr
0.693147180559945
本地高度拱形(我,前c=无)[来源]#

返回我-这一点的无限位置。

输入：

  • 我–一个整数。

  • 前c–所需的浮点精度（默认值：默认RealField精度）。

输出：

  • 一个实数。

示例：

圣人： P（P）.<x个,年,z（z）> = 投影空间(QQ（QQ）, 2)
圣人： 问 = P（P）.指向([4, 4, 1/150], False（错误）)
圣人： 问.本地高度拱形(0)                                                #需要sage.rings.real_mpfr
1.38629436111989

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）.指向([整数(4), 整数(4), 整数(1)/整数(150)], False（错误）)
>>> 问.本地高度拱形(整数(0))                                                #需要sage.rings.real_mpfr
1.38629436111989

圣人： #需要sage.rings.number_field
圣人： P（P）.<x个,年,z（z）> = 投影空间(象限域(5, “w”), 2)
圣人： 问 = P（P）.指向([4, 1, 30], False（错误）)
圣人： 问.本地高度拱形(1)
3.401197381662155375413236691607

>>> 从 sage.all公司 进口 *
>>> #需要sage.rings.number_field
>>> P（P） = 投影空间(象限域(整数(5), “w”), 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）.指向([整数(4), 整数(1), 整数(30)], False（错误）)
>>> 问.本地高度拱形(整数(1))
3.401197381662155375413236691607
乘数，乘数(（f）,n个,检查=真的)[来源]#

返回此时段点的乘数n个通过函数（f）.

（f）必须是射影空间的自同态。

输入：

  • （f）–这一点的密码子的自同态。

  • n个–一个正整数，表示该点的周期。

  • 检查–检查是否P（P）是周期的周期n个，默认值：True。

输出：

  • 大小方阵self.codomain（）.dimension_relative（）在中底座（_R）这一点。

示例：

圣人： P（P）.<x个,年,z（z）,w个> = 投影空间(QQ（QQ）, 三)
圣人： （f） = 动态系统_项目([x个^2, 年^2, 4*w个^2, 4*z（z）^2], 领域=P（P）)    #需要sage.方案
圣人： 问 = P（P）.指向([4, 4, 1, 1], False（错误）)
圣人： 问.乘数，乘数(（f）, 1)                                                    #需要sage.方案
[ 2  0 -8]
[ 0  2 -8]
[ 0  0 -2]

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(QQ（QQ）, 整数(三), 姓名=(“x”, “是”, “z”, “w”,)); (x个, 年, z（z）, w个,) = P（P）._first_ngens（第一个_基因）(4)
>>> （f） = 动态系统_对象([x个**整数(2), 年**整数(2), 整数(4)*w个**整数(2), 整数(4)*z（z）**整数(2)], 领域=P（P）)    #需要sage.方案
>>> 问 = P（P）.指向([整数(4), 整数(4), 整数(1), 整数(1)], False（错误）)
>>> 问.乘数，乘数(（f）, 整数(1))                                                    #需要sage.方案
[ 2  0 -8]
[ 0  2 -8]
[ 0  0 -2]
normalize_coordinates（规范_坐标）()[来源]#

从该点的坐标中删除gcd（包括\(-1\)).

警告

gcd将取决于基环。

输出：无。

示例：

圣人： P（P） = 投影空间(ZZ公司, 2, “x”)
圣人： 第页 = P（P）([-5, -15, -20])
圣人： 第页.normalize_coordinates（规范_坐标）(); 第页
(1 : 3 : 4)

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(ZZ公司, 整数(2), “x”)
>>> 第页 = P（P）([-整数(5), -整数(15), -整数(20)])
>>> 第页.normalize_coordinates（规范_坐标）(); 第页
(1 : 3 : 4)

圣人： #需要sage.rings.padics
圣人： P（P） = 投影空间(兹普(7), 2, “x”)
圣人： 第页 = P（P）([-5, -15, -2])
圣人： 第页.normalize_coordinates（规范_坐标）(); 第页
（5+O（7^20）:1+2*7+O（9^20）:2+O（6^20））

>>> 从 sage.all公司 进口 *
>>> #需要sage.rings.padics
>>> P（P） = 投影空间(兹普(整数(7)), 整数(2), “x”)
>>> 第页 = P（P）([-整数(5), -整数(15), -整数(2)])
>>> 第页.normalize_coordinates（规范_坐标）(); 第页
（5+O（7^20）:1+2*7+O（9^20）:2+O（6^20））

圣人： R（右）.<吨> = 多项式环(QQ（QQ）)
圣人： P（P） = 投影空间(R（右）, 2, “x”)
圣人： 第页 = P（P）([三/5*吨^三, 6*吨, 吨])
圣人： 第页.normalize_coordinates（规范_坐标）(); 第页
（3/5*t^2:6:1）

>>> 从 sage.all公司 进口 *
>>> R（右） = 多项式环(QQ（QQ）, 姓名=(“t”,)); (吨,) = R（右）._first_ngens（第一个_基因）(1)
>>> P（P） = 投影空间(R（右）, 整数(2), “x”)
>>> 第页 = P（P）([整数(三)/整数(5)*吨**整数(三), 整数(6)*吨, 吨])
>>> 第页.normalize_coordinates（规范_坐标）(); 第页
（3/5*t^2:6:1）

圣人： P（P）.<x个,年> = 投影空间(Zmod公司(20), 1)
圣人： 问 = P（P）(三, 6)
圣人： 问.normalize_coordinates（规范_坐标）()
圣人： 问
(1 : 2)

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(Zmod公司(整数(20)), 整数(1), 姓名=(“x”, “是”,)); (x个, 年,) = P（P）._first_ngens（第一个_基因）(2)
>>> 问 = P（P）(整数(三), 整数(6))
>>> 问.归一化坐标()
>>> 问
(1 : 2)

由于基环是域上的多项式环，因此只有gcd公司\（c）已删除。

圣人： R（右）.<c（c）> = 多项式环(QQ（QQ）)
圣人： P（P） = 投影空间(R（右）, 1)
圣人： 问 = P（P）(2*c（c）, 4*c（c）)
圣人： 问.normalize_coordinates（规范_坐标）();问
(2 : 4)

>>> 从 sage.all公司 进口 *
>>> R（右） = 多项式环(QQ（QQ）, 姓名=(“c”,)); (c（c）,) = R（右）._first_ngens（第一个_基因）(1)
>>> P（P） = 投影空间(R（右）, 整数(1))
>>> 问 = P（P）(整数(2)*c（c）, 整数(4)*c（c）)
>>> 问.normalize_coordinates（规范_坐标）();问
(2 : 4)

环上的多项式环给出了更直观的结果。

圣人： R（右）.<c（c）> = 多项式环(ZZ公司)
圣人： P（P） = 投影空间(R（右）, 1)
圣人： 问 = P（P）(2*c（c）, 4*c（c）)
圣人： 问.normalize_coordinates（规范_坐标）();问
(1 : 2)

>>> 从 sage.all公司 进口 *
>>> R（右） = 多项式环(ZZ公司, 姓名=(“c”,)); (c（c）,) = R（右）._first_ngens（第一个_基因）(1)
>>> P（P） = 投影空间(R（右）, 整数(1))
>>> 问 = P（P）(整数(2)*c（c）, 整数(4)*c（c）)
>>> 问.normalize_coordinates（规范_坐标）();问
(1 : 2)

圣人： #需要sage.libs.singular
圣人： R（右）.<吨> = QQ（QQ）[]
圣人： S公司 = R（右）.商_ring(R（右）.理想的(吨^三))
圣人： P（P）.<x个,年> = 投影空间(S公司, 1)
圣人： 问 = P（P）(吨 + 1, 吨^2 + 吨)
圣人： 问.normalize_coordinates（规范_坐标）()
圣人： 问
（1:tbar）

>>> 从 sage.all公司 进口 *
>>> #需要sage.libs.singular
>>> R（右） = QQ（QQ）[“t”]; (吨,) = R（右）._first_ngens（第一个_基因）(1)
>>> S公司 = R（右）.商_ring(R（右）.理想的(吨**整数(三)))
>>> P（P） = 投影空间(S公司, 整数(1), 姓名=(“x”, “是”,)); (x个, 年,) = P（P）._first_ngens（第一个_基因）(2)
>>> 问 = P（P）(吨 + 整数(1), 吨**整数(2) + 吨)
>>> 问.normalize_coordinates（规范_坐标）()
>>> 问
（1:tbar）
缩放（_B）(吨)[来源]#

按比例缩放点的坐标吨.

A类类型错误如果点不在缩放后的密码域的碱基环。

输入：

  • 吨–环形元件。

输出：无。

示例：

圣人： R（右）.<吨> = 多项式环(QQ（QQ）)
圣人： P（P） = 投影空间(R（右）, 2, “x”)
圣人： 第页 = P（P）([三/5*吨^三, 6*吨, 吨])
圣人： 第页.缩放（_B）(1/吨); 第页
（3/5*t^2:6:1）

>>> 从 sage.all公司 进口 *
>>> R（右） = 多项式环(QQ（QQ）, 姓名=(“t”,)); (吨,) = R（右）._first_ngens（第一个_基因）(1)
>>> P（P） = 投影空间(R（右）, 整数(2), “x”)
>>> 第页 = P（P）([整数(三)/整数(5)*吨**整数(三), 整数(6)*吨, 吨])
>>> 第页.缩放（_B）(整数(1)/吨); 第页
（3/5*t^2:6:1）

圣人： #需要sage.libs.pari
圣人： R（右）.<吨> = 多项式环(QQ（QQ）)
圣人： S公司 = R（右）.现状(R（右）.理想的(吨^三))
圣人： P（P）.<x个,年,z（z）> = 投影空间(S公司, 2)
圣人： 问 = P（P）(吨, 1, 1)
圣人： 问.缩放（_B）(吨);问
（tbar^2:tbar:tbar）

>>> 从 sage.all公司 进口 *
>>> #需要sage.libs.pari
>>> R（右） = 多项式环(QQ（QQ）, 姓名=(“t”,)); (吨,) = R（右）._first_ngens（第一个_基因）(1)
>>> S公司 = R（右）.现状(R（右）.理想的(吨**整数(三)))
>>> P（P） = 投影空间(S公司, 整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）(吨, 整数(1), 整数(1))
>>> 问.缩放（_B）(吨);问
（tbar^2:tbar:tbar）

圣人： P（P）.<x个,年,z（z）> = 投影空间(ZZ公司,2)
圣人： 问 = P（P）(2, 2, 2)
圣人： 问.缩放（_B）(1/2);问
(1 : 1 : 1)

>>> 从 sage.all公司 进口 *
>>> P（P） = 投影空间(ZZ公司,整数(2), 姓名=(“x”, “是”, “z”,)); (x个, 年, z（z）,) = P（P）._first_ngens（第一个_基因）(三)
>>> 问 = P（P）(整数(2), 整数(2), 整数(2))
>>> 问.缩放（_B）(整数(1)/整数(2));问
(1 : 1 : 1)