def entropy(x, q):
"""
Computes the entropy on the q-ary symmetric channel.
"""
q = ZZ(q)
H = x * log(q - 1, q) - x * log(x, q) - (1 - x) * log(1 - x, q)
return H
def entropy(x,q):
"""
Computes the entropy on the q-ary symmetric channel.
"""
q = ZZ(q)
H = x*log(q-1,q)-x*log(x,q)-(1-x)*log(1-x,q)
return H
def local_coordinates_at_infinity(self, prec=20, name='t'):
"""
For the genus `g` hyperelliptic curve `y^2 = f(x)`, return
`(x(t), y(t))` such that `(y(t))^2 = f(x(t))`, where `t = x^g/y` is
the local parameter at infinity
INPUT:
- ``prec`` -- desired precision of the local coordinates
- ``name`` -- generator of the power series ring (default: ``t``)
OUTPUT:
`(x(t),y(t))` such that `y(t)^2 = f(x(t))` and `t = x^g/y`
is the local parameter at infinity
EXAMPLES::
sage: R.<x> = QQ['x']
sage: H = HyperellipticCurve(x^5-5*x^2+1)
sage: x,y = H.local_coordinates_at_infinity(10)
sage: x
t^-2 + 5*t^4 - t^8 - 50*t^10 + O(t^12)
sage: y
t^-5 + 10*t - 2*t^5 - 75*t^7 + 50*t^11 + O(t^12)
::
sage: R.<x> = QQ['x']
sage: H = HyperellipticCurve(x^3-x+1)
sage: x,y = H.local_coordinates_at_infinity(10)
sage: x
t^-2 + t^2 - t^4 - t^6 + 3*t^8 + O(t^12)
sage: y
t^-3 + t - t^3 - t^5 + 3*t^7 - 10*t^11 + O(t^12)
Note: if even degree model, just returns local coordinate above one point
AUTHOR:
- Jennifer Balakrishnan (2007-12)
"""
g = self.genus()
pol = self.hyperelliptic_polynomials()[0]
K = LaurentSeriesRing(self.base_ring(), name)
t = K.gen()
K.set_default_prec(prec + 2)
L = PolynomialRing(K, 'x')
x = L.gen()
i = 0
w = (x**g / t)**2 - pol
wprime = w.derivative(x)
if pol.degree() == 2 * g + 1:
x = t**-2
else:
x = t**-1
for i in range((RR(log(prec + 2) / log(2))).ceil()):
x = x - w(x) / wprime(x)
y = x**g / t
return x + O(t**(prec + 2)), y + O(t**(prec + 2))
def set_params(lam, k):
n = pow(2, ceil(log(lam**2 * k)/log(2))) # dim of poly ring, closest power of 2 to k(lam^2)
q = next_prime(ZZ(2)**(8*k*lam) * n**k, proof=False) # prime modulus
sigma = int(sqrt(lam * n))
sigma_prime = lam * int(n**(1.5))
return (n, q, sigma, sigma_prime, k)
def test_issue_4023():
from sage.symbolic.ring import SR
from sage.functions.all import log
from sympy import integrate, simplify
a, x = SR.var("a x")
i = integrate(log(x) / a, (x, a, a + 1))
i2 = simplify(i)
s = SR(i2)
assert s == (a * log(1 + a) - a * log(a) + log(1 + a) - 1) / a
def test_issue_4023():
from sage.symbolic.ring import SR
from sage.functions.all import log
from sympy import integrate, simplify
a,x = SR.var("a x")
i = integrate(log(x)/a, (x, a, a + 1))
i2 = simplify(i)
s = SR(i2)
assert s == (a*log(1 + a) - a*log(a) + log(1 + a) - 1)/a
def local_coordinates_at_nonweierstrass(self, P, prec=20, name='t'):
"""
For a non-Weierstrass point `P = (a,b)` on the hyperelliptic
curve `y^2 = f(x)`, return `(x(t), y(t))` such that `(y(t))^2 = f(x(t))`,
where `t = x - a` is the local parameter.
INPUT:
- ``P = (a, b)`` -- a non-Weierstrass point on self
- ``prec`` -- desired precision of the local coordinates
- ``name`` -- gen of the power series ring (default: ``t``)
OUTPUT:
`(x(t),y(t))` such that `y(t)^2 = f(x(t))` and `t = x - a`
is the local parameter at `P`
EXAMPLES::
sage: R.<x> = QQ['x']
sage: H = HyperellipticCurve(x^5-23*x^3+18*x^2+40*x)
sage: P = H(1,6)
sage: x,y = H.local_coordinates_at_nonweierstrass(P,prec=5)
sage: x
1 + t + O(t^5)
sage: y
6 + t - 7/2*t^2 - 1/2*t^3 - 25/48*t^4 + O(t^5)
sage: Q = H(-2,12)
sage: x,y = H.local_coordinates_at_nonweierstrass(Q,prec=5)
sage: x
-2 + t + O(t^5)
sage: y
12 - 19/2*t - 19/32*t^2 + 61/256*t^3 - 5965/24576*t^4 + O(t^5)
AUTHOR:
- Jennifer Balakrishnan (2007-12)
"""
d = P[1]
if d == 0:
raise TypeError(
"P = %s is a Weierstrass point. Use local_coordinates_at_weierstrass instead!"
% P)
pol = self.hyperelliptic_polynomials()[0]
L = PowerSeriesRing(self.base_ring(), name)
t = L.gen()
L.set_default_prec(prec)
K = PowerSeriesRing(L, 'x')
pol = K(pol)
x = K.gen()
b = P[0]
f = pol(t + b)
for i in range((RR(log(prec) / log(2))).ceil()):
d = (d + f / d) / 2
return t + b + O(t**(prec)), d + O(t**(prec))
def set_params(lam, k):
n = pow(2, ceil(
log(lam**2 * k) /
log(2))) # dim of poly ring, closest power of 2 to k(lam^2)
q = next_prime(ZZ(2)**(8 * k * lam) * n**k,
proof=False) # prime modulus
sigma = int(sqrt(lam * n))
sigma_prime = lam * int(n**(1.5))
return (n, q, sigma, sigma_prime, k)
def local_coordinates_at_infinity(self, prec = 20, name = 't'):
"""
For the genus `g` hyperelliptic curve `y^2 = f(x)`, return
`(x(t), y(t))` such that `(y(t))^2 = f(x(t))`, where `t = x^g/y` is
the local parameter at infinity
INPUT:
- ``prec`` -- desired precision of the local coordinates
- ``name`` -- generator of the power series ring (default: ``t``)
OUTPUT:
`(x(t),y(t))` such that `y(t)^2 = f(x(t))` and `t = x^g/y`
is the local parameter at infinity
EXAMPLES::
sage: R.<x> = QQ['x']
sage: H = HyperellipticCurve(x^5-5*x^2+1)
sage: x,y = H.local_coordinates_at_infinity(10)
sage: x
t^-2 + 5*t^4 - t^8 - 50*t^10 + O(t^12)
sage: y
t^-5 + 10*t - 2*t^5 - 75*t^7 + 50*t^11 + O(t^12)
::
sage: R.<x> = QQ['x']
sage: H = HyperellipticCurve(x^3-x+1)
sage: x,y = H.local_coordinates_at_infinity(10)
sage: x
t^-2 + t^2 - t^4 - t^6 + 3*t^8 + O(t^12)
sage: y
t^-3 + t - t^3 - t^5 + 3*t^7 - 10*t^11 + O(t^12)
AUTHOR:
- Jennifer Balakrishnan (2007-12)
"""
g = self.genus()
pol = self.hyperelliptic_polynomials()[0]
K = LaurentSeriesRing(self.base_ring(), name, default_prec=prec+2)
t = K.gen()
L = PolynomialRing(K,'x')
x = L.gen()
i = 0
w = (x**g/t)**2-pol
wprime = w.derivative(x)
x = t**-2
for i in range((RR(log(prec+2)/log(2))).ceil()):
x = x - w(x)/wprime(x)
y = x**g/t
return x+O(t**(prec+2)) , y+O(t**(prec+2))
def local_coordinates_at_nonweierstrass(self, P, prec=20, name='t'):
"""
For a non-Weierstrass point `P = (a,b)` on the hyperelliptic
curve `y^2 = f(x)`, return `(x(t), y(t))` such that `(y(t))^2 = f(x(t))`,
where `t = x - a` is the local parameter.
INPUT:
- ``P = (a, b)`` -- a non-Weierstrass point on self
- ``prec`` -- desired precision of the local coordinates
- ``name`` -- gen of the power series ring (default: ``t``)
OUTPUT:
`(x(t),y(t))` such that `y(t)^2 = f(x(t))` and `t = x - a`
is the local parameter at `P`
EXAMPLES::
sage: R.<x> = QQ['x']
sage: H = HyperellipticCurve(x^5-23*x^3+18*x^2+40*x)
sage: P = H(1,6)
sage: x,y = H.local_coordinates_at_nonweierstrass(P,prec=5)
sage: x
1 + t + O(t^5)
sage: y
6 + t - 7/2*t^2 - 1/2*t^3 - 25/48*t^4 + O(t^5)
sage: Q = H(-2,12)
sage: x,y = H.local_coordinates_at_nonweierstrass(Q,prec=5)
sage: x
-2 + t + O(t^5)
sage: y
12 - 19/2*t - 19/32*t^2 + 61/256*t^3 - 5965/24576*t^4 + O(t^5)
AUTHOR:
- Jennifer Balakrishnan (2007-12)
"""
d = P[1]
if d == 0:
raise TypeError("P = %s is a Weierstrass point. Use local_coordinates_at_weierstrass instead!"%P)
pol = self.hyperelliptic_polynomials()[0]
L = PowerSeriesRing(self.base_ring(), name)
t = L.gen()
L.set_default_prec(prec)
K = PowerSeriesRing(L, 'x')
pol = K(pol)
x = K.gen()
b = P[0]
f = pol(t+b)
for i in range((RR(log(prec)/log(2))).ceil()):
d = (d + f/d)/2
return t+b+O(t**(prec)), d + O(t**(prec))
def local_coordinates_at_weierstrass(self, P, prec=20, name='t'):
"""
For a finite Weierstrass point on the hyperelliptic
curve y^2 = f(x), returns (x(t), y(t)) such that
(y(t))^2 = f(x(t)), where t = y is the local parameter.
INPUT:
- P a finite Weierstrass point on self
- prec: desired precision of the local coordinates
- name: gen of the power series ring (default: 't')
OUTPUT:
(x(t),y(t)) such that y(t)^2 = f(x(t)) and t = y
is the local parameter at P
EXAMPLES:
sage: R.<x> = QQ['x']
sage: H = HyperellipticCurve(x^5-23*x^3+18*x^2+40*x)
sage: A = H(4,0)
sage: x,y = H.local_coordinates_at_weierstrass(A,prec =5)
sage: x
4 + 1/360*t^2 - 191/23328000*t^4 + 7579/188956800000*t^6 + O(t^7)
sage: y
t + O(t^7)
sage: B = H(-5,0)
sage: x,y = H.local_coordinates_at_weierstrass(B,prec = 5)
sage: x
-5 + 1/1260*t^2 + 887/2000376000*t^4 + 643759/1587898468800000*t^6 + O(t^7)
sage: y
t + O(t^7)
AUTHOR:
- Jennifer Balakrishnan (2007-12)
"""
if P[1] != 0:
raise TypeError, "P = %s is not a finite Weierstrass point. Use local_coordinates_at_nonweierstrass instead!" % P
pol = self.hyperelliptic_polynomials()[0]
L = PowerSeriesRing(self.base_ring(), name)
t = L.gen()
L.set_default_prec(prec + 2)
K = PowerSeriesRing(L, 'x')
pol = K(pol)
x = K.gen()
b = P[0]
g = pol / (x - b)
c = b + 1 / g(b) * t**2
f = pol - t**2
fprime = f.derivative()
for i in range((RR(log(prec + 2) / log(2))).ceil()):
c = c - f(c) / fprime(c)
return c + O(t**(prec + 2)), t + O(t**(prec + 2))
def local_coordinates_at_weierstrass(self, P, prec=20, name="t"):
"""
For a finite Weierstrass point on the hyperelliptic
curve y^2 = f(x), returns (x(t), y(t)) such that
(y(t))^2 = f(x(t)), where t = y is the local parameter.
INPUT:
- P a finite Weierstrass point on self
- prec: desired precision of the local coordinates
- name: gen of the power series ring (default: 't')
OUTPUT:
(x(t),y(t)) such that y(t)^2 = f(x(t)) and t = y
is the local parameter at P
EXAMPLES:
sage: R.<x> = QQ['x']
sage: H = HyperellipticCurve(x^5-23*x^3+18*x^2+40*x)
sage: A = H(4,0)
sage: x,y = H.local_coordinates_at_weierstrass(A,prec =5)
sage: x
4 + 1/360*t^2 - 191/23328000*t^4 + 7579/188956800000*t^6 + O(t^7)
sage: y
t + O(t^7)
sage: B = H(-5,0)
sage: x,y = H.local_coordinates_at_weierstrass(B,prec = 5)
sage: x
-5 + 1/1260*t^2 + 887/2000376000*t^4 + 643759/1587898468800000*t^6 + O(t^7)
sage: y
t + O(t^7)
AUTHOR:
- Jennifer Balakrishnan (2007-12)
"""
if P[1] != 0:
raise TypeError, "P = %s is not a finite Weierstrass point. Use local_coordinates_at_nonweierstrass instead!" % P
pol = self.hyperelliptic_polynomials()[0]
L = PowerSeriesRing(self.base_ring(), name)
t = L.gen()
L.set_default_prec(prec + 2)
K = PowerSeriesRing(L, "x")
pol = K(pol)
x = K.gen()
b = P[0]
g = pol / (x - b)
c = b + 1 / g(b) * t ** 2
f = pol - t ** 2
fprime = f.derivative()
for i in range((RR(log(prec + 2) / log(2))).ceil()):
c = c - f(c) / fprime(c)
return c + O(t ** (prec + 2)), t + O(t ** (prec + 2))
def local_coordinates_at_infinity(self, prec=20, name='t'):
"""
For the genus g hyperelliptic curve y^2 = f(x), returns (x(t), y(t)) such that
(y(t))^2 = f(x(t)), where t = x^g/y is the local parameter at infinity
INPUT:
- prec: desired precision of the local coordinates
- name: gen of the power series ring (default: 't')
OUTPUT:
(x(t),y(t)) such that y(t)^2 = f(x(t)) and t = x^g/y
is the local parameter at infinity
EXAMPLES:
sage: R.<x> = QQ['x']
sage: H = HyperellipticCurve(x^5-5*x^2+1)
sage: x,y = H.local_coordinates_at_infinity(10)
sage: x
t^-2 + 5*t^4 - t^8 - 50*t^10 + O(t^12)
sage: y
t^-5 + 10*t - 2*t^5 - 75*t^7 + 50*t^11 + O(t^12)
sage: R.<x> = QQ['x']
sage: H = HyperellipticCurve(x^3-x+1)
sage: x,y = H.local_coordinates_at_infinity(10)
sage: x
t^-2 + t^2 - t^4 - t^6 + 3*t^8 + O(t^12)
sage: y
t^-3 + t - t^3 - t^5 + 3*t^7 - 10*t^11 + O(t^12)
AUTHOR:
- Jennifer Balakrishnan (2007-12)
"""
g = self.genus()
pol = self.hyperelliptic_polynomials()[0]
K = LaurentSeriesRing(self.base_ring(), name)
t = K.gen()
K.set_default_prec(prec + 2)
L = PolynomialRing(self.base_ring(), 'x')
x = L.gen()
i = 0
w = (x**g / t)**2 - pol
wprime = w.derivative(x)
x = t**-2
for i in range((RR(log(prec + 2) / log(2))).ceil()):
x = x - w(x) / wprime(x)
y = x**g / t
return x + O(t**(prec + 2)), y + O(t**(prec + 2))
def local_coordinates_at_infinity(self, prec=20, name="t"):
"""
For the genus g hyperelliptic curve y^2 = f(x), returns (x(t), y(t)) such that
(y(t))^2 = f(x(t)), where t = x^g/y is the local parameter at infinity
INPUT:
- prec: desired precision of the local coordinates
- name: gen of the power series ring (default: 't')
OUTPUT:
(x(t),y(t)) such that y(t)^2 = f(x(t)) and t = x^g/y
is the local parameter at infinity
EXAMPLES:
sage: R.<x> = QQ['x']
sage: H = HyperellipticCurve(x^5-5*x^2+1)
sage: x,y = H.local_coordinates_at_infinity(10)
sage: x
t^-2 + 5*t^4 - t^8 - 50*t^10 + O(t^12)
sage: y
t^-5 + 10*t - 2*t^5 - 75*t^7 + 50*t^11 + O(t^12)
sage: R.<x> = QQ['x']
sage: H = HyperellipticCurve(x^3-x+1)
sage: x,y = H.local_coordinates_at_infinity(10)
sage: x
t^-2 + t^2 - t^4 - t^6 + 3*t^8 + O(t^12)
sage: y
t^-3 + t - t^3 - t^5 + 3*t^7 - 10*t^11 + O(t^12)
AUTHOR:
- Jennifer Balakrishnan (2007-12)
"""
g = self.genus()
pol = self.hyperelliptic_polynomials()[0]
K = LaurentSeriesRing(self.base_ring(), name)
t = K.gen()
K.set_default_prec(prec + 2)
L = PolynomialRing(self.base_ring(), "x")
x = L.gen()
i = 0
w = (x ** g / t) ** 2 - pol
wprime = w.derivative(x)
x = t ** -2
for i in range((RR(log(prec + 2) / log(2))).ceil()):
x = x - w(x) / wprime(x)
y = x ** g / t
return x + O(t ** (prec + 2)), y + O(t ** (prec + 2))
def is_supersingular(E):
p = E.base_field().characteristic()
j = E.j_invariant()
if not j in GF(p**2):
return False
if p <= 3:
return j == 0
F = ClassicalModularPolynomialDatabase()[2]
x = PolynomialRing(GF(p**2), 'x').gen()
f = F(x, j)
roots = [i[0] for i in f.roots() for _ in range(i[1])]
if len(roots) < 3:
return False
vertices = [j, j, j]
m = floor(log(p, 2)) + 1
for k in range(1, m + 1):
for i in range(3):
f = F(x, roots[i])
g = x - vertices[i]
a = f.quo_rem(g)[0]
vertices[i] = roots[i]
attempt = a.roots()
if len(attempt) == 0:
return False
roots[i] = attempt[0][0]
return True
def dimension_upper_bound(n,d,q,algorithm=None):
r"""
Returns an upper bound for the dimension of a linear code.
Returns an upper bound `B(n,d) = B_q(n,d)` for the
dimension of a linear code of length n, minimum distance d over a
field of size q.
Parameter "algorithm" has the same meaning as in :func:`codesize_upper_bound`
EXAMPLES::
sage: codes.bounds.dimension_upper_bound(10,3,2)
6
sage: codes.bounds.dimension_upper_bound(30,15,4)
13
sage: codes.bounds.dimension_upper_bound(30,15,4,algorithm="LP")
12
TESTS:
Meaningless code parameters are rejected::
sage: codes.bounds.dimension_upper_bound(13,3,6)
Traceback (most recent call last):
...
ValueError: The alphabet size does not make sense for a code over a field
"""
_check_n_q_d(n, q, d)
q = ZZ(q)
if algorithm=="LP":
return delsarte_bound_additive_hamming_space(n,d,q)
else: # algorithm==None or algorithm=="gap":
return int(log(codesize_upper_bound(n,d,q,algorithm=algorithm),q))
def entropy(x, q=2):
"""
Computes the entropy at `x` on the `q`-ary symmetric channel.
INPUT:
- ``x`` - real number in the interval `[0, 1]`.
- ``q`` - (default: 2) integer greater than 1. This is the base of the
logarithm.
EXAMPLES::
sage: codes.bounds.entropy(0, 2)
0
sage: codes.bounds.entropy(1/5,4)
1/5*log(3)/log(4) - 4/5*log(4/5)/log(4) - 1/5*log(1/5)/log(4)
sage: codes.bounds.entropy(1, 3)
log(2)/log(3)
Check that values not within the limits are properly handled::
sage: codes.bounds.entropy(1.1, 2)
Traceback (most recent call last):
...
ValueError: The entropy function is defined only for x in the interval [0, 1]
sage: codes.bounds.entropy(1, 1)
Traceback (most recent call last):
...
ValueError: The value q must be an integer greater than 1
"""
if x < 0 or x > 1:
raise ValueError("The entropy function is defined only for x in the"
" interval [0, 1]")
q = ZZ(q) # This will error out if q is not an integer
if q < 2: # Here we check that q is actually at least 2
raise ValueError("The value q must be an integer greater than 1")
if x == 0:
return 0
if x == 1:
return log(q - 1, q)
H = x * log(q - 1, q) - x * log(x, q) - (1 - x) * log(1 - x, q)
return H
def entropy(x, q=2):
"""
Computes the entropy at `x` on the `q`-ary symmetric channel.
INPUT:
- ``x`` - real number in the interval `[0, 1]`.
- ``q`` - (default: 2) integer greater than 1. This is the base of the
logarithm.
EXAMPLES::
sage: codes.bounds.entropy(0, 2)
0
sage: codes.bounds.entropy(1/5,4)
1/5*log(3)/log(4) - 4/5*log(4/5)/log(4) - 1/5*log(1/5)/log(4)
sage: codes.bounds.entropy(1, 3)
log(2)/log(3)
Check that values not within the limits are properly handled::
sage: codes.bounds.entropy(1.1, 2)
Traceback (most recent call last):
...
ValueError: The entropy function is defined only for x in the interval [0, 1]
sage: codes.bounds.entropy(1, 1)
Traceback (most recent call last):
...
ValueError: The value q must be an integer greater than 1
"""
if x < 0 or x > 1:
raise ValueError("The entropy function is defined only for x in the"
" interval [0, 1]")
q = ZZ(q) # This will error out if q is not an integer
if q < 2: # Here we check that q is actually at least 2
raise ValueError("The value q must be an integer greater than 1")
if x == 0:
return 0
if x == 1:
return log(q-1,q)
H = x*log(q-1,q)-x*log(x,q)-(1-x)*log(1-x,q)
return H
def local_coordinates_at_weierstrass(self, P, prec=20, name='t'):
"""
For a finite Weierstrass point on the hyperelliptic
curve y^2 = f(x), returns (x(t), y(t)) such that
(y(t))^2 = f(x(t)), where t = y is the local parameter.
INPUT:
- P a finite Weierstrass point on self
- prec: desired precision of the local coordinates
- name: gen of the power series ring (default: 't')
OUTPUT:
(x(t),y(t)) such that y(t)^2 = f(x(t)) and t = y
is the local parameter at P
EXAMPLES:
sage: R.<x> = QQ['x']
sage: H = HyperellipticCurve(x^5-23*x^3+18*x^2+40*x)
sage: A = H(4, 0)
sage: x, y = H.local_coordinates_at_weierstrass(A, prec=7)
sage: x
4 + 1/360*t^2 - 191/23328000*t^4 + 7579/188956800000*t^6 + O(t^7)
sage: y
t + O(t^7)
sage: B = H(-5, 0)
sage: x, y = H.local_coordinates_at_weierstrass(B, prec=5)
sage: x
-5 + 1/1260*t^2 + 887/2000376000*t^4 + O(t^5)
sage: y
t + O(t^5)
AUTHOR:
- Jennifer Balakrishnan (2007-12)
- Francis Clarke (2012-08-26)
"""
if P[1] != 0:
raise TypeError(
"P = %s is not a finite Weierstrass point. Use local_coordinates_at_nonweierstrass instead!"
% P)
L = PowerSeriesRing(self.base_ring(), name)
t = L.gen()
pol = self.hyperelliptic_polynomials()[0]
pol_prime = pol.derivative()
b = P[0]
t2 = t**2
c = b + t2 / pol_prime(b)
c = c.add_bigoh(prec)
for _ in range(1 + log(prec, 2)):
c -= (pol(c) - t2) / pol_prime(c)
return (c, t.add_bigoh(prec))
def local_coordinates_at_weierstrass(self, P, prec=20, name="t"):
"""
For a finite Weierstrass point on the hyperelliptic
curve y^2 = f(x), returns (x(t), y(t)) such that
(y(t))^2 = f(x(t)), where t = y is the local parameter.
INPUT:
- P a finite Weierstrass point on self
- prec: desired precision of the local coordinates
- name: gen of the power series ring (default: 't')
OUTPUT:
(x(t),y(t)) such that y(t)^2 = f(x(t)) and t = y
is the local parameter at P
EXAMPLES:
sage: R.<x> = QQ['x']
sage: H = HyperellipticCurve(x^5-23*x^3+18*x^2+40*x)
sage: A = H(4, 0)
sage: x, y = H.local_coordinates_at_weierstrass(A, prec=7)
sage: x
4 + 1/360*t^2 - 191/23328000*t^4 + 7579/188956800000*t^6 + O(t^7)
sage: y
t + O(t^7)
sage: B = H(-5, 0)
sage: x, y = H.local_coordinates_at_weierstrass(B, prec=5)
sage: x
-5 + 1/1260*t^2 + 887/2000376000*t^4 + O(t^5)
sage: y
t + O(t^5)
AUTHOR:
- Jennifer Balakrishnan (2007-12)
- Francis Clarke (2012-08-26)
"""
if P[1] != 0:
raise TypeError, "P = %s is not a finite Weierstrass point. Use local_coordinates_at_nonweierstrass instead!" % P
L = PowerSeriesRing(self.base_ring(), name)
t = L.gen()
pol = self.hyperelliptic_polynomials()[0]
pol_prime = pol.derivative()
b = P[0]
t2 = t ** 2
c = b + t2 / pol_prime(b)
c = c.add_bigoh(prec)
for _ in range(1 + log(prec, 2)):
c -= (pol(c) - t2) / pol_prime(c)
return (c, t.add_bigoh(prec))
def gv_info_rate(n, delta, q):
"""
GV lower bound for information rate of a q-ary code of length n
minimum distance delta\*n
EXAMPLES::
sage: RDF(codes.bounds.gv_info_rate(100,1/4,3)) # abs tol 1e-15
0.36704992608261894
"""
q = ZZ(q)
ans = log(gilbert_lower_bound(n, q, int(n * delta)), q) / n
return ans
def gv_info_rate(n,delta,q):
"""
GV lower bound for information rate of a q-ary code of length n
minimum distance delta\*n
EXAMPLES::
sage: RDF(gv_info_rate(100,1/4,3))
0.367049926083
"""
q = ZZ(q)
ans=log(gilbert_lower_bound(n,q,int(n*delta)),q)/n
return ans
def dimension_upper_bound(n,d,q):
r"""
Returns an upper bound `B(n,d) = B_q(n,d)` for the
dimension of a linear code of length n, minimum distance d over a
field of size q.
EXAMPLES::
sage: dimension_upper_bound(10,3,2)
6
"""
q = ZZ(q)
return int(log(codesize_upper_bound(n,d,q),q))
def dimension_upper_bound(n, d, q):
r"""
Returns an upper bound `B(n,d) = B_q(n,d)` for the
dimension of a linear code of length n, minimum distance d over a
field of size q.
EXAMPLES::
sage: dimension_upper_bound(10,3,2)
6
"""
q = ZZ(q)
return int(log(codesize_upper_bound(n, d, q), q))
def gv_info_rate(n,delta,q):
"""
The Gilbert-Varshamov lower bound for information rate.
The Gilbert-Varshamov lower bound for information rate of a `q`-ary code of
length `n` and minimum distance `n\delta`.
EXAMPLES::
sage: RDF(codes.bounds.gv_info_rate(100,1/4,3)) # abs tol 1e-15
0.36704992608261894
"""
q = ZZ(q)
ans=log(gilbert_lower_bound(n,q,int(n*delta)),q)/n
return ans
def dimension_upper_bound(n, d, q, algorithm=None):
r"""
Returns an upper bound `B(n,d) = B_q(n,d)` for the
dimension of a linear code of length n, minimum distance d over a
field of size q.
Parameter "algorithm" has the same meaning as in :func:`codesize_upper_bound`
EXAMPLES::
sage: codes.bounds.dimension_upper_bound(10,3,2)
6
sage: codes.bounds.dimension_upper_bound(30,15,4)
13
sage: codes.bounds.dimension_upper_bound(30,15,4,algorithm="LP")
12
"""
q = ZZ(q)
if algorithm == "LP":
return delsarte_bound_additive_hamming_space(n, d, q)
else: # algorithm==None or algorithm=="gap":
return int(log(codesize_upper_bound(n, d, q, algorithm=algorithm), q))
def dimension_upper_bound(n,d,q,algorithm=None):
r"""
Returns an upper bound `B(n,d) = B_q(n,d)` for the
dimension of a linear code of length n, minimum distance d over a
field of size q.
Parameter "algorithm" has the same meaning as in :func:`codesize_upper_bound`
EXAMPLES::
sage: codes.bounds.dimension_upper_bound(10,3,2)
6
sage: codes.bounds.dimension_upper_bound(30,15,4)
13
sage: codes.bounds.dimension_upper_bound(30,15,4,algorithm="LP")
12
"""
q = ZZ(q)
if algorithm=="LP":
return delsarte_bound_additive_hamming_space(n,d,q)
else: # algorithm==None or algorithm=="gap":
return int(log(codesize_upper_bound(n,d,q,algorithm=algorithm),q))
def topological_entropy(self, n):
r"""
Return the topological entropy for the factors of length n.
The topological entropy of a sequence `u` is defined as the
exponential growth rate of the complexity of `u` as the length
increases: `H_{top}(u)=\lim_{n\to\infty}\frac{\log_d(p_u(n))}{n}`
where `d` denotes the cardinality of the alphabet and `p_u(n)` is
the complexity function, i.e. the number of factors of length `n`
in the sequence `u` [1].
INPUT:
- ``self`` - a word defined over a finite alphabet
- ``n`` - positive integer
OUTPUT:
real number (a symbolic expression)
EXAMPLES::
sage: W = Words([0, 1])
sage: w = W([0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1])
sage: t = w.topological_entropy(3); t
1/3*log(7)/log(2)
sage: n(t)
0.935784974019201
::
sage: w = words.ThueMorseWord()[:100]
sage: topo = w.topological_entropy
sage: for i in range(0, 41, 5): print i, n(topo(i), digits=5)
0 1.0000
5 0.71699
10 0.48074
15 0.36396
20 0.28774
25 0.23628
30 0.20075
35 0.17270
40 0.14827
If no alphabet is specified, an error is raised::
sage: w = Word(range(20))
sage: w.topological_entropy(3)
Traceback (most recent call last):
...
TypeError: The word must be defined over a finite alphabet
The following is ok::
sage: W = Words(range(20))
sage: w = W(range(20))
sage: w.topological_entropy(3)
1/3*log(18)/log(20)
REFERENCES:
[1] N. Pytheas Fogg, Substitutions in Dynamics, Arithmetics,
and Combinatorics, Lecture Notes in Mathematics 1794, Springer
Verlag. V. Berthe, S. Ferenczi, C. Mauduit and A. Siegel, Eds.
(2002).
"""
d = self.parent().size_of_alphabet()
if d is Infinity:
raise TypeError, "The word must be defined over a finite alphabet"
if n == 0:
return 1
pn = self.number_of_factors(n)
from sage.functions.all import log
return log(pn, base=d)/n
def diffop(word):
dlog = [Rat(log(a).diff().canonicalize_radical()) for a in word]
factors = [(Dx - sum(dlog[:i])) for i in range(len(dlog))]
dop = prod(reversed([(Dx - sum(dlog[:i])) for i in range(len(dlog) + 1)]))
dop = dop.numerator()
return dop
