def test_minpoly_domain(): assert minimal_polynomial(sqrt(2), x, domain=QQ.algebraic_field(sqrt(2))) == \ x - sqrt(2) assert minimal_polynomial(sqrt(8), x, domain=QQ.algebraic_field(sqrt(2))) == \ x - 2*sqrt(2) assert minimal_polynomial(sqrt(Rational(3, 2)), x, domain=QQ.algebraic_field( sqrt(2))) == 2 * x**2 - 3 raises(NotAlgebraic, lambda: minimal_polynomial(y, x, domain=QQ))
def test_minimal_polynomial_sq(): from sympy.core.add import Add from sympy.core.function import expand_multinomial p = expand_multinomial((1 + 5 * sqrt(2) + 2 * sqrt(3))**3) mp = minimal_polynomial(p**Rational(1, 3), x) assert mp == x**4 - 4 * x**3 - 118 * x**2 + 244 * x + 1321 p = expand_multinomial((1 + sqrt(2) - 2 * sqrt(3) + sqrt(7))**3) mp = minimal_polynomial(p**Rational(1, 3), x) assert mp == x**8 - 8 * x**7 - 56 * x**6 + 448 * x**5 + 480 * x**4 - 5056 * x**3 + 1984 * x**2 + 7424 * x - 3008 p = Add(*[sqrt(i) for i in range(1, 12)]) mp = minimal_polynomial(p, x) assert mp.subs({x: 0}) == -71965773323122507776
def test_minpoly_issue_7113(): # see discussion in https://github.com/sympy/sympy/pull/2234 from sympy.simplify.simplify import nsimplify r = nsimplify(pi, tolerance=0.000000001) mp = minimal_polynomial(r, x) assert mp == 1768292677839237920489538677417507171630859375*x**109 - \ 2734577732179183863586489182929671773182898498218854181690460140337930774573792597743853652058046464
def test_minimal_polynomial_hi_prec(): p = 1 / sqrt(1 - 9 * sqrt(2) + 7 * sqrt(3) + Rational(1, 10)**30) mp = minimal_polynomial(p, x) # checked with Wolfram Alpha assert mp.coeff( x**6 ) == -1232000000000000000000000000001223999999999999999999999999999987999999999999999999999999999996000000000000000000000000000000
def test_minimal_polynomial_issue_19732(): # https://github.com/sympy/sympy/issues/19732 expr = ( -280898097948878450887044002323982963174671632174995451265117559518123750720061943079105185551006003416773064305074191140286225850817291393988597615 / (-488144716373031204149459129212782509078221364279079444636386844223983756114492222145074506571622290776245390771587888364089507840000000 * sqrt(238368341569) * sqrt( S(11918417078450) / 63568729 - 24411360 * sqrt(238368341569) / 63568729) + 238326799225996604451373809274348704114327860564921529846705817404208077866956345381951726531296652901169111729944612727047670549086208000000 * sqrt( S(11918417078450) / 63568729 - 24411360 * sqrt(238368341569) / 63568729)) - 180561807339168676696180573852937120123827201075968945871075967679148461189459480842956689723484024031016208588658753107 / (-59358007109636562851035004992802812513575019937126272896569856090962677491318275291141463850327474176000000 * sqrt(238368341569) * sqrt( S(11918417078450) / 63568729 - 24411360 * sqrt(238368341569) / 63568729) + 28980348180319251787320809875930301310576055074938369007463004788921613896002936637780993064387310446267596800000 * sqrt( S(11918417078450) / 63568729 - 24411360 * sqrt(238368341569) / 63568729))) poly = ( 2151288870990266634727173620565483054187142169311153766675688628985237817262915166497766867289157986631135400926544697981091151416655364879773546003475813114962656742744975460025956167152918469472166170500512008351638710934022160294849059721218824490226159355197136265032810944357335461128949781377875451881300105989490353140886315677977149440000000000000000000000 * x**4 - 5773274155644072033773937864114266313663195672820501581692669271302387257492905909558846459600429795784309388968498783843631580008547382703258503404023153694528041873101120067477617592651525155101107144042679962433039557235772239171616433004024998230222455940044709064078962397144550855715640331680262171410099614469231080995436488414164502751395405398078353242072696360734131090111239998110773292915337556205692674790561090109440000000000000 * x**2 + 211295968822207088328287206509522887719741955693091053353263782924470627623790749534705683380138972642560898936171035770539616881000369889020398551821767092685775598633794696371561234818461806577723412581353857653829324364446419444210520602157621008010129702779407422072249192199762604318993590841636967747488049176548615614290254356975376588506729604345612047361483789518445332415765213187893207704958013682516462853001964919444736320672860140355089 ) assert minimal_polynomial(expr, x) == poly
def test_issue_19760(): e = 1 / (sqrt(1 + sqrt(2)) - sqrt(2) * sqrt(1 + sqrt(2))) + 1 mp_expected = x**4 - 4 * x**3 + 4 * x**2 - 2 for comp in (True, False): mp = Poly(minimal_polynomial(e, compose=comp)) assert mp( x ) == mp_expected, "minimal_polynomial(e, compose=%s) = %s; %s expected" % ( comp, mp(x), mp_expected)
def primitive_element(extension, x=None, *, ex=False, polys=False): r""" Find a single generator for a number field given by several generators. Explanation =========== The basic problem is this: Given several algebraic numbers $\alpha_1, \alpha_2, \ldots, \alpha_n$, find a single algebraic number $\theta$ such that $\mathbb{Q}(\alpha_1, \alpha_2, \ldots, \alpha_n) = \mathbb{Q}(\theta)$. This function actually guarantees that $\theta$ will be a linear combination of the $\alpha_i$, with non-negative integer coefficients. Furthermore, if desired, this function will tell you how to express each $\alpha_i$ as a $\mathbb{Q}$-linear combination of the powers of $\theta$. Examples ======== >>> from sympy import primitive_element, sqrt, S, minpoly, simplify >>> from sympy.abc import x >>> f, lincomb, reps = primitive_element([sqrt(2), sqrt(3)], x, ex=True) Then ``lincomb`` tells us the primitive element as a linear combination of the given generators ``sqrt(2)`` and ``sqrt(3)``. >>> print(lincomb) [1, 1] This means the primtiive element is $\sqrt{2} + \sqrt{3}$. Meanwhile ``f`` is the minimal polynomial for this primitive element. >>> print(f) x**4 - 10*x**2 + 1 >>> print(minpoly(sqrt(2) + sqrt(3), x)) x**4 - 10*x**2 + 1 Finally, ``reps`` (which was returned only because we set keyword arg ``ex=True``) tells us how to recover each of the generators $\sqrt{2}$ and $\sqrt{3}$ as $\mathbb{Q}$-linear combinations of the powers of the primitive element $\sqrt{2} + \sqrt{3}$. >>> print([S(r) for r in reps[0]]) [1/2, 0, -9/2, 0] >>> theta = sqrt(2) + sqrt(3) >>> print(simplify(theta**3/2 - 9*theta/2)) sqrt(2) >>> print([S(r) for r in reps[1]]) [-1/2, 0, 11/2, 0] >>> print(simplify(-theta**3/2 + 11*theta/2)) sqrt(3) Parameters ========== extension : list of :py:class:`~.Expr` Each expression must represent an algebraic number $\alpha_i$. x : :py:class:`~.Symbol`, optional (default=None) The desired symbol to appear in the computed minimal polynomial for the primitive element $\theta$. If ``None``, we use a dummy symbol. ex : boolean, optional (default=False) If and only if ``True``, compute the representation of each $\alpha_i$ as a $\mathbb{Q}$-linear combination over the powers of $\theta$. polys : boolean, optional (default=False) If ``True``, return the minimal polynomial as a :py:class:`~.Poly`. Otherwise return it as an :py:class:`~.Expr`. Returns ======= Pair (f, coeffs) or triple (f, coeffs, reps), where: ``f`` is the minimal polynomial for the primitive element. ``coeffs`` gives the primitive element as a linear combination of the given generators. ``reps`` is present if and only if argument ``ex=True`` was passed, and is a list of lists of rational numbers. Each list gives the coefficients of falling powers of the primitive element, to recover one of the original, given generators. """ if not extension: raise ValueError("Cannot compute primitive element for empty extension") extension = [_sympify(ext) for ext in extension] if x is not None: x, cls = sympify(x), Poly else: x, cls = Dummy('x'), PurePoly if not ex: gen, coeffs = extension[0], [1] g = minimal_polynomial(gen, x, polys=True) for ext in extension[1:]: if ext.is_Rational: coeffs.append(0) continue _, factors = factor_list(g, extension=ext) g = _choose_factor(factors, x, gen) s, _, g = g.sqf_norm() gen += s*ext coeffs.append(s) if not polys: return g.as_expr(), coeffs else: return cls(g), coeffs gen, coeffs = extension[0], [1] f = minimal_polynomial(gen, x, polys=True) K = QQ.algebraic_field((f, gen)) # incrementally constructed field reps = [K.unit] # representations of extension elements in K for ext in extension[1:]: if ext.is_Rational: coeffs.append(0) # rational ext is not included in the expression of a primitive element reps.append(K.convert(ext)) # but it is included in reps continue p = minimal_polynomial(ext, x, polys=True) L = QQ.algebraic_field((p, ext)) _, factors = factor_list(f, domain=L) f = _choose_factor(factors, x, gen) s, g, f = f.sqf_norm() gen += s*ext coeffs.append(s) K = QQ.algebraic_field((f, gen)) h = _switch_domain(g, K) erep = _linsolve(h.gcd(p)) # ext as element of K ogen = K.unit - s*erep # old gen as element of K reps = [dup_eval(_.rep, ogen, K) for _ in reps] + [erep] if K.ext.root.is_Rational: # all extensions are rational H = [K.convert(_).rep for _ in extension] coeffs = [0]*len(extension) f = cls(x, domain=QQ) else: H = [_.rep for _ in reps] if not polys: return f.as_expr(), coeffs, H else: return f, coeffs, H
def test_issue_22561(): a = AlgebraicNumber(sqrt(2) + sqrt(3), [S(1) / 2, 0, S(-9) / 2, 0], gen=x) assert a.as_expr() == sqrt(2) assert minimal_polynomial(a, x) == x**2 - 2 assert minimal_polynomial(a**3, x) == x**2 - 8
def test_issue_22559(): alpha = AlgebraicNumber(sqrt(2)) assert minimal_polynomial(alpha**3, x) == x**2 - 8
def test_issue_14831(): a = -2 * sqrt(2) * sqrt(12 * sqrt(2) + 17) assert minimal_polynomial(a, x) == x**2 + 16 * x - 8 e = (-3 * sqrt(12 * sqrt(2) + 17) + 12 * sqrt(2) + 17 - 2 * sqrt(2) * sqrt(12 * sqrt(2) + 17)) assert minimal_polynomial(e, x) == x
def test_minpoly_fraction_field_slow(): assert minimal_polynomial( minimal_polynomial(sqrt(x**Rational(1, 5) - 1), y).subs(y, sqrt(x**Rational(1, 5) - 1)), z) == z
def test_minimal_polynomial(): assert minimal_polynomial(-7, x) == x + 7 assert minimal_polynomial(-1, x) == x + 1 assert minimal_polynomial(0, x) == x assert minimal_polynomial(1, x) == x - 1 assert minimal_polynomial(7, x) == x - 7 assert minimal_polynomial(sqrt(2), x) == x**2 - 2 assert minimal_polynomial(sqrt(5), x) == x**2 - 5 assert minimal_polynomial(sqrt(6), x) == x**2 - 6 assert minimal_polynomial(2 * sqrt(2), x) == x**2 - 8 assert minimal_polynomial(3 * sqrt(5), x) == x**2 - 45 assert minimal_polynomial(4 * sqrt(6), x) == x**2 - 96 assert minimal_polynomial(2 * sqrt(2) + 3, x) == x**2 - 6 * x + 1 assert minimal_polynomial(3 * sqrt(5) + 6, x) == x**2 - 12 * x - 9 assert minimal_polynomial(4 * sqrt(6) + 7, x) == x**2 - 14 * x - 47 assert minimal_polynomial(2 * sqrt(2) - 3, x) == x**2 + 6 * x + 1 assert minimal_polynomial(3 * sqrt(5) - 6, x) == x**2 + 12 * x - 9 assert minimal_polynomial(4 * sqrt(6) - 7, x) == x**2 + 14 * x - 47 assert minimal_polynomial(sqrt(1 + sqrt(6)), x) == x**4 - 2 * x**2 - 5 assert minimal_polynomial(sqrt(I + sqrt(6)), x) == x**8 - 10 * x**4 + 49 assert minimal_polynomial(2 * I + sqrt(2 + I), x) == x**4 + 4 * x**2 + 8 * x + 37 assert minimal_polynomial(sqrt(2) + sqrt(3), x) == x**4 - 10 * x**2 + 1 assert minimal_polynomial(sqrt(2) + sqrt(3) + sqrt(6), x) == x**4 - 22 * x**2 - 48 * x - 23 a = 1 - 9 * sqrt(2) + 7 * sqrt(3) assert minimal_polynomial( 1 / a, x) == 392 * x**4 - 1232 * x**3 + 612 * x**2 + 4 * x - 1 assert minimal_polynomial( 1 / sqrt(a), x) == 392 * x**8 - 1232 * x**6 + 612 * x**4 + 4 * x**2 - 1 raises(NotAlgebraic, lambda: minimal_polynomial(oo, x)) raises(NotAlgebraic, lambda: minimal_polynomial(2**y, x)) raises(NotAlgebraic, lambda: minimal_polynomial(sin(1), x)) assert minimal_polynomial(sqrt(2)).dummy_eq(x**2 - 2) assert minimal_polynomial(sqrt(2), x) == x**2 - 2 assert minimal_polynomial(sqrt(2), polys=True) == Poly(x**2 - 2) assert minimal_polynomial(sqrt(2), x, polys=True) == Poly(x**2 - 2, domain='QQ') assert minimal_polynomial(sqrt(2), x, polys=True, compose=False) == Poly(x**2 - 2, domain='QQ') a = AlgebraicNumber(sqrt(2)) b = AlgebraicNumber(sqrt(3)) assert minimal_polynomial(a, x) == x**2 - 2 assert minimal_polynomial(b, x) == x**2 - 3 assert minimal_polynomial(a, x, polys=True) == Poly(x**2 - 2, domain='QQ') assert minimal_polynomial(b, x, polys=True) == Poly(x**2 - 3, domain='QQ') assert minimal_polynomial(sqrt(a / 2 + 17), x) == 2 * x**4 - 68 * x**2 + 577 assert minimal_polynomial(sqrt(b / 2 + 17), x) == 4 * x**4 - 136 * x**2 + 1153 a, b = sqrt(2) / 3 + 7, AlgebraicNumber(sqrt(2) / 3 + 7) f = 81*x**8 - 2268*x**6 - 4536*x**5 + 22644*x**4 + 63216*x**3 - \ 31608*x**2 - 189648*x + 141358 assert minimal_polynomial(sqrt(a) + sqrt(sqrt(a)), x) == f assert minimal_polynomial(sqrt(b) + sqrt(sqrt(b)), x) == f assert minimal_polynomial(a**Q(3, 2), x) == 729 * x**4 - 506898 * x**2 + 84604519 # issue 5994 eq = S(''' -1/(800*sqrt(-1/240 + 1/(18000*(-1/17280000 + sqrt(15)*I/28800000)**(1/3)) + 2*(-1/17280000 + sqrt(15)*I/28800000)**(1/3)))''') assert minimal_polynomial(eq, x) == 8000 * x**2 - 1 ex = (sqrt(5) * sqrt(I) / (5 * sqrt(1 + 125 * I)) + 25 * sqrt(5) / (I**Q(5, 2) * (1 + 125 * I)**Q(3, 2)) + 3125 * sqrt(5) / (I**Q(11, 2) * (1 + 125 * I)**Q(3, 2)) + 5 * I * sqrt(1 - I / 125)) mp = minimal_polynomial(ex, x) assert mp == 25 * x**4 + 5000 * x**2 + 250016 ex = 1 + sqrt(2) + sqrt(3) mp = minimal_polynomial(ex, x) assert mp == x**4 - 4 * x**3 - 4 * x**2 + 16 * x - 8 ex = 1 / (1 + sqrt(2) + sqrt(3)) mp = minimal_polynomial(ex, x) assert mp == 8 * x**4 - 16 * x**3 + 4 * x**2 + 4 * x - 1 p = (expand((1 + sqrt(2) - 2 * sqrt(3) + sqrt(7))**3))**Rational(1, 3) mp = minimal_polynomial(p, x) assert mp == x**8 - 8 * x**7 - 56 * x**6 + 448 * x**5 + 480 * x**4 - 5056 * x**3 + 1984 * x**2 + 7424 * x - 3008 p = expand((1 + sqrt(2) - 2 * sqrt(3) + sqrt(7))**3) mp = minimal_polynomial(p, x) assert mp == x**8 - 512 * x**7 - 118208 * x**6 + 31131136 * x**5 + 647362560 * x**4 - 56026611712 * x**3 + 116994310144 * x**2 + 404854931456 * x - 27216576512 assert minimal_polynomial(S("-sqrt(5)/2 - 1/2 + (-sqrt(5)/2 - 1/2)**2"), x) == x - 1 a = 1 + sqrt(2) assert minimal_polynomial((a * sqrt(2) + a)**3, x) == x**2 - 198 * x + 1 p = 1 / (1 + sqrt(2) + sqrt(3)) assert minimal_polynomial( p, x, compose=False) == 8 * x**4 - 16 * x**3 + 4 * x**2 + 4 * x - 1 p = 2 / (1 + sqrt(2) + sqrt(3)) assert minimal_polynomial( p, x, compose=False) == x**4 - 4 * x**3 + 2 * x**2 + 4 * x - 2 assert minimal_polynomial(1 + sqrt(2) * I, x, compose=False) == x**2 - 2 * x + 3 assert minimal_polynomial(1 / (1 + sqrt(2)) + 1, x, compose=False) == x**2 - 2 assert minimal_polynomial(sqrt(2) * I + I * (1 + sqrt(2)), x, compose=False) == x**4 + 18 * x**2 + 49 # minimal polynomial of I assert minimal_polynomial(I, x, domain=QQ.algebraic_field(I)) == x - I K = QQ.algebraic_field(I * (sqrt(2) + 1)) assert minimal_polynomial(I, x, domain=K) == x - I assert minimal_polynomial(I, x, domain=QQ) == x**2 + 1 assert minimal_polynomial(I, x, domain='QQ(y)') == x**2 + 1 #issue 11553 assert minimal_polynomial(GoldenRatio, x) == x**2 - x - 1 assert minimal_polynomial(TribonacciConstant + 3, x) == x**3 - 10 * x**2 + 32 * x - 34 assert minimal_polynomial(GoldenRatio, x, domain=QQ.algebraic_field(sqrt(5))) == \ 2*x - sqrt(5) - 1 assert minimal_polynomial(TribonacciConstant, x, domain=QQ.algebraic_field(cbrt(19 - 3*sqrt(33)))) == \ 48*x - 19*(19 - 3*sqrt(33))**Rational(2, 3) - 3*sqrt(33)*(19 - 3*sqrt(33))**Rational(2, 3) \ - 16*(19 - 3*sqrt(33))**Rational(1, 3) - 16 # AlgebraicNumber with an alias. # Wester H24 phi = AlgebraicNumber(S.GoldenRatio.expand(func=True), alias='phi') assert minimal_polynomial(phi, x) == x**2 - x - 1
def test_minpoly_fraction_field(): assert minimal_polynomial(1 / x, y) == -x * y + 1 assert minimal_polynomial(1 / (x + 1), y) == (x + 1) * y - 1 assert minimal_polynomial(sqrt(x), y) == y**2 - x assert minimal_polynomial(sqrt(x + 1), y) == y**2 - x - 1 assert minimal_polynomial(sqrt(x) / x, y) == x * y**2 - 1 assert minimal_polynomial(sqrt(2) * sqrt(x), y) == y**2 - 2 * x assert minimal_polynomial(sqrt(2) + sqrt(x), y) == \ y**4 + (-2*x - 4)*y**2 + x**2 - 4*x + 4 assert minimal_polynomial(x**Rational(1, 3), y) == y**3 - x assert minimal_polynomial(x**Rational(1,3) + sqrt(x), y) == \ y**6 - 3*x*y**4 - 2*x*y**3 + 3*x**2*y**2 - 6*x**2*y - x**3 + x**2 assert minimal_polynomial(sqrt(x) / z, y) == z**2 * y**2 - x assert minimal_polynomial(sqrt(x) / (z + 1), y) == (z**2 + 2 * z + 1) * y**2 - x assert minimal_polynomial(1 / x, y, polys=True) == Poly(-x * y + 1, y, domain='ZZ(x)') assert minimal_polynomial(1 / (x + 1), y, polys=True) == \ Poly((x + 1)*y - 1, y, domain='ZZ(x)') assert minimal_polynomial(sqrt(x), y, polys=True) == Poly(y**2 - x, y, domain='ZZ(x)') assert minimal_polynomial(sqrt(x) / z, y, polys=True) == \ Poly(z**2*y**2 - x, y, domain='ZZ(x, z)') # this is (sqrt(1 + x**3)/x).integrate(x).diff(x) - sqrt(1 + x**3)/x a = sqrt(x)/sqrt(1 + x**(-3)) - sqrt(x**3 + 1)/x + 1/(x**Rational(5, 2)* \ (1 + x**(-3))**Rational(3, 2)) + 1/(x**Rational(11, 2)*(1 + x**(-3))**Rational(3, 2)) assert minimal_polynomial(a, y) == y raises(NotAlgebraic, lambda: minimal_polynomial(exp(x), y)) raises(GeneratorsError, lambda: minimal_polynomial(sqrt(x), x)) raises(GeneratorsError, lambda: minimal_polynomial(sqrt(x) - y, x)) raises(NotImplementedError, lambda: minimal_polynomial(sqrt(x), y, compose=False))
def test_minpoly_issue_7574(): ex = -(-1)**Rational(1, 3) + (-1)**Rational(2, 3) assert minimal_polynomial(ex, x) == x + 1
def test_minpoly_compose(): # issue 6868 eq = S(''' -1/(800*sqrt(-1/240 + 1/(18000*(-1/17280000 + sqrt(15)*I/28800000)**(1/3)) + 2*(-1/17280000 + sqrt(15)*I/28800000)**(1/3)))''') mp = minimal_polynomial(eq + 3, x) assert mp == 8000 * x**2 - 48000 * x + 71999 # issue 5888 assert minimal_polynomial(exp(I * pi / 8), x) == x**8 + 1 mp = minimal_polynomial(sin(pi / 7) + sqrt(2), x) assert mp == 4096*x**12 - 63488*x**10 + 351488*x**8 - 826496*x**6 + \ 770912*x**4 - 268432*x**2 + 28561 mp = minimal_polynomial(cos(pi / 7) + sqrt(2), x) assert mp == 64*x**6 - 64*x**5 - 432*x**4 + 304*x**3 + 712*x**2 - \ 232*x - 239 mp = minimal_polynomial(exp(I * pi / 7) + sqrt(2), x) assert mp == x**12 - 2 * x**11 - 9 * x**10 + 16 * x**9 + 43 * x**8 - 70 * x**7 - 97 * x**6 + 126 * x**5 + 211 * x**4 - 212 * x**3 - 37 * x**2 + 142 * x + 127 mp = minimal_polynomial(sin(pi / 7) + sqrt(2), x) assert mp == 4096*x**12 - 63488*x**10 + 351488*x**8 - 826496*x**6 + \ 770912*x**4 - 268432*x**2 + 28561 mp = minimal_polynomial(cos(pi / 7) + sqrt(2), x) assert mp == 64*x**6 - 64*x**5 - 432*x**4 + 304*x**3 + 712*x**2 - \ 232*x - 239 mp = minimal_polynomial(exp(I * pi / 7) + sqrt(2), x) assert mp == x**12 - 2 * x**11 - 9 * x**10 + 16 * x**9 + 43 * x**8 - 70 * x**7 - 97 * x**6 + 126 * x**5 + 211 * x**4 - 212 * x**3 - 37 * x**2 + 142 * x + 127 mp = minimal_polynomial(exp(I * pi * Rational(2, 7)), x) assert mp == x**6 + x**5 + x**4 + x**3 + x**2 + x + 1 mp = minimal_polynomial(exp(I * pi * Rational(2, 15)), x) assert mp == x**8 - x**7 + x**5 - x**4 + x**3 - x + 1 mp = minimal_polynomial(cos(pi * Rational(2, 7)), x) assert mp == 8 * x**3 + 4 * x**2 - 4 * x - 1 mp = minimal_polynomial(sin(pi * Rational(2, 7)), x) ex = (5 * cos(pi * Rational(2, 7)) - 7) / (9 * cos(pi / 7) - 5 * cos(pi * Rational(3, 7))) mp = minimal_polynomial(ex, x) assert mp == x**3 + 2 * x**2 - x - 1 assert minimal_polynomial(-1 / (2 * cos(pi / 7)), x) == x**3 + 2 * x**2 - x - 1 assert minimal_polynomial(sin(pi*Rational(2, 15)), x) == \ 256*x**8 - 448*x**6 + 224*x**4 - 32*x**2 + 1 assert minimal_polynomial(sin(pi * Rational(5, 14)), x) == 8 * x**3 - 4 * x**2 - 4 * x + 1 assert minimal_polynomial(cos( pi / 15), x) == 16 * x**4 + 8 * x**3 - 16 * x**2 - 8 * x + 1 ex = rootof(x**3 + x * 4 + 1, 0) mp = minimal_polynomial(ex, x) assert mp == x**3 + 4 * x + 1 mp = minimal_polynomial(ex + 1, x) assert mp == x**3 - 3 * x**2 + 7 * x - 4 assert minimal_polynomial(exp(I * pi / 3), x) == x**2 - x + 1 assert minimal_polynomial(exp(I * pi / 4), x) == x**4 + 1 assert minimal_polynomial(exp(I * pi / 6), x) == x**4 - x**2 + 1 assert minimal_polynomial(exp(I * pi / 9), x) == x**6 - x**3 + 1 assert minimal_polynomial(exp(I * pi / 10), x) == x**8 - x**6 + x**4 - x**2 + 1 assert minimal_polynomial(sin(pi / 9), x) == 64 * x**6 - 96 * x**4 + 36 * x**2 - 3 assert minimal_polynomial(sin(pi/11), x) == 1024*x**10 - 2816*x**8 + \ 2816*x**6 - 1232*x**4 + 220*x**2 - 11 assert minimal_polynomial(sin(pi/21), x) == 4096*x**12 - 11264*x**10 + \ 11264*x**8 - 4992*x**6 + 960*x**4 - 64*x**2 + 1 assert minimal_polynomial(cos(pi / 9), x) == 8 * x**3 - 6 * x - 1 ex = 2**Rational(1, 3) * exp(2 * I * pi / 3) assert minimal_polynomial(ex, x) == x**3 - 2 raises(NotAlgebraic, lambda: minimal_polynomial(cos(pi * sqrt(2)), x)) raises(NotAlgebraic, lambda: minimal_polynomial(sin(pi * sqrt(2)), x)) raises(NotAlgebraic, lambda: minimal_polynomial(exp(1.618 * I * pi), x)) raises(NotAlgebraic, lambda: minimal_polynomial(exp(I * pi * sqrt(2)), x)) # issue 5934 ex = 1 / (-36000 - 7200 * sqrt(5) + (12 * sqrt(10) * sqrt(sqrt(5) + 5) + 24 * sqrt(10) * sqrt(-sqrt(5) + 5))**2) + 1 raises(ZeroDivisionError, lambda: minimal_polynomial(ex, x)) ex = sqrt(1 + 2**Rational(1, 3)) + sqrt(1 + 2**Rational(1, 4)) + sqrt(2) mp = minimal_polynomial(ex, x) assert degree(mp) == 48 and mp.subs({x: 0}) == -16630256576 ex = tan(pi / 5, evaluate=False) mp = minimal_polynomial(ex, x) assert mp == x**4 - 10 * x**2 + 5 assert mp.subs(x, tan(pi / 5)).is_zero ex = tan(pi / 6, evaluate=False) mp = minimal_polynomial(ex, x) assert mp == 3 * x**2 - 1 assert mp.subs(x, tan(pi / 6)).is_zero ex = tan(pi / 10, evaluate=False) mp = minimal_polynomial(ex, x) assert mp == 5 * x**4 - 10 * x**2 + 1 assert mp.subs(x, tan(pi / 10)).is_zero raises(NotAlgebraic, lambda: minimal_polynomial(tan(pi * sqrt(2)), x))