gh-35778: Return the points in the ring of integers after renormalization
    
<!-- Please provide a concise, informative and self-explanatory title.
-->
<!-- Don't put issue numbers in the title. Put it in the Description
below. -->
<!-- For example, instead of "Fixes #12345", use "Add a new method to
multiply two integers" -->

### 📚 Description

<!-- Describe your changes here in detail. -->
<!-- Why is this change required? What problem does it solve? -->
<!-- If this PR resolves an open issue, please link to it here. For
example "Fixes #12345". -->
<!-- If your change requires a documentation PR, please link it
appropriately. -->

`points_of_bounded_height` function in `proj_bdd_height.py` now returns
correct results after renormalization by scaling, if in the ring of
integers.

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. It should be `[x]` not `[x
]`. -->

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
- [x] I have linked a relevant issue or discussion.
- [x] I have created tests covering the changes.
- [x] I have updated the documentation accordingly.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on
- #12345: short description why this is a dependency
- #34567: ...
-->

<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
    
URL: #35778
Reported by: Jing Guo
Reviewer(s):

Author: Release Manager

src/sage/schemes/projective/proj_bdd_height.py

@@ -22,71 +22,143 @@
 from math import floor
 
 from sage.schemes.projective.projective_space import ProjectiveSpace
+from sage.rings.integer_ring import ZZ
 from sage.rings.rational_field import QQ
 from sage.rings.real_mpfr import RealField
 from sage.rings.number_field.unit_group import UnitGroup
-from sage.arith.misc import GCD as gcd
+from sage.arith.misc import gcd
+from sage.arith.functions import lcm
 from sage.matrix.constructor import matrix, column_matrix
 from sage.libs.pari.all import pari
 from sage.modules.free_module_element import vector
 from sage.rings.integer import Integer
 from sage.geometry.polyhedron.constructor import Polyhedron
 
 
-def QQ_points_of_bounded_height(dim, bound):
+def ZZ_points_of_bounded_height(PS, dim, bound):
     r"""
     Return an iterator of the points in ``self`` of absolute multiplicative
     height of at most ``bound`` in the rational field.
 
     INPUT:
 
+    - ``PS`` -- a projective space
+
+    - ``dim`` -- a positive integer
+
+    - ``bound`` -- a positive integer
+
+    OUTPUT:
+
+    - an iterator of points of bounded height
+
+    EXAMPLES:
+
+        sage: from sage.schemes.projective.proj_bdd_height import ZZ_points_of_bounded_height
+        sage: PS = ProjectiveSpace(ZZ, 1)
+        sage: sorted(list(ZZ_points_of_bounded_height(PS, 1, 1)))
+        [(-1 : -1), (-1 : 0), (-1 : 1), (0 : -1)]
+        sage: len(list(ZZ_points_of_bounded_height(PS, 1, 5)))
+        40
+        sage: sorted(list(ZZ_points_of_bounded_height(PS, 1, 2)))
+        [(-2 : -1), (-2 : 1), (-1 : -2), (-1 : -1),
+         (-1 : 0), (-1 : 1), (-1 : 2), (0 : -1)]
+        sage: PS = ProjectiveSpace(ZZ, 2)
+        sage: sorted(list(ZZ_points_of_bounded_height(PS, 2, 1)))
+        [(-1 : -1 : -1), (-1 : -1 : 0), (-1 : -1 : 1), (-1 : 0 : -1),
+         (-1 : 0 : 0), (-1 : 0 : 1), (-1 : 1 : -1), (-1 : 1 : 0),
+         (-1 : 1 : 1), (0 : -1 : -1), (0 : -1 : 0), (0 : -1 : 1),
+         (0 : 0 : -1)]
+
+    There are no points of negative height::
+
+        sage: from sage.schemes.projective.proj_bdd_height import ZZ_points_of_bounded_height
+        sage: PS = ProjectiveSpace(ZZ, 1)
+        sage: list(ZZ_points_of_bounded_height(PS, 1, -3))
+        []
+    """
+    if bound < 1:
+        return iter(set([]))
+
+    points_of_bounded_height = set([])
+
+    for t in itertools.product(range(-bound, bound+1), repeat=dim+1):
+        if gcd(t) == 1:
+            point = PS(t)
+            if point not in points_of_bounded_height:
+                points_of_bounded_height.add(point)
+                yield point
+
+
+def QQ_points_of_bounded_height(PS, dim, bound, normalize=False):
+    r"""
+    Return an iterator of the points in ``self`` of absolute multiplicative
+    height of at most ``bound`` in the rational field.
+
+    INPUT:
+
+    - ``PS`` -- a projective space
+
     - ``dim`` -- a positive integer
 
     - ``bound`` -- a real number
 
+    - ``normalize`` -- boolean (optional, default: ``False``); whether to
+      normalize the coordinates of returned points
+
     OUTPUT:
 
     - an iterator of points of bounded height
 
     EXAMPLES:
 
         sage: from sage.schemes.projective.proj_bdd_height import QQ_points_of_bounded_height
-        sage: sorted(list(QQ_points_of_bounded_height(1, 1)))
+        sage: PS = ProjectiveSpace(QQ, 1)
+        sage: sorted(list(QQ_points_of_bounded_height(PS, 1, 1)))
         [(-1 : 1), (0 : 1), (1 : 0), (1 : 1)]
-        sage: len(list(QQ_points_of_bounded_height(1, 5)))
+        sage: len(list(QQ_points_of_bounded_height(PS, 1, 5)))
         40
+        sage: sorted(list(QQ_points_of_bounded_height(PS, 1, 2)))
+        [(-2 : 1), (-1 : 1), (-1/2 : 1), (0 : 1),
+         (1/2 : 1), (1 : 0), (1 : 1), (2 : 1)]
+        sage: sorted(list(QQ_points_of_bounded_height(PS, 1, 2, normalize=True)))
+        [(-2 : 1), (-1 : 1), (-1 : 2), (0 : 1),
+         (1 : 0), (1 : 1), (1 : 2), (2 : 1)]
 
     There are no points of negative height::
 
         sage: from sage.schemes.projective.proj_bdd_height import QQ_points_of_bounded_height
-        sage: list(QQ_points_of_bounded_height(1, -3))
+        sage: PS = ProjectiveSpace(QQ, 1)
+        sage: list(QQ_points_of_bounded_height(PS, 1, -3))
         []
     """
     if bound < 1:
         return iter(set([]))
 
-    PN = ProjectiveSpace(QQ, dim)
     unit_tuples = list(itertools.product([-1, 1], repeat=dim))
     points_of_bounded_height = set([])
     increasing_tuples = itertools.combinations_with_replacement(range(floor(bound + 1)), dim + 1)
     for t in increasing_tuples:
         if gcd(t) == 1:
             for p in itertools.permutations(t):
                 for u in unit_tuples:
-                    point = PN([a*b for a, b in zip(u, p)] + [p[dim]])
+                    point = PS([a*b for a, b in zip(u, p)] + [p[dim]])
                     if point not in points_of_bounded_height:
+                        if normalize:
+                            point.scale_by(lcm([point[i].denominator() for i in range(dim + 1)]))
+
                         points_of_bounded_height.add(point)
                         yield point
 
 
-def IQ_points_of_bounded_height(PN, K, dim, bound):
+def IQ_points_of_bounded_height(PS, K, dim, bound):
     r"""
     Return an iterator of the points in ``self`` of absolute multiplicative
     height of at most ``bound`` in the imaginary quadratic field ``K``.
 
     INPUT:
 
-    - ``PN`` -- a projective space
+    - ``PS`` -- a projective space
 
     - ``K`` -- a number field
 
@@ -147,13 +219,14 @@ def IQ_points_of_bounded_height(PN, K, dim, bound):
             if a == K.ideal(point_coordinates):
                 for p in itertools.permutations(point_coordinates):
                     for u in unit_tuples:
-                        point = PN([i*j for i, j in zip(u, p)] + [p[dim]])
+                        point = PS([i*j for i, j in zip(u, p)] + [p[dim]])
+
                         if point not in points_in_class_a:
                             points_in_class_a.add(point)
                             yield point
 
 
-def points_of_bounded_height(PN, K, dim, bound, prec=53):
+def points_of_bounded_height(PS, K, dim, bound, prec=53):
     r"""
     Return an iterator of the points in ``K`` with dimension ``dim`` of
     absolute multiplicative height of at most ``bound``.
@@ -164,7 +237,7 @@ def points_of_bounded_height(PN, K, dim, bound, prec=53):
 
     INPUT:
 
-    - ``PN`` -- a projective space
+    - ``PS`` -- a projective space
 
     - ``K`` -- a number field
 
@@ -184,8 +257,39 @@ def points_of_bounded_height(PN, K, dim, bound, prec=53):
         sage: x = polygen(ZZ, 'x')
         sage: K.<a> = NumberField(x^3 - 7)                                                          # optional - sage.rings.number_field
         sage: P.<x,y,z> = ProjectiveSpace(K, 2)                                                     # optional - sage.rings.number_field
-        sage: len(list(points_of_bounded_height(P, K, 2, 1)))                                       # optional - sage.rings.number_field
-        13
+        sage: sorted(list(points_of_bounded_height(P, K, 2, 1)))                                    # optional - sage.rings.number_field
+        [(0 : 0 : 1), (0 : 1 : 0), (1 : 0 : 0), (0 : -1 : 1), (0 : 1 : 1),
+         (-1 : 0 : 1), (1 : 0 : 1), (1 : 1 : 0), (-1 : 1 : 0), (-1 : -1 : 1),
+         (-1 : 1 : 1), (1 : -1 : 1), (1 : 1 : 1)]
+
+    ::
+
+        sage: R.<x> = QQ[]
+        sage: K.<a> = NumberField(3*x^2 + 1)
+        sage: O = K.maximal_order()
+        sage: P.<z,w> = ProjectiveSpace(O, 1)
+        sage: len(list(P.points_of_bounded_height(bound=2)))
+        44
+
+    ::
+
+        sage: R.<x> = QQ[]
+        sage: K.<a> = NumberField(3*x^2 + 1)
+        sage: O = K.maximal_order()
+        sage: P.<z,w> = ProjectiveSpace(O, 1)
+        sage: sorted(list(P.points_of_bounded_height(bound=1)))
+        [(-1 : 1), (-3/2*a - 1/2 : 1), (3/2*a - 1/2 : 1), (0 : 1),
+         (-3/2*a + 1/2 : 0), (-3/2*a + 1/2 : 1), (3/2*a + 1/2 : 1), (1 : 1)]
+
+    ::
+
+        sage: R.<x> = QQ[]
+        sage: K.<z> = NumberField(x^2 - 2)
+        sage: R2.<y> = K[]
+        sage: L.<w> = K.extension(y^2 - 3)
+        sage: P.<a,b> = ProjectiveSpace(L, 1)
+        sage: len(list(P.points_of_bounded_height(bound=2)))
+        256
     """
     if bound < 1:
         return iter([])
@@ -344,7 +448,8 @@ def points_of_bounded_height(PN, K, dim, bound, prec=53):
             if log_arch_height <= log_arch_height_bound and a == K.ideal(point_coordinates):
                 for p in itertools.permutations(point_coordinates):
                     for u in unit_tuples:
-                        point = PN([i*j for i, j in zip(u, p)] + [p[dim]])
+                        point = PS([i*j for i, j in zip(u, p)] + [p[dim]])
+
                         if point not in points_in_class_a:
                             points_in_class_a.add(point)
                             yield point