def translation_length(self): #UHP r""" For hyperbolic elements, return the translation length; otherwise, raise a ``ValueError``. EXAMPLES:: sage: UHP = HyperbolicPlane().UHP() sage: UHP.get_isometry(matrix(2,[2,0,0,1/2])).translation_length() 2*arccosh(5/4) :: sage: H = UHP.isometry_from_fixed_points(-1,1) sage: p = UHP.get_point(exp(i*7*pi/8)) sage: Hp = H(p) sage: bool((UHP.dist(p, Hp) - H.translation_length()) < 10**-9) True """ d = sqrt(self._matrix.det()**2) tau = sqrt((self._matrix / sqrt(d)).trace()**2) if self.classification() in [ 'hyperbolic', 'orientation-reversing hyperbolic' ]: return 2 * arccosh(tau / 2) raise TypeError( "translation length is only defined for hyperbolic transformations" )
def _derivative_(self, n, z, m, diff_param): """ EXAMPLES:: sage: n,z,m = var('n,z,m') sage: elliptic_pi(n,z,m).diff(n) 1/4*(sqrt(-m*sin(z)^2 + 1)*n*sin(2*z)/(n*sin(z)^2 - 1) + 2*(m - n)*elliptic_f(z, m)/n + 2*(n^2 - m)*elliptic_pi(n, z, m)/n + 2*elliptic_e(z, m))/((m - n)*(n - 1)) sage: elliptic_pi(n,z,m).diff(z) -1/(sqrt(-m*sin(z)^2 + 1)*(n*sin(z)^2 - 1)) sage: elliptic_pi(n,z,m).diff(m) 1/4*(m*sin(2*z)/(sqrt(-m*sin(z)^2 + 1)*(m - 1)) - 2*elliptic_e(z, m)/(m - 1) - 2*elliptic_pi(n, z, m))/(m - n) """ if diff_param == 0: return ((Integer(1) / (Integer(2) * (m - n) * (n - Integer(1)))) * (elliptic_e(z, m) + ((m - n) / n) * elliptic_f(z, m) + ((n**Integer(2) - m) / n) * elliptic_pi(n, z, m) - (n * sqrt(Integer(1) - m * sin(z)**Integer(2)) * sin(Integer(2) * z)) / (Integer(2) * (Integer(1) - n * sin(z)**Integer(2))))) elif diff_param == 1: return (Integer(1) / (sqrt(Integer(1) - m * sin(z)**Integer(Integer(2))) * (Integer(1) - n * sin(z)**Integer(2)))) elif diff_param == 2: return ((Integer(1) / (Integer(2) * (n - m))) * ( elliptic_e(z, m) / (m - Integer(1)) + elliptic_pi(n, z, m) - (m * sin(Integer(2) * z)) / (Integer(2) * (m - Integer(1)) * sqrt(Integer(1) - m * sin(z)**Integer(2)))) )
def _derivative_(self, u, m, diff_param): """ EXAMPLES:: sage: x,m = var('x,m') sage: elliptic_eu(x,m).diff(x) sqrt(-m*jacobi_sn(x, m)^2 + 1)*jacobi_dn(x, m) sage: elliptic_eu(x,m).diff(m) 1/2*(elliptic_eu(x, m) - elliptic_f(jacobi_am(x, m), m))/m - 1/2*(m*jacobi_cn(x, m)*jacobi_sn(x, m) - (m - 1)*x - elliptic_eu(x, m)*jacobi_dn(x, m))*sqrt(-m*jacobi_sn(x, m)^2 + 1)/((m - 1)*m) """ from sage.functions.jacobi import jacobi, jacobi_am if diff_param == 0: return (sqrt(-m * jacobi('sn', u, m)**Integer(2) + Integer(1)) * jacobi('dn', u, m)) elif diff_param == 1: return (Integer(1) / Integer(2) * (elliptic_eu(u, m) - elliptic_f(jacobi_am(u, m), m)) / m - Integer(1) / Integer(2) * sqrt(-m * jacobi('sn', u, m)**Integer(2) + Integer(1)) * (m * jacobi('sn', u, m) * jacobi('cn', u, m) - (m - Integer(1)) * u - elliptic_eu(u, m) * jacobi('dn', u, m)) / ((m - Integer(1)) * m))
def __eq__(self, other): r""" Return ``True`` if the isometries are the same and ``False`` otherwise. EXAMPLES:: sage: UHP = HyperbolicPlane().UHP() sage: A = UHP.get_isometry(identity_matrix(2)) sage: B = UHP.get_isometry(-identity_matrix(2)) sage: A == B True sage: HM = HyperbolicPlane().HM() sage: A = HM.random_isometry() sage: A == A True """ if not isinstance(other, HyperbolicIsometry): return False test_matrix = bool((self.matrix() - other.matrix()).norm() < EPSILON) if self.domain().is_isometry_group_projective(): A, B = self.matrix(), other.matrix() # Rename for simplicity m = self.matrix().ncols() A = A / sqrt(A.det(), m) # Normalized to have determinant 1 B = B / sqrt(B.det(), m) test_matrix = ((A - B).norm() < EPSILON or (A + B).norm() < EPSILON) return self.domain() is other.domain() and test_matrix
def SO21_to_SL2R(M): r""" A homomorphism from `SO(2, 1)` to `SL(2, \RR)`. Note that this is not the only homomorphism, but it is the only one that works in the context of the implemented 2D hyperbolic geometry models. EXAMPLES:: sage: from sage.geometry.hyperbolic_space.hyperbolic_coercion import SO21_to_SL2R sage: (SO21_to_SL2R(identity_matrix(3)) - identity_matrix(2)).norm() < 10**-4 True """ #################################################################### # SL(2,R) is the double cover of SO (2,1)^+, so we need to choose # # a lift. I have formulas for the absolute values of each entry # # a,b ,c,d of the lift matrix(2,[a,b,c,d]), but we need to choose # # one entry to be positive. I choose d for no particular reason, # # unless d = 0, then we choose c > 0. The basic strategy for this # # function is to find the linear map induced by the SO(2,1) # # element on the Lie algebra sl(2, R). This corresponds to the # # Adjoint action by a matrix A or -A in SL(2,R). To find which # # matrix let X,Y,Z be a basis for sl(2,R) and look at the images # # of X,Y,Z as well as the second and third standard basis vectors # # for 2x2 matrices (these are traceless, so are in the Lie # # algebra). These corresponds to AXA^-1 etc and give formulas # # for the entries of A. # #################################################################### (m_1, m_2, m_3, m_4, m_5, m_6, m_7, m_8, m_9) = M.list() d = sqrt( Integer(1) / Integer(2) * m_5 - Integer(1) / Integer(2) * m_6 - Integer(1) / Integer(2) * m_8 + Integer(1) / Integer(2) * m_9) if M.det() > 0: # EPSILON? det_sign = 1 elif M.det() < 0: # EPSILON? det_sign = -1 if d > 0: # EPSILON? c = (-Integer(1) / Integer(2) * m_4 + Integer(1) / Integer(2) * m_7) / d b = (-Integer(1) / Integer(2) * m_2 + Integer(1) / Integer(2) * m_3) / d ad = det_sign * 1 + b * c # ad - bc = pm 1 a = ad / d else: # d is 0, so we make c > 0 c = sqrt(-Integer(1) / Integer(2) * m_5 - Integer(1) / Integer(2) * m_6 + Integer(1) / Integer(2) * m_8 + Integer(1) / Integer(2) * m_9) d = (-Integer(1) / Integer(2) * m_4 + Integer(1) / Integer(2) * m_7) / c # d = 0, so ad - bc = -bc = pm 1. b = -(det_sign * 1) / c a = (Integer(1) / Integer(2) * m_4 + Integer(1) / Integer(2) * m_7) / b A = matrix(2, [a, b, c, d]) return A
def _eval_(self, n, m, theta, phi, **kwargs): r""" TESTS:: sage: x, y = var('x y') sage: spherical_harmonic(1, 2, x, y) 0 sage: spherical_harmonic(1, -2, x, y) 0 sage: spherical_harmonic(1/2, 2, x, y) spherical_harmonic(1/2, 2, x, y) sage: spherical_harmonic(3, 2, x, y) 1/8*sqrt(30)*sqrt(7)*cos(x)*e^(2*I*y)*sin(x)^2/sqrt(pi) sage: spherical_harmonic(3, 2, 1, 2) 1/8*sqrt(30)*sqrt(7)*cos(1)*e^(4*I)*sin(1)^2/sqrt(pi) sage: spherical_harmonic(3 + I, 2., 1, 2) -0.351154337307488 - 0.415562233975369*I Check that :trac:`20939` is fixed:: sage: ex = spherical_harmonic(3,2,1,2*pi/3) sage: QQbar(ex * sqrt(pi)/cos(1)/sin(1)^2).minpoly() x^4 + 105/32*x^2 + 11025/1024 Check whether :trac:`25034` yields correct results compared to Maxima:: sage: spherical_harmonic(1,1,pi/3,pi/6).n() # abs tol 1e-14 0.259120612103502 + 0.149603355150537*I sage: maxima.spherical_harmonic(1,1,pi/3,pi/6).n() # abs tol 1e-14 0.259120612103502 + 0.149603355150537*I sage: spherical_harmonic(1,-1,pi/3,pi/6).n() # abs tol 1e-14 -0.259120612103502 + 0.149603355150537*I sage: maxima.spherical_harmonic(1,-1,pi/3,pi/6).n() # abs tol 1e-14 -0.259120612103502 + 0.149603355150537*I """ if n in ZZ and m in ZZ and n > -1: if abs(m) > n: return ZZ(0) if m == 0 and theta.is_zero(): return sqrt((2 * n + 1) / 4 / pi) from sage.arith.misc import factorial from sage.functions.trig import cos from sage.functions.orthogonal_polys import gen_legendre_P return (sqrt( factorial(n - m) * (2 * n + 1) / (4 * pi * factorial(n + m))) * exp(I * m * phi) * gen_legendre_P(n, m, cos(theta)) * (-1)**m).simplify_trig()
def solve_degree2_to_integer_range(a, b, c): r""" Returns the greatest integer range `[i_1, i_2]` such that `i_1 > x_1` and `i_2 < x_2` where `x_1, x_2` are the two zeroes of the equation in `x`: `ax^2+bx+c=0`. If there is no real solution to the equation, it returns an empty range with negative coefficients. INPUT: - ``a``, ``b`` and ``c`` -- coefficients of a second degree equation, ``a`` being the coefficient of the higher degree term. EXAMPLES:: sage: from sage.coding.guruswami_sudan.utils import solve_degree2_to_integer_range sage: solve_degree2_to_integer_range(1, -5, 1) (1, 4) If there is no real solution:: sage: solve_degree2_to_integer_range(50, 5, 42) (-2, -1) """ D = b**2 - 4 * a * c if D < 0: return (-2, -1) sD = float(sqrt(D)) minx, maxx = (-b - sD) / 2.0 / a, (-b + sD) / 2.0 / a mini, maxi = (ligt(minx), gilt(maxx)) if mini > maxi: return (-2, -1) else: return (mini, maxi)
def _base(j, k, c): assert k - j == 1 aajk = subbasis(j, k) assert all(a.order() in (1, p) for a in aajk) idxs = [i for i, a in enumerate(aajk) if a.order() == p] rs = [([0], [0]) for i in range(len(aajk))] for i in range(len(idxs)): rs[idxs[i]] = (range(p), [0]) if i % 2 else ([0], range(p)) if len(idxs) % 2: m = ceil(sqrt(p)) rs[idxs[-1]] = range(0, p, m), range(m) tab = {} for x in iproduct(*(r for r, _ in rs)): key = dotprod(x, aajk) if hasattr(key, 'set_immutable'): key.set_immutable() tab[key] = vector(x) for y in iproduct(*(r for _, r in rs)): key = c - dotprod(y, aajk) if hasattr(key, 'set_immutable'): key.set_immutable() if key in tab: return tab[key] + vector(y) raise TypeError('Not in group')
def _test_representation(self, **options): """ Check (on some elements) that ``self`` is a representation of the given semigroup. EXAMPLES:: sage: G = groups.permutation.Dihedral(4) sage: R = G.regular_representation() sage: R._test_representation() sage: G = CoxeterGroup(['A',4,1], base_ring=ZZ) sage: M = CombinatorialFreeModule(QQ, ['v']) sage: from sage.modules.with_basis.representation import Representation sage: on_basis = lambda g,m: M.term(m, (-1)**g.length()) sage: R = Representation(G, M, on_basis, side="right") sage: R._test_representation(max_runs=500) """ from sage.misc.functional import sqrt tester = self._tester(**options) S = tester.some_elements() L = [] max_len = int(sqrt(tester._max_runs)) + 1 for i, x in enumerate(self._semigroup): L.append(x) if i >= max_len: break for x in L: for y in L: for elt in S: if self._left_repr: tester.assertEqual(x * (y * elt), (x * y) * elt) else: tester.assertEqual((elt * y) * x, elt * (y * x))
def __init__(self, n, instance='key', m=None): """ Construct LWE instance parameterised by security parameter ``n`` where all other parameters are chosen as in [CGW2013]_. INPUT: - ``n`` - security parameter (integer >= 89) - ``instance`` - one of - "key" - the LWE-instance that hides the secret key is generated - "encrypt" - the LWE-instance that hides the message is generated (default: ``key``) - ``m`` - number of allowed samples or ``None`` in which case ``m`` is chosen as in [CGW2013]_. (default: ``None``) EXAMPLES:: sage: from sage.crypto.lwe import UniformNoiseLWE sage: UniformNoiseLWE(89) LWE(89, 64311834871, UniformSampler(0, 6577), 'noise', 131) sage: UniformNoiseLWE(89, instance='encrypt') LWE(131, 64311834871, UniformSampler(0, 11109), 'noise', 181) """ if n < 89: raise TypeError("Parameter too small") n2 = n C = 4 / sqrt(2 * pi) kk = floor((n2 - 2 * log(n2, 2)**2) / 5) n1 = (3 * n2 - 5 * kk) // 2 ke = floor((n1 - 2 * log(n1, 2)**2) / 5) l = (3 * n1 - 5 * ke) // 2 - n2 sk = ceil((C * (n1 + n2))**(ZZ(3) / 2)) se = ceil((C * (n1 + n2 + l))**(ZZ(3) / 2)) q = next_prime( max(ceil((4 * sk)**(ZZ(n1 + n2) / n1)), ceil((4 * se)**(ZZ(n1 + n2 + l) / (n2 + l))), ceil(4 * (n1 + n2) * se * sk + 4 * se + 1))) if kk <= 0: raise TypeError("Parameter too small") if instance == 'key': D = UniformSampler(0, sk - 1) if m is None: m = n1 LWE.__init__(self, n=n2, q=q, D=D, secret_dist='noise', m=m) elif instance == 'encrypt': D = UniformSampler(0, se - 1) if m is None: m = n2 + l LWE.__init__(self, n=n1, q=q, D=D, secret_dist='noise', m=m) else: raise TypeError("Parameter instance=%s not understood." % (instance))
def _2x2_matrix_entries(self, beta): r""" Young's representations are constructed by combining `2 \times 2`-matrices that depend on ``beta``. For the orthogonal representation, this is the following matrix:: [ -beta sqrt(1-beta^2) ] [ sqrt(1-beta^2) beta ] EXAMPLES:: sage: orth = SymmetricGroupRepresentation([2,1], "orthogonal") sage: orth._2x2_matrix_entries(1/2) (-1/2, 1/2*sqrt(3), 1/2*sqrt(3), 1/2) """ return (-beta, sqrt(1 - beta**2), sqrt(1 - beta**2), beta)
def __lalg__(self, D): r""" For positive `D`, this function evaluates the quotient `L(E_D,1)\cdot \sqrt(D)/\Omega_E` where `E_D` is the twist of `E` by `D`, `\Omega_E` is the least positive period of `E`. For negative `E`, it is the quotient `L(E_D,1)\cdot \sqrt(-D)/\Omega^{-}_E` where `\Omega^{-}_E` is the least positive imaginary part of a non-real period of `E`. EXAMPLES:: sage: E = EllipticCurve('11a1') sage: m = E.modular_symbol(sign=+1, implementation='sage') sage: m.__lalg__(1) 1/5 sage: m.__lalg__(3) 5/2 """ from sage.misc.functional import sqrt # the computation of the L-value could take a lot of time, # but then the conductor is so large # that the computation of modular symbols for E took even longer E = self._E ED = E.quadratic_twist(D) lv = ED.lseries().L_ratio( ) # this is L(ED,1) divided by the Néron period omD of ED lv *= ED.real_components() # now it is by the least positive period omD = ED.period_lattice().basis()[0] if D > 0: om = E.period_lattice().basis()[0] q = sqrt(D) * omD / om * 8 else: om = E.period_lattice().basis()[1].imag() if E.real_components() == 1: om *= 2 q = sqrt(-D) * omD / om * 8 # see padic_lseries.pAdicLeries._quotient_of_periods_to_twist # for the explanation of the second factor verbose('real approximation is %s' % q) return lv / 8 * QQ(q.round())
def _derivative_(self, x, diff_param=None): """ Derivative of erfc function. EXAMPLES:: sage: erfc(x).diff(x) -2*e^(-x^2)/sqrt(pi) """ return -2*exp(-x**2)/sqrt(pi)
def __init__(self, N, delta=0.01, m=None): """ Construct a Ring-LWE oracle in dimension ``n=phi(N)`` where the modulus ``q`` and the ``stddev`` of the noise is chosen as in [LP2011]_. INPUT: - ``N`` - index of cyclotomic polynomial (integer > 0, must be power of 2) - ``delta`` - error probability per symbol (default: 0.01) - ``m`` - number of allowed samples or ``None`` in which case ``3*n`` is used (default: ``None``) EXAMPLES:: sage: from sage.crypto.lwe import RingLindnerPeikert sage: RingLindnerPeikert(N=16) RingLWE(16, 1031, Discrete Gaussian sampler for polynomials of degree < 8 with σ=2.803372 in each component, x^8 + 1, 'noise', 24) """ n = euler_phi(N) if m is None: m = 3 * n # Find c>=1 such that c*exp((1-c**2)/2))**(2*n) == 2**-40 # i.e c>=1 such that 2*n*log(c)+n*(1-c**2) + 40*log(2) == 0 c = SR.var('c') c = find_root(2 * n * log(c) + n * (1 - c**2) + 40 * log(2) == 0, 1, 10) # Upper bound on s**2/t s_t_bound = (sqrt(2) * pi / c / sqrt(2 * n * log(2 / delta))).n() # Interpretation of "choose q just large enough to allow for a Gaussian parameter s>=8" in [LP2011]_ q = next_prime(floor(2**round(log(256 / s_t_bound, 2)))) # Gaussian parameter as defined in [LP2011]_ s = sqrt(s_t_bound * floor(q / 4)) # Transform s into stddev stddev = s / sqrt(2 * pi.n()) D = DiscreteGaussianDistributionPolynomialSampler(ZZ['x'], n, stddev) RingLWE.__init__(self, N=N, q=q, D=D, poly=None, secret_dist='noise', m=m)
def _derivative_(self, x, diff_param=None): """ Derivative of inverse erf function. EXAMPLES:: sage: erfinv(x).diff(x) 1/2*sqrt(pi)*e^(erfinv(x)^2) """ return sqrt(pi)*exp(erfinv(x)**2)/2
def __init__(self, n, delta=0.01, m=None): """ Construct LWE instance parameterised by security parameter ``n`` where the modulus ``q`` and the ``stddev`` of the noise is chosen as in [LP2011]_. INPUT: - ``n`` - security parameter (integer > 0) - ``delta`` - error probability per symbol (default: 0.01) - ``m`` - number of allowed samples or ``None`` in which case ``m=2*n + 128`` as in [LP2011]_ (default: ``None``) EXAMPLES:: sage: from sage.crypto.lwe import LindnerPeikert sage: LindnerPeikert(n=20) LWE(20, 2053, Discrete Gaussian sampler over the Integers with sigma = 3.600954 and c = 0, 'noise', 168) """ if m is None: m = 2 * n + 128 # Find c>=1 such that c*exp((1-c**2)/2))**(2*n) == 2**-40 # (c*exp((1-c**2)/2))**(2*n) == 2**-40 # log((c*exp((1-c**2)/2))**(2*n)) == -40*log(2) # (2*n)*log(c*exp((1-c**2)/2)) == -40*log(2) # 2*n*(log(c)+log(exp((1-c**2)/2))) == -40*log(2) # 2*n*(log(c)+(1-c**2)/2) == -40*log(2) # 2*n*log(c)+n*(1-c**2) == -40*log(2) # 2*n*log(c)+n*(1-c**2) + 40*log(2) == 0 c = SR.var('c') c = find_root(2 * n * log(c) + n * (1 - c**2) + 40 * log(2) == 0, 1, 10) # Upper bound on s**2/t s_t_bound = (sqrt(2) * pi / c / sqrt(2 * n * log(2 / delta))).n() # Interpretation of "choose q just large enough to allow for a Gaussian parameter s>=8" in [LP2011]_ q = next_prime(floor(2**round(log(256 / s_t_bound, 2)))) # Gaussian parameter as defined in [LP2011]_ s = sqrt(s_t_bound * floor(q / 4)) # Transform s into stddev stddev = s / sqrt(2 * pi.n()) D = DiscreteGaussianDistributionIntegerSampler(stddev) LWE.__init__(self, n=n, q=q, D=D, secret_dist='noise', m=m)
def _derivative_(self, z, m, diff_param): """ EXAMPLES:: sage: x,m = var('x,m') sage: elliptic_f(x,m).diff(x) 1/sqrt(-m*sin(x)^2 + 1) sage: elliptic_f(x,m).diff(m) -1/2*elliptic_f(x, m)/m + 1/4*sin(2*x)/(sqrt(-m*sin(x)^2 + 1)*(m - 1)) - 1/2*elliptic_e(x, m)/((m - 1)*m) """ if diff_param == 0: return Integer(1) / sqrt(Integer(1) - m * sin(z)**Integer(2)) elif diff_param == 1: return (elliptic_e(z, m) / (Integer(2) * (Integer(1) - m) * m) - elliptic_f(z, m) / (Integer(2) * m) - (sin(Integer(2) * z) / (Integer(4) * (Integer(1) - m) * sqrt(Integer(1) - m * sin(z)**Integer(2)))))
def _derivative_(self, x, diff_param=None): """ Derivative of erfi function. EXAMPLES:: sage: erfi(x).diff(x) 2*e^(x^2)/sqrt(pi) """ return 2*exp(x**2)/sqrt(pi)
def image_coordinates(self, x): """ Return the image of the coordinates of the hyperbolic point ``x`` under ``self``. EXAMPLES:: sage: KM = HyperbolicPlane().KM() sage: UHP = HyperbolicPlane().UHP() sage: phi = UHP.coerce_map_from(KM) sage: phi.image_coordinates((0, 0)) I sage: phi.image_coordinates((0, 1)) +Infinity """ if tuple(x) == (0, 1): return infinity return (-x[0] / (x[1] - 1) + I * (-(sqrt(-x[0]**2 - x[1]**2 + 1) - x[0]**2 - x[1]**2 + 1) / ((x[1] - 1) * sqrt(-x[0]**2 - x[1]**2 + 1) + x[1] - 1)))
def elias_bound_asymp(delta, q): r""" The asymptotic Elias bound for the information rate. This only makes sense when `0 < \delta < 1-1/q`. EXAMPLES:: sage: codes.bounds.elias_bound_asymp(1/4,2) 0.39912396330... """ r = 1 - 1 / q return RDF((1 - entropy(r - sqrt(r * (r - delta)), q)))
def standard_deviation(self): r""" The standard deviation of the discrete random variable. Let `S` be the probability space of `X` = self, with probability function `p`, and `E(X)` be the expectation of `X`. Then the standard deviation of `X` is defined to be .. math:: \sigma(X) = \sqrt{ \sum_{x \in S} p(x) (X(x) - E(x))**2} """ return sqrt(self.variance())
def mrrw1_bound_asymp(delta, q): r""" The first asymptotic McEliese-Rumsey-Rodemich-Welsh bound. This only makes sense when `0 < \delta < 1-1/q`. EXAMPLES:: sage: codes.bounds.mrrw1_bound_asymp(1/4,2) # abs tol 4e-16 0.3545789026652697 """ return RDF( entropy((q - 1 - delta * (q - 2) - 2 * sqrt( (q - 1) * delta * (1 - delta))) / q, q))
def _derivative_(self, z, m, diff_param): """ EXAMPLES:: sage: x,z = var('x,z') sage: elliptic_e(z, x).diff(z, 1) sqrt(-x*sin(z)^2 + 1) sage: elliptic_e(z, x).diff(x, 1) 1/2*(elliptic_e(z, x) - elliptic_f(z, x))/x """ if diff_param == 0: return sqrt(Integer(1) - m * sin(z)**Integer(2)) elif diff_param == 1: return (elliptic_e(z, m) - elliptic_f(z, m)) / (Integer(2) * m)
def translation_standard_deviation(self, map): r""" The standard deviation of the translated discrete random variable `X \circ e`, where `X` = self and `e` = map. Let `S` be the probability space of `X` = self, with probability function `p`, and `E(X)` be the expectation of `X`. Then the standard deviation of `X` is defined to be .. math:: \sigma(X) = \sqrt{ \sum_{x \in S} p(x) (X(x) - E(x))**2} """ return sqrt(self.translation_variance(map))
def johnson_radius(n, d): r""" Returns the Johnson-radius for the code length `n` and the minimum distance `d`. The Johnson radius is defined as `n - \sqrt(n(n-d))`. INPUT: - ``n`` -- an integer, the length of the code - ``d`` -- an integer, the minimum distance of the code EXAMPLES:: sage: sage.coding.guruswami_sudan.utils.johnson_radius(250, 181) -5*sqrt(690) + 250 """ return n - sqrt(n * (n - d))
def is_quasigeometric(self): """ Decide whether the binary recurrence sequence is degenerate and similar to a geometric sequence, i.e. the union of multiple geometric sequences, or geometric after term ``u0``. If `\\alpha/\\beta` is a `k` th root of unity, where `k>1`, then necessarily `k = 2, 3, 4, 6`. Then `F = [[0,1],[c,b]` is diagonalizable, and `F^k = [[\\alpha^k, 0], [0,\\beta^k]]` is scaler matrix. Thus for all values of `j` mod `k`, the `j` mod `k` terms of `u_n` form a geometric series. If `\\alpha` or `\\beta` is zero, this implies that `c=0`. This is the case when `F` is singular. In this case, `u_1, u_2, u_3, ...` is geometric. EXAMPLES:: sage: S = BinaryRecurrenceSequence(0,1) sage: [S(i) for i in range(10)] [0, 1, 0, 1, 0, 1, 0, 1, 0, 1] sage: S.is_quasigeometric() True sage: R = BinaryRecurrenceSequence(3,0) sage: [R(i) for i in range(10)] [0, 1, 3, 9, 27, 81, 243, 729, 2187, 6561] sage: R.is_quasigeometric() True """ # First test if F is singular... i.e. beta = 0 if self.c == 0: return True # Otherwise test if alpha/beta is a root of unity that is not 1 D = self.b**2 + 4 * self.c if D != 0: # thus alpha/beta != 1 if D.is_square(): A = sqrt(D) else: K = QuadraticField(D, 'x') A = K.gen() if ((self.b + A) / (self.b - A))**6 == 1: return True return False
def _derivative_(self, n, m, theta, phi, diff_param): r""" TESTS:: sage: n, m, theta, phi = var('n m theta phi') sage: spherical_harmonic(n, m, theta, phi).diff(theta) m*cot(theta)*spherical_harmonic(n, m, theta, phi) + sqrt(-(m + n + 1)*(m - n))*e^(-I*phi)*spherical_harmonic(n, m + 1, theta, phi) sage: spherical_harmonic(n, m, theta, phi).diff(phi) I*m*spherical_harmonic(n, m, theta, phi) """ if diff_param == 2: return (m * cot(theta) * spherical_harmonic(n, m, theta, phi) + sqrt((n - m) * (n + m + 1)) * exp(-I * phi) * spherical_harmonic(n, m + 1, theta, phi)) if diff_param == 3: return I * m * spherical_harmonic(n, m, theta, phi) raise ValueError('only derivative with respect to theta or phi' ' supported')
def get_background_graphic(self, **bdry_options): r""" Return a graphic object that makes the model easier to visualize. For the hyperboloid model, the background object is the hyperboloid itself. EXAMPLES:: sage: H = HyperbolicPlane().HM().get_background_graphic() """ from sage.plot.plot3d.all import plot3d from sage.symbolic.ring import SR hyperboloid_opacity = bdry_options.get('hyperboloid_opacity', .1) z_height = bdry_options.get('z_height', 7.0) x_max = sqrt((z_height**2 - 1) / 2.0) x = SR.var('x') y = SR.var('y') return plot3d((1 + x**2 + y**2).sqrt(), (x, -x_max, x_max), (y, -x_max, x_max), opacity=hyperboloid_opacity, **bdry_options)
def _derivative_(self, x, diff_param=None): """ Derivative of erf function. EXAMPLES:: sage: erf(x).diff(x) 2*e^(-x^2)/sqrt(pi) TESTS: Check if :trac:`8568` is fixed:: sage: var('c,x') (c, x) sage: derivative(erf(c*x),x) 2*c*e^(-c^2*x^2)/sqrt(pi) sage: erf(c*x).diff(x)._maxima_init_() '((%pi)^(-1/2))*(_SAGE_VAR_c)*(exp(((_SAGE_VAR_c)^(2))*((_SAGE_VAR_x)^(2))*(-1)))*(2)' """ return 2*exp(-x**2)/sqrt(pi)
def __init__(self, n, secret_dist='uniform', m=None): """ Construct LWE instance parameterised by security parameter ``n`` where the modulus ``q`` and the ``stddev`` of the noise are chosen as in [Reg09]_. INPUT: - ``n`` - security parameter (integer > 0) - ``secret_dist`` - distribution of the secret. See documentation of :class:`LWE` for details (default='uniform') - ``m`` - number of allowed samples or ``None`` if no such limit exists (default: ``None``) EXAMPLES:: sage: from sage.crypto.lwe import Regev sage: Regev(n=20) LWE(20, 401, Discrete Gaussian sampler over the Integers with sigma = 1.915069 and c = 401, 'uniform', None) """ q = ZZ(next_prime(n**2)) s = RR(1 / (RR(n).sqrt() * log(n, 2)**2) * q) D = DiscreteGaussianDistributionIntegerSampler(s / sqrt(2 * pi.n()), q) LWE.__init__(self, n=n, q=q, D=D, secret_dist=secret_dist, m=m)