def vectors_by_length(self, bound):
"""
Returns a list of short vectors together with their values.
This is a naive algorithm which uses the Cholesky decomposition,
but does not use the LLL-reduction algorithm.
INPUT:
bound -- an integer >= 0
OUTPUT:
A list L of length (bound + 1) whose entry L `[i]` is a list of
all vectors of length `i`.
Reference: This is a slightly modified version of Cohn's Algorithm
2.7.5 in "A Course in Computational Number Theory", with the
increment step moved around and slightly re-indexed to allow clean
looping.
Note: We could speed this up for very skew matrices by using LLL
first, and then changing coordinates back, but for our purposes
the simpler method is efficient enough. =)
EXAMPLES::
sage: Q = DiagonalQuadraticForm(ZZ, [1,1])
sage: Q.vectors_by_length(5)
[[[0, 0]],
[[0, -1], [-1, 0]],
[[-1, -1], [1, -1]],
[],
[[0, -2], [-2, 0]],
[[-1, -2], [1, -2], [-2, -1], [2, -1]]]
::
sage: Q1 = DiagonalQuadraticForm(ZZ, [1,3,5,7])
sage: Q1.vectors_by_length(5)
[[[0, 0, 0, 0]],
[[-1, 0, 0, 0]],
[],
[[0, -1, 0, 0]],
[[-1, -1, 0, 0], [1, -1, 0, 0], [-2, 0, 0, 0]],
[[0, 0, -1, 0]]]
::
sage: Q = QuadraticForm(ZZ, 4, [1,1,1,1, 1,0,0, 1,0, 1])
sage: list(map(len, Q.vectors_by_length(2)))
[1, 12, 12]
::
sage: Q = QuadraticForm(ZZ, 4, [1,-1,-1,-1, 1,0,0, 4,-3, 4])
sage: list(map(len, Q.vectors_by_length(3)))
[1, 3, 0, 3]
"""
# pari uses eps = 1e-6 ; nothing bad should happen if eps is too big
# but if eps is too small, roundoff errors may knock off some
# vectors of norm = bound (see #7100)
eps = RDF(1e-6)
bound = ZZ(floor(max(bound, 0)))
Theta_Precision = bound + eps
n = self.dim()
## Make the vector of vectors which have a given value
## (So theta_vec[i] will have all vectors v with Q(v) = i.)
theta_vec = [[] for i in range(bound + 1)]
## Initialize Q with zeros and Copy the Cholesky array into Q
Q = self.cholesky_decomposition()
## 1. Initialize
T = n * [RDF(0)] ## Note: We index the entries as 0 --> n-1
U = n * [RDF(0)]
i = n - 1
T[i] = RDF(Theta_Precision)
U[i] = RDF(0)
L = n * [0]
x = n * [0]
Z = RDF(0)
## 2. Compute bounds
Z = (T[i] / Q[i][i]).sqrt(extend=False)
L[i] = (Z - U[i]).floor()
x[i] = (-Z - U[i]).ceil()
done_flag = False
Q_val_double = RDF(0)
Q_val = 0 ## WARNING: Still need a good way of checking overflow for this value...
## Big loop which runs through all vectors
while not done_flag:
## 3b. Main loop -- try to generate a complete vector x (when i=0)
while (i > 0):
#print " i = ", i
#print " T[i] = ", T[i]
#print " Q[i][i] = ", Q[i][i]
#print " x[i] = ", x[i]
#print " U[i] = ", U[i]
#print " x[i] + U[i] = ", (x[i] + U[i])
#print " T[i-1] = ", T[i-1]
T[i - 1] = T[i] - Q[i][i] * (x[i] + U[i]) * (x[i] + U[i])
#print " T[i-1] = ", T[i-1]
#print " x = ", x
#print
i = i - 1
U[i] = 0
for j in range(i + 1, n):
U[i] = U[i] + Q[i][j] * x[j]
## Now go back and compute the bounds...
## 2. Compute bounds
Z = (T[i] / Q[i][i]).sqrt(extend=False)
L[i] = (Z - U[i]).floor()
x[i] = (-Z - U[i]).ceil()
# carry if we go out of bounds -- when Z is so small that
# there aren't any integral vectors between the bounds
# Note: this ensures T[i-1] >= 0 in the next iteration
while (x[i] > L[i]):
i += 1
x[i] += 1
## 4. Solution found (This happens when i = 0)
#print "-- Solution found! --"
#print " x = ", x
#print " Q_val = Q(x) = ", Q_val
Q_val_double = Theta_Precision - T[0] + Q[0][0] * (x[0] + U[0]) * (
x[0] + U[0])
Q_val = Q_val_double.round()
## SANITY CHECK: Roundoff Error is < 0.001
if abs(Q_val_double - Q_val) > 0.001:
print(" x = ", x)
print(" Float = ", Q_val_double, " Long = ", Q_val)
raise RuntimeError(
"The roundoff error is bigger than 0.001, so we should use more precision somewhere..."
)
#print " Float = ", Q_val_double, " Long = ", Q_val, " XX "
#print " The float value is ", Q_val_double
#print " The associated long value is ", Q_val
if (Q_val <= bound):
#print " Have vector ", x, " with value ", Q_val
theta_vec[Q_val].append(deepcopy(x))
## 5. Check if x = 0, for exit condition. =)
j = 0
done_flag = True
while (j < n):
if (x[j] != 0):
done_flag = False
j += 1
## 3a. Increment (and carry if we go out of bounds)
x[i] += 1
while (x[i] > L[i]) and (i < n - 1):
i += 1
x[i] += 1
#print " Leaving ThetaVectors()"
return theta_vec
def vectors_by_length(self, bound):
"""
Returns a list of short vectors together with their values.
This is a naive algorithm which uses the Cholesky decomposition,
but does not use the LLL-reduction algorithm.
INPUT:
bound -- an integer >= 0
OUTPUT:
A list L of length (bound + 1) whose entry L `[i]` is a list of
all vectors of length `i`.
Reference: This is a slightly modified version of Cohn's Algorithm
2.7.5 in "A Course in Computational Number Theory", with the
increment step moved around and slightly re-indexed to allow clean
looping.
Note: We could speed this up for very skew matrices by using LLL
first, and then changing coordinates back, but for our purposes
the simpler method is efficient enough. =)
EXAMPLES::
sage: Q = DiagonalQuadraticForm(ZZ, [1,1])
sage: Q.vectors_by_length(5)
[[[0, 0]],
[[0, -1], [-1, 0]],
[[-1, -1], [1, -1]],
[],
[[0, -2], [-2, 0]],
[[-1, -2], [1, -2], [-2, -1], [2, -1]]]
::
sage: Q1 = DiagonalQuadraticForm(ZZ, [1,3,5,7])
sage: Q1.vectors_by_length(5)
[[[0, 0, 0, 0]],
[[-1, 0, 0, 0]],
[],
[[0, -1, 0, 0]],
[[-1, -1, 0, 0], [1, -1, 0, 0], [-2, 0, 0, 0]],
[[0, 0, -1, 0]]]
::
sage: Q = QuadraticForm(ZZ, 4, [1,1,1,1, 1,0,0, 1,0, 1])
sage: map(len, Q.vectors_by_length(2))
[1, 12, 12]
::
sage: Q = QuadraticForm(ZZ, 4, [1,-1,-1,-1, 1,0,0, 4,-3, 4])
sage: map(len, Q.vectors_by_length(3))
[1, 3, 0, 3]
"""
# pari uses eps = 1e-6 ; nothing bad should happen if eps is too big
# but if eps is too small, roundoff errors may knock off some
# vectors of norm = bound (see #7100)
eps = RDF(1e-6)
bound = ZZ(floor(max(bound, 0)))
Theta_Precision = bound + eps
n = self.dim()
## Make the vector of vectors which have a given value
## (So theta_vec[i] will have all vectors v with Q(v) = i.)
theta_vec = [[] for i in range(bound + 1)]
## Initialize Q with zeros and Copy the Cholesky array into Q
Q = self.cholesky_decomposition()
## 1. Initialize
T = n * [RDF(0)] ## Note: We index the entries as 0 --> n-1
U = n * [RDF(0)]
i = n-1
T[i] = RDF(Theta_Precision)
U[i] = RDF(0)
L = n * [0]
x = n * [0]
Z = RDF(0)
## 2. Compute bounds
Z = (T[i] / Q[i][i]).sqrt(extend=False)
L[i] = ( Z - U[i]).floor()
x[i] = (-Z - U[i]).ceil()
done_flag = False
Q_val_double = RDF(0)
Q_val = 0 ## WARNING: Still need a good way of checking overflow for this value...
## Big loop which runs through all vectors
while not done_flag:
## 3b. Main loop -- try to generate a complete vector x (when i=0)
while (i > 0):
#print " i = ", i
#print " T[i] = ", T[i]
#print " Q[i][i] = ", Q[i][i]
#print " x[i] = ", x[i]
#print " U[i] = ", U[i]
#print " x[i] + U[i] = ", (x[i] + U[i])
#print " T[i-1] = ", T[i-1]
T[i-1] = T[i] - Q[i][i] * (x[i] + U[i]) * (x[i] + U[i])
#print " T[i-1] = ", T[i-1]
#print " x = ", x
#print
i = i - 1
U[i] = 0
for j in range(i+1, n):
U[i] = U[i] + Q[i][j] * x[j]
## Now go back and compute the bounds...
## 2. Compute bounds
Z = (T[i] / Q[i][i]).sqrt(extend=False)
L[i] = ( Z - U[i]).floor()
x[i] = (-Z - U[i]).ceil()
# carry if we go out of bounds -- when Z is so small that
# there aren't any integral vectors between the bounds
# Note: this ensures T[i-1] >= 0 in the next iteration
while (x[i] > L[i]):
i += 1
x[i] += 1
## 4. Solution found (This happens when i = 0)
#print "-- Solution found! --"
#print " x = ", x
#print " Q_val = Q(x) = ", Q_val
Q_val_double = Theta_Precision - T[0] + Q[0][0] * (x[0] + U[0]) * (x[0] + U[0])
Q_val = Q_val_double.round()
## SANITY CHECK: Roundoff Error is < 0.001
if abs(Q_val_double - Q_val) > 0.001:
print " x = ", x
print " Float = ", Q_val_double, " Long = ", Q_val
raise RuntimeError("The roundoff error is bigger than 0.001, so we should use more precision somewhere...")
#print " Float = ", Q_val_double, " Long = ", Q_val, " XX "
#print " The float value is ", Q_val_double
#print " The associated long value is ", Q_val
if (Q_val <= bound):
#print " Have vector ", x, " with value ", Q_val
theta_vec[Q_val].append(deepcopy(x))
## 5. Check if x = 0, for exit condition. =)
j = 0
done_flag = True
while (j < n):
if (x[j] != 0):
done_flag = False
j += 1
## 3a. Increment (and carry if we go out of bounds)
x[i] += 1
while (x[i] > L[i]) and (i < n-1):
i += 1
x[i] += 1
#print " Leaving ThetaVectors()"
return theta_vec
