def check_conj_q_matrix(M): """ sage: from sage.monoids.j_trivial_monoids import * sage: for p in Posets(3): ... check_conj_q_matrix(NDPFMonoidPoset(p)) ([1], 1, 1) ( [1 0] [0 1], 2, 2 ) ( [1 0 0 0] [0 1 0 0] [0 0 1 0] [0 0 0 1], 4, 4 ) ( [1 0 0 0] [0 1 q 0] [0 0 1 0] [0 0 0 1], q + 4, q + 4 ) ([1], 1, 1) """ msage = M.cartan_matrix(var('q')) rsage = sum(sum(msage)) mmup = M.cartan_matrix_mupad(var('q')) rmup = sum(sum(mmup)) assert (rmup == rsage), "Conjecture False " return msage, rsage, rmup
def findz(input, p, q, sig): """Function to find individual z variables in terms of x and y. Args: input (int): The number of the z variable to be shown in terms of x and y. Returns: z term(symb exp): The z variable expressed in terms of x and y. """ if input == 0: return 0 else: if p + q + 1 > input > p: final = 0 alt = itertools.cycle([0, 1]).next for l in xrange(1, 2 * (input - p) + 1): altvar = alt() if altvar == 0: final = final + var("y" + str(l)) else: final = final - (var("y" + str(l))) return z_adder(p) + final elif input == p + q + 1: return findt(p + q + 1 + sig, p, q) - var("y" + str(2 * q + 2)) else: return z_adder(input)
def create_power_list(r, s): list_of_powers = [] for number_of_xs in xrange(1, r + 1): list_of_powers.append(var("xpower" + str(number_of_xs))) for number_of_ys in xrange(1, s + 1): list_of_powers.append(var("ypower" + str(number_of_ys))) return list_of_powers
def belfunc(self): """ Returns belonging function of ellipsoid. """ X = Matrix([[var('x')], [var('y')], [var('z')]]) v = self.pos B = self.red_belonging_matrix() return (expand((X - v).transpose() * B * (X - v)) - 1)[0, 0]
def create_template_monomial(r, s): test_monomial = 1 for number_of_xs in xrange(1, r + 1): test_monomial = test_monomial * var("x" + str(number_of_xs))**var( "xpower" + str(number_of_xs)) for number_of_ys in xrange(1, s + 1): test_monomial = test_monomial * var("y" + str(number_of_ys))**var( "ypower" + str(number_of_ys)) return test_monomial
def _arc(p,q,s,**kwds): #rewrite this to use polar_plot and get points to do filled triangles from sage.misc.functional import det from sage.plot.line import line from sage.misc.functional import norm from sage.symbolic.all import pi from sage.plot.arc import arc p,q,s = map( lambda x: vector(x), [p,q,s]) # to avoid running into division by 0 we set to be colinear vectors that are # almost colinear if abs(det(matrix([p-s,q-s])))<0.01: return line((p,q),**kwds) (cx,cy)=var('cx','cy') equations=[ 2*cx*(s[0]-p[0])+2*cy*(s[1]-p[1]) == s[0]**2+s[1]**2-p[0]**2-p[1]**2, 2*cx*(s[0]-q[0])+2*cy*(s[1]-q[1]) == s[0]**2+s[1]**2-q[0]**2-q[1]**2 ] c = vector( [solve( equations, (cx,cy), solution_dict=True )[0][i] for i in [cx,cy]] ) r = norm(p-c) a_p, a_q, a_s = map(lambda x: atan2(x[1],x[0]), [p-c,q-c,s-c]) a_p, a_q = sorted([a_p,a_q]) if a_s < a_p or a_s > a_q: return arc( c, r, angle=a_q, sector=(0,2*pi-a_q+a_p), **kwds) return arc( c, r, angle=a_p, sector=(0,a_q-a_p), **kwds)
def __init__(self, Sym, t = 't'): r""" The family of Hall-Littlewood symmetric function bases By default the paramter for these functions is `t` and whatever the paramter is, it must be in the base ring. INPUT: - ``self`` -- a class of Hall-Littlewood symmetric function bases EXAMPLES:: sage: SymmetricFunctions(QQ).hall_littlewood(1) Hall-Littlewood polynomials with t=1 over Rational Field sage: SymmetricFunctions(QQ['t'].fraction_field()).hall_littlewood() Hall-Littlewood polynomials over Fraction Field of Univariate Polynomial Ring in t over Rational Field """ self._sym = Sym if not (t in Sym.base_ring() or var(t) in Sym.base_ring()): raise ValueError, "parameter t must be in the base ring" self.t = Sym.base_ring()(t) self._name_suffix = "" if str(t) !='t': self._name_suffix += " with t=%s"%t self._name = "Hall-Littlewood polynomials"+self._name_suffix
def _arc(p, q, s, **kwds): #rewrite this to use polar_plot and get points to do filled triangles from sage.misc.functional import det from sage.plot.line import line from sage.misc.functional import norm from sage.symbolic.all import pi from sage.plot.arc import arc p, q, s = map(lambda x: vector(x), [p, q, s]) # to avoid running into division by 0 we set to be colinear vectors that are # almost colinear if abs(det(matrix([p - s, q - s]))) < 0.01: return line((p, q), **kwds) (cx, cy) = var('cx', 'cy') equations = [ 2 * cx * (s[0] - p[0]) + 2 * cy * (s[1] - p[1]) == s[0]**2 + s[1]**2 - p[0]**2 - p[1]**2, 2 * cx * (s[0] - q[0]) + 2 * cy * (s[1] - q[1]) == s[0]**2 + s[1]**2 - q[0]**2 - q[1]**2 ] c = vector([ solve(equations, (cx, cy), solution_dict=True)[0][i] for i in [cx, cy] ]) r = norm(p - c) a_p, a_q, a_s = map(lambda x: atan2(x[1], x[0]), [p - c, q - c, s - c]) a_p, a_q = sorted([a_p, a_q]) if a_s < a_p or a_s > a_q: return arc(c, r, angle=a_q, sector=(0, 2 * pi - a_q + a_p), **kwds) return arc(c, r, angle=a_p, sector=(0, a_q - a_p), **kwds)
def weight_distribution(self): r""" Returns the list whose `i`'th entry is the number of words of weight `i` in ``self``. Computing the weight distribution for a GRS code is very fast. Note that for random linear codes, it is computationally hard. EXAMPLES:: sage: F = GF(11) sage: n, k = 10, 5 sage: C = codes.GeneralizedReedSolomonCode(F.list()[:n], k) sage: C.weight_distribution() [1, 0, 0, 0, 0, 0, 2100, 6000, 29250, 61500, 62200] """ d = self.minimum_distance() n = self.length() q = self.base_ring().order() s = var('s') wd = [1] + [0] * (d - 1) for i in range(d, n + 1): tmp = binomial(n, i) * (q - 1) wd.append(tmp * symbolic_sum( binomial(i - 1, s) * (-1)**s * q**(i - d - s), s, 0, i - d)) return wd
def weight_enumerator(self): r""" Returns the polynomial whose coefficient to `x^i` is the number of codewords of weight `i` in ``self``. Computing the weight enumerator for a GRS code is very fast. Note that for random linear codes, it is computationally hard. EXAMPLES:: sage: F = GF(11) sage: n, k = 10, 5 sage: C = codes.GeneralizedReedSolomonCode(F.list()[:n], k) sage: C.weight_enumerator() 62200*x^10 + 61500*x^9 + 29250*x^8 + 6000*x^7 + 2100*x^6 + 1 """ PolRing = ZZ['x'] x = PolRing.gen() s = var('s') wd = self.weight_distribution() d = self.minimum_distance() n = self.length() w_en = PolRing(1) for i in range(n + 1 - d): w_en += wd[i + d] * x**(i + d) return w_en
def weight_distribution(self): r""" Returns the list whose `i`'th entry is the number of words of weight `i` in ``self``. Computing the weight distribution for a GRS code is very fast. Note that for random linear codes, it is computationally hard. EXAMPLES:: sage: F = GF(11) sage: n, k = 10, 5 sage: C = codes.GeneralizedReedSolomonCode(F.list()[:n], k) sage: C.weight_distribution() [1, 0, 0, 0, 0, 0, 2100, 6000, 29250, 61500, 62200] """ d = self.minimum_distance() n = self.length() q = self.base_ring().order() s = var('s') wd = [1] + [0] * (d - 1) for i in range(d, n+1): tmp = binomial(n, i) * (q - 1) wd.append(tmp * symbolic_sum(binomial(i-1, s) * (-1) ** s * q ** (i - d - s), s, 0, i-d)) return wd
def weight_enumerator(self): r""" Returns the polynomial whose coefficient to `x^i` is the number of codewords of weight `i` in ``self``. Computing the weight enumerator for a GRS code is very fast. Note that for random linear codes, it is computationally hard. EXAMPLES:: sage: F = GF(11) sage: n, k = 10, 5 sage: C = codes.GeneralizedReedSolomonCode(F.list()[:n], k) sage: C.weight_enumerator() 62200*x^10 + 61500*x^9 + 29250*x^8 + 6000*x^7 + 2100*x^6 + 1 """ PolRing = ZZ['x'] x = PolRing.gen() s = var('s') wd = self.weight_distribution() d = self.minimum_distance() n = self.length() w_en = PolRing(1) for i in range(n + 1 - d): w_en += wd[i + d] * x ** (i + d) return w_en
def _step_upper_bound_internal(r, m, q, generating_function): r""" Common implementation for :func:`step_upper_bound` and :func:`step_upper_bound_specific` """ L = LieAlgebra(QQ, ['X_%d' % k for k in range(r)]).Lyndon() dim_fm = L.graded_dimension(m) t = var('t') pt = symbolic_prod( (1 / ((1 - t**k)**L.graded_dimension(k)) for k in range(1, m)), (1 - dim_fm * (1 - t**q)) * t**m) increment = series_precision() i = 0 coeffsum = ZZ.zero() while True: # sum the coefficients of the series for t^i...t^(i+increment-1) p_series = pt.series(t, i + increment) for s in range(i, i + increment): coeffsum += ZZ(p_series.coefficient(t, s)) if coeffsum > 0: verbose("upper bound for abnormality: step %d" % s) if generating_function: return s, pt return s # exponential growth to avoid recomputing the series too much i += increment increment += increment
def show(self, boundary=True, **options): r""" Plot ``self``. EXAMPLES:: sage: HyperbolicPlane().UHP().get_geodesic(0, 1).show() Graphics object consisting of 2 graphics primitives """ opts = {'axes': False, 'aspect_ratio': 1} opts.update(self.graphics_options()) opts.update(options) end_1, end_2 = [CC(k.coordinates()) for k in self.endpoints()] bd_1, bd_2 = [CC(k.coordinates()) for k in self.ideal_endpoints()] if (abs(real(end_1) - real(end_2)) < EPSILON) \ or CC(infinity) in [end_1, end_2]: #on same vertical line # If one of the endpoints is infinity, we replace it with a # large finite point if end_1 == CC(infinity): end_1 = (real(end_2), (imag(end_2) + 10)) end_2 = (real(end_2), imag(end_2)) elif end_2 == CC(infinity): end_2 = (real(end_1), (imag(end_1) + 10)) end_1 = (real(end_1), imag(end_1)) from sage.plot.line import line pic = line((end_1, end_2), **opts) if boundary: cent = min(bd_1, bd_2) bd_dict = {'bd_min': cent - 3, 'bd_max': cent + 3} bd_pic = self._model.get_background_graphic(**bd_dict) pic = bd_pic + pic return pic else: center = (bd_1 + bd_2)/2 # Circle center radius = abs(bd_1 - bd_2)/2 theta1 = CC(end_1 - center).arg() theta2 = CC(end_2 - center).arg() if abs(theta1 - theta2) < EPSILON: theta2 += pi [theta1, theta2] = sorted([theta1, theta2]) from sage.calculus.var import var from sage.plot.plot import parametric_plot x = var('x') pic = parametric_plot((radius*cos(x) + real(center), radius*sin(x) + imag(center)), (x, theta1, theta2), **opts) if boundary: # We want to draw a segment of the real line. The # computations below compute the projection of the # geodesic to the real line, and then draw a little # to the left and right of the projection. shadow_1, shadow_2 = [real(k) for k in [end_1, end_2]] midpoint = (shadow_1 + shadow_2)/2 length = abs(shadow_1 - shadow_2) bd_dict = {'bd_min': midpoint - length, 'bd_max': midpoint + length} bd_pic = self._model.get_background_graphic(**bd_dict) pic = bd_pic + pic return pic
def test_geometric(self): G = (1 - x) * y - 1 S = newton_iteration(G, 9).truncate(x, 10) z = var('z') series = taylor(1 / (1 - z), z, 0, 9) series = R(series.subs({z: x})) self.assertEqual(S, series)
def test_geometric(self): G = (1-x)*y - 1 S = newton_iteration(G,9).truncate(x,10) z = var('z') series = taylor(1/(1-z),z,0,9) series = R(series.subs({z:x})) self.assertEqual(S,series)
def test_cuberoot(self): # recenter cuberoot(x) at x+1 G = (y+1)**3 - (x+1) S = newton_iteration(G,9).truncate(x,10) + 1 z = var('z') series = taylor(z**(QQ(1)/QQ(3)),z,1,9) series = R(series.subs({z:x+1})) self.assertEqual(S,series)
def test_cuberoot(self): # recenter cuberoot(x) at x+1 G = (y + 1)**3 - (x + 1) S = newton_iteration(G, 9).truncate(x, 10) + 1 z = var('z') series = taylor(z**(QQ(1) / QQ(3)), z, 1, 9) series = R(series.subs({z: x + 1})) self.assertEqual(S, series)
def test_sqrt(self): # recenter sqrt(x) at x+1 G = (y+1)**2 - (x+1) S = newton_iteration(G,9).truncate(x,10) + 1 z = var('z') series = taylor(sqrt(z),z,1,9) series = R(series.subs({z:x+1})) self.assertEqual(S,series)
def test_sqrt(self): # recenter sqrt(x) at x+1 G = (y + 1)**2 - (x + 1) S = newton_iteration(G, 9).truncate(x, 10) + 1 z = var('z') series = taylor(sqrt(z), z, 1, 9) series = R(series.subs({z: x + 1})) self.assertEqual(S, series)
def t_adder(input, p): """Function similar to z_adder(), but for t variables. Args: input(int): The number of the t variable to be shown in terms of x and y. Returns: t_added(symb exp): Series of x and y variables added together. """ t_added = 0 alty = itertools.cycle([0, 1]).next for i in xrange(1, 2 * input): altyvar = alty() if altyvar == 0: t_added = t_added + var("y" + str(i)) else: t_added = t_added - (var("y" + str(i))) return t_added + z_adder(p)
def ring_lists(r, s): slist = '' for i in xrange(1, r + 1): slist = slist + 'x' + str(i) + ', ' for i in xrange(1, s + 1): slist = slist + 'y' + str(i) + ', ' slist = slist[0:-2] vlist = var(slist) return [slist, vlist]
def tangent_vector(f): # https://doc.sagemath.org/html/en/reference/manifolds/sage/manifolds/differentiable/tangent_vector.html?highlight=partial%20differential # XXX: There is TangentVector in Sage but a little bit more complicated. Does it pay to use that one ? r""" Do a tangent vector DEFINITION: missing INPUT: - ``f`` - symbolic expression of type 'function' OUTPUT: the tangent vector .. NOTE:: none so far .. EXAMPLES: compute the tangent vector of :: sage: from delierium.helpers import tangent_vector sage: x,y,z = var ("x y z") sage: tangent_vector (x**2 - 3*y**4 - z*x*y + z - x) [-y*z + 2*x - 1, -12*y^3 - x*z, -x*y + 1] sage: tangent_vector (x**2 + 2*y**3 - 3*z**4) [2*x, 6*y^2, -12*z^3] sage: tangent_vector (x**2) [2*x] """ t = var("t") newvars = [var("x%s" % i) for i in f.variables()] for o, n in zip(f.variables(), newvars): f = f.subs({o: o+t*n}) d = diff(f, t).limit(t=0) return [d.coefficient(_) for _ in newvars]
def generating_function(self): ''' starts with minimum, subtracts off basis ''' if using_sage or using_sympy: k = len(self) dots = self.minimum.count(1) dimension = k - dots # sets up 'x' as an algebraic variable in both sympy and sage var('x') fcn = ( x ** sum(self.minimum) ) / ((1 - x) ** dimension) basis_size = len(self.basis) mult = 1 for level in range(1, basis_size + 1): mult *= -1 for comb in it.combinations(self.basis, level): # comb is a list of vectors maxvector = [max(t) for t in zip(*comb)] maxvector = [max(t) for t in zip(maxvector, self.minimum)] fcn = fcn + mult * (x ** sum(maxvector)) / ((1-x) ** dimension) return fcn if function_strings: # spits out LONG list of strings that can be input into sage # use L = self.generating_function(); print '\n +'.join(L) biglist = [] k = len(self) dots = self.minimum.count(1) dimension = k - dots # sets up 'x' as an algebraic variable in both sympy and sage mult = 1 biglist.append('(%d)*(x ** %d)/(1 - x) ** %d' % (mult, sum(self.minimum), dimension)) basis_size = len(self.basis) for level in range(1, basis_size + 1): mult *= -1 for comb in it.combinations(self.basis, level): # comb is a list of vectors maxvector = [max(t) for t in zip(*comb)] maxvector = [max(t) for t in zip(maxvector, self.minimum)] biglist.append('(%d)*(x ** %d)/(1 - x) ** %d' % (mult, sum(maxvector), dimension)) return biglist else: return '''either install sympy or run this script in a sage session for
def FrechetD(support, dependVar, independVar, testfunction): frechet = [] var("eps") for j in range(len(support)): deriv = [] for i in range(len(support)): def r0(*args): return dependVar[i]( *independVar) + testfunction[i](*independVar) * eps #def _r0(*args): # # this version has issues as it always uses w2 ?!? investigate further # # when time and motivation. Online version on asksage works perfectly # return dependVar[i](*independVar)+ testfunction[i](*independVar) * eps #r0 = function('r0', eval_func=_r0) s = support[j].substitute_function(dependVar[i], r0) deriv.append(diff(s, eps).subs({eps: 0})) frechet.append(deriv) return frechet
def plot_arc(radius, p, q, **opts): # TODO: THIS SHOULD USE THE EXISTING PLOT OF ARCS! # plot the arc from p to q differently depending on the type of self p = ZZ(p) q = ZZ(q) t = var('t') if p - q in [1, -1]: def f(t): return (radius * cos(t), radius * sin(t)) (p, q) = sorted([p, q]) angle_p = vertex_to_angle(p) angle_q = vertex_to_angle(q) return parametric_plot(f(t), (t, angle_q, angle_p), **opts) if self.type() == 'A': angle_p = vertex_to_angle(p) angle_q = vertex_to_angle(q) if angle_p < angle_q: angle_p += 2 * pi internal_angle = angle_p - angle_q if internal_angle > pi: (angle_p, angle_q) = (angle_q + 2 * pi, angle_p) internal_angle = angle_p - angle_q angle_center = (angle_p + angle_q) / 2 hypotenuse = radius / cos(internal_angle / 2) radius_arc = hypotenuse * sin(internal_angle / 2) center = (hypotenuse * cos(angle_center), hypotenuse * sin(angle_center)) center_angle_p = angle_p + pi / 2 center_angle_q = angle_q + 3 * pi / 2 def f(t): return (radius_arc * cos(t) + center[0], radius_arc * sin(t) + center[1]) return parametric_plot(f(t), (t, center_angle_p, center_angle_q), **opts) elif self.type() == 'D': if p >= q: q += self.r() px = -2 * pi * p / self.r() + pi / 2 qx = -2 * pi * q / self.r() + pi / 2 arc_radius = (px - qx) / 2 arc_center = qx + arc_radius def f(t): return exp(I * ((cos(t) + I * sin(t)) * arc_radius + arc_center)) * radius return parametric_plot((real_part(f(t)), imag_part(f(t))), (t, 0, pi), **opts)
def show(self, boundary=True, **options): r""" Plot ``self``. EXAMPLES:: sage: HyperbolicPlane().PD().get_geodesic(0, 1).show() Graphics object consisting of 2 graphics primitives """ opts = dict([('axes', False), ('aspect_ratio', 1)]) opts.update(self.graphics_options()) opts.update(options) end_1, end_2 = [CC(k.coordinates()) for k in self.endpoints()] bd_1, bd_2 = [CC(k.coordinates()) for k in self.ideal_endpoints()] # Check to see if it's a line if bool(real(bd_1)*imag(bd_2) - real(bd_2)*imag(bd_1))**2 < EPSILON: from sage.plot.line import line pic = line([(real(bd_1),imag(bd_1)),(real(bd_2),imag(bd_2))], **opts) else: # If we are here, we know it's not a line # So we compute the center and radius of the circle center = (1/(real(bd_1)*imag(bd_2) - real(bd_2)*imag(bd_1)) * ((imag(bd_2)-imag(bd_1)) + (real(bd_1)-real(bd_2))*I)) radius = RR(abs(bd_1 - center)) # abs is Euclidean distance # Now we calculate the angles for the parametric plot theta1 = CC(end_1 - center).arg() theta2 = CC(end_2 - center).arg() if theta2 < theta1: theta1, theta2 = theta2, theta1 from sage.calculus.var import var from sage.plot.plot import parametric_plot x = var('x') mid = (theta1 + theta2)/2.0 if (radius*cos(mid) + real(center))**2 + \ (radius*sin(mid) + imag(center))**2 > 1.0: # Swap theta1 and theta2 tmp = theta1 + 2*pi theta1 = theta2 theta2 = tmp pic = parametric_plot((radius*cos(x) + real(center), radius*sin(x) + imag(center)), (x, theta1, theta2), **opts) else: pic = parametric_plot((radius*cos(x) + real(center), radius*sin(x) + imag(center)), (x, theta1, theta2), **opts) if boundary: bd_pic = self._model.get_background_graphic() pic = bd_pic + pic return pic
def z_adder(input): """Function for use in building z and t variables. Args: input(int): The number of the z variable to be shown in terms of x. Returns: z_added(symb exp): Series of x variables added together. """ z_added = 0 for i in xrange(1, input + 1): z_added = z_added + var("x" + str(i)) return z_added
def EulerD(density, depend, independ): r''' >>> t = var("t") >>> u= function('u') >>> v= function('v') >>> L=u(t)*v(t) + diff(u(t), t)**2 + diff(v(t), t)**2 - u(t)**2 - v(t)**2 >>> EulerD(L, (u,v), t) [-2*u(t) + v(t) - 2*diff(u(t), t, t), u(t) - 2*v(t) - 2*diff(v(t), t, t)] >>> L=u(t)*v(t) + diff(u(t), t)**2 + diff(v(t), t)**2 + 2*diff(u(t), t) * diff(v(t), t) >>> EulerD(L, (u,v), t) [v(t) - 2*diff(u(t), t, t) - 2*diff(v(t), t, t), u(t) - 2*diff(u(t), t, t) - 2*diff(v(t), t, t)] ''' wtable = [function("w_%s" % i) for i in range(len(depend))] y = function('y') w = function('w') e = var('e') result = [] for j in range(len(depend)): loc_result = 0 def f0(*args): return y(independ) + e * w(independ) def dep(*args): return depend[j](independ) fh = density.substitute_function(depend[j], f0) fh = fh.substitute_function(y, dep) fh = fh.substitute_function(w, wtable[j]) fh = fh.diff(e) fh = fh.subs({e: 0}).expand() if fh.operator().__name__ == 'mul_vararg': operands = [fh] else: operands = fh.operands() for operand in operands: d = None coeff = [] for _ops in operand.operands(): if is_op_du(_ops, wtable[j](independ)): d = _ops.operands().count(independ) elif is_function(_ops) and _ops.operator() == wtable[j]: pass else: coeff.append(_ops) coeff = functools.reduce(mul, coeff, 1) if d is not None: coeff = ((-1)**d) * diff(coeff, independ, d) loc_result += coeff result.append(loc_result) return result
def FrechetD(support, dependVar, independVar, testfunction): """ >>> t, x = var ("t x") >>> v = function ("v") >>> u = function ("u") >>> w1 = function ("w1") >>> w2 = function ("w2") >>> eqsys = [diff(v(x,t), x) - u(x,t), diff(v(x,t), t) - diff(u(x,t), x)/(u(x,t)**2)] >>> m = Matrix(FrechetD (eqsys, [u,v], [x,t], [w1,w2])) >>> m[0][0] -w1(x, t) >>> m[0][1] diff(w2(x, t), x) >>> m[1][0] 2*w1(x, t)*diff(u(x, t), x)/u(x, t)^3 - diff(w1(x, t), x)/u(x, t)^2 >>> m[1][1] diff(w2(x, t), t) """ frechet = [] var("eps") for j in range(len(support)): deriv = [] for i in range(len(support)): def r0(*args): return dependVar[i]( *independVar) + testfunction[i](*independVar) * eps #def _r0(*args): # # this version has issues as it always uses w2 ?!? investigate further # # when time and motivation. Online version on asksage works perfectly # return dependVar[i](*independVar)+ testfunction[i](*independVar) * eps #r0 = function('r0', eval_func=_r0) s = support[j].substitute_function(dependVar[i], r0) deriv.append(diff(s, eps).subs({eps: 0})) frechet.append(deriv) return frechet
def plot_arc(radius, p, q, **opts): # TODO: THIS SHOULD USE THE EXISTING PLOT OF ARCS! # plot the arc from p to q differently depending on the type of self p = ZZ(p) q = ZZ(q) t = var('t') if p - q in [1, -1]: def f(t): return (radius * cos(t), radius * sin(t)) (p, q) = sorted([p, q]) angle_p = vertex_to_angle(p) angle_q = vertex_to_angle(q) return parametric_plot(f(t), (t, angle_q, angle_p), **opts) if self.type() == 'A': angle_p = vertex_to_angle(p) angle_q = vertex_to_angle(q) if angle_p < angle_q: angle_p += 2 * pi internal_angle = angle_p - angle_q if internal_angle > pi: (angle_p, angle_q) = (angle_q + 2 * pi, angle_p) internal_angle = angle_p - angle_q angle_center = (angle_p+angle_q) / 2 hypotenuse = radius / cos(internal_angle / 2) radius_arc = hypotenuse * sin(internal_angle / 2) center = (hypotenuse * cos(angle_center), hypotenuse * sin(angle_center)) center_angle_p = angle_p + pi / 2 center_angle_q = angle_q + 3 * pi / 2 def f(t): return (radius_arc * cos(t) + center[0], radius_arc * sin(t) + center[1]) return parametric_plot(f(t), (t, center_angle_p, center_angle_q), **opts) elif self.type() == 'D': if p >= q: q += self.r() px = -2 * pi * p / self.r() + pi / 2 qx = -2 * pi * q / self.r() + pi / 2 arc_radius = (px - qx) / 2 arc_center = qx + arc_radius def f(t): return exp(I * ((cos(t) + I * sin(t)) * arc_radius + arc_center)) * radius return parametric_plot((real_part(f(t)), imag_part(f(t))), (t, 0, pi), **opts)
def findt(input, p, q): """Function to find individual t variables in terms of x and y. Args: input(int): The number of the t variable. Returns: t term(symb exp): The t variable expressed in terms of x and y. """ if input > q + 1: final = 0 for l in xrange(p + 1, input - q + p): final = final - (var("x" + str(l))) return t_adder(q + 1, p) + final else: return t_adder(input, p)
def _to_expr_on_basis(self, vector, alphabet=None): r""" Transforms a vector key of a finite basis into a symbolic expression factor. It uses formal variables with names : basis_repr + i (by default, 'x1' to 'xn') INPUT : - ``vector`` a key element of a finite basis ``CominatorialFreeModule`` - ``alphabet`` an obtional alphabet of formal variables, if let to ``None``, it uses basis_repr + i (by default, 'x1' to 'xn') OUTPUT: - a symbolic expression corresponding to the monomial EXAMPLES:: sage: from multipolynomial_bases import MultivariatePolynomialAlgebra sage: A.<x> = MultivariatePolynomialAlgebra(QQ) sage: pol = x[2,2,1] + x[3,2]; pol x[2, 2, 1] + x[3, 2, 0] sage: key = list(pol)[0][0]; key [2, 2, 1] sage: x._to_expr_on_basis(key) x1^2*x2^2*x3 sage: var('a,b,c') (a, b, c) sage: alphabet = [a,b,c] sage: x._to_expr_on_basis(key, alphabet=alphabet) a^2*b^2*c """ from sage.calculus.var import var key = list(vector) if alphabet is None: alphabet = [ var(self.basis_repr() + str(i)) for i in range(1, len(key) + 1) ] expr = 1 for i in range(len(key)): expr *= alphabet[i]**key[i] return expr
def __init__(self, Sym, t = 't'): """ Initialize ``self``. EXAMPLES:: sage: HL = SymmetricFunctions(FractionField(QQ['t'])).hall_littlewood() sage: TestSuite(HL).run() """ self._sym = Sym if not (t in Sym.base_ring() or var(t) in Sym.base_ring()): raise ValueError, "parameter t must be in the base ring" self.t = Sym.base_ring()(t) self._name_suffix = "" if str(t) !='t': self._name_suffix += " with t=%s"%t self._name = "Hall-Littlewood polynomials"+self._name_suffix
def __init__(self, Sym, t='t'): """ Initialize ``self``. EXAMPLES:: sage: HL = SymmetricFunctions(FractionField(QQ['t'])).hall_littlewood() sage: TestSuite(HL).run() """ self._sym = Sym if not (t in Sym.base_ring() or var(t) in Sym.base_ring()): raise ValueError, "parameter t must be in the base ring" self.t = Sym.base_ring()(t) self._name_suffix = "" if str(t) != 't': self._name_suffix += " with t=%s" % t self._name = "Hall-Littlewood polynomials" + self._name_suffix
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 [LP11]_. 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, DiscreteGaussianPolynomialSamplerRejection(8, 2.803372, 53, 4), 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 = 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 [LP11]_ q = next_prime(floor(2**round(log(256 / s_t_bound, 2)))) # Gaussian parameter as defined in [LP11]_ s = sqrt(s_t_bound * floor(q / 4)) # Transform s into stddev stddev = s / sqrt(2 * pi.n()) D = DiscreteGaussianPolynomialSampler(n, stddev) RingLWE.__init__(self, N=N, q=q, D=D, poly=None, secret_dist='noise', m=m)
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 [LP11]_. 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 [LP11]_ (default: ``None``) EXAMPLES:: sage: from sage.crypto.lwe import LindnerPeikert sage: LindnerPeikert(n=20) LWE(20, 2053, DiscreteGaussianSamplerRejection(3.600954, 53, 4), '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 = 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 [LP11]_ q = next_prime(floor(2**round(log(256 / s_t_bound, 2)))) # Gaussian parameter as defined in [LP11]_ s = sqrt(s_t_bound * floor(q / 4)) # Transform s into stddev stddev = s / sqrt(2 * pi.n()) D = DiscreteGaussianSampler(stddev) LWE.__init__(self, n=n, q=q, D=D, secret_dist='noise', m=m)
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 [LP11]_. 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 [LP11]_ (default: ``None``) EXAMPLES:: sage: from sage.crypto.lwe import LindnerPeikert sage: LindnerPeikert(n=20) LWE(20, 2053, DiscreteGaussianSamplerRejection(3.600954, 53, 4), '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 = 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 [LP11]_ q = next_prime(floor(2**round(log(256 / s_t_bound, 2)))) # Gaussian parameter as defined in [LP11]_ s = sqrt(s_t_bound*floor(q/4)) # Transform s into stddev stddev = s/sqrt(2*pi.n()) D = DiscreteGaussianSampler(stddev) LWE.__init__(self, n=n, q=q, D=D, secret_dist='noise', m=m)
def __init__(self, Sym, k, t='t'): r""" Class of LLT symmetric function bases INPUT: - ``self`` -- a family of LLT symmetric function bases - ``k`` -- a positive integer (the level) - ``t`` -- a parameter (default: `t`) EXAMPLES:: sage: L3 = SymmetricFunctions(FractionField(QQ['t'])).llt(3) sage: L3 == loads(dumps(L3)) True sage: TestSuite(L3).run(skip=["_test_associativity","_test_distributivity","_test_prod"]) TESTS:: sage: L3 != SymmetricFunctions(FractionField(QQ['t'])).llt(2) True sage: L3p = SymmetricFunctions(FractionField(QQ['t'])).llt(3,t=1) sage: L3 != L3p True sage: L3p != SymmetricFunctions(QQ).llt(3,t=1) True """ self._k = k self._sym = Sym self._name = "level %s LLT polynomials"%self._k if not (t in Sym.base_ring() or var(t) in Sym.base_ring()): raise ValueError("parameter t must be in the base ring") self.t = Sym.base_ring()(t) self._name_suffix = "" if str(t) !='t': self._name_suffix += " with t=%s"%self.t self._name += self._name_suffix+" over %s"%self._sym.base_ring() self._m = sage.combinat.sf.sf.SymmetricFunctions(QQt).monomial()
def mu(self, epsilon=1e-12): """ Returns rescaling factor associated to the couple with precision epsilon in the search of the root of the contact function. """ eta = var('eta') Y = (eta * self.ellipsoid2.red_belonging_matrix().inverse() + (1 - eta) * self.ellipsoid1.red_belonging_matrix().inverse()) p = (eta * (1 - eta) * ((self.ellipsoid2.pos - self.ellipsoid1.pos).transpose()) * (Y.adjugate()) * (self.ellipsoid2.pos - self.ellipsoid1.pos)) q = Y.determinant() h = expand(p.derivative(eta) * q - p * q.derivative(eta))[0, 0] F = expand(p / q)[0, 0] root, iter = halleyMethod( h, eta, self.ellipsoid1.R[0] / (self.ellipsoid1.R[0] + self.ellipsoid2.R[0]), epsilon) return sqrt(F(eta=root))
def map_coefficients_to_variable_index(M, x): r""" INPUT: - ``M`` -- matrix - ``x`` -- string, variable EXAMPLES:: sage: from slabbe.matrices import map_coefficients_to_variable_index sage: M = matrix(2, range(4)) sage: map_coefficients_to_variable_index(M, 's') [s_0 s_1] [s_2 s_3] sage: latex(_) \left(\begin{array}{rr} s_{0} & s_{1} \\ s_{2} & s_{3} \end{array}\right) """ from sage.calculus.var import var L = [var('{}_{}'.format(x,a)) for a in M.list()] return matrix(M.nrows(), L)
def show(self, show_hyperboloid=True, **graphics_options): r""" Plot ``self``. EXAMPLES:: sage: from sage.geometry.hyperbolic_space.hyperbolic_geodesic import * sage: g = HyperbolicPlane().HM().random_geodesic() sage: g.show() Graphics3d Object """ from sage.calculus.var import var (x,y,z) = var('x,y,z') opts = self.graphics_options() opts.update(graphics_options) v1,u2 = [vector(k.coordinates()) for k in self.endpoints()] # Lorentzian Gram Shmidt. The original vectors will be # u1, u2 and the orthogonal ones will be v1, v2. Except # v1 = u1, and I don't want to declare another variable, # hence the odd naming convention above. # We need the Lorentz dot product of v1 and u2. v1_ldot_u2 = u2[0]*v1[0] + u2[1]*v1[1] - u2[2]*v1[2] v2 = u2 + v1_ldot_u2*v1 v2_norm = sqrt(v2[0]**2 + v2[1]**2 - v2[2]**2) v2 = v2/v2_norm v2_ldot_u2 = u2[0]*v2[0] + u2[1]*v2[1] - u2[2]*v2[2] # Now v1 and v2 are Lorentz orthogonal, and |v1| = -1, |v2|=1 # That is, v1 is unit timelike and v2 is unit spacelike. # This means that cosh(x)*v1 + sinh(x)*v2 is unit timelike. hyperbola = cosh(x)*v1 + sinh(x)*v2 endtime = arcsinh(v2_ldot_u2) from sage.plot.plot3d.all import parametric_plot3d pic = parametric_plot3d(hyperbola,(x,0, endtime), **graphics_options) if show_hyperboloid: bd_pic = self._model.get_background_graphic() pic = bd_pic + pic return pic
def __init__(self, base_ring, fibre_names, base_names, max_differential_orders): self._fibre_names = tuple(fibre_names) self._base_names = tuple(base_names) self._max_differential_orders = tuple(max_differential_orders) base_dim = len(self._base_names) fibre_dim = len(self._fibre_names) jet_names = [] idx_to_name = {} for fibre_idx in range(fibre_dim): u = self._fibre_names[fibre_idx] idx_to_name[(fibre_idx, ) + tuple([0] * base_dim)] = u for d in range(1, max_differential_orders[fibre_idx] + 1): for multi_index in IntegerVectors(d, base_dim): v = '{}_{}'.format( u, ''.join(self._base_names[i] * multi_index[i] for i in range(base_dim))) jet_names.append(v) idx_to_name[(fibre_idx, ) + tuple(multi_index)] = v self._polynomial_ring = PolynomialRing( base_ring, base_names + fibre_names + tuple(jet_names)) self._idx_to_var = { idx: self._polynomial_ring(idx_to_name[idx]) for idx in idx_to_name } self._var_to_idx = { jet: idx for (idx, jet) in self._idx_to_var.items() } # for conversion: base_vars = [var(b) for b in self._base_names] symbolic_functions = [ function(f)(*base_vars) for f in self._fibre_names ] self._subs_jet_vars = SubstituteJetVariables(symbolic_functions) self._subs_tot_ders = SubstituteTotalDerivatives(symbolic_functions)
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 [LP11]_. 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, DiscreteGaussianPolynomialSamplerRejection(8, 2.803372, 53, 4), 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 = 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 [LP11]_ q = next_prime(floor(2**round(log(256 / s_t_bound, 2)))) # Gaussian parameter as defined in [LP11]_ s = sqrt(s_t_bound*floor(q/4)) # Transform s into stddev stddev = s/sqrt(2*pi.n()) D = DiscreteGaussianPolynomialSampler(n, stddev) RingLWE.__init__(self, N=N, q=q, D=D, poly=None, secret_dist='noise', m=m)
def curve(nb_equipes, max_points=100, K=1, R=2, base=2, verbose=False): r""" INPUT: - ``nb_equipes`` -- integer - ``max_points`` -- integer - ``K`` -- the value at ``p = nb_equipes`` - ``R`` -- real (default: ``2``), curve parameter - ``base`` -- 2 - ``verbose`` - bool EXEMPLES:: sage: from slabbe.ranking_scale import curve sage: curve(20, 100) -99*(p*(log(40) + 1) - p*log(p) - 20*log(40) + 20*log(20) - 20)/(19*log(40) - 20*log(20) + 19) + 1 sage: curve(64, 100) -33*(p*(7*log(2) + 1) - p*log(p) - 64*log(2) - 64)/(19*log(2) + 21) + 1 :: sage: curve(64, 100)(p=64) 1 sage: curve(64, 100)(p=1) 100 sage: curve(64, 100)(p=2) 66*(26*log(2) + 31)/(19*log(2) + 21) + 1 sage: n(curve(64, 100)(p=2)) # abs tol 1e-10 95.6871477097753 :: sage: curve(64, 100, verbose=True) fn = -(p*(7*log(2) + 1) - p*log(p) - 64*log(2) - 64)/log(2) aire = 147.889787576005 fn normalise = -33*(p*(7*log(2) + 1) - p*log(p) - 64*log(2) - 64)/(19*log(2) + 21) + 1 -33*(p*(7*log(2) + 1) - p*log(p) - 64*log(2) - 64)/(19*log(2) + 21) + 1 The base argument seems to be useless (why?):: sage: curve(100,100,base=3) -99*(p*(log(200) + 1) - p*log(p) - 100*log(200) + 200*log(10) - 100)/(99*log(200) - 200*log(10) + 99) + 1 sage: curve(100,100,base=2) -99*(p*(log(200) + 1) - p*log(p) - 100*log(200) + 200*log(10) - 100)/(99*log(200) - 200*log(10) + 99) + 1 """ from sage.symbolic.assumptions import forget, assume from sage.misc.functional import integrate, n from sage.functions.log import log from sage.calculus.var import var x,p = var('x,p') forget() assume(p - 1 > 0) assume(p-nb_equipes < 0) fn = integrate(log(R*nb_equipes, base=base) - log(x, base=base), x, p, nb_equipes) if verbose: print("fn = %s" % fn) aire = fn(p=1) if verbose: print("aire = %s" % n(aire)) fn_normalise = fn / aire * (max_points - K) + K if verbose: print("fn normalise = %s" % fn_normalise) return fn_normalise
def cluster_expansion(self, beta): if beta == 0: return dict() coefficients=beta.monomial_coefficients() if any ( x < 0 for x in coefficients.values() ): alpha = [ -x for x in self.initial_cluster() ] negative_part = dict( [(-alpha[x],-coefficients[x]) for x in coefficients if coefficients[x] < 0 ] ) positive_part = sum( [ coefficients[x]*alpha[x] for x in coefficients if coefficients[x] > 0 ] ) return dict( negative_part.items() + self.cluster_expansion(positive_part).items() ) if self.is_affine(): if self.gamma().associated_coroot().scalar(beta) < 0: shifted_expansion = self.cluster_expansion( self.tau_c()(beta) ) return dict( [ (self.tau_c_inverse()(x),shifted_expansion[x]) for x in shifted_expansion ] ) elif self.gamma().associated_coroot().scalar(beta) > 0: shifted_expansion = self.cluster_expansion( self.tau_c_inverse()(beta) ) return dict( [ (self.tau_c()(x),shifted_expansion[x]) for x in shifted_expansion ] ) else: ### # Assumptions # # Two cases are possible for vectors in the interior of the cone # according to how many tubes there are: # 1) If there is only one tube then its extremal rays are linearly # independent, therefore a point is in the interior of the cone # if and only if it is a linear combination of all the extremal # rays with strictly positive coefficients. In this case solve() # should produce only one solution. # 2) If there are two or three tubes then the extreme rays are # linearly dependent. A vector is in the interior of the cone if # and only if it can be written as a strictly positive linear # combination of all the rays of at least one tube. In this case # solve() should return at least two solutions. # # If a vector is on one face of the cone than it can be written # uniquely as linear combination of the rays of that face (they # are linearly independent). solve() should return only one # solution no matter how many tubes there are. rays = flatten([ t[0] for t in self.affine_tubes() ]) system = matrix( map( vector, rays ) ).transpose() x = vector( var ( ['x%d'%i for i in range(len(rays))] ) ) eqs = [ (system*x)[i] == vector(beta)[i] for i in range(self._n)] ieqs = [ y >= 0 for y in x ] solutions = solve( eqs+ieqs, x, solution_dict=True ) if not solutions: # we are outside the cone shifted_expansion = self.cluster_expansion( self.tau_c()(beta) ) return dict( [ (self.tau_c_inverse()(v),shifted_expansion[v]) for v in shifted_expansion ] ) if len(solutions) > 1 or all( v > 0 for v in solutions[0].values() ): # we are in the interior of the cone raise ValueError("Vectors in the interior of the cone do " "not have a cluster expansion") # we are on the boundary of the cone solution_dict=dict( [(rays[i],solutions[0][x[i]]) for i in range(len(rays)) ] ) tube_bases = [ t[0] for t in self.affine_tubes() ] connected_components = [] index = 0 for t in tube_bases: component = [] for a in t: if solution_dict[a] == 0: if component: connected_components.append( component ) component = [] else: component.append( (a,solution_dict[a]) ) if component: if connected_components: connected_components[index] = ( component + connected_components[index] ) else: connected_components.append( component ) index = len(connected_components) expansion = dict() while connected_components: component = connected_components.pop() c = min( [ a[1] for a in component] ) expansion[sum( [a[0] for a in component])] = c component = [ (a[0],a[1]-c) for a in component ] new_component = [] for a in component: if a[1] == 0: if new_component: connected_components.append( new_component ) new_component = [] else: new_component.append( a ) if new_component: connected_components.append( new_component ) return expansion if self.is_finite(): shifted_expansion = self.cluster_expansion( self.tau_c()(beta) ) return dict( [ (self.tau_c_inverse()(x),shifted_expansion[x]) for x in shifted_expansion ] )
def gghlite_params(n, kappa, target_lambda=_sage_const_80 , xi=None, rerand=False, gddh_hard=False): """ Return GGHLite parameter estimates for a given dimension ‘n‘ and multilinearity level ‘κ‘. :param n: lattice dimension, must be power of two :param kappa: multilinearity level ‘κ>1‘ :param target_lambda: target security level :param xi: pick ‘ξ‘ manually :param rerand:is the instance supposed to support re-randomisation This should be true for ‘N‘-partite DH key exchange and false for iO and friends. :param gddh_hard:should the GDDH problem be hard :returns: parameter choices for a GGHLite-like graded-encoding scheme """ n = ZZ(n) kappa = ZZ(kappa) RR = RealField(_sage_const_2 *target_lambda) sigma= RR(_sage_const_4 *pi*n * sqrt(e*log(_sage_const_8 *n)/pi)) ell_g = RR(_sage_const_4 *sqrt(pi*e*n)/(sigma)) sigma_p = RR(_sage_const_7 * n**(_sage_const_2p5 ) * log(n)**(_sage_const_1p5 ) * sigma) ell_b = RR(_sage_const_1p0 /(_sage_const_2p0 *sqrt(pi*e*n)) * sigma_p) eps = RR(log(target_lambda)/kappa) ell = RR(log(_sage_const_8 *n*sigma, _sage_const_2 )) m = RR(_sage_const_2 ) if rerand: sigma_s = RR(n**(_sage_const_1p5 ) * sigma_p**_sage_const_2 * sqrt(_sage_const_8 *pi/eps)/ell_b) if gddh_hard: sigma_s *= _sage_const_2 **target_lambda * sqrt(kappa) * target_lambda / n else: sigma_s = _sage_const_1 normk = sqrt(n)**(kappa-_sage_const_1 ) * ((sigma_p)**_sage_const_2 * n**RR(_sage_const_1p5 ) + _sage_const_2 *sigma_s * sigma_p * n**RR(_sage_const_1p5 ))**kappa q_base = RR(n * ell_g * normk) if xi is None: log_negl = target_lambda xivar = var('xivar') f = (ell + log_negl) == (_sage_const_2 *xivar/(_sage_const_1 -_sage_const_2 *xivar))*log(q_base, _sage_const_2 ) xi = RR(f.solve(xivar)[_sage_const_0 ].rhs()) q = q_base**(ZZ(_sage_const_2 )/(_sage_const_1 -_sage_const_2 *xi)) t = q**xi * _sage_const_2 **(-ell + _sage_const_2 ) assert(q > _sage_const_2 *t*n*sigma**(_sage_const_1 /xi)) assert(abs(xi*log(q, _sage_const_2 ) - log_negl - ell) <= _sage_const_0p1 ) else: q = q_base**(ZZ(_sage_const_2 )/(_sage_const_1 -_sage_const_2 *xi)) t = q**xi * _sage_const_2 **(-ell + _sage_const_2 ) params = OrderedDict() params[u"κ"] = kappa params["n"] = n params[u"σ"] = sigma params[u"σ’"] = sigma_p if rerand: params[u"σ^*"] = sigma_s params[u"lnorm_κ"] = normk params[u"unorm_κ"] = normk# if we had re-rand at higher levels this could be bigger params[u"ℓ_g"] = ell_g params[u"ℓ_b"] = ell_b params[u"ǫ"] = eps params[u"m"] = m params[u"ξ"] = xi params["q"] = q params["|enc|"] = RR(log(q, _sage_const_2 ) * n) if rerand: params["|par|"] = (_sage_const_2 + _sage_const_1 + _sage_const_1 )*RR(log(q, _sage_const_2 ) * n) else: params["|par|"] = RR(log(q, _sage_const_2 ) * n) return params
second_vector=second_point-center radius=norm(first_vector) if norm(second_vector)!=radius: raise ValueError("Ellipse not implemented") first_unit_vector=first_vector/radius second_unit_vector=second_vector/radius normal_vector=second_vector-(second_vector*first_unit_vector)*first_unit_vector if norm(normal_vector)==0: print (first_point,second_point) return normal_unit_vector=normal_vector/norm(normal_vector) scalar_product=first_unit_vector*second_unit_vector if abs(scalar_product) == 1: raise ValueError("The points are alligned") angle=arccos(scalar_product) var('t') return parametric_plot3d(center+first_vector*cos(t)+radius*normal_unit_vector*sin(t),(0,angle),**kwds) def _arc(p,q,s,**kwds): #rewrite this to use polar_plot and get points to do filled triangles from sage.misc.functional import det from sage.plot.line import line from sage.misc.functional import norm from sage.symbolic.all import pi from sage.plot.arc import arc p,q,s = map( lambda x: vector(x), [p,q,s]) # to avoid running into division by 0 we set to be colinear vectors that are # almost colinear